transition.go

     1  // Copyright 2011 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package template
     6  
     7  import (
     8  	"bytes"
     9  	"strings"
    10  )
    11  
    12  // transitionFunc is the array of context transition functions for text nodes.
    13  // A transition function takes a context and template text input, and returns
    14  // the updated context and the number of bytes consumed from the front of the
    15  // input.
    16  var transitionFunc = [...]func(context, []byte) (context, int){
    17  	stateText:           tText,
    18  	stateTag:            tTag,
    19  	stateAttrName:       tAttrName,
    20  	stateAfterName:      tAfterName,
    21  	stateBeforeValue:    tBeforeValue,
    22  	stateHTMLCmt:        tHTMLCmt,
    23  	stateRCDATA:         tSpecialTagEnd,
    24  	stateAttr:           tAttr,
    25  	stateURL:            tURL,
    26  	stateMetaContent:    tMetaContent,
    27  	stateMetaContentURL: tMetaContentURL,
    28  	stateSrcset:         tURL,
    29  	stateJS:             tJS,
    30  	stateJSDqStr:        tJSDelimited,
    31  	stateJSSqStr:        tJSDelimited,
    32  	stateJSRegexp:       tJSDelimited,
    33  	stateJSTmplLit:      tJSTmpl,
    34  	stateJSBlockCmt:     tBlockCmt,
    35  	stateJSLineCmt:      tLineCmt,
    36  	stateJSHTMLOpenCmt:  tLineCmt,
    37  	stateJSHTMLCloseCmt: tLineCmt,
    38  	stateCSS:            tCSS,
    39  	stateCSSDqStr:       tCSSStr,
    40  	stateCSSSqStr:       tCSSStr,
    41  	stateCSSDqURL:       tCSSStr,
    42  	stateCSSSqURL:       tCSSStr,
    43  	stateCSSURL:         tCSSStr,
    44  	stateCSSBlockCmt:    tBlockCmt,
    45  	stateCSSLineCmt:     tLineCmt,
    46  	stateError:          tError,
    47  }
    48  
    49  var commentStart = []byte("<!--")
    50  var commentEnd = []byte("-->")
    51  
    52  // tText is the context transition function for the text state.
    53  func tText(c context, s []byte) (context, int) {
    54  	k := 0
    55  	for {
    56  		i := k + bytes.IndexByte(s[k:], '<')
    57  		if i < k || i+1 == len(s) {
    58  			return c, len(s)
    59  		} else if i+4 <= len(s) && bytes.Equal(commentStart, s[i:i+4]) {
    60  			return context{state: stateHTMLCmt}, i + 4
    61  		}
    62  		i++
    63  		end := false
    64  		if s[i] == '/' {
    65  			if i+1 == len(s) {
    66  				return c, len(s)
    67  			}
    68  			end, i = true, i+1
    69  		}
    70  		j, e := eatTagName(s, i)
    71  		if j != i {
    72  			if end {
    73  				e = elementNone
    74  			}
    75  			// We've found an HTML tag.
    76  			return context{state: stateTag, element: e}, j
    77  		}
    78  		k = j
    79  	}
    80  }
    81  
    82  var elementContentType = [...]state{
    83  	elementNone:     stateText,
    84  	elementScript:   stateJS,
    85  	elementStyle:    stateCSS,
    86  	elementTextarea: stateRCDATA,
    87  	elementTitle:    stateRCDATA,
    88  	elementMeta:     stateText,
    89  }
    90  
    91  // tTag is the context transition function for the tag state.
    92  func tTag(c context, s []byte) (context, int) {
    93  	// Find the attribute name.
    94  	i := eatWhiteSpace(s, 0)
    95  	if i == len(s) {
    96  		return c, len(s)
    97  	}
    98  	if s[i] == '>' {
    99  		// Treat <meta> specially, because it doesn't have an end tag, and we
   100  		// want to transition into the correct state/element for it.
   101  		if c.element == elementMeta {
   102  			return context{state: stateText, element: elementNone}, i + 1
   103  		}
   104  		return context{
   105  			state:   elementContentType[c.element],
   106  			element: c.element,
   107  		}, i + 1
   108  	}
   109  	j, err := eatAttrName(s, i)
   110  	if err != nil {
   111  		return context{state: stateError, err: err}, len(s)
   112  	}
   113  	state, attr := stateTag, attrNone
   114  	if i == j {
   115  		return context{
   116  			state: stateError,
   117  			err:   errorf(ErrBadHTML, nil, 0, "expected space, attr name, or end of tag, but got %q", s[i:]),
   118  		}, len(s)
   119  	}
   120  
   121  	attrName := strings.ToLower(string(s[i:j]))
   122  	if c.element == elementScript && attrName == "type" {
   123  		attr = attrScriptType
   124  	} else if c.element == elementMeta && attrName == "content" {
   125  		attr = attrMetaContent
   126  	} else {
   127  		switch attrType(attrName) {
   128  		case contentTypeURL:
   129  			attr = attrURL
   130  		case contentTypeCSS:
   131  			attr = attrStyle
   132  		case contentTypeJS:
   133  			attr = attrScript
   134  		case contentTypeSrcset:
   135  			attr = attrSrcset
   136  		}
   137  	}
   138  
   139  	if j == len(s) {
   140  		state = stateAttrName
   141  	} else {
   142  		state = stateAfterName
   143  	}
   144  	return context{state: state, element: c.element, attr: attr}, j
   145  }
   146  
   147  // tAttrName is the context transition function for stateAttrName.
   148  func tAttrName(c context, s []byte) (context, int) {
   149  	i, err := eatAttrName(s, 0)
   150  	if err != nil {
   151  		return context{state: stateError, err: err}, len(s)
   152  	} else if i != len(s) {
   153  		c.state = stateAfterName
   154  	}
   155  	return c, i
   156  }
   157  
   158  // tAfterName is the context transition function for stateAfterName.
   159  func tAfterName(c context, s []byte) (context, int) {
   160  	// Look for the start of the value.
   161  	i := eatWhiteSpace(s, 0)
   162  	if i == len(s) {
   163  		return c, len(s)
   164  	} else if s[i] != '=' {
   165  		// Occurs due to tag ending '>', and valueless attribute.
   166  		c.state = stateTag
   167  		return c, i
   168  	}
   169  	c.state = stateBeforeValue
   170  	// Consume the "=".
   171  	return c, i + 1
   172  }
   173  
   174  var attrStartStates = [...]state{
   175  	attrNone:        stateAttr,
   176  	attrScript:      stateJS,
   177  	attrScriptType:  stateAttr,
   178  	attrStyle:       stateCSS,
   179  	attrURL:         stateURL,
   180  	attrSrcset:      stateSrcset,
   181  	attrMetaContent: stateMetaContent,
   182  }
   183  
   184  // tBeforeValue is the context transition function for stateBeforeValue.
   185  func tBeforeValue(c context, s []byte) (context, int) {
   186  	i := eatWhiteSpace(s, 0)
   187  	if i == len(s) {
   188  		return c, len(s)
   189  	}
   190  	// Find the attribute delimiter.
   191  	delim := delimSpaceOrTagEnd
   192  	switch s[i] {
   193  	case '\'':
   194  		delim, i = delimSingleQuote, i+1
   195  	case '"':
   196  		delim, i = delimDoubleQuote, i+1
   197  	}
   198  	c.state, c.delim = attrStartStates[c.attr], delim
   199  	return c, i
   200  }
   201  
   202  // tHTMLCmt is the context transition function for stateHTMLCmt.
   203  func tHTMLCmt(c context, s []byte) (context, int) {
   204  	if i := bytes.Index(s, commentEnd); i != -1 {
   205  		return context{}, i + 3
   206  	}
   207  	return c, len(s)
   208  }
   209  
   210  // specialTagEndMarkers maps element types to the character sequence that
   211  // case-insensitively signals the end of the special tag body.
   212  var specialTagEndMarkers = [...][]byte{
   213  	elementScript:   []byte("script"),
   214  	elementStyle:    []byte("style"),
   215  	elementTextarea: []byte("textarea"),
   216  	elementTitle:    []byte("title"),
   217  	elementMeta:     []byte(""),
   218  }
   219  
   220  var (
   221  	specialTagEndPrefix = []byte("</")
   222  	tagEndSeparators    = []byte("> \t\n\f/")
   223  )
   224  
   225  // tSpecialTagEnd is the context transition function for raw text and RCDATA
   226  // element states.
   227  func tSpecialTagEnd(c context, s []byte) (context, int) {
   228  	if c.element != elementNone {
   229  		// script end tags ("</script") within script literals are ignored, so that
   230  		// we can properly escape them.
   231  		if c.element == elementScript && (isInScriptLiteral(c.state) || isComment(c.state)) {
   232  			return c, len(s)
   233  		}
   234  		if i := indexTagEnd(s, specialTagEndMarkers[c.element]); i != -1 {
   235  			return context{}, i
   236  		}
   237  	}
   238  	return c, len(s)
   239  }
   240  
   241  // indexTagEnd finds the index of a special tag end in a case insensitive way, or returns -1
   242  func indexTagEnd(s []byte, tag []byte) int {
   243  	res := 0
   244  	plen := len(specialTagEndPrefix)
   245  	for len(s) > 0 {
   246  		// Try to find the tag end prefix first
   247  		i := bytes.Index(s, specialTagEndPrefix)
   248  		if i == -1 {
   249  			return i
   250  		}
   251  		s = s[i+plen:]
   252  		// Try to match the actual tag if there is still space for it
   253  		if len(tag) <= len(s) && bytes.EqualFold(tag, s[:len(tag)]) {
   254  			s = s[len(tag):]
   255  			// Check the tag is followed by a proper separator
   256  			if len(s) > 0 && bytes.IndexByte(tagEndSeparators, s[0]) != -1 {
   257  				return res + i
   258  			}
   259  			res += len(tag)
   260  		}
   261  		res += i + plen
   262  	}
   263  	return -1
   264  }
   265  
   266  // tAttr is the context transition function for the attribute state.
   267  func tAttr(c context, s []byte) (context, int) {
   268  	return c, len(s)
   269  }
   270  
   271  // tURL is the context transition function for the URL state.
   272  func tURL(c context, s []byte) (context, int) {
   273  	if bytes.ContainsAny(s, "#?") {
   274  		c.urlPart = urlPartQueryOrFrag
   275  	} else if len(s) != eatWhiteSpace(s, 0) && c.urlPart == urlPartNone {
   276  		// HTML5 uses "Valid URL potentially surrounded by spaces" for
   277  		// attrs: https://www.w3.org/TR/html5/index.html#attributes-1
   278  		c.urlPart = urlPartPreQuery
   279  	}
   280  	return c, len(s)
   281  }
   282  
   283  // tJS is the context transition function for the JS state.
   284  func tJS(c context, s []byte) (context, int) {
   285  	i := bytes.IndexAny(s, "\"`'/{}<-#")
   286  	if i == -1 {
   287  		// Entire input is non string, comment, regexp tokens.
   288  		c.jsCtx = nextJSCtx(s, c.jsCtx)
   289  		return c, len(s)
   290  	}
   291  	c.jsCtx = nextJSCtx(s[:i], c.jsCtx)
   292  	switch s[i] {
   293  	case '"':
   294  		c.state, c.jsCtx = stateJSDqStr, jsCtxRegexp
   295  	case '\'':
   296  		c.state, c.jsCtx = stateJSSqStr, jsCtxRegexp
   297  	case '`':
   298  		c.state, c.jsCtx = stateJSTmplLit, jsCtxRegexp
   299  	case '/':
   300  		switch {
   301  		case i+1 < len(s) && s[i+1] == '/':
   302  			c.state, i = stateJSLineCmt, i+1
   303  		case i+1 < len(s) && s[i+1] == '*':
   304  			c.state, i = stateJSBlockCmt, i+1
   305  		case c.jsCtx == jsCtxRegexp:
   306  			c.state = stateJSRegexp
   307  		case c.jsCtx == jsCtxDivOp:
   308  			c.jsCtx = jsCtxRegexp
   309  		default:
   310  			return context{
   311  				state: stateError,
   312  				err:   errorf(ErrSlashAmbig, nil, 0, "'/' could start a division or regexp: %.32q", s[i:]),
   313  			}, len(s)
   314  		}
   315  	// ECMAScript supports HTML style comments for legacy reasons, see Appendix
   316  	// B.1.1 "HTML-like Comments". The handling of these comments is somewhat
   317  	// confusing. Multi-line comments are not supported, i.e. anything on lines
   318  	// between the opening and closing tokens is not considered a comment, but
   319  	// anything following the opening or closing token, on the same line, is
   320  	// ignored. As such we simply treat any line prefixed with "<!--" or "-->"
   321  	// as if it were actually prefixed with "//" and move on.
   322  	case '<':
   323  		if i+3 < len(s) && bytes.Equal(commentStart, s[i:i+4]) {
   324  			c.state, i = stateJSHTMLOpenCmt, i+3
   325  		}
   326  	case '-':
   327  		if i+2 < len(s) && bytes.Equal(commentEnd, s[i:i+3]) {
   328  			c.state, i = stateJSHTMLCloseCmt, i+2
   329  		}
   330  	// ECMAScript also supports "hashbang" comment lines, see Section 12.5.
   331  	case '#':
   332  		if i+1 < len(s) && s[i+1] == '!' {
   333  			c.state, i = stateJSLineCmt, i+1
   334  			break
   335  		}
   336  		// A private identifier such as #yield is never a keyword, and
   337  		// precedes a div op.
   338  		for i+1 < len(s) && isJSIdentPart(rune(s[i+1])) {
   339  			i++
   340  		}
   341  		c.jsCtx = jsCtxDivOp
   342  	case '{':
   343  		// We only care about tracking brace depth if we are inside of a
   344  		// template literal.
   345  		if len(c.jsBraceDepth) == 0 {
   346  			c.jsCtx = nextJSCtx(s[i:i+1], c.jsCtx)
   347  			return c, i + 1
   348  		}
   349  		c.jsBraceDepth[len(c.jsBraceDepth)-1]++
   350  		c.jsCtx = nextJSCtx(s[i:i+1], c.jsCtx)
   351  	case '}':
   352  		if len(c.jsBraceDepth) == 0 {
   353  			c.jsCtx = nextJSCtx(s[i:i+1], c.jsCtx)
   354  			return c, i + 1
   355  		}
   356  		// There are no cases where a brace can be escaped in the JS context
   357  		// that are not syntax errors, it seems. Because of this we can just
   358  		// count "\}" as "}" and move on, the script is already broken as
   359  		// fully fledged parsers will just fail anyway.
   360  		c.jsBraceDepth[len(c.jsBraceDepth)-1]--
   361  		if c.jsBraceDepth[len(c.jsBraceDepth)-1] >= 0 {
   362  			c.jsCtx = nextJSCtx(s[i:i+1], c.jsCtx)
   363  			return c, i + 1
   364  		}
   365  		c.jsBraceDepth = c.jsBraceDepth[:len(c.jsBraceDepth)-1]
   366  		c.state = stateJSTmplLit
   367  	default:
   368  		panic("unreachable")
   369  	}
   370  	return c, i + 1
   371  }
   372  
   373  func tJSTmpl(c context, s []byte) (context, int) {
   374  	var k int
   375  	for {
   376  		i := k + bytes.IndexAny(s[k:], "`\\$")
   377  		if i < k {
   378  			break
   379  		}
   380  		switch s[i] {
   381  		case '\\':
   382  			i++
   383  			if i == len(s) {
   384  				return context{
   385  					state: stateError,
   386  					err:   errorf(ErrPartialEscape, nil, 0, "unfinished escape sequence in JS string: %q", s),
   387  				}, len(s)
   388  			}
   389  		case '$':
   390  			if len(s) >= i+2 && s[i+1] == '{' {
   391  				c.jsBraceDepth = append(c.jsBraceDepth, 0)
   392  				c.state, c.jsCtx = stateJS, jsCtxRegexp
   393  				return c, i + 2
   394  			}
   395  		case '`':
   396  			// end
   397  			c.state = stateJS
   398  			return c, i + 1
   399  		}
   400  		k = i + 1
   401  	}
   402  
   403  	return c, len(s)
   404  }
   405  
   406  // tJSDelimited is the context transition function for the JS string and regexp
   407  // states.
   408  func tJSDelimited(c context, s []byte) (context, int) {
   409  	specials := `\"`
   410  	switch c.state {
   411  	case stateJSSqStr:
   412  		specials = `\'`
   413  	case stateJSRegexp:
   414  		specials = `\/[]`
   415  	}
   416  
   417  	k, inCharset := 0, false
   418  	for {
   419  		i := k + bytes.IndexAny(s[k:], specials)
   420  		if i < k {
   421  			break
   422  		}
   423  		switch s[i] {
   424  		case '\\':
   425  			i++
   426  			if i == len(s) {
   427  				return context{
   428  					state: stateError,
   429  					err:   errorf(ErrPartialEscape, nil, 0, "unfinished escape sequence in JS string: %q", s),
   430  				}, len(s)
   431  			}
   432  		case '[':
   433  			inCharset = true
   434  		case ']':
   435  			inCharset = false
   436  		case '/':
   437  			// If "</script" appears in a regex literal, the '/' should not
   438  			// close the regex literal, and it will later be escaped to
   439  			// "\x3C/script" in escapeText.
   440  			if i > 0 && i+7 <= len(s) && bytes.EqualFold(s[i-1:i+7], []byte("</script")) {
   441  				i++
   442  			} else if !inCharset {
   443  				c.state, c.jsCtx = stateJS, jsCtxDivOp
   444  				return c, i + 1
   445  			}
   446  		default:
   447  			// end delimiter
   448  			if !inCharset {
   449  				c.state, c.jsCtx = stateJS, jsCtxDivOp
   450  				return c, i + 1
   451  			}
   452  		}
   453  		k = i + 1
   454  	}
   455  
   456  	if inCharset {
   457  		// This can be fixed by making context richer if interpolation
   458  		// into charsets is desired.
   459  		return context{
   460  			state: stateError,
   461  			err:   errorf(ErrPartialCharset, nil, 0, "unfinished JS regexp charset: %q", s),
   462  		}, len(s)
   463  	}
   464  
   465  	return c, len(s)
   466  }
   467  
   468  var blockCommentEnd = []byte("*/")
   469  
   470  // tBlockCmt is the context transition function for /*comment*/ states.
   471  func tBlockCmt(c context, s []byte) (context, int) {
   472  	i := bytes.Index(s, blockCommentEnd)
   473  	if i == -1 {
   474  		return c, len(s)
   475  	}
   476  	switch c.state {
   477  	case stateJSBlockCmt:
   478  		c.state = stateJS
   479  	case stateCSSBlockCmt:
   480  		c.state = stateCSS
   481  	default:
   482  		panic(c.state.String())
   483  	}
   484  	return c, i + 2
   485  }
   486  
   487  // tLineCmt is the context transition function for //comment states, and the JS HTML-like comment state.
   488  func tLineCmt(c context, s []byte) (context, int) {
   489  	var lineTerminators string
   490  	var endState state
   491  	switch c.state {
   492  	case stateJSLineCmt, stateJSHTMLOpenCmt, stateJSHTMLCloseCmt:
   493  		lineTerminators, endState = "\n\r\u2028\u2029", stateJS
   494  	case stateCSSLineCmt:
   495  		lineTerminators, endState = "\n\f\r", stateCSS
   496  		// Line comments are not part of any published CSS standard but
   497  		// are supported by the 4 major browsers.
   498  		// This defines line comments as
   499  		//     LINECOMMENT ::= "//" [^\n\f\d]*
   500  		// since https://www.w3.org/TR/css3-syntax/#SUBTOK-nl defines
   501  		// newlines:
   502  		//     nl ::= #xA | #xD #xA | #xD | #xC
   503  	default:
   504  		panic(c.state.String())
   505  	}
   506  
   507  	i := bytes.IndexAny(s, lineTerminators)
   508  	if i == -1 {
   509  		return c, len(s)
   510  	}
   511  	c.state = endState
   512  	// Per section 7.4 of EcmaScript 5 : https://es5.github.io/#x7.4
   513  	// "However, the LineTerminator at the end of the line is not
   514  	// considered to be part of the single-line comment; it is
   515  	// recognized separately by the lexical grammar and becomes part
   516  	// of the stream of input elements for the syntactic grammar."
   517  	return c, i
   518  }
   519  
   520  // tCSS is the context transition function for the CSS state.
   521  func tCSS(c context, s []byte) (context, int) {
   522  	// CSS quoted strings are almost never used except for:
   523  	// (1) URLs as in background: "/foo.png"
   524  	// (2) Multiword font-names as in font-family: "Times New Roman"
   525  	// (3) List separators in content values as in inline-lists:
   526  	//    <style>
   527  	//    ul.inlineList { list-style: none; padding:0 }
   528  	//    ul.inlineList > li { display: inline }
   529  	//    ul.inlineList > li:before { content: ", " }
   530  	//    ul.inlineList > li:first-child:before { content: "" }
   531  	//    </style>
   532  	//    <ul class=inlineList><li>One<li>Two<li>Three</ul>
   533  	// (4) Attribute value selectors as in a[href="http://example.com/"]
   534  	//
   535  	// We conservatively treat all strings as URLs, but make some
   536  	// allowances to avoid confusion.
   537  	//
   538  	// In (1), our conservative assumption is justified.
   539  	// In (2), valid font names do not contain ':', '?', or '#', so our
   540  	// conservative assumption is fine since we will never transition past
   541  	// urlPartPreQuery.
   542  	// In (3), our protocol heuristic should not be tripped, and there
   543  	// should not be non-space content after a '?' or '#', so as long as
   544  	// we only %-encode RFC 3986 reserved characters we are ok.
   545  	// In (4), we should URL escape for URL attributes, and for others we
   546  	// have the attribute name available if our conservative assumption
   547  	// proves problematic for real code.
   548  
   549  	k := 0
   550  	for {
   551  		i := k + bytes.IndexAny(s[k:], `("'/`)
   552  		if i < k {
   553  			return c, len(s)
   554  		}
   555  		switch s[i] {
   556  		case '(':
   557  			// Look for url to the left.
   558  			p := bytes.TrimRight(s[:i], "\t\n\f\r ")
   559  			if endsWithCSSKeyword(p, "url") {
   560  				j := len(s) - len(bytes.TrimLeft(s[i+1:], "\t\n\f\r "))
   561  				switch {
   562  				case j != len(s) && s[j] == '"':
   563  					c.state, j = stateCSSDqURL, j+1
   564  				case j != len(s) && s[j] == '\'':
   565  					c.state, j = stateCSSSqURL, j+1
   566  				default:
   567  					c.state = stateCSSURL
   568  				}
   569  				return c, j
   570  			}
   571  		case '/':
   572  			if i+1 < len(s) {
   573  				switch s[i+1] {
   574  				case '/':
   575  					c.state = stateCSSLineCmt
   576  					return c, i + 2
   577  				case '*':
   578  					c.state = stateCSSBlockCmt
   579  					return c, i + 2
   580  				}
   581  			}
   582  		case '"':
   583  			c.state = stateCSSDqStr
   584  			return c, i + 1
   585  		case '\'':
   586  			c.state = stateCSSSqStr
   587  			return c, i + 1
   588  		}
   589  		k = i + 1
   590  	}
   591  }
   592  
   593  // tCSSStr is the context transition function for the CSS string and URL states.
   594  func tCSSStr(c context, s []byte) (context, int) {
   595  	var endAndEsc string
   596  	switch c.state {
   597  	case stateCSSDqStr, stateCSSDqURL:
   598  		endAndEsc = `\"`
   599  	case stateCSSSqStr, stateCSSSqURL:
   600  		endAndEsc = `\'`
   601  	case stateCSSURL:
   602  		// Unquoted URLs end with a newline or close parenthesis.
   603  		// The below includes the wc (whitespace character) and nl.
   604  		endAndEsc = "\\\t\n\f\r )"
   605  	default:
   606  		panic(c.state.String())
   607  	}
   608  
   609  	k := 0
   610  	for {
   611  		i := k + bytes.IndexAny(s[k:], endAndEsc)
   612  		if i < k {
   613  			c, nread := tURL(c, decodeCSS(s[k:]))
   614  			return c, k + nread
   615  		}
   616  		if s[i] == '\\' {
   617  			i++
   618  			if i == len(s) {
   619  				return context{
   620  					state: stateError,
   621  					err:   errorf(ErrPartialEscape, nil, 0, "unfinished escape sequence in CSS string: %q", s),
   622  				}, len(s)
   623  			}
   624  		} else {
   625  			c.state = stateCSS
   626  			return c, i + 1
   627  		}
   628  		c, _ = tURL(c, decodeCSS(s[:i+1]))
   629  		k = i + 1
   630  	}
   631  }
   632  
   633  // tError is the context transition function for the error state.
   634  func tError(c context, s []byte) (context, int) {
   635  	return c, len(s)
   636  }
   637  
   638  // tMetaContent is the context transition function for the meta content attribute state.
   639  func tMetaContent(c context, s []byte) (context, int) {
   640  	for i := range len(s) {
   641  		if i+3 <= len(s)-1 && bytes.EqualFold(s[i:i+3], []byte("url")) {
   642  			if j := eatWhiteSpace(s, i+3); j < len(s) && s[j] == '=' {
   643  				c.state = stateMetaContentURL
   644  				return c, j + 1
   645  			}
   646  		}
   647  	}
   648  	return c, len(s)
   649  }
   650  
   651  // tMetaContentURL is the context transition function for the "url=" part of a meta content attribute state.
   652  func tMetaContentURL(c context, s []byte) (context, int) {
   653  	for i := range len(s) {
   654  		if s[i] == ';' {
   655  			c.state = stateMetaContent
   656  			return c, i + 1
   657  		}
   658  	}
   659  	return c, len(s)
   660  }
   661  
   662  // eatAttrName returns the largest j such that s[i:j] is an attribute name.
   663  // It returns an error if s[i:] does not look like it begins with an
   664  // attribute name, such as encountering a quote mark without a preceding
   665  // equals sign.
   666  func eatAttrName(s []byte, i int) (int, *Error) {
   667  	for j := i; j < len(s); j++ {
   668  		switch s[j] {
   669  		case ' ', '\t', '\n', '\f', '\r', '=', '>':
   670  			return j, nil
   671  		case '\'', '"', '<':
   672  			// These result in a parse warning in HTML5 and are
   673  			// indicative of serious problems if seen in an attr
   674  			// name in a template.
   675  			return -1, errorf(ErrBadHTML, nil, 0, "%q in attribute name: %.32q", s[j:j+1], s)
   676  		default:
   677  			// No-op.
   678  		}
   679  	}
   680  	return len(s), nil
   681  }
   682  
   683  var elementNameMap = map[string]element{
   684  	"script":   elementScript,
   685  	"style":    elementStyle,
   686  	"textarea": elementTextarea,
   687  	"title":    elementTitle,
   688  	"meta":     elementMeta,
   689  }
   690  
   691  // asciiAlpha reports whether c is an ASCII letter.
   692  func asciiAlpha(c byte) bool {
   693  	return 'A' <= c && c <= 'Z' || 'a' <= c && c <= 'z'
   694  }
   695  
   696  // asciiAlphaNum reports whether c is an ASCII letter or digit.
   697  func asciiAlphaNum(c byte) bool {
   698  	return asciiAlpha(c) || '0' <= c && c <= '9'
   699  }
   700  
   701  // eatTagName returns the largest j such that s[i:j] is a tag name and the tag type.
   702  func eatTagName(s []byte, i int) (int, element) {
   703  	if i == len(s) || !asciiAlpha(s[i]) {
   704  		return i, elementNone
   705  	}
   706  	j := i + 1
   707  	for j < len(s) {
   708  		x := s[j]
   709  		if asciiAlphaNum(x) {
   710  			j++
   711  			continue
   712  		}
   713  		// Allow "x-y" or "x:y" but not "x-", "-y", or "x--y".
   714  		if (x == ':' || x == '-') && j+1 < len(s) && asciiAlphaNum(s[j+1]) {
   715  			j += 2
   716  			continue
   717  		}
   718  		break
   719  	}
   720  	return j, elementNameMap[strings.ToLower(string(s[i:j]))]
   721  }
   722  
   723  // eatWhiteSpace returns the largest j such that s[i:j] is white space.
   724  func eatWhiteSpace(s []byte, i int) int {
   725  	for j := i; j < len(s); j++ {
   726  		switch s[j] {
   727  		case ' ', '\t', '\n', '\f', '\r':
   728  			// No-op.
   729  		default:
   730  			return j
   731  		}
   732  	}
   733  	return len(s)
   734  }
   735
View as plain text