// Copyright 2011 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package template

import (

// context describes the state an HTML parser must be in when it reaches the
// portion of HTML produced by evaluating a particular template node.
// The zero value of type context is the start context for a template that
// produces an HTML fragment as defined at
// https://www.w3.org/TR/html5/syntax.html#the-end
// where the context element is null.
type context struct {
	state   state
	delim   delim
	urlPart urlPart
	jsCtx   jsCtx
	attr    attr
	element element
	err     *Error

func ( context) () string {
	var  error
	if .err != nil {
		 = .err
	return fmt.Sprintf("{%v %v %v %v %v %v %v}", .state, .delim, .urlPart, .jsCtx, .attr, .element, )

// eq reports whether two contexts are equal.
func ( context) ( context) bool {
	return .state == .state &&
		.delim == .delim &&
		.urlPart == .urlPart &&
		.jsCtx == .jsCtx &&
		.attr == .attr &&
		.element == .element &&
		.err == .err

// mangle produces an identifier that includes a suffix that distinguishes it
// from template names mangled with different contexts.
func ( context) ( string) string {
	// The mangled name for the default context is the input templateName.
	if .state == stateText {
	 :=  + "$htmltemplate_" + .state.String()
	if .delim != delimNone {
		 += "_" + .delim.String()
	if .urlPart != urlPartNone {
		 += "_" + .urlPart.String()
	if .jsCtx != jsCtxRegexp {
		 += "_" + .jsCtx.String()
	if .attr != attrNone {
		 += "_" + .attr.String()
	if .element != elementNone {
		 += "_" + .element.String()

// state describes a high-level HTML parser state.
// It bounds the top of the element stack, and by extension the HTML insertion
// mode, but also contains state that does not correspond to anything in the
// HTML5 parsing algorithm because a single token production in the HTML
// grammar may contain embedded actions in a template. For instance, the quoted
// HTML attribute produced by
//     <div title="Hello {{.World}}">
// is a single token in HTML's grammar but in a template spans several nodes.
type state uint8

//go:generate stringer -type state

const (
	// stateText is parsed character data. An HTML parser is in
	// this state when its parse position is outside an HTML tag,
	// directive, comment, and special element body.
	stateText state = iota
	// stateTag occurs before an HTML attribute or the end of a tag.
	// stateAttrName occurs inside an attribute name.
	// It occurs between the ^'s in ` ^name^ = value`.
	// stateAfterName occurs after an attr name has ended but before any
	// equals sign. It occurs between the ^'s in ` name^ ^= value`.
	// stateBeforeValue occurs after the equals sign but before the value.
	// It occurs between the ^'s in ` name =^ ^value`.
	// stateHTMLCmt occurs inside an <!-- HTML comment -->.
	// stateRCDATA occurs inside an RCDATA element (<textarea> or <title>)
	// as described at https://www.w3.org/TR/html5/syntax.html#elements-0
	// stateAttr occurs inside an HTML attribute whose content is text.
	// stateURL occurs inside an HTML attribute whose content is a URL.
	// stateSrcset occurs inside an HTML srcset attribute.
	// stateJS occurs inside an event handler or script element.
	// stateJSDqStr occurs inside a JavaScript double quoted string.
	// stateJSSqStr occurs inside a JavaScript single quoted string.
	// stateJSRegexp occurs inside a JavaScript regexp literal.
	// stateJSBlockCmt occurs inside a JavaScript /* block comment */.
	// stateJSLineCmt occurs inside a JavaScript // line comment.
	// stateCSS occurs inside a <style> element or style attribute.
	// stateCSSDqStr occurs inside a CSS double quoted string.
	// stateCSSSqStr occurs inside a CSS single quoted string.
	// stateCSSDqURL occurs inside a CSS double quoted url("...").
	// stateCSSSqURL occurs inside a CSS single quoted url('...').
	// stateCSSURL occurs inside a CSS unquoted url(...).
	// stateCSSBlockCmt occurs inside a CSS /* block comment */.
	// stateCSSLineCmt occurs inside a CSS // line comment.
	// stateError is an infectious error state outside any valid
	// HTML/CSS/JS construct.

// isComment is true for any state that contains content meant for template
// authors & maintainers, not for end-users or machines.
func isComment( state) bool {
	switch  {
	case stateHTMLCmt, stateJSBlockCmt, stateJSLineCmt, stateCSSBlockCmt, stateCSSLineCmt:
		return true
	return false

// isInTag return whether s occurs solely inside an HTML tag.
func isInTag( state) bool {
	switch  {
	case stateTag, stateAttrName, stateAfterName, stateBeforeValue, stateAttr:
		return true
	return false

// delim is the delimiter that will end the current HTML attribute.
type delim uint8

//go:generate stringer -type delim

const (
	// delimNone occurs outside any attribute.
	delimNone delim = iota
	// delimDoubleQuote occurs when a double quote (") closes the attribute.
	// delimSingleQuote occurs when a single quote (') closes the attribute.
	// delimSpaceOrTagEnd occurs when a space or right angle bracket (>)
	// closes the attribute.

// urlPart identifies a part in an RFC 3986 hierarchical URL to allow different
// encoding strategies.
type urlPart uint8

//go:generate stringer -type urlPart

const (
	// urlPartNone occurs when not in a URL, or possibly at the start:
	// ^ in "^http://auth/path?k=v#frag".
	urlPartNone urlPart = iota
	// urlPartPreQuery occurs in the scheme, authority, or path; between the
	// ^s in "h^ttp://auth/path^?k=v#frag".
	// urlPartQueryOrFrag occurs in the query portion between the ^s in
	// "http://auth/path?^k=v#frag^".
	// urlPartUnknown occurs due to joining of contexts both before and
	// after the query separator.

// jsCtx determines whether a '/' starts a regular expression literal or a
// division operator.
type jsCtx uint8

//go:generate stringer -type jsCtx

const (
	// jsCtxRegexp occurs where a '/' would start a regexp literal.
	jsCtxRegexp jsCtx = iota
	// jsCtxDivOp occurs where a '/' would start a division operator.
	// jsCtxUnknown occurs where a '/' is ambiguous due to context joining.

// element identifies the HTML element when inside a start tag or special body.
// Certain HTML element (for example <script> and <style>) have bodies that are
// treated differently from stateText so the element type is necessary to
// transition into the correct context at the end of a tag and to identify the
// end delimiter for the body.
type element uint8

//go:generate stringer -type element

const (
	// elementNone occurs outside a special tag or special element body.
	elementNone element = iota
	// elementScript corresponds to the raw text <script> element
	// with JS MIME type or no type attribute.
	// elementStyle corresponds to the raw text <style> element.
	// elementTextarea corresponds to the RCDATA <textarea> element.
	// elementTitle corresponds to the RCDATA <title> element.

//go:generate stringer -type attr

// attr identifies the current HTML attribute when inside the attribute,
// that is, starting from stateAttrName until stateTag/stateText (exclusive).
type attr uint8

const (
	// attrNone corresponds to a normal attribute or no attribute.
	attrNone attr = iota
	// attrScript corresponds to an event handler attribute.
	// attrScriptType corresponds to the type attribute in script HTML element
	// attrStyle corresponds to the style attribute whose value is CSS.
	// attrURL corresponds to an attribute whose value is a URL.
	// attrSrcset corresponds to a srcset attribute.