html

package
v0.13.66 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Sep 24, 2025 License: BSD-3-Clause, BSD-3-Clause Imports: 17 Imported by: 4

README

html

WARNING: This package is in flux. You should not use it in production yet. API will / might break.

type save html and css generation for golang with functions (inspired by http://godoc.org/github.com/daaku/go.h)

example

package main

import (
	"fmt"
	. "gitlab.com/golang-utils/web/lib/html"
)

func main(){
	font := NewCss(
		Class("default-font"),
		Style("font-size","20","font-weight","normal"))

	css := NewCss(
		Class("yellow-button"),
		Tags("a","button"),
		Style("background-color","yellow"),
		font)

	a := A(css)

	doc := NewTemplate(
		Doc(
			Head(),
			Body(a)))

	doc.AddCss(css)

	fmt.Println(doc)
}

results in

<head>
	<style>
		a.yellow-button,
		button.yellow-button {
			background-color: yellow;
			font-weight: normal;	/* inherited from ».default-font« */
			font-size: 20;	/* inherited from ».default-font« */
		}
	</style>
</head>
<body><a class="yellow-button"></a></body>

Documentation

see https://pkg.go.dev/gitlab.com/golang-utils/web/lib/html

TODO

Documentation

Overview

Package html constructs html element trees (something like DOM), html templates and integrates them with css rules. All of them are done by using types, not strings. This makes reuse and shortcuts easy.

It is inspired by http://godoc.org/github.com/daaku/go.h

It is easy to extend html and build upon it and you may bring in some html and css strings as well.

Elements

There are some helper functions to generate elements for you. For instance 

element := A()

gives you an anchor element. Here is how A() is defined and how you may define your own shortcuts. 

func A(objects ...Stringer) (t *Element) {
	t = NewElement(Tag("a"), Inline)
	t.Set(objects...)
	return
}

A() calls NewElement() with a typed Tag (created from a string) and a flag that indicates that it's an inline element. All flags are defined as constants and may be combined with the bitwise or | or given as seperate parameters.

Then A() sets up the element by passing the optional Stringer to the Set() method. This allows you do some neat things, for instance 

a := A(
	Class("button"),
	Id("start"),
	Text("begin"))

a.String() // <a class="button" id="start">begin</a>

a = A(
	Attr("href","#","_target","_blank"),
	Text("something"))

a.String() // <a href="#" target="_blank">something</a>

a = A(
	Style("color","red"),
	Strong(
		Html("not <escaped>!")))
a.String() // <a style="color:red;"><strong>not <escaped></strong></a>

Then you may get all the nice methods of element 

children := a.Children() // only the Elements
inner := a.InnerHtml()   // everything inside
buttons := a.All(Class("button"))
start := a.Any(Id("start"))
...

You may define your own Matcher and pass it to All() and Any().

Templates and Css

Template is an element that can Assign() anything that can be inside an element to any element within the tree, that has the given Id(). 

content := Div(Id("content"))
body := NewTemplate(Body(content))
body.Assign(Id("content"), P(Text("here I am")))
body.String() // <body><div id="content"><p>here I am</p></div></body>

Template may also add css to your head element. In this case you need to use the Doc() pseudo element, that holds the root of the document. And you need a head obviously. 

doc := NewTemplate(Doc(Head()))
doc.AddCss("body{ color: red; }")
doc.String() // <head><style>body { color: red; }</style></head>

Element and Template are structs you can inherit from them, e.g. 

type Layout struct {
	*Template
}

func (xyyy *Layout) String() string {
	// do your thing here
}

If you want type safe reusable css, you can use Css. 

fontsize := NewCss(Class("default-font-size"),Style("font-size","20"))
css := NewCss(
	Class("yellow-button"),
	Tags("a","button"),
	Style("background-color","yellow"),
	fontsize)

and then you might apply it to your elements. 

a := A()
a.ApplyCss(css)
a.String() // <a class="yellow-button"></a>

don't forget to put your css into the template (we don't put fontsize into it, since it is only a building block) 

doc := NewTemplate(Doc(Head(),Body(a)))
doc.AddCss(css)
doc.String()

this results in the following (no auto indentation at the moment, sorry): 

<head>
	<style>
		a.yellow-button,
		button.yellow-button {
			background-color: yellow;
			font-size: 20;	\/* inherited from ».default-font-size« *\/
		}
	</style>
</head>
<body><a class="yellow-button"></a></body>

Index

Examples

Constants

View Source 
const (
	IDForbidden       flag // element should not have an id attribute
	ClassForbidden         // element should not have a class attribute
	SelfClosing            // element is selfclosing and contains no content
	Inline                 // element is an inline element (only for visible elements)
	FormField              // element is a field of a form
	Invisible              // element doesn't render anything visible
	WithoutEscaping        // element does not escape inner Text
	WithoutDecoration      // element just prints the InnerHtml
)

Variables

View Source 
var ErrUnsupported = fmt.Errorf("unsupported")
View Source 
var Escaper = templ.Escaper{
	"text":     handleStrings(gohtml.EscapeString, true),
	"":         handleStrings(gohtml.EscapeString, true),
	"html":     handleStrings(idem, true),
	"px":       units("%vpx"),
	"%":        units("%v%%"),
	"em":       units("%vem"),
	"pt":       units("%vpt"),
	"urlparam": handleStrings(url.QueryEscape, false),
}

Functions

func And 

func And(m ...Matcher) and

func Child 

func Child(selectors ...Sel) combinator

F element child of an E element

func Classes 

func Classes(c ...string) classes

func Descendant 

func Descendant(selectors ...Sel) combinator

F element descendant of an E element

func DirectFollows 

func DirectFollows(selectors ...Sel) combinator

F element immediately preceded by an E element

func Each 

func Each(selectors ...Sel) combinator

for each given selector the rules apply

func Follows 

func Follows(selectors ...Sel) combinator

F element preceded by an E element

func Not 

func Not(m Matcher) *not

func Or 

func Or(m ...Matcher) or

func Str 

func Str(in interface{}) string

takes different types and outputs a string

func Tags 

func Tags(tag string, xyyy ...string) (a tags)

func View 

func View(stru interface{}, tag string) *view

Types

type Attrs 

type Attrs []SingleAttr

func Attr 

func Attr(key1, val1 string, xyyy ...string) (s Attrs)

helper to easily create multiple SingleAttrs use is like this Attr("width","200px","height","30px","value","hiho")

func (Attrs) Matches 

func (at Attrs) Matches(t *Element) (m bool)

func (Attrs) String 

func (as Attrs) String() (s string)

type Class 

type Class string

func Classf 

func Classf(format string, i ...interface{}) Class

func (Class) AddTo added in v0.13.60 

func (i Class) AddTo(elm js.Expression) js.Statement

func (Class) IsIn added in v0.13.60 

func (i Class) IsIn(elm js.Expression) js.Condition

func (Class) JsStatement added in v0.13.60 

func (c Class) JsStatement() string

func (Class) JsValue added in v0.13.60 

func (i Class) JsValue() string

func (Class) Matches 

func (cl Class) Matches(t *Element) bool

func (Class) Pos added in v0.13.42 

func (c Class) Pos() Pos

func (Class) RemoveFrom added in v0.13.60 

func (i Class) RemoveFrom(elm js.Expression) js.Statement

func (Class) Selector 

func (c Class) Selector() string

func (Class) String 

func (c Class) String() string

type Comment 

type Comment string

func (Comment) Pos added in v0.13.42 

func (c Comment) Pos() Pos

func (Comment) String 

func (c Comment) String() string

type CompiledTemplate 

type CompiledTemplate struct {
	*templ.Template
	ElementTemplate *Template
}

func (*CompiledTemplate) HTML added in v0.6.0 

func (t *CompiledTemplate) HTML() HTML

type Csser 

type Csser interface {
	Matcher
	Class() string
}

a Csser might be applied as Css to an Element

type Element 

type Element struct {
	Comment Comment

	ParentTags tags
	// contains filtered or unexported fields
}

the base of what becomes a tag when printed

func Bundle added in v0.9.2 

func Bundle(sth ...any) *Element

func NewElement 

func NewElement(t Tag, flags ...flag) (el *Element)

contruct a new element with some flags.

the tag constructors A(), Body(),... use these method, see tags.go file for examples

use it for your own tags

the following flags are supported 

IdForbidden                        // element should not have an id attribute
ClassForbidden                     // element should not have a class attribute
SelfClosing                        // element is selfclosing and contains no content
Inline                             // element is an inline element (only for visible elements)
Field                              // element is a field of a form
Invisible                          // element doesn't render anything visible
WithoutEscaping                    // element does not escape inner Text
WithoutDecoration                  // element just prints the InnerHtml

see Add() and Set() methods for how to modify the Element

Example

create an element with a simple self defined tag 

t := NewElement(Tag("special"))
fmt.Println(t.HTML())

Output:

<special></special>
Example (MultipleFlags)

multiple flags may be passed with bitwise or | and as several parameters 

t := NewElement(Tag("input"), SelfClosing|Inline, FormField)
fmt.Println(t.HTML())

Output:

<input />
Example (Selfclosing)

a selfclosing tag can't have content 

t := NewElement(Tag("special"), SelfClosing)
fmt.Println(t.HTML())
if err := t.Add("will fail"); err != nil {
	fmt.Println("can't add to selfclosing element")
}

Output:

<special />
can't add to selfclosing element
Example (WithoutDecoration)

create an element that does not output it tags when printed 

doc := NewElement(Tag("doc"), WithoutDecoration)

layout := NewTemplate(doc)

body := NewElement(Tag("body"))
body.Add(ID("content"))

doc.Add(
	HTML("<!DOCTYPE html>"),
	body,
	HTML("</html>"))

layout.Assign("content", "in the body")
fmt.Println(layout)

Output:

<!DOCTYPE html><body id="content">in the body</body></html>

func (*Element) Add 

func (el *Element) Add(objects ...interface{}) (err error)

adds new inner content or properties based on Stringer objects and returns an error if changes could not be applied

the following types are handled in a special way:

  • Comment: sets the comment
  • Style: set a single style
  • Styles: sets multiple styles
  • Attr: set a single attribute // do not set id or class via Attr(s) directly, use Id() and Class() instead
  • Attrs: sets multiple attribute
  • Class: adds a class
  • ID: sets the id
  • *Css: applies the css, see ApplyCss()

the following types are added to the inner content:

  • Text: ís escaped if the WithoutEscaping flag isn't set
  • Html: is never escaped

If the Stringer can be casted to an Elementer (as Element can), it is added to the inner content as well otherwise it is handled like Text(), that means any type implementing Stringer can be added as (escaped) text

Example

html, text and elementer are added as inner content 

div := NewElement(Tag("div"))
span := NewElement(Tag("span"))
span.Add("hiho")

div.Add(
	HTML("<b>hello</b>"), // is not escaped
	Text("c > d"),        // is escaped
	span)                 // objects to tag constructors like Div(), Span(),... gets passed to Add()

fmt.Println(div.HTML())

Output:

<div><b>hello</b>c &gt; d<span>hiho</span></div>
Example (Properties)

add / set properties 

//	css := NewCss(Class("yellow"), Style("background-color", "yellow"))
d := NewElement(Tag("div"))
d.Add(Class("first"))

d.Add(
	ID("main"),
	Class("second"),
	//		css, // adds the class of the css to the element, multiple *Css can be given
	Comment("main row"),
	Attr("height", "200")) // multiple attributes at once with Attrs{"height", "200", "width", "300"}
//Style("width", "500px")) // multiple styles at once with Styles{"height", "200", "width", "300"}

//fmt.Printf("---CSS---%s---HTML---%s\n", css, d)

func (*Element) AddAfter 

func (el *Element) AddAfter(v *Element, nu Elementer) (err error)

adds Elementer at the position before the Element in the inner content the following elements are moved down

func (*Element) AddAtPosition 

func (el *Element) AddAtPosition(pos int, v Elementer) (err error)

adds Elementer to the inner content at position pos

func (*Element) AddBefore 

func (el *Element) AddBefore(v *Element, nu Elementer) (err error)

adds Elementer at the position before the Element in the inner content the following elements are moved down

func (*Element) AddClass 

func (el *Element) AddClass(classes ...Class) (err error)

use this func to add the classes of the tag, do not set it via Attr directly

func (*Element) All 

func (el *Element) All(m Matcher) (r []*Element)

filter by anything that fullfills the matcher interface, e.g. Class, Id, Attr, Attrs, Css, Tag, Style, Styles recursive finds all tags from the children

func (*Element) Any 

func (el *Element) Any(m Matcher) (r *Element)

filter by anything that fullfills the matcher interface, e.g. Class, Id, Attr, Attrs, Css, Tag, Style, Styles returns the first tag in the children and the subchildren that matches

func (*Element) AsTemplate 

func (el *Element) AsTemplate() *Template

func (*Element) Attribute 

func (el *Element) Attribute(k string) string

func (*Element) Attributes 

func (el *Element) Attributes() map[string]string

func (*Element) AttrsString 

func (el *Element) AttrsString() (res string)

prepare the id attribute for output

func (*Element) Children 

func (el *Element) Children() (c []*Element)

returns only children that are Elements, no Text or Html

func (*Element) Classes 

func (el *Element) Classes() (c []Class)

use this method to get the classes since they won't show up in attributes

func (*Element) Clear 

func (el *Element) Clear()

clears the inner elements and strings

func (*Element) Compile 

func (el *Element) Compile(name string) *CompiledTemplate

func (*Element) ContentType added in v0.0.4 

func (el *Element) ContentType() string

func (*Element) Dup added in v0.9.2 

func (e *Element) Dup() *Element

func (*Element) Fields 

func (el *Element) Fields() (fields []*Element)

returns the formfields

func (*Element) HTML added in v0.6.0 

func (el *Element) HTML() (res HTML)

returns the html with inner content (and the own tags if WithoutDecoration is not set)

func (*Element) HasClass 

func (el *Element) HasClass(class Class) bool

func (*Element) ID added in v0.6.0 

func (el *Element) ID() ID

use this method to get the id since it won't show up in attributes

func (*Element) IDPath added in v0.13.59 

func (el *Element) IDPath() (s string)

func (*Element) InnerHTML added in v0.6.0 

func (el *Element) InnerHTML() (res HTML)

func (*Element) Is 

func (el *Element) Is(f flag) bool

checks if a given flag is set, e.g. 

Is(Inline)

checks for the Inline flag

func (*Element) IsParentAllowed 

func (el *Element) IsParentAllowed(parent Tager) (allowed bool)

return false if the given Parent tag is not allowed for Elements tag

func (*Element) JsLiteral added in v0.13.66 

func (e *Element) JsLiteral(expr ...js.Expression) js.Raw

func (*Element) JsStatement added in v0.13.60 

func (el *Element) JsStatement() string

func (*Element) JsValue added in v0.13.60 

func (el *Element) JsValue() string

func (*Element) NotEscape 

func (el *Element) NotEscape() *Element

func (*Element) Parent 

func (el *Element) Parent() Pather

func (*Element) Path 

func (el *Element) Path() string

func (*Element) Position added in v0.7.0 

func (el *Element) Position(name string) *CompiledTemplate

func (*Element) PositionOf 

func (el *Element) PositionOf(v *Element) (pos int, found bool)

returns the position of the Element in the inner content. if it could not be found, the last parameter is false

func (*Element) ReadFrom added in v0.0.4 

func (el *Element) ReadFrom(rd io.Reader) error

keep it to fullfill the wc.Content interface

func (*Element) RemoveAttribute 

func (el *Element) RemoveAttribute(k string)

removes an attribute

func (*Element) RemoveClass 

func (el *Element) RemoveClass(class Class)

func (*Element) Selecter 

func (el *Element) Selecter(other ...Sel) Sel

func (*Element) Selector 

func (el *Element) Selector() string

func (*Element) SetAtPosition 

func (el *Element) SetAtPosition(pos int, v Elementer) (err error)

set the Elementer to the inner content at position pos and overwrite the current content at that position

func (*Element) SetAttribute 

func (el *Element) SetAttribute(k, v string)

sets the attribute k to v as long as k is not "id" or "class" use SetId() to set the id and AddClass() to add a class

func (*Element) SetAttributes 

func (el *Element) SetAttributes(a ...string)

func (*Element) SetBottom 

func (el *Element) SetBottom(v Elementer) (err error)

sets the Elementer to the last position of the inner content and overwrites the current content at that position

If you want to append to the inner content, use Add() instead

func (*Element) SetClass 

func (el *Element) SetClass(classes ...Class)

use this func to set the classes of the Element do not set them via Attr directly

func (*Element) SetContent 

func (el *Element) SetContent(objects ...interface{}) (err error)

clears the inner object array and then calls Add() method to add content

see Add() method for more details

func (*Element) SetID added in v0.6.0 

func (el *Element) SetID(id ID) (err error)

use this func to set the id of the Element, do not set it via Attr directly returns error if IdForbidden flag is set

func (*Element) SetParent 

func (el *Element) SetParent(parent Pather)

func (*Element) Tag 

func (el *Element) Tag() string

func (*Element) With added in v0.7.0 

func (el *Element) With(objects ...interface{}) *Element

With is like Add, but panics on errors and allows chaining

func (*Element) WithContent added in v0.9.2 

func (el *Element) WithContent(objects ...interface{}) *Element

WithContent is like SetContent, but panics on errors and allows chaining

func (*Element) WrapChildren 

func (el *Element) WrapChildren(wrapper *Element)

wraps the children with the given element

func (*Element) WriteTo 

func (el *Element) WriteTo(w io.Writer) error

type Elementer 

type Elementer interface {
	HTMLer
	Tager
	IsParentAllowed(Tager) bool
	SetParent(Pather)
}

an Elementer might be parent of an Element by implementing a type that fulfills this interface you might peek into the execution. when String() method is called, the html of the tree is built and when SetParent() it is embedded in another Elementer it could be combined with the Pather interface that allows you to modify specific css selectors for any children Elements

type FieldMatcher 

type FieldMatcher int

func (FieldMatcher) Matches 

func (f FieldMatcher) Matches(t *Element) (m bool)

type HTML added in v0.6.0 

type HTML string

func HTMLf added in v0.6.0 

func HTMLf(format string, i ...interface{}) HTML

func (HTML) ContentType added in v0.6.0 

func (s HTML) ContentType() string

func (HTML) HTML added in v0.6.0 

func (h HTML) HTML() HTML

func (HTML) JsLiteral added in v0.13.66 

func (h HTML) JsLiteral(expr ...js.Expression) js.Raw

func (HTML) Matches added in v0.6.0 

func (ht HTML) Matches(t *Element) bool

matching an html string, ignoring whitespace

func (HTML) Pos added in v0.13.42 

func (ht HTML) Pos() Pos

func (HTML) ReadFrom added in v0.6.0 

func (s HTML) ReadFrom(rd io.Reader) error

func (HTML) ServeHTTP added in v0.6.0 

func (s HTML) ServeHTTP(w http.ResponseWriter, r *http.Request)

func (HTML) String added in v0.6.0 

func (h HTML) String() string

func (HTML) WriteTo added in v0.6.0 

func (s HTML) WriteTo(w io.Writer) error

type HTMLer added in v0.6.0 

type HTMLer interface {
	HTML() HTML
}

type ID added in v0.6.0 

type ID string

func (ID) Elm added in v0.13.60 

func (me ID) Elm() js.Raw

func (ID) JsStatement added in v0.13.60 

func (i ID) JsStatement() string

func (ID) JsValue added in v0.13.60 

func (i ID) JsValue() string

func (ID) Matches added in v0.6.0 

func (i ID) Matches(t *Element) bool

func (ID) Pos added in v0.13.42 

func (i ID) Pos() Pos

func (ID) Selector added in v0.6.0 

func (i ID) Selector() string

func (ID) String added in v0.6.0 

func (i ID) String() string

type IDPather added in v0.13.59 

type IDPather interface {
	IDPath() string
}

type Matcher 

type Matcher interface {
	Matches(*Element) bool
}

something that matches an Element

type Pather 

type Pather interface {
	Path() string
}

type Pos added in v0.7.0 

type Pos interface {
	templ.Setter
	sql.Scanner
	Set(val any) Pos
	Setf(format string, val ...any) Pos
	String() string
	Type() any
}

type PositionMatcher 

type PositionMatcher struct {
	Element *Element
	Pos     int
	Found   bool
}

func (*PositionMatcher) Matches 

func (p *PositionMatcher) Matches(e *Element) (f bool)

type Scss 

type Scss string

func (Scss) String 

func (sc Scss) String() string

type Sel added in v0.13.53 

type Sel interface {
	Selector() string
	js.Any
}

func Context 

func Context(ctx Sel, inner1 Sel, inner ...Sel) (r Sel)

func ContextString 

func ContextString(ctx string, inner1 Sel, inner ...Sel) (r Sel)

func SelJoin added in v0.13.53 

func SelJoin(sel1 Sel, selects ...Sel) Sel

combine several selectors to one

type SelAdder added in v0.13.53 

type SelAdder interface {
	Sel
	Add(Sel) SelAdder
	Sel() Sel
	Embed(outer Sel) Sel
}

type SelString added in v0.13.53 

type SelString string

func (SelString) JsStatement added in v0.13.60 

func (sl SelString) JsStatement() string

func (SelString) JsValue added in v0.13.60 

func (sl SelString) JsValue() string

func (SelString) Selector added in v0.13.53 

func (sl SelString) Selector() string

type SingleAttr 

type SingleAttr struct {
	Key   string
	Value string
}

func (SingleAttr) And added in v0.13.66 

func (a SingleAttr) And(other SingleAttr) SingleAttr

func (SingleAttr) JsStatement added in v0.13.60 

func (i SingleAttr) JsStatement() string

func (SingleAttr) JsValue added in v0.13.60 

func (i SingleAttr) JsValue() string

func (SingleAttr) Matches 

func (at SingleAttr) Matches(t *Element) bool

func (SingleAttr) Pos added in v0.13.42 

func (at SingleAttr) Pos() Pos

func (SingleAttr) Selector added in v0.13.60 

func (a SingleAttr) Selector() string

func (SingleAttr) String 

func (a SingleAttr) String() string

type Styling added in v0.13.42 

type Styling [][2]string // map[string]string

func Style 

func Style(kvpairs ...string) Styling

func (*Styling) Add added in v0.13.60 

func (s *Styling) Add(kvpairs ...string)

func (*Styling) Append added in v0.13.42 

func (s *Styling) Append(sts ...Styling) Styling

func (Styling) CSS added in v0.13.42 

func (s Styling) CSS() string

func (Styling) Matches added in v0.13.42 

func (s Styling) Matches(e *Element) bool

func (Styling) Pos added in v0.13.42 

func (s Styling) Pos() Pos

func (*Styling) With added in v0.13.42 

func (s *Styling) With(kvpairs ...string) Styling

type Tag 

type Tag string

func (Tag) Matches 

func (t Tag) Matches(e *Element) bool

func (Tag) Pos added in v0.13.42 

func (t Tag) Pos() Pos

func (Tag) Selector 

func (t Tag) Selector() string

func (Tag) String 

func (t Tag) String() string

type Tager 

type Tager interface {
	Tag() string
}

type Templatable 

type Templatable interface {
	HTMLer
	Tag() string
	Path() string
	Any(m Matcher) (r *Element)
	Add(objects ...interface{}) (err error)
}

type Template 

type Template struct {
	Element Templatable //*Element
	// contains filtered or unexported fields
}

func NewTemplate 

func NewTemplate(t Templatable) *Template

creates a new template with the given element as root

func (*Template) Add 

func (t *Template) Add(objects ...interface{}) (err error)

func (*Template) AddCss 

func (t *Template) AddCss(css ...fmt.Stringer) (err error)

add css to the head of the template returns an error if Element is no doc or has no head child

func (*Template) Assign 

func (t *Template) Assign(id ID, html interface{}) (err error)

replaces the content of an child Element with the given id with Stringer e.g. 

t := NewTemplate(Body(Div(Id("content"))))
t.Assign("content", P(Text("here we go")))

results in <body><div id="content"><p>here we go</p></div></body>

func (*Template) Compile 

func (t *Template) Compile(name string) (c *CompiledTemplate, ſ error)

returns a *CompiledTemplate that is a template.Template (see github.com/metakeule/templ) the template can then be initialized with New and merged with positions with Replace and Merge if you need to change the original template again, you can get it via CompiledTemplate.ElementTemplate then call Compile() again to get a new CompiledTemplate

func (*Template) HTML added in v0.6.0 

func (t *Template) HTML() HTML

func (*Template) MustCompile 

func (t *Template) MustCompile(name string) *CompiledTemplate

panics on error

func (*Template) String 

func (t *Template) String() string

type Text 

type Text string

func Textf 

func Textf(format string, i ...interface{}) Text

func (Text) ContentType added in v0.0.9 

func (s Text) ContentType() string

func (Text) HTML added in v0.6.0 

func (t Text) HTML() HTML

func (Text) Pos added in v0.13.42 

func (tx Text) Pos() Pos

func (Text) ReadFrom added in v0.0.9 

func (s Text) ReadFrom(rd io.Reader) error

func (Text) ServeHTTP added in v0.0.9 

func (s Text) ServeHTTP(w http.ResponseWriter, r *http.Request)

func (Text) String 

func (t Text) String() string

func (Text) WriteTo added in v0.0.9 

func (s Text) WriteTo(w io.Writer) error

Source Files

View all Source files

Directories

Path Synopsis
css
example command
example
doctype command
template command
js
jq
sel
attmatch
pseudo
color
tag
short

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.