if e := equivEscapers[b]; e != "" {
		s = append(s, "html_template_htmlescaper")
// escapeTree escapes the named template starting in the given context as
		for k, v := range e1.actionNodeEdits {
//     `<a href=x`
func nudge(c context) context {
			return context{
				b.WriteByte(' ')
	"html_template_cssescaper": {
	"html_template_cssescaper":      cssEscaper,
var funcMap = template.FuncMap{
}
	"html_template_commentescaper":  commentEscaper,
		s = append(s, "html_template_cssvaluefilter")
	if i == len(s) {
				state: stateError,
			// Preserve the portion between written and the comment start.
		map[*parse.TemplateNode]string{},
	"bytes"
				if id.Ident == "noescape" {
	}
		// A local variable assignment, not an interpolation.

// escapeListConditionally escapes a list node but only preserves edits and

// escapeAction escapes an action template node.
// For example, if p is (.X | html) and s is ["escapeJSVal", "html"] then it
				err:   errorf(ErrBadHTML, 0, "%q in unquoted attr: %q", s[j:j+1], s[:i]),
		last, ok := cmds[n-1].Args[0].(*parse.IdentifierNode)
		for u := []byte(html.UnescapeString(string(s))); len(u) != 0; {
		}
			}, len(s)
	}
	return e.computeOutCtx(c, t), dname
}
		if eq(s, t) {
func newIdentCmd(identifier string) *parse.CommandNode {
var doctypeBytes = []byte("<!DOCTYPE")
		for k, v := range e1.templateNodeEdits {
// newEscaper creates a blank escaper for the given set.
		NodeType: parse.NodeCommand,
	switch c.state {
		} else {
	return e.escapeListConditionally(c, t.Tree.Root, filter)
	c = a
				return
	e.textNodeEdits[n] = text
}
			written = i1
				}
	//   div.innerHTML = "<span title=x" + String.fromCharCode(i) + "-bar>";
	case *parse.IfNode:
	"html"
	"html_template_jsvalescaper":    jsValEscaper,
		newCmds = appendCmd(newCmds, id)
					b.WriteString("&lt;")
	}
func newEscaper(t *Template) *escaper {
		// Look for a fixed point by assuming c1 as the output context.
	p.Cmds = newCmds
		if cmd := p.Cmds[i]; len(cmd.Args) != 0 {
	n := len(p.Cmds)
		"html_template_attrescaper": true,
			err, c.err.Name = c.err, name
					b.WriteByte(' ')
	"html_template_jsregexpescaper": {
}
	if _, ok := e.actionNodeEdits[n]; ok {
	actionNodeEdits   map[*parse.ActionNode][]string
			c0.err.Line = n.Line
	"html_template_commentescaper": {
	"html_template_attrescaper":    "html",
var redundantFuncs = map[string]map[string]bool{
}
		}
	case delimSpaceOrTagEnd:
func (e *escaper) escapeListConditionally(c context, n *parse.ListNode, filter func(*escaper, context) bool) (context, bool) {
		map[string]bool{},
		if err != nil {
func (e *escaper) editActionNode(n *parse.ActionNode, cmds []string) {
		return context{
		// c1 is accurate if it matches our assumed output context.
			end := i1
		return c
		}
			c1, i1 := transitionFunc[c.state](c, u)
		}
					t.text.Tree = nil
			e.editTextNode(k, v)
	},
// the identifiers in s in order.
	c := a
	}
// escapeText escapes a text template node.
func (e *escaper) editTextNode(n *parse.TextNode, text []byte) {
		panic(fmt.Sprintf("node %s shared between templates", n))
	}
}
	e1 := newEscaper(e.tmpl)
		return c
	s := make([]string, 0, 3)
		// The "true" branch of a "range" node can execute multiple times.
	// On exiting an attribute, we discard all state information
	}
			}
// inferences in e if the inferences and output context satisfy filter.

		if e := join(c, d, line, nodeName); e.state != stateError {
	copy(newCmds, p.Cmds)
			e.derived[dname] = dt
	}
// join joins the two contexts of a branch template node. The result is an

		// In `<foo bar={{.}}`, the action is an undelimited value.
		if escFnsEq(s[dups], (id.Args[0].(*parse.IdentifierNode)).Ident) {
	}
		return e.escapeList(c, n)
	// ends in an unquoted value state even though the else branch
	//   if (div.getElementsByTagName("SPAN")[0].title.indexOf("bar") < 0)
// all templates that might be Executed but need not include helper
	}
	"html_template_urlfilter":       urlFilter,
		e.editTextNode(n, b.Bytes())
			return i
		if i == i1 && c.state == c1.state {
	e.editActionNode(n, s)
		// "<a id= onclick=f("     ends inside id's or onclick's value,

	// for (var i = 0; i < 0x10000; ++i) {
		tmpl.escaped = true
			e.derived[k] = v
			}
	return c
	}
		err:   errorf(ErrBranchEnd, line, "{{%s}} branches end in different contexts: %v, %v", nodeName, a, b),
		return out, dname
		c1, _ := e.escapeListConditionally(c0, n.List, nil)
}
	}
	case *parse.TemplateNode:
}
	for _, name := range names {
}

	"html_template_urlescaper": {
		return e.escapeBranch(c, &n.BranchNode, "range")
	return &escaper{
	if a.eq(b) {
		c.state, c.delim, c.attr = attrStartStates[c.attr], delimSpaceOrTagEnd, attrNone
	"html_template_nospaceescaper":  htmlNospaceEscaper,
		return e.escapeTemplate(c, n)
		// Already escaped.
		} else if isComment(c.state) && c.delim == delimNone {
		}
		return c
	return c
		}
		s = append(s, "html_template_jsregexpescaper")
		c.jsCtx = jsCtxUnknown
		"html_template_nospaceescaper": true,
func join(a, b context, line int, nodeName string) context {
			err: errorf(ErrOutputContext, 0, "cannot compute output context for template %s", t.Name()),
		state: stateError,
// error context if either of the input contexts are error contexts, or if the
		// The contexts differ only by jsCtx.
				err:   errorf(ErrNoSuchTemplate, line, "%q is an incomplete or empty template", name),
func (e *escaper) editTemplateNode(n *parse.TemplateNode, callee string) {

			return context{
	for n, name := range e.templateNodeEdits {
		}
// It returns the best guess at an output context, and the result of the filter
	}
		// as executing n.List twice.
// If the pipeline already has some of the sanitizers, do not interfere.
// unusable.
		case urlPartNone:
			}

				if t := tmpl.set[name]; t != nil {
	if b.state == stateError {
		s = append(s, "html_template_nospaceescaper")
		}
		idents = p.Cmds[i+1:]
	"html_template_urlnormalizer":  "urlquery",
	return append(cmds, cmd)
	}
			cs := i1 - 2
func (e *escaper) escapeTemplate(c context, n *parse.TemplateNode) context {
	"html_template_urlescaper":     "urlquery",
	if e := equivEscapers[a]; e != "" {
	"html_template_urlnormalizer":   urlNormalizer,
			}
	case stateBeforeValue:
	if len(s) == 0 {
		// Use c1 as the error context if neither assumption worked.
			// If t is not recursively called, then c1 is an
				// http://es5.github.com/#x7.4:
// the input contexts differ.
	for n, s := range e.textNodeEdits {
	if t == nil {

				}
	// output[templateName] is the output context for a templateName that
	return c
			}
	// named name templateName for the start context c.
func escFnsEq(a, b string) bool {
	}
)

			s = s[i+1:]
// escapeTemplates rewrites the named templates, which must be

		// Two cases: The template exists but is empty, or has never been mentioned at
		if c.err != nil {
}
		}
package template
	}
		s = append(s, "html_template_jsvalescaper")
		if _, err := e.tmpl.text.AddParseTree(t.Name(), t.Tree); err != nil {
	}
			if c1.state != c.state {
		case urlPartUnknown:
func (e *escaper) escapeBranch(c context, n *parse.BranchNode, nodeName string) context {
		c1, i := tSpecialTagEnd(c, s)
		t,
	case *parse.ListNode:
			// Do not update the input escaper, e.
		i1 := i + nread
				// contains a line terminator character, then
// it is distinct enough that a developer can find the source of the problem
			for _, name := range s[:i] {
		n.Name = name
	}
			s = append(s, "html_template_urlfilter")
	}
	switch c.delim {
	"html_template_urlescaper":      urlEscaper,
	textNodeEdits     map[*parse.TextNode][]byte
		}
		// without having to entity decode token boundaries.
		// In `<foo {{.}}`, the action should emit an attribute.
				} else {
	newCmds := make([]*parse.CommandNode, n-len(idents), n+len(s)-dups)
			b.Write(n.Text[written:])

// escapeTemplate escapes a {{template}} call node.
	}
// templates is properly escaped.  Names should include the names of


	dups := 0
		// Consume any quote.
type escaper struct {
		// A slash after a value starts a div operator.
	return c, ok
	return a == b
			for _, name := range names {
		// "<a style=font:'Arial'" needs open-quote fixup.
	"html_template_jsstrescaper":    jsStrEscaper,
	}
// appendCmd appends the given command to the end of the command pipeline
		if j := bytes.IndexAny(s[:i], "\"'<=`"); j >= 0 {
	}
		return e.escapeBranch(c, &n.BranchNode, "with")
			return c0
		dt := e.template(dname)

	"html_template_attrescaper":     attrEscaper,
	i := bytes.IndexAny(s, delimEnds[c.delim])
func escapeTemplates(tmpl *Template, names ...string) error {
	switch n := n.(type) {
func (e *escaper) commit() {
		"html_template_attrescaper":    true,
}
		Args:     []parse.Node{parse.NewIdentifier(identifier)},
	return context{state: stateTag, element: c.element}, i
		if c.state != c1.state && isComment(c1.state) && c1.delim == delimNone {
			// all content preceding it has been consumed.
		}
// assumption was correct.
	case *parse.WithNode:
		if !isComment(c.state) || c.delim != delimNone {
				if bytes.IndexAny(s[written:i1], "\n\r\u2028\u2029") != -1 {
		//     <button onclick="alert(&quot;Hi!&quot;)">
			if c1.state == stateHTMLCmt {
// indexOfStr is the first i such that eq(s, strs[i]) or -1 if s was not found.

		return e.escapeBranch(c, &n.BranchNode, "if")
	case stateAfterName:
func appendCmd(cmds []*parse.CommandNode, cmd *parse.CommandNode) []*parse.CommandNode {
		newCmds = appendCmd(newCmds, newIdentCmd(name))
	}
	"html_template_htmlescaper":    "html",
	if t == nil {
	c, name := e.escapeTree(c, n.Name, n.Line)
	// identifier.
// escFnsEq returns whether the two escaping functions are equivalent.
		}
	"html_template_htmlescaper":     htmlEscaper,
// funcMap maps command names to functions that render their inputs safe.
		"html_template_htmlescaper":    true,
	}
		return c
}
			state: stateError,
		// Remain inside the attribute.
	case *parse.RangeNode:
		"html_template_urlnormalizer": true,
	"html_template_nospaceescaper": "html",
	for k, v := range e.output {
			if dups == len(s) {
			c0.err.Description = "on range loop re-entry: " + c0.err.Description
		return c.eq(c1)
	s, written, i, b := n.Text, 0, 0, new(bytes.Buffer)
			c1, ok = c2, true
		if i != -1 {
		n.Text = s
func indexOfStr(s string, strs []string, eq func(a, b string) bool) int {
	e.actionNodeEdits[n] = cmds
			panic("error adding derived template")
func (e *escaper) escapeAction(c context, n *parse.ActionNode) context {
	}
// editTemplateNode records a change to a {{template}} callee for later commit.
		s = append(s, "html_template_jsstrescaper")
}
		default:
	switch c.state {
		// all. Distinguish the cases in the error messages.
		return e.escapeText(c, n)
	case stateAttr:
		if ok && redundantFuncs[last.Ident][next.Ident] {
				err:   errorf(ErrAmbigContext, n.Line, "%s appears in an ambiguous URL context", n),
		for k, v := range e1.called {
			s = append(s, "html_template_urlescaper")
	case stateJS:
		}
// In this case, nudging produces the context after (1) happens.
	t := e.tmpl.text.Lookup(name)
		} else if c.state != stateText {
		if c2, ok2 := e.escapeTemplateBody(c1, t); ok2 {
	// has been mangled to include its input context.

	}
	}
		i = len(s)
					b.Write(s[written:j])
			// TODO: Find the first node with a line in t.text.Tree.Root

	case *parse.TextNode:
		}, dname
	if written != 0 && c.state != stateError {
			dt = template.New(dname)
		s = append(s, "html_template_rcdataescaper")
	panic("escaping " + n.String() + " is unimplemented")
		// Copy inferences and edits from e1 back into e.
			// Make clear that this is a problem on loop re-entry
	// take the fast path out of escapeTree instead of infinitely recursing.
				continue
// escapeBranch escapes a branch template node: "if", "range" and "with".
		// with different top level templates, or clone if necessary.

// been modified.  Otherwise the named templates have been rendered
		}
import (
	if i == -1 {
	}


	// Determined empirically by running the below in various browsers.
	//   <p title={{if .C}}{{.}}{{end}}
	e.templateNodeEdits[n] = callee
	if _, ok := e.textNodeEdits[n]; ok {
func (e *escaper) template(name string) *template.Template {
}
	// derived[c.mangle(name)] maps to a template derived from the template
// license that can be found in the LICENSE file.
// template returns the named template given a mangled template name.
		switch c.urlPart {

				// "<!--" instead of "/*" or "//"
		if c1.state == stateError {
			}, dname
		c.jsCtx = jsCtxDivOp
		}
			dups++
	// Mangle the template name with the input context to produce a reliable
// (.X | escapeJSVal | html).
		}
	// works >90% of the time.
				newCmds = appendCmd(newCmds, newIdentCmd(name))
	case stateText:
// Use of this source code is governed by a BSD-style
	delimDoubleQuote: `"`,
		map[*parse.TextNode][]byte{},
	for _, id := range idents {
			switch c.state {
				}
var delimEnds = [...]string{
// escapeTemplateBody escapes the given template assuming the given output
	if c.delim == delimNone {
			}
				// discarded except that, if a MultiLineComment
}
		// "<a class=`foo "        ends inside a value,
	// var div = document.createElement("DIV");

	"html_template_cssvaluefilter":  cssValueFilter,
		// Consider all content up to any end tag.
	if out, ok := e.output[dname]; ok {
	for i != len(s) {
			panic(fmt.Sprintf("infinite loop from %v to %v on %q..%q", c, c1, s[:i], s[i:]))

				for j := end - 1; j >= i; j-- {
	}
// associated with t, to guarantee that the output of any of the named
	}
	// Make type inferences available to f.
		map[string]context{},

		// Handled below in delim check.
	for i, t := range strs {
func (e *escaper) escapeTemplateBody(c context, t *template.Template) (context, bool) {
	e.commit()
	// This means that
	},
	filter := func(e1 *escaper, c1 context) bool {
	return &parse.CommandNode{
	},
	"html_template_jsstrescaper": {
				}
			}
	//     document.write("<p>U+" + i.toString(16));
	// called[templateName] is a set of called mangled template names.
	derived map[string]*template.Template
		}
		}
			default:
}
		return e.escapeAction(c, n)
// s, then returns the context after those tokens and the unprocessed suffix.
				// the entire comment is considered to be a
		}
		// In `<foo bar {{.}}`, the action is an attribute name.
		c.state = stateAttrName
	"html_template_htmlnamefilter":  htmlNameFilter,
			return true
	c = nudge(c)

	case delimNone:
			return err
			return false
	case stateRCDATA:
// Copyright 2011 The Go Authors. All rights reserved.
				state: stateError,
	}
				}
		e.template(name).Funcs(funcMap)
		t = e.derived[name]
		}
		"html_template_attrescaper": true,
	// except the state and element.
}
				// "Comments behave like white space and are
		b = e

	}
}
}
		// IE treats '`' as a quotation character.
	// Allow a nudged context to join with an unnudged one.
// via a search engine.
			fallthrough
	output map[string]context
		return transitionFunc[c.state](c, s[:i])
// newIdentCmd produces a command containing a single identifier node.
}
// context while storing any inferences in e.
	case stateJSDqStr, stateJSSqStr:
// filterFailsafe is an innocuous word that is emitted in place of unsafe values
	idents := p.Cmds
						break
			return e
			}
				state: stateError,
	return c
	for i := n - 1; i >= 0; i-- {
		}
	if len(n.Pipe.Decl) != 0 {
	e := newEscaper(tmpl)
	templateNodeEdits map[*parse.TemplateNode]string
	dname := c.mangle(name)
	default:
}
		next, _ := cmd.Args[0].(*parse.IdentifierNode)
// escaper collects type inferences about templates and changes needed to make
	"text/template"
				// LineTerminator for purposes of parsing by
// transitions from the input context.
// will end in context{stateBeforeValue, attrURL}, but parsing one extra rune:
	}
		}
// will end in context{stateURL, delimSpaceOrTagEnd, ...}.
	}
	return c1
	}
	"fmt"
			c, u = c1, u[i1:]
		c.urlPart = urlPartUnknown
func (e *escaper) escapeTree(c context, name string, line int) (context, string) {
		s = append(s, "html_template_attrescaper")
	// }
// escapeList escapes a list template node.

		return c
// contextAfterText starts in context c, consumes some tokens from the front of
	}
		if c.state == stateText || c.state == stateRCDATA {
			e.called[k] = v
	}
	}
					written = j + 1
		return a
		c.state = stateAttrName
	if c.eq(b) {
				if s[j] == '<' && !bytes.HasPrefix(bytes.ToUpper(s[j:]), doctypeBytes) {

// necessary and returns its output context.
	case stateCSS:
		return b
			case stateJSBlockCmt:
			e.editActionNode(k, v)
		return a
			// since developers tend to overlook that branch when

func ensurePipelineContains(p *parse.PipeNode, s []string) {
		// lists the runes below as error characters.
		panic(fmt.Sprintf("node %s shared between templates", n))
// unless it is redundant with the last command.
					if s[j] == '<' {
	// ends in stateBeforeValue.
		s = append(s, "html_template_htmlnamefilter")
var equivEscapers = map[string]string{
const filterFailsafe = "ZgotmplZ"
	"html_template_rcdataescaper":  "html",
				s = append(s, "html_template_cssescaper")
		if i == 0 {
	}
			e.output[k] = v
			err:   errorf(ErrNoSuchTemplate, line, "no such template %q", name),
		if !e1.called[t.Name()] {
	// We need to assume an output context so that recursive template calls
	"text/template/parse"
// There are two transitions that happen when the 'x' is seen:
	}
	case stateAttrName, stateTag:
		e.editTemplateNode(n, name)
	},

			// accurate output context.
	}
	return -1
			written = i1

	}
func (e *escaper) escape(c context, n parse.Node) context {
	c0 := e.escapeList(c, n.List)
		// Use any template derived during an earlier call to escapeTemplate
			b.Write(s[written:cs])
func (e *escaper) escapeList(c context, n *parse.ListNode) context {

	t := e.template(name)
}
// nudge returns the context that would result from following empty string
// context, and returns the best guess at the output context and whether the
			}
// templates injection safe.

	for name := range e.output {
	c.jsCtx = b.jsCtx
	if _, ok := e.templateNodeEdits[n]; ok {
		"html_template_attrescaper": true,
func contextAfterText(c context, s []byte) (context, int) {
	if c, d := nudge(a), nudge(b); !(c.eq(a) && d.eq(b)) {
		c, i = c1, i1
					return
func (e *escaper) computeOutCtx(c context, t *template.Template) context {
		return c, len(s)
		c = e.escape(c, m)
			if id, ok := cmd.Args[0].(*parse.IdentifierNode); ok {
}
// has one matching, "html", and one to insert, "escapeJSVal", to produce
// commit applies changes to actions and template calls needed to contextually
			state: stateError,
			err = &Error{ErrEndContext, name, 0, fmt.Sprintf("ends in a non-text context: %v", c)}
	e.output[t.Name()] = c
			s = append(s, "html_template_commentescaper")
	c1, ok := e.escapeTemplateBody(c, t)
	}
	if c.delim != delimSpaceOrTagEnd {
	if nodeName == "range" && c0.state != stateError {
			// debugging templates.
// which is the same as whether e was updated.
	for _, name := range s {
	ok := filter != nil && filter(e1, c)
	for n, s := range e.actionNodeEdits {
	called map[string]bool
	if !ok && c1.state != stateError {
		}
		// No extra-escaping needed for raw text content.
	for _, m := range n.Nodes {
		}
	}
		for k, v := range e1.textNodeEdits {
	// xxxNodeEdits are the accumulated edits to apply during commit.
	return nil
// computeOutCtx takes a template and its start context and computes the output
	}
	case stateTag:
		// http://www.w3.org/TR/html5/tokenization.html#attribute-value-unquoted-state
// editTextNode records a change to a text node for later commit.
// For example, parsing:
}
	if c.eq(b) {
			// Prevent execution of unsafe templates.
	// executes a given template in different escaping contexts.
// contains no special characters, is not empty, and when it appears in output
	// Find the identifiers at the end of the command chain.
// ensurePipelineContains ensures that the pipeline has commands with
		}
	tmpl *Template
	c.urlPart = b.urlPart
	}
		// The contexts differ only by urlPart.
	case stateJSRegexp:
	}
			panic("unexpected state " + c.state.String())
					}
				cs -= 2
		ensurePipelineContains(n.Pipe, s)
		}
	if !ok {
	c1 := e.escapeList(c, n.ElseList)
		if dt == nil {
	if n := len(cmds); n != 0 {
		map[*parse.ActionNode][]string{},
	if a.state == stateError {
// (2) Consume 'x' and transition past the first value character.

// equivEscapers matches contextual escapers to equivalent template builtins.
			switch c.state {
	for _, t := range e.derived {
			case stateCSSBlockCmt:
	// Merge existing identifier commands with the sanitizers needed.
	}

//     `<a href=`
		// Decode the value so non-HTML rules can easily handle
	return t
		for k, v := range e1.derived {
	delimSingleQuote: "'",
			panic(c.urlPart.String())
	"html_template_rcdataescaper":   rcdataEscaper,
	}

}
// templates.  If no error is returned, then the named templates have
	case stateURL, stateCSSDqStr, stateCSSSqStr, stateCSSDqURL, stateCSSSqURL, stateCSSURL:
		case urlPartPreQuery:
		var err error
	return context{
// editActionNode records a change to an action pipeline for later commit.
		if isComment(c.state) {
	for _, id := range idents {
			e.editTemplateNode(k, v)
		if c0.state == stateError {

					b.WriteByte('\n')
		panic(fmt.Sprintf("node %s shared between templates", n))
	"html_template_jsregexpescaper": jsRegexpEscaper,
		for k, v := range e1.output {
			return cmds
}
	if n == nil {
	if dname != name {
	c = e1.escapeList(c, n)
	default:
				// the syntactic grammar."
}
// (1) Transition from a before-value state to a start-of-value state without
			return context{
		case urlPartQueryOrFrag:
}
			return c1, 0
// escape escapes a template node.
		c1, nread := contextAfterText(c, s[i:])
		// We check that executing n.List once results in the same context
		e1.output[k] = v
	if c.delim == delimSpaceOrTagEnd {
			}
	},
		}

// redundantFuncs[a][b] implies that funcMap[b](funcMap[a](x)) == funcMap[a](x)
						end = j
		c0 = join(c0, c1, n.Line, nodeName)
	// Naively assuming that the input context is the same as the output
			for j := i; j < end; j++ {
// delimEnds maps each delim to a string of characters that terminate it.
		i++
}
// for all x.
		t = dt
		a = e
		i := indexOfStr((id.Args[0].(*parse.IdentifierNode)).Ident, s, escFnsEq)
	// Such edits are not applied immediately in case a template set
	}
				s = append(s, "html_template_urlnormalizer")
	// Create any remaining sanitizers.
		c, _ := e.escapeTree(context{}, name, 0)
	case *parse.ActionNode:
	}
		}
			// A special end tag (`</script>`) has been seen and
// autoescape content and adds any derived templates to the set.
		}
		if e.tmpl.set[name] != nil {
		map[string]*template.Template{},
	case stateError:
			dt.Tree = &parse.Tree{Name: dname, Root: t.Root.CopyList()}
	// Propagate context over the body.
// by sanitizer functions. It is not a keyword in any programming language,
		return context{
		c.state, c.attr = stateAttrName, attrNone
	if name != n.Name {
		}
	return c
func (e *escaper) escapeText(c context, n *parse.TextNode) context {
		return
}
			case stateCSSDqStr, stateCSSSqStr:
		// Error out because HTML parsers may differ on whether
		}
	}
	delimSpaceOrTagEnd: " \t\n\f\r>",
	}
	e.called[dname] = true
	return join(c0, c1, n.Line, nodeName)
	if ok {

//     consuming any character.