Source file src/encoding/xml/xml.go

     1  // Copyright 2009 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 xml implements a simple XML 1.0 parser that
     6  // understands XML name spaces.
     7  package xml
     8  
     9  // References:
    10  //    Annotated XML spec: https://www.xml.com/axml/testaxml.htm
    11  //    XML name spaces: https://www.w3.org/TR/REC-xml-names/
    12  
    13  import (
    14  	"bufio"
    15  	"bytes"
    16  	"errors"
    17  	"fmt"
    18  	"io"
    19  	"strconv"
    20  	"strings"
    21  	"unicode"
    22  	"unicode/utf8"
    23  )
    24  
    25  // A SyntaxError represents a syntax error in the XML input stream.
    26  type SyntaxError struct {
    27  	Msg  string
    28  	Line int
    29  }
    30  
    31  func (e *SyntaxError) Error() string {
    32  	return "XML syntax error on line " + strconv.Itoa(e.Line) + ": " + e.Msg
    33  }
    34  
    35  // A Name represents an XML name (Local) annotated
    36  // with a name space identifier (Space).
    37  // In tokens returned by [Decoder.Token], the Space identifier
    38  // is given as a canonical URL, not the short prefix used
    39  // in the document being parsed.
    40  type Name struct {
    41  	Space, Local string
    42  }
    43  
    44  // An Attr represents an attribute in an XML element (Name=Value).
    45  type Attr struct {
    46  	Name  Name
    47  	Value string
    48  }
    49  
    50  // A Token is an interface holding one of the token types:
    51  // [StartElement], [EndElement], [CharData], [Comment], [ProcInst], or [Directive].
    52  type Token any
    53  
    54  // A StartElement represents an XML start element.
    55  type StartElement struct {
    56  	Name Name
    57  	Attr []Attr
    58  }
    59  
    60  // Copy creates a new copy of StartElement.
    61  func (e StartElement) Copy() StartElement {
    62  	attrs := make([]Attr, len(e.Attr))
    63  	copy(attrs, e.Attr)
    64  	e.Attr = attrs
    65  	return e
    66  }
    67  
    68  // End returns the corresponding XML end element.
    69  func (e StartElement) End() EndElement {
    70  	return EndElement{e.Name}
    71  }
    72  
    73  // An EndElement represents an XML end element.
    74  type EndElement struct {
    75  	Name Name
    76  }
    77  
    78  // A CharData represents XML character data (raw text),
    79  // in which XML escape sequences have been replaced by
    80  // the characters they represent.
    81  type CharData []byte
    82  
    83  // Copy creates a new copy of CharData.
    84  func (c CharData) Copy() CharData { return CharData(bytes.Clone(c)) }
    85  
    86  // A Comment represents an XML comment of the form <!--comment-->.
    87  // The bytes do not include the <!-- and --> comment markers.
    88  type Comment []byte
    89  
    90  // Copy creates a new copy of Comment.
    91  func (c Comment) Copy() Comment { return Comment(bytes.Clone(c)) }
    92  
    93  // A ProcInst represents an XML processing instruction of the form <?target inst?>
    94  type ProcInst struct {
    95  	Target string
    96  	Inst   []byte
    97  }
    98  
    99  // Copy creates a new copy of ProcInst.
   100  func (p ProcInst) Copy() ProcInst {
   101  	p.Inst = bytes.Clone(p.Inst)
   102  	return p
   103  }
   104  
   105  // A Directive represents an XML directive of the form <!text>.
   106  // The bytes do not include the <! and > markers.
   107  type Directive []byte
   108  
   109  // Copy creates a new copy of Directive.
   110  func (d Directive) Copy() Directive { return Directive(bytes.Clone(d)) }
   111  
   112  // CopyToken returns a copy of a Token.
   113  func CopyToken(t Token) Token {
   114  	switch v := t.(type) {
   115  	case CharData:
   116  		return v.Copy()
   117  	case Comment:
   118  		return v.Copy()
   119  	case Directive:
   120  		return v.Copy()
   121  	case ProcInst:
   122  		return v.Copy()
   123  	case StartElement:
   124  		return v.Copy()
   125  	}
   126  	return t
   127  }
   128  
   129  // A TokenReader is anything that can decode a stream of XML tokens, including a
   130  // [Decoder].
   131  //
   132  // When Token encounters an error or end-of-file condition after successfully
   133  // reading a token, it returns the token. It may return the (non-nil) error from
   134  // the same call or return the error (and a nil token) from a subsequent call.
   135  // An instance of this general case is that a TokenReader returning a non-nil
   136  // token at the end of the token stream may return either io.EOF or a nil error.
   137  // The next Read should return nil, [io.EOF].
   138  //
   139  // Implementations of Token are discouraged from returning a nil token with a
   140  // nil error. Callers should treat a return of nil, nil as indicating that
   141  // nothing happened; in particular it does not indicate EOF.
   142  type TokenReader interface {
   143  	Token() (Token, error)
   144  }
   145  
   146  // A Decoder represents an XML parser reading a particular input stream.
   147  // The parser assumes that its input is encoded in UTF-8.
   148  type Decoder struct {
   149  	// Strict defaults to true, enforcing the requirements
   150  	// of the XML specification.
   151  	// If set to false, the parser allows input containing common
   152  	// mistakes:
   153  	//	* If an element is missing an end tag, the parser invents
   154  	//	  end tags as necessary to keep the return values from Token
   155  	//	  properly balanced.
   156  	//	* In attribute values and character data, unknown or malformed
   157  	//	  character entities (sequences beginning with &) are left alone.
   158  	//
   159  	// Setting:
   160  	//
   161  	//	d.Strict = false
   162  	//	d.AutoClose = xml.HTMLAutoClose
   163  	//	d.Entity = xml.HTMLEntity
   164  	//
   165  	// creates a parser that can handle typical HTML.
   166  	//
   167  	// Strict mode does not enforce the requirements of the XML name spaces TR.
   168  	// In particular it does not reject name space tags using undefined prefixes.
   169  	// Such tags are recorded with the unknown prefix as the name space URL.
   170  	Strict bool
   171  
   172  	// When Strict == false, AutoClose indicates a set of elements to
   173  	// consider closed immediately after they are opened, regardless
   174  	// of whether an end element is present.
   175  	AutoClose []string
   176  
   177  	// Entity can be used to map non-standard entity names to string replacements.
   178  	// The parser behaves as if these standard mappings are present in the map,
   179  	// regardless of the actual map content:
   180  	//
   181  	//	"lt": "<",
   182  	//	"gt": ">",
   183  	//	"amp": "&",
   184  	//	"apos": "'",
   185  	//	"quot": `"`,
   186  	Entity map[string]string
   187  
   188  	// CharsetReader, if non-nil, defines a function to generate
   189  	// charset-conversion readers, converting from the provided
   190  	// non-UTF-8 charset into UTF-8. If CharsetReader is nil or
   191  	// returns an error, parsing stops with an error. One of the
   192  	// CharsetReader's result values must be non-nil.
   193  	CharsetReader func(charset string, input io.Reader) (io.Reader, error)
   194  
   195  	// DefaultSpace sets the default name space used for unadorned tags,
   196  	// as if the entire XML stream were wrapped in an element containing
   197  	// the attribute xmlns="DefaultSpace".
   198  	DefaultSpace string
   199  
   200  	r              io.ByteReader
   201  	t              TokenReader
   202  	buf            bytes.Buffer
   203  	saved          *bytes.Buffer
   204  	stk            *stack
   205  	stkDepth       int
   206  	free           *stack
   207  	needClose      bool
   208  	toClose        Name
   209  	nextToken      Token
   210  	nextByte       int
   211  	ns             map[string]string
   212  	err            error
   213  	line           int
   214  	linestart      int64
   215  	offset         int64
   216  	inUnmarshalXML bool
   217  }
   218  
   219  // NewDecoder creates a new XML parser reading from r.
   220  // If r does not implement [io.ByteReader], NewDecoder will
   221  // do its own buffering.
   222  func NewDecoder(r io.Reader) *Decoder {
   223  	d := &Decoder{
   224  		ns:       make(map[string]string),
   225  		nextByte: -1,
   226  		line:     1,
   227  		Strict:   true,
   228  	}
   229  	d.switchToReader(r)
   230  	return d
   231  }
   232  
   233  // NewTokenDecoder creates a new XML parser using an underlying token stream.
   234  func NewTokenDecoder(t TokenReader) *Decoder {
   235  	// Is it already a Decoder?
   236  	if d, ok := t.(*Decoder); ok {
   237  		return d
   238  	}
   239  	d := &Decoder{
   240  		ns:       make(map[string]string),
   241  		t:        t,
   242  		nextByte: -1,
   243  		line:     1,
   244  		Strict:   true,
   245  	}
   246  	return d
   247  }
   248  
   249  // Token returns the next XML token in the input stream.
   250  // At the end of the input stream, Token returns nil, [io.EOF].
   251  //
   252  // Slices of bytes in the returned token data refer to the
   253  // parser's internal buffer and remain valid only until the next
   254  // call to Token. To acquire a copy of the bytes, call [CopyToken]
   255  // or the token's Copy method.
   256  //
   257  // Token expands self-closing elements such as <br>
   258  // into separate start and end elements returned by successive calls.
   259  //
   260  // Token guarantees that the [StartElement] and [EndElement]
   261  // tokens it returns are properly nested and matched:
   262  // if Token encounters an unexpected end element
   263  // or EOF before all expected end elements,
   264  // it will return an error.
   265  //
   266  // If [Decoder.CharsetReader] is called and returns an error,
   267  // the error is wrapped and returned.
   268  //
   269  // Token implements XML name spaces as described by
   270  // https://www.w3.org/TR/REC-xml-names/. Each of the
   271  // [Name] structures contained in the Token has the Space
   272  // set to the URL identifying its name space when known.
   273  // If Token encounters an unrecognized name space prefix,
   274  // it uses the prefix as the Space rather than report an error.
   275  func (d *Decoder) Token() (Token, error) {
   276  	var t Token
   277  	var err error
   278  	if d.stk != nil && d.stk.kind == stkEOF {
   279  		return nil, io.EOF
   280  	}
   281  	if d.nextToken != nil {
   282  		t = d.nextToken
   283  		d.nextToken = nil
   284  	} else {
   285  		if t, err = d.rawToken(); t == nil && err != nil {
   286  			if err == io.EOF && d.stk != nil && d.stk.kind != stkEOF {
   287  				err = d.syntaxError("unexpected EOF")
   288  			}
   289  			return nil, err
   290  		}
   291  		// We still have a token to process, so clear any
   292  		// errors (e.g. EOF) and proceed.
   293  		err = nil
   294  	}
   295  	if !d.Strict {
   296  		if t1, ok := d.autoClose(t); ok {
   297  			d.nextToken = t
   298  			t = t1
   299  		}
   300  	}
   301  	switch t1 := t.(type) {
   302  	case StartElement:
   303  		// In XML name spaces, the translations listed in the
   304  		// attributes apply to the element name and
   305  		// to the other attribute names, so process
   306  		// the translations first.
   307  		for _, a := range t1.Attr {
   308  			if a.Name.Space == xmlnsPrefix {
   309  				v, ok := d.ns[a.Name.Local]
   310  				d.pushNs(a.Name.Local, v, ok)
   311  				d.ns[a.Name.Local] = a.Value
   312  			}
   313  			if a.Name.Space == "" && a.Name.Local == xmlnsPrefix {
   314  				// Default space for untagged names
   315  				v, ok := d.ns[""]
   316  				d.pushNs("", v, ok)
   317  				d.ns[""] = a.Value
   318  			}
   319  		}
   320  
   321  		d.pushElement(t1.Name)
   322  		d.translate(&t1.Name, true)
   323  		for i := range t1.Attr {
   324  			d.translate(&t1.Attr[i].Name, false)
   325  		}
   326  		t = t1
   327  
   328  	case EndElement:
   329  		if !d.popElement(&t1) {
   330  			return nil, d.err
   331  		}
   332  		t = t1
   333  	}
   334  	return t, err
   335  }
   336  
   337  const (
   338  	xmlURL      = "http://www.w3.org/XML/1998/namespace"
   339  	xmlnsPrefix = "xmlns"
   340  	xmlPrefix   = "xml"
   341  )
   342  
   343  // Apply name space translation to name n.
   344  // The default name space (for Space=="")
   345  // applies only to element names, not to attribute names.
   346  func (d *Decoder) translate(n *Name, isElementName bool) {
   347  	switch {
   348  	case n.Space == xmlnsPrefix:
   349  		return
   350  	case n.Space == "" && !isElementName:
   351  		return
   352  	case n.Space == xmlPrefix:
   353  		n.Space = xmlURL
   354  	case n.Space == "" && n.Local == xmlnsPrefix:
   355  		return
   356  	}
   357  	if v, ok := d.ns[n.Space]; ok {
   358  		n.Space = v
   359  	} else if n.Space == "" {
   360  		n.Space = d.DefaultSpace
   361  	}
   362  }
   363  
   364  func (d *Decoder) switchToReader(r io.Reader) {
   365  	// Get efficient byte at a time reader.
   366  	// Assume that if reader has its own
   367  	// ReadByte, it's efficient enough.
   368  	// Otherwise, use bufio.
   369  	if rb, ok := r.(io.ByteReader); ok {
   370  		d.r = rb
   371  	} else {
   372  		d.r = bufio.NewReader(r)
   373  	}
   374  }
   375  
   376  // Parsing state - stack holds old name space translations
   377  // and the current set of open elements. The translations to pop when
   378  // ending a given tag are *below* it on the stack, which is
   379  // more work but forced on us by XML.
   380  type stack struct {
   381  	next *stack
   382  	kind int
   383  	name Name
   384  	ok   bool
   385  }
   386  
   387  const (
   388  	stkStart = iota
   389  	stkNs
   390  	stkEOF
   391  )
   392  
   393  func (d *Decoder) push(kind int) *stack {
   394  	s := d.free
   395  	if s != nil {
   396  		d.free = s.next
   397  	} else {
   398  		s = new(stack)
   399  	}
   400  	s.next = d.stk
   401  	s.kind = kind
   402  	if kind == stkStart {
   403  		d.stkDepth++
   404  	}
   405  	d.stk = s
   406  	return s
   407  }
   408  
   409  func (d *Decoder) pop() *stack {
   410  	s := d.stk
   411  	if s != nil {
   412  		if s.kind == stkStart {
   413  			d.stkDepth--
   414  		}
   415  		d.stk = s.next
   416  		s.next = d.free
   417  		d.free = s
   418  	}
   419  	return s
   420  }
   421  
   422  // Record that after the current element is finished
   423  // (that element is already pushed on the stack)
   424  // Token should return EOF until popEOF is called.
   425  func (d *Decoder) pushEOF() {
   426  	// Walk down stack to find Start.
   427  	// It might not be the top, because there might be stkNs
   428  	// entries above it.
   429  	start := d.stk
   430  	for start.kind != stkStart {
   431  		start = start.next
   432  	}
   433  	// The stkNs entries below a start are associated with that
   434  	// element too; skip over them.
   435  	for start.next != nil && start.next.kind == stkNs {
   436  		start = start.next
   437  	}
   438  	s := d.free
   439  	if s != nil {
   440  		d.free = s.next
   441  	} else {
   442  		s = new(stack)
   443  	}
   444  	s.kind = stkEOF
   445  	s.next = start.next
   446  	start.next = s
   447  }
   448  
   449  // Undo a pushEOF.
   450  // The element must have been finished, so the EOF should be at the top of the stack.
   451  func (d *Decoder) popEOF() bool {
   452  	if d.stk == nil || d.stk.kind != stkEOF {
   453  		return false
   454  	}
   455  	d.pop()
   456  	return true
   457  }
   458  
   459  // Record that we are starting an element with the given name.
   460  func (d *Decoder) pushElement(name Name) {
   461  	s := d.push(stkStart)
   462  	s.name = name
   463  }
   464  
   465  // Record that we are changing the value of ns[local].
   466  // The old value is url, ok.
   467  func (d *Decoder) pushNs(local string, url string, ok bool) {
   468  	s := d.push(stkNs)
   469  	s.name.Local = local
   470  	s.name.Space = url
   471  	s.ok = ok
   472  }
   473  
   474  // Creates a SyntaxError with the current line number.
   475  func (d *Decoder) syntaxError(msg string) error {
   476  	return &SyntaxError{Msg: msg, Line: d.line}
   477  }
   478  
   479  // Record that we are ending an element with the given name.
   480  // The name must match the record at the top of the stack,
   481  // which must be a pushElement record.
   482  // After popping the element, apply any undo records from
   483  // the stack to restore the name translations that existed
   484  // before we saw this element.
   485  func (d *Decoder) popElement(t *EndElement) bool {
   486  	s := d.pop()
   487  	name := t.Name
   488  	switch {
   489  	case s == nil || s.kind != stkStart:
   490  		d.err = d.syntaxError("unexpected end element </" + name.Local + ">")
   491  		return false
   492  	case s.name.Local != name.Local:
   493  		if !d.Strict {
   494  			d.needClose = true
   495  			d.toClose = t.Name
   496  			t.Name = s.name
   497  			return true
   498  		}
   499  		d.err = d.syntaxError("element <" + s.name.Local + "> closed by </" + name.Local + ">")
   500  		return false
   501  	case s.name.Space != name.Space:
   502  		ns := name.Space
   503  		if name.Space == "" {
   504  			ns = `""`
   505  		}
   506  		d.err = d.syntaxError("element <" + s.name.Local + "> in space " + s.name.Space +
   507  			" closed by </" + name.Local + "> in space " + ns)
   508  		return false
   509  	}
   510  
   511  	d.translate(&t.Name, true)
   512  
   513  	// Pop stack until a Start or EOF is on the top, undoing the
   514  	// translations that were associated with the element we just closed.
   515  	for d.stk != nil && d.stk.kind != stkStart && d.stk.kind != stkEOF {
   516  		s := d.pop()
   517  		if s.ok {
   518  			d.ns[s.name.Local] = s.name.Space
   519  		} else {
   520  			delete(d.ns, s.name.Local)
   521  		}
   522  	}
   523  
   524  	return true
   525  }
   526  
   527  // If the top element on the stack is autoclosing and
   528  // t is not the end tag, invent the end tag.
   529  func (d *Decoder) autoClose(t Token) (Token, bool) {
   530  	if d.stk == nil || d.stk.kind != stkStart {
   531  		return nil, false
   532  	}
   533  	for _, s := range d.AutoClose {
   534  		if strings.EqualFold(s, d.stk.name.Local) {
   535  			// This one should be auto closed if t doesn't close it.
   536  			et, ok := t.(EndElement)
   537  			if !ok || !strings.EqualFold(et.Name.Local, d.stk.name.Local) {
   538  				return EndElement{d.stk.name}, true
   539  			}
   540  			break
   541  		}
   542  	}
   543  	return nil, false
   544  }
   545  
   546  var errRawToken = errors.New("xml: cannot use RawToken from UnmarshalXML method")
   547  
   548  // RawToken is like [Decoder.Token] but does not verify that
   549  // start and end elements match and does not translate
   550  // name space prefixes to their corresponding URLs.
   551  func (d *Decoder) RawToken() (Token, error) {
   552  	if d.inUnmarshalXML {
   553  		return nil, errRawToken
   554  	}
   555  	return d.rawToken()
   556  }
   557  
   558  func (d *Decoder) rawToken() (Token, error) {
   559  	if d.t != nil {
   560  		return d.t.Token()
   561  	}
   562  	if d.err != nil {
   563  		return nil, d.err
   564  	}
   565  	if d.needClose {
   566  		// The last element we read was self-closing and
   567  		// we returned just the StartElement half.
   568  		// Return the EndElement half now.
   569  		d.needClose = false
   570  		return EndElement{d.toClose}, nil
   571  	}
   572  
   573  	b, ok := d.getc()
   574  	if !ok {
   575  		return nil, d.err
   576  	}
   577  
   578  	if b != '<' {
   579  		// Text section.
   580  		d.ungetc(b)
   581  		data := d.text(-1, false)
   582  		if data == nil {
   583  			return nil, d.err
   584  		}
   585  		return CharData(data), nil
   586  	}
   587  
   588  	if b, ok = d.mustgetc(); !ok {
   589  		return nil, d.err
   590  	}
   591  	switch b {
   592  	case '/':
   593  		// </: End element
   594  		var name Name
   595  		if name, ok = d.nsname(); !ok {
   596  			if d.err == nil {
   597  				d.err = d.syntaxError("expected element name after </")
   598  			}
   599  			return nil, d.err
   600  		}
   601  		d.space()
   602  		if b, ok = d.mustgetc(); !ok {
   603  			return nil, d.err
   604  		}
   605  		if b != '>' {
   606  			d.err = d.syntaxError("invalid characters between </" + name.Local + " and >")
   607  			return nil, d.err
   608  		}
   609  		return EndElement{name}, nil
   610  
   611  	case '?':
   612  		// <?: Processing instruction.
   613  		var target string
   614  		if target, ok = d.name(); !ok {
   615  			if d.err == nil {
   616  				d.err = d.syntaxError("expected target name after <?")
   617  			}
   618  			return nil, d.err
   619  		}
   620  		d.space()
   621  		d.buf.Reset()
   622  		var b0 byte
   623  		for {
   624  			if b, ok = d.mustgetc(); !ok {
   625  				return nil, d.err
   626  			}
   627  			d.buf.WriteByte(b)
   628  			if b0 == '?' && b == '>' {
   629  				break
   630  			}
   631  			b0 = b
   632  		}
   633  		data := d.buf.Bytes()
   634  		data = data[0 : len(data)-2] // chop ?>
   635  
   636  		if target == "xml" {
   637  			content := string(data)
   638  			ver := procInst("version", content)
   639  			if ver != "" && ver != "1.0" {
   640  				d.err = fmt.Errorf("xml: unsupported version %q; only version 1.0 is supported", ver)
   641  				return nil, d.err
   642  			}
   643  			enc := procInst("encoding", content)
   644  			if enc != "" && enc != "utf-8" && enc != "UTF-8" && !strings.EqualFold(enc, "utf-8") {
   645  				if d.CharsetReader == nil {
   646  					d.err = fmt.Errorf("xml: encoding %q declared but Decoder.CharsetReader is nil", enc)
   647  					return nil, d.err
   648  				}
   649  				newr, err := d.CharsetReader(enc, d.r.(io.Reader))
   650  				if err != nil {
   651  					d.err = fmt.Errorf("xml: opening charset %q: %w", enc, err)
   652  					return nil, d.err
   653  				}
   654  				if newr == nil {
   655  					panic("CharsetReader returned a nil Reader for charset " + enc)
   656  				}
   657  				d.switchToReader(newr)
   658  			}
   659  		}
   660  		return ProcInst{target, data}, nil
   661  
   662  	case '!':
   663  		// <!: Maybe comment, maybe CDATA.
   664  		if b, ok = d.mustgetc(); !ok {
   665  			return nil, d.err
   666  		}
   667  		switch b {
   668  		case '-': // <!-
   669  			// Probably <!-- for a comment.
   670  			if b, ok = d.mustgetc(); !ok {
   671  				return nil, d.err
   672  			}
   673  			if b != '-' {
   674  				d.err = d.syntaxError("invalid sequence <!- not part of <!--")
   675  				return nil, d.err
   676  			}
   677  			// Look for terminator.
   678  			d.buf.Reset()
   679  			var b0, b1 byte
   680  			for {
   681  				if b, ok = d.mustgetc(); !ok {
   682  					return nil, d.err
   683  				}
   684  				d.buf.WriteByte(b)
   685  				if b0 == '-' && b1 == '-' {
   686  					if b != '>' {
   687  						d.err = d.syntaxError(
   688  							`invalid sequence "--" not allowed in comments`)
   689  						return nil, d.err
   690  					}
   691  					break
   692  				}
   693  				b0, b1 = b1, b
   694  			}
   695  			data := d.buf.Bytes()
   696  			data = data[0 : len(data)-3] // chop -->
   697  			return Comment(data), nil
   698  
   699  		case '[': // <![
   700  			// Probably <![CDATA[.
   701  			for i := 0; i < 6; i++ {
   702  				if b, ok = d.mustgetc(); !ok {
   703  					return nil, d.err
   704  				}
   705  				if b != "CDATA["[i] {
   706  					d.err = d.syntaxError("invalid <![ sequence")
   707  					return nil, d.err
   708  				}
   709  			}
   710  			// Have <![CDATA[.  Read text until ]]>.
   711  			data := d.text(-1, true)
   712  			if data == nil {
   713  				return nil, d.err
   714  			}
   715  			return CharData(data), nil
   716  		}
   717  
   718  		// Probably a directive: <!DOCTYPE ...>, <!ENTITY ...>, etc.
   719  		// We don't care, but accumulate for caller. Quoted angle
   720  		// brackets do not count for nesting.
   721  		d.buf.Reset()
   722  		d.buf.WriteByte(b)
   723  		inquote := uint8(0)
   724  		depth := 0
   725  		for {
   726  			if b, ok = d.mustgetc(); !ok {
   727  				return nil, d.err
   728  			}
   729  			if inquote == 0 && b == '>' && depth == 0 {
   730  				break
   731  			}
   732  		HandleB:
   733  			d.buf.WriteByte(b)
   734  			switch {
   735  			case b == inquote:
   736  				inquote = 0
   737  
   738  			case inquote != 0:
   739  				// in quotes, no special action
   740  
   741  			case b == '\'' || b == '"':
   742  				inquote = b
   743  
   744  			case b == '>' && inquote == 0:
   745  				depth--
   746  
   747  			case b == '<' && inquote == 0:
   748  				// Look for <!-- to begin comment.
   749  				s := "!--"
   750  				for i := 0; i < len(s); i++ {
   751  					if b, ok = d.mustgetc(); !ok {
   752  						return nil, d.err
   753  					}
   754  					if b != s[i] {
   755  						for j := 0; j < i; j++ {
   756  							d.buf.WriteByte(s[j])
   757  						}
   758  						depth++
   759  						goto HandleB
   760  					}
   761  				}
   762  
   763  				// Remove < that was written above.
   764  				d.buf.Truncate(d.buf.Len() - 1)
   765  
   766  				// Look for terminator.
   767  				var b0, b1 byte
   768  				for {
   769  					if b, ok = d.mustgetc(); !ok {
   770  						return nil, d.err
   771  					}
   772  					if b0 == '-' && b1 == '-' && b == '>' {
   773  						break
   774  					}
   775  					b0, b1 = b1, b
   776  				}
   777  
   778  				// Replace the comment with a space in the returned Directive
   779  				// body, so that markup parts that were separated by the comment
   780  				// (like a "<" and a "!") don't get joined when re-encoding the
   781  				// Directive, taking new semantic meaning.
   782  				d.buf.WriteByte(' ')
   783  			}
   784  		}
   785  		return Directive(d.buf.Bytes()), nil
   786  	}
   787  
   788  	// Must be an open element like <a href="foo">
   789  	d.ungetc(b)
   790  
   791  	var (
   792  		name  Name
   793  		empty bool
   794  		attr  []Attr
   795  	)
   796  	if name, ok = d.nsname(); !ok {
   797  		if d.err == nil {
   798  			d.err = d.syntaxError("expected element name after <")
   799  		}
   800  		return nil, d.err
   801  	}
   802  
   803  	attr = []Attr{}
   804  	for {
   805  		d.space()
   806  		if b, ok = d.mustgetc(); !ok {
   807  			return nil, d.err
   808  		}
   809  		if b == '/' {
   810  			empty = true
   811  			if b, ok = d.mustgetc(); !ok {
   812  				return nil, d.err
   813  			}
   814  			if b != '>' {
   815  				d.err = d.syntaxError("expected /> in element")
   816  				return nil, d.err
   817  			}
   818  			break
   819  		}
   820  		if b == '>' {
   821  			break
   822  		}
   823  		d.ungetc(b)
   824  
   825  		a := Attr{}
   826  		if a.Name, ok = d.nsname(); !ok {
   827  			if d.err == nil {
   828  				d.err = d.syntaxError("expected attribute name in element")
   829  			}
   830  			return nil, d.err
   831  		}
   832  		d.space()
   833  		if b, ok = d.mustgetc(); !ok {
   834  			return nil, d.err
   835  		}
   836  		if b != '=' {
   837  			if d.Strict {
   838  				d.err = d.syntaxError("attribute name without = in element")
   839  				return nil, d.err
   840  			}
   841  			d.ungetc(b)
   842  			a.Value = a.Name.Local
   843  		} else {
   844  			d.space()
   845  			data := d.attrval()
   846  			if data == nil {
   847  				return nil, d.err
   848  			}
   849  			a.Value = string(data)
   850  		}
   851  		attr = append(attr, a)
   852  	}
   853  	if empty {
   854  		d.needClose = true
   855  		d.toClose = name
   856  	}
   857  	return StartElement{name, attr}, nil
   858  }
   859  
   860  func (d *Decoder) attrval() []byte {
   861  	b, ok := d.mustgetc()
   862  	if !ok {
   863  		return nil
   864  	}
   865  	// Handle quoted attribute values
   866  	if b == '"' || b == '\'' {
   867  		return d.text(int(b), false)
   868  	}
   869  	// Handle unquoted attribute values for strict parsers
   870  	if d.Strict {
   871  		d.err = d.syntaxError("unquoted or missing attribute value in element")
   872  		return nil
   873  	}
   874  	// Handle unquoted attribute values for unstrict parsers
   875  	d.ungetc(b)
   876  	d.buf.Reset()
   877  	for {
   878  		b, ok = d.mustgetc()
   879  		if !ok {
   880  			return nil
   881  		}
   882  		// https://www.w3.org/TR/REC-html40/intro/sgmltut.html#h-3.2.2
   883  		if 'a' <= b && b <= 'z' || 'A' <= b && b <= 'Z' ||
   884  			'0' <= b && b <= '9' || b == '_' || b == ':' || b == '-' {
   885  			d.buf.WriteByte(b)
   886  		} else {
   887  			d.ungetc(b)
   888  			break
   889  		}
   890  	}
   891  	return d.buf.Bytes()
   892  }
   893  
   894  // Skip spaces if any
   895  func (d *Decoder) space() {
   896  	for {
   897  		b, ok := d.getc()
   898  		if !ok {
   899  			return
   900  		}
   901  		switch b {
   902  		case ' ', '\r', '\n', '\t':
   903  		default:
   904  			d.ungetc(b)
   905  			return
   906  		}
   907  	}
   908  }
   909  
   910  // Read a single byte.
   911  // If there is no byte to read, return ok==false
   912  // and leave the error in d.err.
   913  // Maintain line number.
   914  func (d *Decoder) getc() (b byte, ok bool) {
   915  	if d.err != nil {
   916  		return 0, false
   917  	}
   918  	if d.nextByte >= 0 {
   919  		b = byte(d.nextByte)
   920  		d.nextByte = -1
   921  	} else {
   922  		b, d.err = d.r.ReadByte()
   923  		if d.err != nil {
   924  			return 0, false
   925  		}
   926  		if d.saved != nil {
   927  			d.saved.WriteByte(b)
   928  		}
   929  	}
   930  	if b == '\n' {
   931  		d.line++
   932  		d.linestart = d.offset + 1
   933  	}
   934  	d.offset++
   935  	return b, true
   936  }
   937  
   938  // InputOffset returns the input stream byte offset of the current decoder position.
   939  // The offset gives the location of the end of the most recently returned token
   940  // and the beginning of the next token.
   941  func (d *Decoder) InputOffset() int64 {
   942  	return d.offset
   943  }
   944  
   945  // InputPos returns the line of the current decoder position and the 1 based
   946  // input position of the line. The position gives the location of the end of the
   947  // most recently returned token.
   948  func (d *Decoder) InputPos() (line, column int) {
   949  	return d.line, int(d.offset-d.linestart) + 1
   950  }
   951  
   952  // Return saved offset.
   953  // If we did ungetc (nextByte >= 0), have to back up one.
   954  func (d *Decoder) savedOffset() int {
   955  	n := d.saved.Len()
   956  	if d.nextByte >= 0 {
   957  		n--
   958  	}
   959  	return n
   960  }
   961  
   962  // Must read a single byte.
   963  // If there is no byte to read,
   964  // set d.err to SyntaxError("unexpected EOF")
   965  // and return ok==false
   966  func (d *Decoder) mustgetc() (b byte, ok bool) {
   967  	if b, ok = d.getc(); !ok {
   968  		if d.err == io.EOF {
   969  			d.err = d.syntaxError("unexpected EOF")
   970  		}
   971  	}
   972  	return
   973  }
   974  
   975  // Unread a single byte.
   976  func (d *Decoder) ungetc(b byte) {
   977  	if b == '\n' {
   978  		d.line--
   979  	}
   980  	d.nextByte = int(b)
   981  	d.offset--
   982  }
   983  
   984  var entity = map[string]rune{
   985  	"lt":   '<',
   986  	"gt":   '>',
   987  	"amp":  '&',
   988  	"apos": '\'',
   989  	"quot": '"',
   990  }
   991  
   992  // Read plain text section (XML calls it character data).
   993  // If quote >= 0, we are in a quoted string and need to find the matching quote.
   994  // If cdata == true, we are in a <![CDATA[ section and need to find ]]>.
   995  // On failure return nil and leave the error in d.err.
   996  func (d *Decoder) text(quote int, cdata bool) []byte {
   997  	var b0, b1 byte
   998  	var trunc int
   999  	d.buf.Reset()
  1000  Input:
  1001  	for {
  1002  		b, ok := d.getc()
  1003  		if !ok {
  1004  			if cdata {
  1005  				if d.err == io.EOF {
  1006  					d.err = d.syntaxError("unexpected EOF in CDATA section")
  1007  				}
  1008  				return nil
  1009  			}
  1010  			break Input
  1011  		}
  1012  
  1013  		// <![CDATA[ section ends with ]]>.
  1014  		// It is an error for ]]> to appear in ordinary text,
  1015  		// but it is allowed in quoted strings.
  1016  		if quote < 0 && b0 == ']' && b1 == ']' && b == '>' {
  1017  			if cdata {
  1018  				trunc = 2
  1019  				break Input
  1020  			}
  1021  			d.err = d.syntaxError("unescaped ]]> not in CDATA section")
  1022  			return nil
  1023  		}
  1024  
  1025  		// Stop reading text if we see a <.
  1026  		if b == '<' && !cdata {
  1027  			if quote >= 0 {
  1028  				d.err = d.syntaxError("unescaped < inside quoted string")
  1029  				return nil
  1030  			}
  1031  			d.ungetc('<')
  1032  			break Input
  1033  		}
  1034  		if quote >= 0 && b == byte(quote) {
  1035  			break Input
  1036  		}
  1037  		if b == '&' && !cdata {
  1038  			// Read escaped character expression up to semicolon.
  1039  			// XML in all its glory allows a document to define and use
  1040  			// its own character names with <!ENTITY ...> directives.
  1041  			// Parsers are required to recognize lt, gt, amp, apos, and quot
  1042  			// even if they have not been declared.
  1043  			before := d.buf.Len()
  1044  			d.buf.WriteByte('&')
  1045  			var ok bool
  1046  			var text string
  1047  			var haveText bool
  1048  			if b, ok = d.mustgetc(); !ok {
  1049  				return nil
  1050  			}
  1051  			if b == '#' {
  1052  				d.buf.WriteByte(b)
  1053  				if b, ok = d.mustgetc(); !ok {
  1054  					return nil
  1055  				}
  1056  				base := 10
  1057  				if b == 'x' {
  1058  					base = 16
  1059  					d.buf.WriteByte(b)
  1060  					if b, ok = d.mustgetc(); !ok {
  1061  						return nil
  1062  					}
  1063  				}
  1064  				start := d.buf.Len()
  1065  				for '0' <= b && b <= '9' ||
  1066  					base == 16 && 'a' <= b && b <= 'f' ||
  1067  					base == 16 && 'A' <= b && b <= 'F' {
  1068  					d.buf.WriteByte(b)
  1069  					if b, ok = d.mustgetc(); !ok {
  1070  						return nil
  1071  					}
  1072  				}
  1073  				if b != ';' {
  1074  					d.ungetc(b)
  1075  				} else {
  1076  					s := string(d.buf.Bytes()[start:])
  1077  					d.buf.WriteByte(';')
  1078  					n, err := strconv.ParseUint(s, base, 64)
  1079  					if err == nil && n <= unicode.MaxRune {
  1080  						text = string(rune(n))
  1081  						haveText = true
  1082  					}
  1083  				}
  1084  			} else {
  1085  				d.ungetc(b)
  1086  				if !d.readName() {
  1087  					if d.err != nil {
  1088  						return nil
  1089  					}
  1090  				}
  1091  				if b, ok = d.mustgetc(); !ok {
  1092  					return nil
  1093  				}
  1094  				if b != ';' {
  1095  					d.ungetc(b)
  1096  				} else {
  1097  					name := d.buf.Bytes()[before+1:]
  1098  					d.buf.WriteByte(';')
  1099  					if isName(name) {
  1100  						s := string(name)
  1101  						if r, ok := entity[s]; ok {
  1102  							text = string(r)
  1103  							haveText = true
  1104  						} else if d.Entity != nil {
  1105  							text, haveText = d.Entity[s]
  1106  						}
  1107  					}
  1108  				}
  1109  			}
  1110  
  1111  			if haveText {
  1112  				d.buf.Truncate(before)
  1113  				d.buf.WriteString(text)
  1114  				b0, b1 = 0, 0
  1115  				continue Input
  1116  			}
  1117  			if !d.Strict {
  1118  				b0, b1 = 0, 0
  1119  				continue Input
  1120  			}
  1121  			ent := string(d.buf.Bytes()[before:])
  1122  			if ent[len(ent)-1] != ';' {
  1123  				ent += " (no semicolon)"
  1124  			}
  1125  			d.err = d.syntaxError("invalid character entity " + ent)
  1126  			return nil
  1127  		}
  1128  
  1129  		// We must rewrite unescaped \r and \r\n into \n.
  1130  		if b == '\r' {
  1131  			d.buf.WriteByte('\n')
  1132  		} else if b1 == '\r' && b == '\n' {
  1133  			// Skip \r\n--we already wrote \n.
  1134  		} else {
  1135  			d.buf.WriteByte(b)
  1136  		}
  1137  
  1138  		b0, b1 = b1, b
  1139  	}
  1140  	data := d.buf.Bytes()
  1141  	data = data[0 : len(data)-trunc]
  1142  
  1143  	// Inspect each rune for being a disallowed character.
  1144  	buf := data
  1145  	for len(buf) > 0 {
  1146  		r, size := utf8.DecodeRune(buf)
  1147  		if r == utf8.RuneError && size == 1 {
  1148  			d.err = d.syntaxError("invalid UTF-8")
  1149  			return nil
  1150  		}
  1151  		buf = buf[size:]
  1152  		if !isInCharacterRange(r) {
  1153  			d.err = d.syntaxError(fmt.Sprintf("illegal character code %U", r))
  1154  			return nil
  1155  		}
  1156  	}
  1157  
  1158  	return data
  1159  }
  1160  
  1161  // Decide whether the given rune is in the XML Character Range, per
  1162  // the Char production of https://www.xml.com/axml/testaxml.htm,
  1163  // Section 2.2 Characters.
  1164  func isInCharacterRange(r rune) (inrange bool) {
  1165  	return r == 0x09 ||
  1166  		r == 0x0A ||
  1167  		r == 0x0D ||
  1168  		r >= 0x20 && r <= 0xD7FF ||
  1169  		r >= 0xE000 && r <= 0xFFFD ||
  1170  		r >= 0x10000 && r <= 0x10FFFF
  1171  }
  1172  
  1173  // Get name space name: name with a : stuck in the middle.
  1174  // The part before the : is the name space identifier.
  1175  func (d *Decoder) nsname() (name Name, ok bool) {
  1176  	s, ok := d.name()
  1177  	if !ok {
  1178  		return
  1179  	}
  1180  	if strings.Count(s, ":") > 1 {
  1181  		return name, false
  1182  	} else if space, local, ok := strings.Cut(s, ":"); !ok || space == "" || local == "" {
  1183  		name.Local = s
  1184  	} else {
  1185  		name.Space = space
  1186  		name.Local = local
  1187  	}
  1188  	return name, true
  1189  }
  1190  
  1191  // Get name: /first(first|second)*/
  1192  // Do not set d.err if the name is missing (unless unexpected EOF is received):
  1193  // let the caller provide better context.
  1194  func (d *Decoder) name() (s string, ok bool) {
  1195  	d.buf.Reset()
  1196  	if !d.readName() {
  1197  		return "", false
  1198  	}
  1199  
  1200  	// Now we check the characters.
  1201  	b := d.buf.Bytes()
  1202  	if !isName(b) {
  1203  		d.err = d.syntaxError("invalid XML name: " + string(b))
  1204  		return "", false
  1205  	}
  1206  	return string(b), true
  1207  }
  1208  
  1209  // Read a name and append its bytes to d.buf.
  1210  // The name is delimited by any single-byte character not valid in names.
  1211  // All multi-byte characters are accepted; the caller must check their validity.
  1212  func (d *Decoder) readName() (ok bool) {
  1213  	var b byte
  1214  	if b, ok = d.mustgetc(); !ok {
  1215  		return
  1216  	}
  1217  	if b < utf8.RuneSelf && !isNameByte(b) {
  1218  		d.ungetc(b)
  1219  		return false
  1220  	}
  1221  	d.buf.WriteByte(b)
  1222  
  1223  	for {
  1224  		if b, ok = d.mustgetc(); !ok {
  1225  			return
  1226  		}
  1227  		if b < utf8.RuneSelf && !isNameByte(b) {
  1228  			d.ungetc(b)
  1229  			break
  1230  		}
  1231  		d.buf.WriteByte(b)
  1232  	}
  1233  	return true
  1234  }
  1235  
  1236  func isNameByte(c byte) bool {
  1237  	return 'A' <= c && c <= 'Z' ||
  1238  		'a' <= c && c <= 'z' ||
  1239  		'0' <= c && c <= '9' ||
  1240  		c == '_' || c == ':' || c == '.' || c == '-'
  1241  }
  1242  
  1243  func isName(s []byte) bool {
  1244  	if len(s) == 0 {
  1245  		return false
  1246  	}
  1247  	c, n := utf8.DecodeRune(s)
  1248  	if c == utf8.RuneError && n == 1 {
  1249  		return false
  1250  	}
  1251  	if !unicode.Is(first, c) {
  1252  		return false
  1253  	}
  1254  	for n < len(s) {
  1255  		s = s[n:]
  1256  		c, n = utf8.DecodeRune(s)
  1257  		if c == utf8.RuneError && n == 1 {
  1258  			return false
  1259  		}
  1260  		if !unicode.Is(first, c) && !unicode.Is(second, c) {
  1261  			return false
  1262  		}
  1263  	}
  1264  	return true
  1265  }
  1266  
  1267  func isNameString(s string) bool {
  1268  	if len(s) == 0 {
  1269  		return false
  1270  	}
  1271  	c, n := utf8.DecodeRuneInString(s)
  1272  	if c == utf8.RuneError && n == 1 {
  1273  		return false
  1274  	}
  1275  	if !unicode.Is(first, c) {
  1276  		return false
  1277  	}
  1278  	for n < len(s) {
  1279  		s = s[n:]
  1280  		c, n = utf8.DecodeRuneInString(s)
  1281  		if c == utf8.RuneError && n == 1 {
  1282  			return false
  1283  		}
  1284  		if !unicode.Is(first, c) && !unicode.Is(second, c) {
  1285  			return false
  1286  		}
  1287  	}
  1288  	return true
  1289  }
  1290  
  1291  // These tables were generated by cut and paste from Appendix B of
  1292  // the XML spec at https://www.xml.com/axml/testaxml.htm
  1293  // and then reformatting. First corresponds to (Letter | '_' | ':')
  1294  // and second corresponds to NameChar.
  1295  
  1296  var first = &unicode.RangeTable{
  1297  	R16: []unicode.Range16{
  1298  		{0x003A, 0x003A, 1},
  1299  		{0x0041, 0x005A, 1},
  1300  		{0x005F, 0x005F, 1},
  1301  		{0x0061, 0x007A, 1},
  1302  		{0x00C0, 0x00D6, 1},
  1303  		{0x00D8, 0x00F6, 1},
  1304  		{0x00F8, 0x00FF, 1},
  1305  		{0x0100, 0x0131, 1},
  1306  		{0x0134, 0x013E, 1},
  1307  		{0x0141, 0x0148, 1},
  1308  		{0x014A, 0x017E, 1},
  1309  		{0x0180, 0x01C3, 1},
  1310  		{0x01CD, 0x01F0, 1},
  1311  		{0x01F4, 0x01F5, 1},
  1312  		{0x01FA, 0x0217, 1},
  1313  		{0x0250, 0x02A8, 1},
  1314  		{0x02BB, 0x02C1, 1},
  1315  		{0x0386, 0x0386, 1},
  1316  		{0x0388, 0x038A, 1},
  1317  		{0x038C, 0x038C, 1},
  1318  		{0x038E, 0x03A1, 1},
  1319  		{0x03A3, 0x03CE, 1},
  1320  		{0x03D0, 0x03D6, 1},
  1321  		{0x03DA, 0x03E0, 2},
  1322  		{0x03E2, 0x03F3, 1},
  1323  		{0x0401, 0x040C, 1},
  1324  		{0x040E, 0x044F, 1},
  1325  		{0x0451, 0x045C, 1},
  1326  		{0x045E, 0x0481, 1},
  1327  		{0x0490, 0x04C4, 1},
  1328  		{0x04C7, 0x04C8, 1},
  1329  		{0x04CB, 0x04CC, 1},
  1330  		{0x04D0, 0x04EB, 1},
  1331  		{0x04EE, 0x04F5, 1},
  1332  		{0x04F8, 0x04F9, 1},
  1333  		{0x0531, 0x0556, 1},
  1334  		{0x0559, 0x0559, 1},
  1335  		{0x0561, 0x0586, 1},
  1336  		{0x05D0, 0x05EA, 1},
  1337  		{0x05F0, 0x05F2, 1},
  1338  		{0x0621, 0x063A, 1},
  1339  		{0x0641, 0x064A, 1},
  1340  		{0x0671, 0x06B7, 1},
  1341  		{0x06BA, 0x06BE, 1},
  1342  		{0x06C0, 0x06CE, 1},
  1343  		{0x06D0, 0x06D3, 1},
  1344  		{0x06D5, 0x06D5, 1},
  1345  		{0x06E5, 0x06E6, 1},
  1346  		{0x0905, 0x0939, 1},
  1347  		{0x093D, 0x093D, 1},
  1348  		{0x0958, 0x0961, 1},
  1349  		{0x0985, 0x098C, 1},
  1350  		{0x098F, 0x0990, 1},
  1351  		{0x0993, 0x09A8, 1},
  1352  		{0x09AA, 0x09B0, 1},
  1353  		{0x09B2, 0x09B2, 1},
  1354  		{0x09B6, 0x09B9, 1},
  1355  		{0x09DC, 0x09DD, 1},
  1356  		{0x09DF, 0x09E1, 1},
  1357  		{0x09F0, 0x09F1, 1},
  1358  		{0x0A05, 0x0A0A, 1},
  1359  		{0x0A0F, 0x0A10, 1},
  1360  		{0x0A13, 0x0A28, 1},
  1361  		{0x0A2A, 0x0A30, 1},
  1362  		{0x0A32, 0x0A33, 1},
  1363  		{0x0A35, 0x0A36, 1},
  1364  		{0x0A38, 0x0A39, 1},
  1365  		{0x0A59, 0x0A5C, 1},
  1366  		{0x0A5E, 0x0A5E, 1},
  1367  		{0x0A72, 0x0A74, 1},
  1368  		{0x0A85, 0x0A8B, 1},
  1369  		{0x0A8D, 0x0A8D, 1},
  1370  		{0x0A8F, 0x0A91, 1},
  1371  		{0x0A93, 0x0AA8, 1},
  1372  		{0x0AAA, 0x0AB0, 1},
  1373  		{0x0AB2, 0x0AB3, 1},
  1374  		{0x0AB5, 0x0AB9, 1},
  1375  		{0x0ABD, 0x0AE0, 0x23},
  1376  		{0x0B05, 0x0B0C, 1},
  1377  		{0x0B0F, 0x0B10, 1},
  1378  		{0x0B13, 0x0B28, 1},
  1379  		{0x0B2A, 0x0B30, 1},
  1380  		{0x0B32, 0x0B33, 1},
  1381  		{0x0B36, 0x0B39, 1},
  1382  		{0x0B3D, 0x0B3D, 1},
  1383  		{0x0B5C, 0x0B5D, 1},
  1384  		{0x0B5F, 0x0B61, 1},
  1385  		{0x0B85, 0x0B8A, 1},
  1386  		{0x0B8E, 0x0B90, 1},
  1387  		{0x0B92, 0x0B95, 1},
  1388  		{0x0B99, 0x0B9A, 1},
  1389  		{0x0B9C, 0x0B9C, 1},
  1390  		{0x0B9E, 0x0B9F, 1},
  1391  		{0x0BA3, 0x0BA4, 1},
  1392  		{0x0BA8, 0x0BAA, 1},
  1393  		{0x0BAE, 0x0BB5, 1},
  1394  		{0x0BB7, 0x0BB9, 1},
  1395  		{0x0C05, 0x0C0C, 1},
  1396  		{0x0C0E, 0x0C10, 1},
  1397  		{0x0C12, 0x0C28, 1},
  1398  		{0x0C2A, 0x0C33, 1},
  1399  		{0x0C35, 0x0C39, 1},
  1400  		{0x0C60, 0x0C61, 1},
  1401  		{0x0C85, 0x0C8C, 1},
  1402  		{0x0C8E, 0x0C90, 1},
  1403  		{0x0C92, 0x0CA8, 1},
  1404  		{0x0CAA, 0x0CB3, 1},
  1405  		{0x0CB5, 0x0CB9, 1},
  1406  		{0x0CDE, 0x0CDE, 1},
  1407  		{0x0CE0, 0x0CE1, 1},
  1408  		{0x0D05, 0x0D0C, 1},
  1409  		{0x0D0E, 0x0D10, 1},
  1410  		{0x0D12, 0x0D28, 1},
  1411  		{0x0D2A, 0x0D39, 1},
  1412  		{0x0D60, 0x0D61, 1},
  1413  		{0x0E01, 0x0E2E, 1},
  1414  		{0x0E30, 0x0E30, 1},
  1415  		{0x0E32, 0x0E33, 1},
  1416  		{0x0E40, 0x0E45, 1},
  1417  		{0x0E81, 0x0E82, 1},
  1418  		{0x0E84, 0x0E84, 1},
  1419  		{0x0E87, 0x0E88, 1},
  1420  		{0x0E8A, 0x0E8D, 3},
  1421  		{0x0E94, 0x0E97, 1},
  1422  		{0x0E99, 0x0E9F, 1},
  1423  		{0x0EA1, 0x0EA3, 1},
  1424  		{0x0EA5, 0x0EA7, 2},
  1425  		{0x0EAA, 0x0EAB, 1},
  1426  		{0x0EAD, 0x0EAE, 1},
  1427  		{0x0EB0, 0x0EB0, 1},
  1428  		{0x0EB2, 0x0EB3, 1},
  1429  		{0x0EBD, 0x0EBD, 1},
  1430  		{0x0EC0, 0x0EC4, 1},
  1431  		{0x0F40, 0x0F47, 1},
  1432  		{0x0F49, 0x0F69, 1},
  1433  		{0x10A0, 0x10C5, 1},
  1434  		{0x10D0, 0x10F6, 1},
  1435  		{0x1100, 0x1100, 1},
  1436  		{0x1102, 0x1103, 1},
  1437  		{0x1105, 0x1107, 1},
  1438  		{0x1109, 0x1109, 1},
  1439  		{0x110B, 0x110C, 1},
  1440  		{0x110E, 0x1112, 1},
  1441  		{0x113C, 0x1140, 2},
  1442  		{0x114C, 0x1150, 2},
  1443  		{0x1154, 0x1155, 1},
  1444  		{0x1159, 0x1159, 1},
  1445  		{0x115F, 0x1161, 1},
  1446  		{0x1163, 0x1169, 2},
  1447  		{0x116D, 0x116E, 1},
  1448  		{0x1172, 0x1173, 1},
  1449  		{0x1175, 0x119E, 0x119E - 0x1175},
  1450  		{0x11A8, 0x11AB, 0x11AB - 0x11A8},
  1451  		{0x11AE, 0x11AF, 1},
  1452  		{0x11B7, 0x11B8, 1},
  1453  		{0x11BA, 0x11BA, 1},
  1454  		{0x11BC, 0x11C2, 1},
  1455  		{0x11EB, 0x11F0, 0x11F0 - 0x11EB},
  1456  		{0x11F9, 0x11F9, 1},
  1457  		{0x1E00, 0x1E9B, 1},
  1458  		{0x1EA0, 0x1EF9, 1},
  1459  		{0x1F00, 0x1F15, 1},
  1460  		{0x1F18, 0x1F1D, 1},
  1461  		{0x1F20, 0x1F45, 1},
  1462  		{0x1F48, 0x1F4D, 1},
  1463  		{0x1F50, 0x1F57, 1},
  1464  		{0x1F59, 0x1F5B, 0x1F5B - 0x1F59},
  1465  		{0x1F5D, 0x1F5D, 1},
  1466  		{0x1F5F, 0x1F7D, 1},
  1467  		{0x1F80, 0x1FB4, 1},
  1468  		{0x1FB6, 0x1FBC, 1},
  1469  		{0x1FBE, 0x1FBE, 1},
  1470  		{0x1FC2, 0x1FC4, 1},
  1471  		{0x1FC6, 0x1FCC, 1},
  1472  		{0x1FD0, 0x1FD3, 1},
  1473  		{0x1FD6, 0x1FDB, 1},
  1474  		{0x1FE0, 0x1FEC, 1},
  1475  		{0x1FF2, 0x1FF4, 1},
  1476  		{0x1FF6, 0x1FFC, 1},
  1477  		{0x2126, 0x2126, 1},
  1478  		{0x212A, 0x212B, 1},
  1479  		{0x212E, 0x212E, 1},
  1480  		{0x2180, 0x2182, 1},
  1481  		{0x3007, 0x3007, 1},
  1482  		{0x3021, 0x3029, 1},
  1483  		{0x3041, 0x3094, 1},
  1484  		{0x30A1, 0x30FA, 1},
  1485  		{0x3105, 0x312C, 1},
  1486  		{0x4E00, 0x9FA5, 1},
  1487  		{0xAC00, 0xD7A3, 1},
  1488  	},
  1489  }
  1490  
  1491  var second = &unicode.RangeTable{
  1492  	R16: []unicode.Range16{
  1493  		{0x002D, 0x002E, 1},
  1494  		{0x0030, 0x0039, 1},
  1495  		{0x00B7, 0x00B7, 1},
  1496  		{0x02D0, 0x02D1, 1},
  1497  		{0x0300, 0x0345, 1},
  1498  		{0x0360, 0x0361, 1},
  1499  		{0x0387, 0x0387, 1},
  1500  		{0x0483, 0x0486, 1},
  1501  		{0x0591, 0x05A1, 1},
  1502  		{0x05A3, 0x05B9, 1},
  1503  		{0x05BB, 0x05BD, 1},
  1504  		{0x05BF, 0x05BF, 1},
  1505  		{0x05C1, 0x05C2, 1},
  1506  		{0x05C4, 0x0640, 0x0640 - 0x05C4},
  1507  		{0x064B, 0x0652, 1},
  1508  		{0x0660, 0x0669, 1},
  1509  		{0x0670, 0x0670, 1},
  1510  		{0x06D6, 0x06DC, 1},
  1511  		{0x06DD, 0x06DF, 1},
  1512  		{0x06E0, 0x06E4, 1},
  1513  		{0x06E7, 0x06E8, 1},
  1514  		{0x06EA, 0x06ED, 1},
  1515  		{0x06F0, 0x06F9, 1},
  1516  		{0x0901, 0x0903, 1},
  1517  		{0x093C, 0x093C, 1},
  1518  		{0x093E, 0x094C, 1},
  1519  		{0x094D, 0x094D, 1},
  1520  		{0x0951, 0x0954, 1},
  1521  		{0x0962, 0x0963, 1},
  1522  		{0x0966, 0x096F, 1},
  1523  		{0x0981, 0x0983, 1},
  1524  		{0x09BC, 0x09BC, 1},
  1525  		{0x09BE, 0x09BF, 1},
  1526  		{0x09C0, 0x09C4, 1},
  1527  		{0x09C7, 0x09C8, 1},
  1528  		{0x09CB, 0x09CD, 1},
  1529  		{0x09D7, 0x09D7, 1},
  1530  		{0x09E2, 0x09E3, 1},
  1531  		{0x09E6, 0x09EF, 1},
  1532  		{0x0A02, 0x0A3C, 0x3A},
  1533  		{0x0A3E, 0x0A3F, 1},
  1534  		{0x0A40, 0x0A42, 1},
  1535  		{0x0A47, 0x0A48, 1},
  1536  		{0x0A4B, 0x0A4D, 1},
  1537  		{0x0A66, 0x0A6F, 1},
  1538  		{0x0A70, 0x0A71, 1},
  1539  		{0x0A81, 0x0A83, 1},
  1540  		{0x0ABC, 0x0ABC, 1},
  1541  		{0x0ABE, 0x0AC5, 1},
  1542  		{0x0AC7, 0x0AC9, 1},
  1543  		{0x0ACB, 0x0ACD, 1},
  1544  		{0x0AE6, 0x0AEF, 1},
  1545  		{0x0B01, 0x0B03, 1},
  1546  		{0x0B3C, 0x0B3C, 1},
  1547  		{0x0B3E, 0x0B43, 1},
  1548  		{0x0B47, 0x0B48, 1},
  1549  		{0x0B4B, 0x0B4D, 1},
  1550  		{0x0B56, 0x0B57, 1},
  1551  		{0x0B66, 0x0B6F, 1},
  1552  		{0x0B82, 0x0B83, 1},
  1553  		{0x0BBE, 0x0BC2, 1},
  1554  		{0x0BC6, 0x0BC8, 1},
  1555  		{0x0BCA, 0x0BCD, 1},
  1556  		{0x0BD7, 0x0BD7, 1},
  1557  		{0x0BE7, 0x0BEF, 1},
  1558  		{0x0C01, 0x0C03, 1},
  1559  		{0x0C3E, 0x0C44, 1},
  1560  		{0x0C46, 0x0C48, 1},
  1561  		{0x0C4A, 0x0C4D, 1},
  1562  		{0x0C55, 0x0C56, 1},
  1563  		{0x0C66, 0x0C6F, 1},
  1564  		{0x0C82, 0x0C83, 1},
  1565  		{0x0CBE, 0x0CC4, 1},
  1566  		{0x0CC6, 0x0CC8, 1},
  1567  		{0x0CCA, 0x0CCD, 1},
  1568  		{0x0CD5, 0x0CD6, 1},
  1569  		{0x0CE6, 0x0CEF, 1},
  1570  		{0x0D02, 0x0D03, 1},
  1571  		{0x0D3E, 0x0D43, 1},
  1572  		{0x0D46, 0x0D48, 1},
  1573  		{0x0D4A, 0x0D4D, 1},
  1574  		{0x0D57, 0x0D57, 1},
  1575  		{0x0D66, 0x0D6F, 1},
  1576  		{0x0E31, 0x0E31, 1},
  1577  		{0x0E34, 0x0E3A, 1},
  1578  		{0x0E46, 0x0E46, 1},
  1579  		{0x0E47, 0x0E4E, 1},
  1580  		{0x0E50, 0x0E59, 1},
  1581  		{0x0EB1, 0x0EB1, 1},
  1582  		{0x0EB4, 0x0EB9, 1},
  1583  		{0x0EBB, 0x0EBC, 1},
  1584  		{0x0EC6, 0x0EC6, 1},
  1585  		{0x0EC8, 0x0ECD, 1},
  1586  		{0x0ED0, 0x0ED9, 1},
  1587  		{0x0F18, 0x0F19, 1},
  1588  		{0x0F20, 0x0F29, 1},
  1589  		{0x0F35, 0x0F39, 2},
  1590  		{0x0F3E, 0x0F3F, 1},
  1591  		{0x0F71, 0x0F84, 1},
  1592  		{0x0F86, 0x0F8B, 1},
  1593  		{0x0F90, 0x0F95, 1},
  1594  		{0x0F97, 0x0F97, 1},
  1595  		{0x0F99, 0x0FAD, 1},
  1596  		{0x0FB1, 0x0FB7, 1},
  1597  		{0x0FB9, 0x0FB9, 1},
  1598  		{0x20D0, 0x20DC, 1},
  1599  		{0x20E1, 0x3005, 0x3005 - 0x20E1},
  1600  		{0x302A, 0x302F, 1},
  1601  		{0x3031, 0x3035, 1},
  1602  		{0x3099, 0x309A, 1},
  1603  		{0x309D, 0x309E, 1},
  1604  		{0x30FC, 0x30FE, 1},
  1605  	},
  1606  }
  1607  
  1608  // HTMLEntity is an entity map containing translations for the
  1609  // standard HTML entity characters.
  1610  //
  1611  // See the [Decoder.Strict] and [Decoder.Entity] fields' documentation.
  1612  var HTMLEntity map[string]string = htmlEntity
  1613  
  1614  var htmlEntity = map[string]string{
  1615  	/*
  1616  		hget http://www.w3.org/TR/html4/sgml/entities.html |
  1617  		ssam '
  1618  			,y /\&gt;/ x/\&lt;(.|\n)+/ s/\n/ /g
  1619  			,x v/^\&lt;!ENTITY/d
  1620  			,s/\&lt;!ENTITY ([^ ]+) .*U\+([0-9A-F][0-9A-F][0-9A-F][0-9A-F]) .+/	"\1": "\\u\2",/g
  1621  		'
  1622  	*/
  1623  	"nbsp":     "\u00A0",
  1624  	"iexcl":    "\u00A1",
  1625  	"cent":     "\u00A2",
  1626  	"pound":    "\u00A3",
  1627  	"curren":   "\u00A4",
  1628  	"yen":      "\u00A5",
  1629  	"brvbar":   "\u00A6",
  1630  	"sect":     "\u00A7",
  1631  	"uml":      "\u00A8",
  1632  	"copy":     "\u00A9",
  1633  	"ordf":     "\u00AA",
  1634  	"laquo":    "\u00AB",
  1635  	"not":      "\u00AC",
  1636  	"shy":      "\u00AD",
  1637  	"reg":      "\u00AE",
  1638  	"macr":     "\u00AF",
  1639  	"deg":      "\u00B0",
  1640  	"plusmn":   "\u00B1",
  1641  	"sup2":     "\u00B2",
  1642  	"sup3":     "\u00B3",
  1643  	"acute":    "\u00B4",
  1644  	"micro":    "\u00B5",
  1645  	"para":     "\u00B6",
  1646  	"middot":   "\u00B7",
  1647  	"cedil":    "\u00B8",
  1648  	"sup1":     "\u00B9",
  1649  	"ordm":     "\u00BA",
  1650  	"raquo":    "\u00BB",
  1651  	"frac14":   "\u00BC",
  1652  	"frac12":   "\u00BD",
  1653  	"frac34":   "\u00BE",
  1654  	"iquest":   "\u00BF",
  1655  	"Agrave":   "\u00C0",
  1656  	"Aacute":   "\u00C1",
  1657  	"Acirc":    "\u00C2",
  1658  	"Atilde":   "\u00C3",
  1659  	"Auml":     "\u00C4",
  1660  	"Aring":    "\u00C5",
  1661  	"AElig":    "\u00C6",
  1662  	"Ccedil":   "\u00C7",
  1663  	"Egrave":   "\u00C8",
  1664  	"Eacute":   "\u00C9",
  1665  	"Ecirc":    "\u00CA",
  1666  	"Euml":     "\u00CB",
  1667  	"Igrave":   "\u00CC",
  1668  	"Iacute":   "\u00CD",
  1669  	"Icirc":    "\u00CE",
  1670  	"Iuml":     "\u00CF",
  1671  	"ETH":      "\u00D0",
  1672  	"Ntilde":   "\u00D1",
  1673  	"Ograve":   "\u00D2",
  1674  	"Oacute":   "\u00D3",
  1675  	"Ocirc":    "\u00D4",
  1676  	"Otilde":   "\u00D5",
  1677  	"Ouml":     "\u00D6",
  1678  	"times":    "\u00D7",
  1679  	"Oslash":   "\u00D8",
  1680  	"Ugrave":   "\u00D9",
  1681  	"Uacute":   "\u00DA",
  1682  	"Ucirc":    "\u00DB",
  1683  	"Uuml":     "\u00DC",
  1684  	"Yacute":   "\u00DD",
  1685  	"THORN":    "\u00DE",
  1686  	"szlig":    "\u00DF",
  1687  	"agrave":   "\u00E0",
  1688  	"aacute":   "\u00E1",
  1689  	"acirc":    "\u00E2",
  1690  	"atilde":   "\u00E3",
  1691  	"auml":     "\u00E4",
  1692  	"aring":    "\u00E5",
  1693  	"aelig":    "\u00E6",
  1694  	"ccedil":   "\u00E7",
  1695  	"egrave":   "\u00E8",
  1696  	"eacute":   "\u00E9",
  1697  	"ecirc":    "\u00EA",
  1698  	"euml":     "\u00EB",
  1699  	"igrave":   "\u00EC",
  1700  	"iacute":   "\u00ED",
  1701  	"icirc":    "\u00EE",
  1702  	"iuml":     "\u00EF",
  1703  	"eth":      "\u00F0",
  1704  	"ntilde":   "\u00F1",
  1705  	"ograve":   "\u00F2",
  1706  	"oacute":   "\u00F3",
  1707  	"ocirc":    "\u00F4",
  1708  	"otilde":   "\u00F5",
  1709  	"ouml":     "\u00F6",
  1710  	"divide":   "\u00F7",
  1711  	"oslash":   "\u00F8",
  1712  	"ugrave":   "\u00F9",
  1713  	"uacute":   "\u00FA",
  1714  	"ucirc":    "\u00FB",
  1715  	"uuml":     "\u00FC",
  1716  	"yacute":   "\u00FD",
  1717  	"thorn":    "\u00FE",
  1718  	"yuml":     "\u00FF",
  1719  	"fnof":     "\u0192",
  1720  	"Alpha":    "\u0391",
  1721  	"Beta":     "\u0392",
  1722  	"Gamma":    "\u0393",
  1723  	"Delta":    "\u0394",
  1724  	"Epsilon":  "\u0395",
  1725  	"Zeta":     "\u0396",
  1726  	"Eta":      "\u0397",
  1727  	"Theta":    "\u0398",
  1728  	"Iota":     "\u0399",
  1729  	"Kappa":    "\u039A",
  1730  	"Lambda":   "\u039B",
  1731  	"Mu":       "\u039C",
  1732  	"Nu":       "\u039D",
  1733  	"Xi":       "\u039E",
  1734  	"Omicron":  "\u039F",
  1735  	"Pi":       "\u03A0",
  1736  	"Rho":      "\u03A1",
  1737  	"Sigma":    "\u03A3",
  1738  	"Tau":      "\u03A4",
  1739  	"Upsilon":  "\u03A5",
  1740  	"Phi":      "\u03A6",
  1741  	"Chi":      "\u03A7",
  1742  	"Psi":      "\u03A8",
  1743  	"Omega":    "\u03A9",
  1744  	"alpha":    "\u03B1",
  1745  	"beta":     "\u03B2",
  1746  	"gamma":    "\u03B3",
  1747  	"delta":    "\u03B4",
  1748  	"epsilon":  "\u03B5",
  1749  	"zeta":     "\u03B6",
  1750  	"eta":      "\u03B7",
  1751  	"theta":    "\u03B8",
  1752  	"iota":     "\u03B9",
  1753  	"kappa":    "\u03BA",
  1754  	"lambda":   "\u03BB",
  1755  	"mu":       "\u03BC",
  1756  	"nu":       "\u03BD",
  1757  	"xi":       "\u03BE",
  1758  	"omicron":  "\u03BF",
  1759  	"pi":       "\u03C0",
  1760  	"rho":      "\u03C1",
  1761  	"sigmaf":   "\u03C2",
  1762  	"sigma":    "\u03C3",
  1763  	"tau":      "\u03C4",
  1764  	"upsilon":  "\u03C5",
  1765  	"phi":      "\u03C6",
  1766  	"chi":      "\u03C7",
  1767  	"psi":      "\u03C8",
  1768  	"omega":    "\u03C9",
  1769  	"thetasym": "\u03D1",
  1770  	"upsih":    "\u03D2",
  1771  	"piv":      "\u03D6",
  1772  	"bull":     "\u2022",
  1773  	"hellip":   "\u2026",
  1774  	"prime":    "\u2032",
  1775  	"Prime":    "\u2033",
  1776  	"oline":    "\u203E",
  1777  	"frasl":    "\u2044",
  1778  	"weierp":   "\u2118",
  1779  	"image":    "\u2111",
  1780  	"real":     "\u211C",
  1781  	"trade":    "\u2122",
  1782  	"alefsym":  "\u2135",
  1783  	"larr":     "\u2190",
  1784  	"uarr":     "\u2191",
  1785  	"rarr":     "\u2192",
  1786  	"darr":     "\u2193",
  1787  	"harr":     "\u2194",
  1788  	"crarr":    "\u21B5",
  1789  	"lArr":     "\u21D0",
  1790  	"uArr":     "\u21D1",
  1791  	"rArr":     "\u21D2",
  1792  	"dArr":     "\u21D3",
  1793  	"hArr":     "\u21D4",
  1794  	"forall":   "\u2200",
  1795  	"part":     "\u2202",
  1796  	"exist":    "\u2203",
  1797  	"empty":    "\u2205",
  1798  	"nabla":    "\u2207",
  1799  	"isin":     "\u2208",
  1800  	"notin":    "\u2209",
  1801  	"ni":       "\u220B",
  1802  	"prod":     "\u220F",
  1803  	"sum":      "\u2211",
  1804  	"minus":    "\u2212",
  1805  	"lowast":   "\u2217",
  1806  	"radic":    "\u221A",
  1807  	"prop":     "\u221D",
  1808  	"infin":    "\u221E",
  1809  	"ang":      "\u2220",
  1810  	"and":      "\u2227",
  1811  	"or":       "\u2228",
  1812  	"cap":      "\u2229",
  1813  	"cup":      "\u222A",
  1814  	"int":      "\u222B",
  1815  	"there4":   "\u2234",
  1816  	"sim":      "\u223C",
  1817  	"cong":     "\u2245",
  1818  	"asymp":    "\u2248",
  1819  	"ne":       "\u2260",
  1820  	"equiv":    "\u2261",
  1821  	"le":       "\u2264",
  1822  	"ge":       "\u2265",
  1823  	"sub":      "\u2282",
  1824  	"sup":      "\u2283",
  1825  	"nsub":     "\u2284",
  1826  	"sube":     "\u2286",
  1827  	"supe":     "\u2287",
  1828  	"oplus":    "\u2295",
  1829  	"otimes":   "\u2297",
  1830  	"perp":     "\u22A5",
  1831  	"sdot":     "\u22C5",
  1832  	"lceil":    "\u2308",
  1833  	"rceil":    "\u2309",
  1834  	"lfloor":   "\u230A",
  1835  	"rfloor":   "\u230B",
  1836  	"lang":     "\u2329",
  1837  	"rang":     "\u232A",
  1838  	"loz":      "\u25CA",
  1839  	"spades":   "\u2660",
  1840  	"clubs":    "\u2663",
  1841  	"hearts":   "\u2665",
  1842  	"diams":    "\u2666",
  1843  	"quot":     "\u0022",
  1844  	"amp":      "\u0026",
  1845  	"lt":       "\u003C",
  1846  	"gt":       "\u003E",
  1847  	"OElig":    "\u0152",
  1848  	"oelig":    "\u0153",
  1849  	"Scaron":   "\u0160",
  1850  	"scaron":   "\u0161",
  1851  	"Yuml":     "\u0178",
  1852  	"circ":     "\u02C6",
  1853  	"tilde":    "\u02DC",
  1854  	"ensp":     "\u2002",
  1855  	"emsp":     "\u2003",
  1856  	"thinsp":   "\u2009",
  1857  	"zwnj":     "\u200C",
  1858  	"zwj":      "\u200D",
  1859  	"lrm":      "\u200E",
  1860  	"rlm":      "\u200F",
  1861  	"ndash":    "\u2013",
  1862  	"mdash":    "\u2014",
  1863  	"lsquo":    "\u2018",
  1864  	"rsquo":    "\u2019",
  1865  	"sbquo":    "\u201A",
  1866  	"ldquo":    "\u201C",
  1867  	"rdquo":    "\u201D",
  1868  	"bdquo":    "\u201E",
  1869  	"dagger":   "\u2020",
  1870  	"Dagger":   "\u2021",
  1871  	"permil":   "\u2030",
  1872  	"lsaquo":   "\u2039",
  1873  	"rsaquo":   "\u203A",
  1874  	"euro":     "\u20AC",
  1875  }
  1876  
  1877  // HTMLAutoClose is the set of HTML elements that
  1878  // should be considered to close automatically.
  1879  //
  1880  // See the [Decoder.Strict] and [Decoder.Entity] fields' documentation.
  1881  var HTMLAutoClose []string = htmlAutoClose
  1882  
  1883  var htmlAutoClose = []string{
  1884  	/*
  1885  		hget http://www.w3.org/TR/html4/loose.dtd |
  1886  		9 sed -n 's/<!ELEMENT ([^ ]*) +- O EMPTY.+/	"\1",/p' | tr A-Z a-z
  1887  	*/
  1888  	"basefont",
  1889  	"br",
  1890  	"area",
  1891  	"link",
  1892  	"img",
  1893  	"param",
  1894  	"hr",
  1895  	"input",
  1896  	"col",
  1897  	"frame",
  1898  	"isindex",
  1899  	"base",
  1900  	"meta",
  1901  }
  1902  
  1903  var (
  1904  	escQuot = []byte("&#34;") // shorter than "&quot;"
  1905  	escApos = []byte("&#39;") // shorter than "&apos;"
  1906  	escAmp  = []byte("&amp;")
  1907  	escLT   = []byte("&lt;")
  1908  	escGT   = []byte("&gt;")
  1909  	escTab  = []byte("&#x9;")
  1910  	escNL   = []byte("&#xA;")
  1911  	escCR   = []byte("&#xD;")
  1912  	escFFFD = []byte("\uFFFD") // Unicode replacement character
  1913  )
  1914  
  1915  // EscapeText writes to w the properly escaped XML equivalent
  1916  // of the plain text data s.
  1917  func EscapeText(w io.Writer, s []byte) error {
  1918  	return escapeText(w, s, true)
  1919  }
  1920  
  1921  // escapeText writes to w the properly escaped XML equivalent
  1922  // of the plain text data s. If escapeNewline is true, newline
  1923  // characters will be escaped.
  1924  func escapeText(w io.Writer, s []byte, escapeNewline bool) error {
  1925  	var esc []byte
  1926  	last := 0
  1927  	for i := 0; i < len(s); {
  1928  		r, width := utf8.DecodeRune(s[i:])
  1929  		i += width
  1930  		switch r {
  1931  		case '"':
  1932  			esc = escQuot
  1933  		case '\'':
  1934  			esc = escApos
  1935  		case '&':
  1936  			esc = escAmp
  1937  		case '<':
  1938  			esc = escLT
  1939  		case '>':
  1940  			esc = escGT
  1941  		case '\t':
  1942  			esc = escTab
  1943  		case '\n':
  1944  			if !escapeNewline {
  1945  				continue
  1946  			}
  1947  			esc = escNL
  1948  		case '\r':
  1949  			esc = escCR
  1950  		default:
  1951  			if !isInCharacterRange(r) || (r == 0xFFFD && width == 1) {
  1952  				esc = escFFFD
  1953  				break
  1954  			}
  1955  			continue
  1956  		}
  1957  		if _, err := w.Write(s[last : i-width]); err != nil {
  1958  			return err
  1959  		}
  1960  		if _, err := w.Write(esc); err != nil {
  1961  			return err
  1962  		}
  1963  		last = i
  1964  	}
  1965  	_, err := w.Write(s[last:])
  1966  	return err
  1967  }
  1968  
  1969  // EscapeString writes to p the properly escaped XML equivalent
  1970  // of the plain text data s.
  1971  func (p *printer) EscapeString(s string) {
  1972  	var esc []byte
  1973  	last := 0
  1974  	for i := 0; i < len(s); {
  1975  		r, width := utf8.DecodeRuneInString(s[i:])
  1976  		i += width
  1977  		switch r {
  1978  		case '"':
  1979  			esc = escQuot
  1980  		case '\'':
  1981  			esc = escApos
  1982  		case '&':
  1983  			esc = escAmp
  1984  		case '<':
  1985  			esc = escLT
  1986  		case '>':
  1987  			esc = escGT
  1988  		case '\t':
  1989  			esc = escTab
  1990  		case '\n':
  1991  			esc = escNL
  1992  		case '\r':
  1993  			esc = escCR
  1994  		default:
  1995  			if !isInCharacterRange(r) || (r == 0xFFFD && width == 1) {
  1996  				esc = escFFFD
  1997  				break
  1998  			}
  1999  			continue
  2000  		}
  2001  		p.WriteString(s[last : i-width])
  2002  		p.Write(esc)
  2003  		last = i
  2004  	}
  2005  	p.WriteString(s[last:])
  2006  }
  2007  
  2008  // Escape is like [EscapeText] but omits the error return value.
  2009  // It is provided for backwards compatibility with Go 1.0.
  2010  // Code targeting Go 1.1 or later should use [EscapeText].
  2011  func Escape(w io.Writer, s []byte) {
  2012  	EscapeText(w, s)
  2013  }
  2014  
  2015  var (
  2016  	cdataStart  = []byte("<![CDATA[")
  2017  	cdataEnd    = []byte("]]>")
  2018  	cdataEscape = []byte("]]]]><![CDATA[>")
  2019  )
  2020  
  2021  // emitCDATA writes to w the CDATA-wrapped plain text data s.
  2022  // It escapes CDATA directives nested in s.
  2023  func emitCDATA(w io.Writer, s []byte) error {
  2024  	if len(s) == 0 {
  2025  		return nil
  2026  	}
  2027  	if _, err := w.Write(cdataStart); err != nil {
  2028  		return err
  2029  	}
  2030  
  2031  	for {
  2032  		before, after, ok := bytes.Cut(s, cdataEnd)
  2033  		if !ok {
  2034  			break
  2035  		}
  2036  		// Found a nested CDATA directive end.
  2037  		if _, err := w.Write(before); err != nil {
  2038  			return err
  2039  		}
  2040  		if _, err := w.Write(cdataEscape); err != nil {
  2041  			return err
  2042  		}
  2043  		s = after
  2044  	}
  2045  
  2046  	if _, err := w.Write(s); err != nil {
  2047  		return err
  2048  	}
  2049  
  2050  	_, err := w.Write(cdataEnd)
  2051  	return err
  2052  }
  2053  
  2054  // procInst parses the `param="..."` or `param='...'`
  2055  // value out of the provided string, returning "" if not found.
  2056  func procInst(param, s string) string {
  2057  	// TODO: this parsing is somewhat lame and not exact.
  2058  	// It works for all actual cases, though.
  2059  	param = param + "="
  2060  	lenp := len(param)
  2061  	i := 0
  2062  	var sep byte
  2063  	for i < len(s) {
  2064  		sub := s[i:]
  2065  		k := strings.Index(sub, param)
  2066  		if k < 0 || lenp+k >= len(sub) {
  2067  			return ""
  2068  		}
  2069  		i += lenp + k + 1
  2070  		if c := sub[lenp+k]; c == '\'' || c == '"' {
  2071  			sep = c
  2072  			break
  2073  		}
  2074  	}
  2075  	if sep == 0 {
  2076  		return ""
  2077  	}
  2078  	j := strings.IndexByte(s[i:], sep)
  2079  	if j < 0 {
  2080  		return ""
  2081  	}
  2082  	return s[i : i+j]
  2083  }
  2084  

View as plain text