mirror of
https://codeberg.org/forgejo/forgejo.git
synced 2024-12-24 13:09:23 -05:00
86e2789960
* update github.com/PuerkitoBio/goquery * update github.com/alecthomas/chroma * update github.com/blevesearch/bleve/v2 * update github.com/caddyserver/certmagic * update github.com/go-enry/go-enry/v2 * update github.com/go-git/go-billy/v5 * update github.com/go-git/go-git/v5 * update github.com/go-redis/redis/v8 * update github.com/go-testfixtures/testfixtures/v3 * update github.com/jaytaylor/html2text * update github.com/json-iterator/go * update github.com/klauspost/compress * update github.com/markbates/goth * update github.com/mattn/go-isatty * update github.com/mholt/archiver/v3 * update github.com/microcosm-cc/bluemonday * update github.com/minio/minio-go/v7 * update github.com/prometheus/client_golang * update github.com/unrolled/render * update github.com/xanzy/go-gitlab * update github.com/yuin/goldmark * update github.com/yuin/goldmark-highlighting Co-authored-by: techknowlogick <techknowlogick@gitea.io>
2460 lines
59 KiB
Go
Vendored
2460 lines
59 KiB
Go
Vendored
// Copyright 2010 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 html
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"strings"
|
|
|
|
a "golang.org/x/net/html/atom"
|
|
)
|
|
|
|
// A parser implements the HTML5 parsing algorithm:
|
|
// https://html.spec.whatwg.org/multipage/syntax.html#tree-construction
|
|
type parser struct {
|
|
// tokenizer provides the tokens for the parser.
|
|
tokenizer *Tokenizer
|
|
// tok is the most recently read token.
|
|
tok Token
|
|
// Self-closing tags like <hr/> are treated as start tags, except that
|
|
// hasSelfClosingToken is set while they are being processed.
|
|
hasSelfClosingToken bool
|
|
// doc is the document root element.
|
|
doc *Node
|
|
// The stack of open elements (section 12.2.4.2) and active formatting
|
|
// elements (section 12.2.4.3).
|
|
oe, afe nodeStack
|
|
// Element pointers (section 12.2.4.4).
|
|
head, form *Node
|
|
// Other parsing state flags (section 12.2.4.5).
|
|
scripting, framesetOK bool
|
|
// The stack of template insertion modes
|
|
templateStack insertionModeStack
|
|
// im is the current insertion mode.
|
|
im insertionMode
|
|
// originalIM is the insertion mode to go back to after completing a text
|
|
// or inTableText insertion mode.
|
|
originalIM insertionMode
|
|
// fosterParenting is whether new elements should be inserted according to
|
|
// the foster parenting rules (section 12.2.6.1).
|
|
fosterParenting bool
|
|
// quirks is whether the parser is operating in "quirks mode."
|
|
quirks bool
|
|
// fragment is whether the parser is parsing an HTML fragment.
|
|
fragment bool
|
|
// context is the context element when parsing an HTML fragment
|
|
// (section 12.4).
|
|
context *Node
|
|
}
|
|
|
|
func (p *parser) top() *Node {
|
|
if n := p.oe.top(); n != nil {
|
|
return n
|
|
}
|
|
return p.doc
|
|
}
|
|
|
|
// Stop tags for use in popUntil. These come from section 12.2.4.2.
|
|
var (
|
|
defaultScopeStopTags = map[string][]a.Atom{
|
|
"": {a.Applet, a.Caption, a.Html, a.Table, a.Td, a.Th, a.Marquee, a.Object, a.Template},
|
|
"math": {a.AnnotationXml, a.Mi, a.Mn, a.Mo, a.Ms, a.Mtext},
|
|
"svg": {a.Desc, a.ForeignObject, a.Title},
|
|
}
|
|
)
|
|
|
|
type scope int
|
|
|
|
const (
|
|
defaultScope scope = iota
|
|
listItemScope
|
|
buttonScope
|
|
tableScope
|
|
tableRowScope
|
|
tableBodyScope
|
|
selectScope
|
|
)
|
|
|
|
// popUntil pops the stack of open elements at the highest element whose tag
|
|
// is in matchTags, provided there is no higher element in the scope's stop
|
|
// tags (as defined in section 12.2.4.2). It returns whether or not there was
|
|
// such an element. If there was not, popUntil leaves the stack unchanged.
|
|
//
|
|
// For example, the set of stop tags for table scope is: "html", "table". If
|
|
// the stack was:
|
|
// ["html", "body", "font", "table", "b", "i", "u"]
|
|
// then popUntil(tableScope, "font") would return false, but
|
|
// popUntil(tableScope, "i") would return true and the stack would become:
|
|
// ["html", "body", "font", "table", "b"]
|
|
//
|
|
// If an element's tag is in both the stop tags and matchTags, then the stack
|
|
// will be popped and the function returns true (provided, of course, there was
|
|
// no higher element in the stack that was also in the stop tags). For example,
|
|
// popUntil(tableScope, "table") returns true and leaves:
|
|
// ["html", "body", "font"]
|
|
func (p *parser) popUntil(s scope, matchTags ...a.Atom) bool {
|
|
if i := p.indexOfElementInScope(s, matchTags...); i != -1 {
|
|
p.oe = p.oe[:i]
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
// indexOfElementInScope returns the index in p.oe of the highest element whose
|
|
// tag is in matchTags that is in scope. If no matching element is in scope, it
|
|
// returns -1.
|
|
func (p *parser) indexOfElementInScope(s scope, matchTags ...a.Atom) int {
|
|
for i := len(p.oe) - 1; i >= 0; i-- {
|
|
tagAtom := p.oe[i].DataAtom
|
|
if p.oe[i].Namespace == "" {
|
|
for _, t := range matchTags {
|
|
if t == tagAtom {
|
|
return i
|
|
}
|
|
}
|
|
switch s {
|
|
case defaultScope:
|
|
// No-op.
|
|
case listItemScope:
|
|
if tagAtom == a.Ol || tagAtom == a.Ul {
|
|
return -1
|
|
}
|
|
case buttonScope:
|
|
if tagAtom == a.Button {
|
|
return -1
|
|
}
|
|
case tableScope:
|
|
if tagAtom == a.Html || tagAtom == a.Table || tagAtom == a.Template {
|
|
return -1
|
|
}
|
|
case selectScope:
|
|
if tagAtom != a.Optgroup && tagAtom != a.Option {
|
|
return -1
|
|
}
|
|
default:
|
|
panic("unreachable")
|
|
}
|
|
}
|
|
switch s {
|
|
case defaultScope, listItemScope, buttonScope:
|
|
for _, t := range defaultScopeStopTags[p.oe[i].Namespace] {
|
|
if t == tagAtom {
|
|
return -1
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return -1
|
|
}
|
|
|
|
// elementInScope is like popUntil, except that it doesn't modify the stack of
|
|
// open elements.
|
|
func (p *parser) elementInScope(s scope, matchTags ...a.Atom) bool {
|
|
return p.indexOfElementInScope(s, matchTags...) != -1
|
|
}
|
|
|
|
// clearStackToContext pops elements off the stack of open elements until a
|
|
// scope-defined element is found.
|
|
func (p *parser) clearStackToContext(s scope) {
|
|
for i := len(p.oe) - 1; i >= 0; i-- {
|
|
tagAtom := p.oe[i].DataAtom
|
|
switch s {
|
|
case tableScope:
|
|
if tagAtom == a.Html || tagAtom == a.Table || tagAtom == a.Template {
|
|
p.oe = p.oe[:i+1]
|
|
return
|
|
}
|
|
case tableRowScope:
|
|
if tagAtom == a.Html || tagAtom == a.Tr || tagAtom == a.Template {
|
|
p.oe = p.oe[:i+1]
|
|
return
|
|
}
|
|
case tableBodyScope:
|
|
if tagAtom == a.Html || tagAtom == a.Tbody || tagAtom == a.Tfoot || tagAtom == a.Thead || tagAtom == a.Template {
|
|
p.oe = p.oe[:i+1]
|
|
return
|
|
}
|
|
default:
|
|
panic("unreachable")
|
|
}
|
|
}
|
|
}
|
|
|
|
// parseGenericRawTextElements implements the generic raw text element parsing
|
|
// algorithm defined in 12.2.6.2.
|
|
// https://html.spec.whatwg.org/multipage/parsing.html#parsing-elements-that-contain-only-text
|
|
// TODO: Since both RAWTEXT and RCDATA states are treated as tokenizer's part
|
|
// officially, need to make tokenizer consider both states.
|
|
func (p *parser) parseGenericRawTextElement() {
|
|
p.addElement()
|
|
p.originalIM = p.im
|
|
p.im = textIM
|
|
}
|
|
|
|
// generateImpliedEndTags pops nodes off the stack of open elements as long as
|
|
// the top node has a tag name of dd, dt, li, optgroup, option, p, rb, rp, rt or rtc.
|
|
// If exceptions are specified, nodes with that name will not be popped off.
|
|
func (p *parser) generateImpliedEndTags(exceptions ...string) {
|
|
var i int
|
|
loop:
|
|
for i = len(p.oe) - 1; i >= 0; i-- {
|
|
n := p.oe[i]
|
|
if n.Type != ElementNode {
|
|
break
|
|
}
|
|
switch n.DataAtom {
|
|
case a.Dd, a.Dt, a.Li, a.Optgroup, a.Option, a.P, a.Rb, a.Rp, a.Rt, a.Rtc:
|
|
for _, except := range exceptions {
|
|
if n.Data == except {
|
|
break loop
|
|
}
|
|
}
|
|
continue
|
|
}
|
|
break
|
|
}
|
|
|
|
p.oe = p.oe[:i+1]
|
|
}
|
|
|
|
// addChild adds a child node n to the top element, and pushes n onto the stack
|
|
// of open elements if it is an element node.
|
|
func (p *parser) addChild(n *Node) {
|
|
if p.shouldFosterParent() {
|
|
p.fosterParent(n)
|
|
} else {
|
|
p.top().AppendChild(n)
|
|
}
|
|
|
|
if n.Type == ElementNode {
|
|
p.oe = append(p.oe, n)
|
|
}
|
|
}
|
|
|
|
// shouldFosterParent returns whether the next node to be added should be
|
|
// foster parented.
|
|
func (p *parser) shouldFosterParent() bool {
|
|
if p.fosterParenting {
|
|
switch p.top().DataAtom {
|
|
case a.Table, a.Tbody, a.Tfoot, a.Thead, a.Tr:
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// fosterParent adds a child node according to the foster parenting rules.
|
|
// Section 12.2.6.1, "foster parenting".
|
|
func (p *parser) fosterParent(n *Node) {
|
|
var table, parent, prev, template *Node
|
|
var i int
|
|
for i = len(p.oe) - 1; i >= 0; i-- {
|
|
if p.oe[i].DataAtom == a.Table {
|
|
table = p.oe[i]
|
|
break
|
|
}
|
|
}
|
|
|
|
var j int
|
|
for j = len(p.oe) - 1; j >= 0; j-- {
|
|
if p.oe[j].DataAtom == a.Template {
|
|
template = p.oe[j]
|
|
break
|
|
}
|
|
}
|
|
|
|
if template != nil && (table == nil || j > i) {
|
|
template.AppendChild(n)
|
|
return
|
|
}
|
|
|
|
if table == nil {
|
|
// The foster parent is the html element.
|
|
parent = p.oe[0]
|
|
} else {
|
|
parent = table.Parent
|
|
}
|
|
if parent == nil {
|
|
parent = p.oe[i-1]
|
|
}
|
|
|
|
if table != nil {
|
|
prev = table.PrevSibling
|
|
} else {
|
|
prev = parent.LastChild
|
|
}
|
|
if prev != nil && prev.Type == TextNode && n.Type == TextNode {
|
|
prev.Data += n.Data
|
|
return
|
|
}
|
|
|
|
parent.InsertBefore(n, table)
|
|
}
|
|
|
|
// addText adds text to the preceding node if it is a text node, or else it
|
|
// calls addChild with a new text node.
|
|
func (p *parser) addText(text string) {
|
|
if text == "" {
|
|
return
|
|
}
|
|
|
|
if p.shouldFosterParent() {
|
|
p.fosterParent(&Node{
|
|
Type: TextNode,
|
|
Data: text,
|
|
})
|
|
return
|
|
}
|
|
|
|
t := p.top()
|
|
if n := t.LastChild; n != nil && n.Type == TextNode {
|
|
n.Data += text
|
|
return
|
|
}
|
|
p.addChild(&Node{
|
|
Type: TextNode,
|
|
Data: text,
|
|
})
|
|
}
|
|
|
|
// addElement adds a child element based on the current token.
|
|
func (p *parser) addElement() {
|
|
p.addChild(&Node{
|
|
Type: ElementNode,
|
|
DataAtom: p.tok.DataAtom,
|
|
Data: p.tok.Data,
|
|
Attr: p.tok.Attr,
|
|
})
|
|
}
|
|
|
|
// Section 12.2.4.3.
|
|
func (p *parser) addFormattingElement() {
|
|
tagAtom, attr := p.tok.DataAtom, p.tok.Attr
|
|
p.addElement()
|
|
|
|
// Implement the Noah's Ark clause, but with three per family instead of two.
|
|
identicalElements := 0
|
|
findIdenticalElements:
|
|
for i := len(p.afe) - 1; i >= 0; i-- {
|
|
n := p.afe[i]
|
|
if n.Type == scopeMarkerNode {
|
|
break
|
|
}
|
|
if n.Type != ElementNode {
|
|
continue
|
|
}
|
|
if n.Namespace != "" {
|
|
continue
|
|
}
|
|
if n.DataAtom != tagAtom {
|
|
continue
|
|
}
|
|
if len(n.Attr) != len(attr) {
|
|
continue
|
|
}
|
|
compareAttributes:
|
|
for _, t0 := range n.Attr {
|
|
for _, t1 := range attr {
|
|
if t0.Key == t1.Key && t0.Namespace == t1.Namespace && t0.Val == t1.Val {
|
|
// Found a match for this attribute, continue with the next attribute.
|
|
continue compareAttributes
|
|
}
|
|
}
|
|
// If we get here, there is no attribute that matches a.
|
|
// Therefore the element is not identical to the new one.
|
|
continue findIdenticalElements
|
|
}
|
|
|
|
identicalElements++
|
|
if identicalElements >= 3 {
|
|
p.afe.remove(n)
|
|
}
|
|
}
|
|
|
|
p.afe = append(p.afe, p.top())
|
|
}
|
|
|
|
// Section 12.2.4.3.
|
|
func (p *parser) clearActiveFormattingElements() {
|
|
for {
|
|
if n := p.afe.pop(); len(p.afe) == 0 || n.Type == scopeMarkerNode {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
// Section 12.2.4.3.
|
|
func (p *parser) reconstructActiveFormattingElements() {
|
|
n := p.afe.top()
|
|
if n == nil {
|
|
return
|
|
}
|
|
if n.Type == scopeMarkerNode || p.oe.index(n) != -1 {
|
|
return
|
|
}
|
|
i := len(p.afe) - 1
|
|
for n.Type != scopeMarkerNode && p.oe.index(n) == -1 {
|
|
if i == 0 {
|
|
i = -1
|
|
break
|
|
}
|
|
i--
|
|
n = p.afe[i]
|
|
}
|
|
for {
|
|
i++
|
|
clone := p.afe[i].clone()
|
|
p.addChild(clone)
|
|
p.afe[i] = clone
|
|
if i == len(p.afe)-1 {
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
// Section 12.2.5.
|
|
func (p *parser) acknowledgeSelfClosingTag() {
|
|
p.hasSelfClosingToken = false
|
|
}
|
|
|
|
// An insertion mode (section 12.2.4.1) is the state transition function from
|
|
// a particular state in the HTML5 parser's state machine. It updates the
|
|
// parser's fields depending on parser.tok (where ErrorToken means EOF).
|
|
// It returns whether the token was consumed.
|
|
type insertionMode func(*parser) bool
|
|
|
|
// setOriginalIM sets the insertion mode to return to after completing a text or
|
|
// inTableText insertion mode.
|
|
// Section 12.2.4.1, "using the rules for".
|
|
func (p *parser) setOriginalIM() {
|
|
if p.originalIM != nil {
|
|
panic("html: bad parser state: originalIM was set twice")
|
|
}
|
|
p.originalIM = p.im
|
|
}
|
|
|
|
// Section 12.2.4.1, "reset the insertion mode".
|
|
func (p *parser) resetInsertionMode() {
|
|
for i := len(p.oe) - 1; i >= 0; i-- {
|
|
n := p.oe[i]
|
|
last := i == 0
|
|
if last && p.context != nil {
|
|
n = p.context
|
|
}
|
|
|
|
switch n.DataAtom {
|
|
case a.Select:
|
|
if !last {
|
|
for ancestor, first := n, p.oe[0]; ancestor != first; {
|
|
ancestor = p.oe[p.oe.index(ancestor)-1]
|
|
switch ancestor.DataAtom {
|
|
case a.Template:
|
|
p.im = inSelectIM
|
|
return
|
|
case a.Table:
|
|
p.im = inSelectInTableIM
|
|
return
|
|
}
|
|
}
|
|
}
|
|
p.im = inSelectIM
|
|
case a.Td, a.Th:
|
|
// TODO: remove this divergence from the HTML5 spec.
|
|
//
|
|
// See https://bugs.chromium.org/p/chromium/issues/detail?id=829668
|
|
p.im = inCellIM
|
|
case a.Tr:
|
|
p.im = inRowIM
|
|
case a.Tbody, a.Thead, a.Tfoot:
|
|
p.im = inTableBodyIM
|
|
case a.Caption:
|
|
p.im = inCaptionIM
|
|
case a.Colgroup:
|
|
p.im = inColumnGroupIM
|
|
case a.Table:
|
|
p.im = inTableIM
|
|
case a.Template:
|
|
// TODO: remove this divergence from the HTML5 spec.
|
|
if n.Namespace != "" {
|
|
continue
|
|
}
|
|
p.im = p.templateStack.top()
|
|
case a.Head:
|
|
// TODO: remove this divergence from the HTML5 spec.
|
|
//
|
|
// See https://bugs.chromium.org/p/chromium/issues/detail?id=829668
|
|
p.im = inHeadIM
|
|
case a.Body:
|
|
p.im = inBodyIM
|
|
case a.Frameset:
|
|
p.im = inFramesetIM
|
|
case a.Html:
|
|
if p.head == nil {
|
|
p.im = beforeHeadIM
|
|
} else {
|
|
p.im = afterHeadIM
|
|
}
|
|
default:
|
|
if last {
|
|
p.im = inBodyIM
|
|
return
|
|
}
|
|
continue
|
|
}
|
|
return
|
|
}
|
|
}
|
|
|
|
const whitespace = " \t\r\n\f"
|
|
|
|
// Section 12.2.6.4.1.
|
|
func initialIM(p *parser) bool {
|
|
switch p.tok.Type {
|
|
case TextToken:
|
|
p.tok.Data = strings.TrimLeft(p.tok.Data, whitespace)
|
|
if len(p.tok.Data) == 0 {
|
|
// It was all whitespace, so ignore it.
|
|
return true
|
|
}
|
|
case CommentToken:
|
|
p.doc.AppendChild(&Node{
|
|
Type: CommentNode,
|
|
Data: p.tok.Data,
|
|
})
|
|
return true
|
|
case DoctypeToken:
|
|
n, quirks := parseDoctype(p.tok.Data)
|
|
p.doc.AppendChild(n)
|
|
p.quirks = quirks
|
|
p.im = beforeHTMLIM
|
|
return true
|
|
}
|
|
p.quirks = true
|
|
p.im = beforeHTMLIM
|
|
return false
|
|
}
|
|
|
|
// Section 12.2.6.4.2.
|
|
func beforeHTMLIM(p *parser) bool {
|
|
switch p.tok.Type {
|
|
case DoctypeToken:
|
|
// Ignore the token.
|
|
return true
|
|
case TextToken:
|
|
p.tok.Data = strings.TrimLeft(p.tok.Data, whitespace)
|
|
if len(p.tok.Data) == 0 {
|
|
// It was all whitespace, so ignore it.
|
|
return true
|
|
}
|
|
case StartTagToken:
|
|
if p.tok.DataAtom == a.Html {
|
|
p.addElement()
|
|
p.im = beforeHeadIM
|
|
return true
|
|
}
|
|
case EndTagToken:
|
|
switch p.tok.DataAtom {
|
|
case a.Head, a.Body, a.Html, a.Br:
|
|
p.parseImpliedToken(StartTagToken, a.Html, a.Html.String())
|
|
return false
|
|
default:
|
|
// Ignore the token.
|
|
return true
|
|
}
|
|
case CommentToken:
|
|
p.doc.AppendChild(&Node{
|
|
Type: CommentNode,
|
|
Data: p.tok.Data,
|
|
})
|
|
return true
|
|
}
|
|
p.parseImpliedToken(StartTagToken, a.Html, a.Html.String())
|
|
return false
|
|
}
|
|
|
|
// Section 12.2.6.4.3.
|
|
func beforeHeadIM(p *parser) bool {
|
|
switch p.tok.Type {
|
|
case TextToken:
|
|
p.tok.Data = strings.TrimLeft(p.tok.Data, whitespace)
|
|
if len(p.tok.Data) == 0 {
|
|
// It was all whitespace, so ignore it.
|
|
return true
|
|
}
|
|
case StartTagToken:
|
|
switch p.tok.DataAtom {
|
|
case a.Head:
|
|
p.addElement()
|
|
p.head = p.top()
|
|
p.im = inHeadIM
|
|
return true
|
|
case a.Html:
|
|
return inBodyIM(p)
|
|
}
|
|
case EndTagToken:
|
|
switch p.tok.DataAtom {
|
|
case a.Head, a.Body, a.Html, a.Br:
|
|
p.parseImpliedToken(StartTagToken, a.Head, a.Head.String())
|
|
return false
|
|
default:
|
|
// Ignore the token.
|
|
return true
|
|
}
|
|
case CommentToken:
|
|
p.addChild(&Node{
|
|
Type: CommentNode,
|
|
Data: p.tok.Data,
|
|
})
|
|
return true
|
|
case DoctypeToken:
|
|
// Ignore the token.
|
|
return true
|
|
}
|
|
|
|
p.parseImpliedToken(StartTagToken, a.Head, a.Head.String())
|
|
return false
|
|
}
|
|
|
|
// Section 12.2.6.4.4.
|
|
func inHeadIM(p *parser) bool {
|
|
switch p.tok.Type {
|
|
case TextToken:
|
|
s := strings.TrimLeft(p.tok.Data, whitespace)
|
|
if len(s) < len(p.tok.Data) {
|
|
// Add the initial whitespace to the current node.
|
|
p.addText(p.tok.Data[:len(p.tok.Data)-len(s)])
|
|
if s == "" {
|
|
return true
|
|
}
|
|
p.tok.Data = s
|
|
}
|
|
case StartTagToken:
|
|
switch p.tok.DataAtom {
|
|
case a.Html:
|
|
return inBodyIM(p)
|
|
case a.Base, a.Basefont, a.Bgsound, a.Link, a.Meta:
|
|
p.addElement()
|
|
p.oe.pop()
|
|
p.acknowledgeSelfClosingTag()
|
|
return true
|
|
case a.Noscript:
|
|
if p.scripting {
|
|
p.parseGenericRawTextElement()
|
|
return true
|
|
}
|
|
p.addElement()
|
|
p.im = inHeadNoscriptIM
|
|
// Don't let the tokenizer go into raw text mode when scripting is disabled.
|
|
p.tokenizer.NextIsNotRawText()
|
|
return true
|
|
case a.Script, a.Title:
|
|
p.addElement()
|
|
p.setOriginalIM()
|
|
p.im = textIM
|
|
return true
|
|
case a.Noframes, a.Style:
|
|
p.parseGenericRawTextElement()
|
|
return true
|
|
case a.Head:
|
|
// Ignore the token.
|
|
return true
|
|
case a.Template:
|
|
// TODO: remove this divergence from the HTML5 spec.
|
|
//
|
|
// We don't handle all of the corner cases when mixing foreign
|
|
// content (i.e. <math> or <svg>) with <template>. Without this
|
|
// early return, we can get into an infinite loop, possibly because
|
|
// of the "TODO... further divergence" a little below.
|
|
//
|
|
// As a workaround, if we are mixing foreign content and templates,
|
|
// just ignore the rest of the HTML. Foreign content is rare and a
|
|
// relatively old HTML feature. Templates are also rare and a
|
|
// relatively new HTML feature. Their combination is very rare.
|
|
for _, e := range p.oe {
|
|
if e.Namespace != "" {
|
|
p.im = ignoreTheRemainingTokens
|
|
return true
|
|
}
|
|
}
|
|
|
|
p.addElement()
|
|
p.afe = append(p.afe, &scopeMarker)
|
|
p.framesetOK = false
|
|
p.im = inTemplateIM
|
|
p.templateStack = append(p.templateStack, inTemplateIM)
|
|
return true
|
|
}
|
|
case EndTagToken:
|
|
switch p.tok.DataAtom {
|
|
case a.Head:
|
|
p.oe.pop()
|
|
p.im = afterHeadIM
|
|
return true
|
|
case a.Body, a.Html, a.Br:
|
|
p.parseImpliedToken(EndTagToken, a.Head, a.Head.String())
|
|
return false
|
|
case a.Template:
|
|
if !p.oe.contains(a.Template) {
|
|
return true
|
|
}
|
|
// TODO: remove this further divergence from the HTML5 spec.
|
|
//
|
|
// See https://bugs.chromium.org/p/chromium/issues/detail?id=829668
|
|
p.generateImpliedEndTags()
|
|
for i := len(p.oe) - 1; i >= 0; i-- {
|
|
if n := p.oe[i]; n.Namespace == "" && n.DataAtom == a.Template {
|
|
p.oe = p.oe[:i]
|
|
break
|
|
}
|
|
}
|
|
p.clearActiveFormattingElements()
|
|
p.templateStack.pop()
|
|
p.resetInsertionMode()
|
|
return true
|
|
default:
|
|
// Ignore the token.
|
|
return true
|
|
}
|
|
case CommentToken:
|
|
p.addChild(&Node{
|
|
Type: CommentNode,
|
|
Data: p.tok.Data,
|
|
})
|
|
return true
|
|
case DoctypeToken:
|
|
// Ignore the token.
|
|
return true
|
|
}
|
|
|
|
p.parseImpliedToken(EndTagToken, a.Head, a.Head.String())
|
|
return false
|
|
}
|
|
|
|
// 12.2.6.4.5.
|
|
func inHeadNoscriptIM(p *parser) bool {
|
|
switch p.tok.Type {
|
|
case DoctypeToken:
|
|
// Ignore the token.
|
|
return true
|
|
case StartTagToken:
|
|
switch p.tok.DataAtom {
|
|
case a.Html:
|
|
return inBodyIM(p)
|
|
case a.Basefont, a.Bgsound, a.Link, a.Meta, a.Noframes, a.Style:
|
|
return inHeadIM(p)
|
|
case a.Head:
|
|
// Ignore the token.
|
|
return true
|
|
case a.Noscript:
|
|
// Don't let the tokenizer go into raw text mode even when a <noscript>
|
|
// tag is in "in head noscript" insertion mode.
|
|
p.tokenizer.NextIsNotRawText()
|
|
// Ignore the token.
|
|
return true
|
|
}
|
|
case EndTagToken:
|
|
switch p.tok.DataAtom {
|
|
case a.Noscript, a.Br:
|
|
default:
|
|
// Ignore the token.
|
|
return true
|
|
}
|
|
case TextToken:
|
|
s := strings.TrimLeft(p.tok.Data, whitespace)
|
|
if len(s) == 0 {
|
|
// It was all whitespace.
|
|
return inHeadIM(p)
|
|
}
|
|
case CommentToken:
|
|
return inHeadIM(p)
|
|
}
|
|
p.oe.pop()
|
|
if p.top().DataAtom != a.Head {
|
|
panic("html: the new current node will be a head element.")
|
|
}
|
|
p.im = inHeadIM
|
|
if p.tok.DataAtom == a.Noscript {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
// Section 12.2.6.4.6.
|
|
func afterHeadIM(p *parser) bool {
|
|
switch p.tok.Type {
|
|
case TextToken:
|
|
s := strings.TrimLeft(p.tok.Data, whitespace)
|
|
if len(s) < len(p.tok.Data) {
|
|
// Add the initial whitespace to the current node.
|
|
p.addText(p.tok.Data[:len(p.tok.Data)-len(s)])
|
|
if s == "" {
|
|
return true
|
|
}
|
|
p.tok.Data = s
|
|
}
|
|
case StartTagToken:
|
|
switch p.tok.DataAtom {
|
|
case a.Html:
|
|
return inBodyIM(p)
|
|
case a.Body:
|
|
p.addElement()
|
|
p.framesetOK = false
|
|
p.im = inBodyIM
|
|
return true
|
|
case a.Frameset:
|
|
p.addElement()
|
|
p.im = inFramesetIM
|
|
return true
|
|
case a.Base, a.Basefont, a.Bgsound, a.Link, a.Meta, a.Noframes, a.Script, a.Style, a.Template, a.Title:
|
|
p.oe = append(p.oe, p.head)
|
|
defer p.oe.remove(p.head)
|
|
return inHeadIM(p)
|
|
case a.Head:
|
|
// Ignore the token.
|
|
return true
|
|
}
|
|
case EndTagToken:
|
|
switch p.tok.DataAtom {
|
|
case a.Body, a.Html, a.Br:
|
|
// Drop down to creating an implied <body> tag.
|
|
case a.Template:
|
|
return inHeadIM(p)
|
|
default:
|
|
// Ignore the token.
|
|
return true
|
|
}
|
|
case CommentToken:
|
|
p.addChild(&Node{
|
|
Type: CommentNode,
|
|
Data: p.tok.Data,
|
|
})
|
|
return true
|
|
case DoctypeToken:
|
|
// Ignore the token.
|
|
return true
|
|
}
|
|
|
|
p.parseImpliedToken(StartTagToken, a.Body, a.Body.String())
|
|
p.framesetOK = true
|
|
return false
|
|
}
|
|
|
|
// copyAttributes copies attributes of src not found on dst to dst.
|
|
func copyAttributes(dst *Node, src Token) {
|
|
if len(src.Attr) == 0 {
|
|
return
|
|
}
|
|
attr := map[string]string{}
|
|
for _, t := range dst.Attr {
|
|
attr[t.Key] = t.Val
|
|
}
|
|
for _, t := range src.Attr {
|
|
if _, ok := attr[t.Key]; !ok {
|
|
dst.Attr = append(dst.Attr, t)
|
|
attr[t.Key] = t.Val
|
|
}
|
|
}
|
|
}
|
|
|
|
// Section 12.2.6.4.7.
|
|
func inBodyIM(p *parser) bool {
|
|
switch p.tok.Type {
|
|
case TextToken:
|
|
d := p.tok.Data
|
|
switch n := p.oe.top(); n.DataAtom {
|
|
case a.Pre, a.Listing:
|
|
if n.FirstChild == nil {
|
|
// Ignore a newline at the start of a <pre> block.
|
|
if d != "" && d[0] == '\r' {
|
|
d = d[1:]
|
|
}
|
|
if d != "" && d[0] == '\n' {
|
|
d = d[1:]
|
|
}
|
|
}
|
|
}
|
|
d = strings.Replace(d, "\x00", "", -1)
|
|
if d == "" {
|
|
return true
|
|
}
|
|
p.reconstructActiveFormattingElements()
|
|
p.addText(d)
|
|
if p.framesetOK && strings.TrimLeft(d, whitespace) != "" {
|
|
// There were non-whitespace characters inserted.
|
|
p.framesetOK = false
|
|
}
|
|
case StartTagToken:
|
|
switch p.tok.DataAtom {
|
|
case a.Html:
|
|
if p.oe.contains(a.Template) {
|
|
return true
|
|
}
|
|
copyAttributes(p.oe[0], p.tok)
|
|
case a.Base, a.Basefont, a.Bgsound, a.Link, a.Meta, a.Noframes, a.Script, a.Style, a.Template, a.Title:
|
|
return inHeadIM(p)
|
|
case a.Body:
|
|
if p.oe.contains(a.Template) {
|
|
return true
|
|
}
|
|
if len(p.oe) >= 2 {
|
|
body := p.oe[1]
|
|
if body.Type == ElementNode && body.DataAtom == a.Body {
|
|
p.framesetOK = false
|
|
copyAttributes(body, p.tok)
|
|
}
|
|
}
|
|
case a.Frameset:
|
|
if !p.framesetOK || len(p.oe) < 2 || p.oe[1].DataAtom != a.Body {
|
|
// Ignore the token.
|
|
return true
|
|
}
|
|
body := p.oe[1]
|
|
if body.Parent != nil {
|
|
body.Parent.RemoveChild(body)
|
|
}
|
|
p.oe = p.oe[:1]
|
|
p.addElement()
|
|
p.im = inFramesetIM
|
|
return true
|
|
case a.Address, a.Article, a.Aside, a.Blockquote, a.Center, a.Details, a.Dialog, a.Dir, a.Div, a.Dl, a.Fieldset, a.Figcaption, a.Figure, a.Footer, a.Header, a.Hgroup, a.Main, a.Menu, a.Nav, a.Ol, a.P, a.Section, a.Summary, a.Ul:
|
|
p.popUntil(buttonScope, a.P)
|
|
p.addElement()
|
|
case a.H1, a.H2, a.H3, a.H4, a.H5, a.H6:
|
|
p.popUntil(buttonScope, a.P)
|
|
switch n := p.top(); n.DataAtom {
|
|
case a.H1, a.H2, a.H3, a.H4, a.H5, a.H6:
|
|
p.oe.pop()
|
|
}
|
|
p.addElement()
|
|
case a.Pre, a.Listing:
|
|
p.popUntil(buttonScope, a.P)
|
|
p.addElement()
|
|
// The newline, if any, will be dealt with by the TextToken case.
|
|
p.framesetOK = false
|
|
case a.Form:
|
|
if p.form != nil && !p.oe.contains(a.Template) {
|
|
// Ignore the token
|
|
return true
|
|
}
|
|
p.popUntil(buttonScope, a.P)
|
|
p.addElement()
|
|
if !p.oe.contains(a.Template) {
|
|
p.form = p.top()
|
|
}
|
|
case a.Li:
|
|
p.framesetOK = false
|
|
for i := len(p.oe) - 1; i >= 0; i-- {
|
|
node := p.oe[i]
|
|
switch node.DataAtom {
|
|
case a.Li:
|
|
p.oe = p.oe[:i]
|
|
case a.Address, a.Div, a.P:
|
|
continue
|
|
default:
|
|
if !isSpecialElement(node) {
|
|
continue
|
|
}
|
|
}
|
|
break
|
|
}
|
|
p.popUntil(buttonScope, a.P)
|
|
p.addElement()
|
|
case a.Dd, a.Dt:
|
|
p.framesetOK = false
|
|
for i := len(p.oe) - 1; i >= 0; i-- {
|
|
node := p.oe[i]
|
|
switch node.DataAtom {
|
|
case a.Dd, a.Dt:
|
|
p.oe = p.oe[:i]
|
|
case a.Address, a.Div, a.P:
|
|
continue
|
|
default:
|
|
if !isSpecialElement(node) {
|
|
continue
|
|
}
|
|
}
|
|
break
|
|
}
|
|
p.popUntil(buttonScope, a.P)
|
|
p.addElement()
|
|
case a.Plaintext:
|
|
p.popUntil(buttonScope, a.P)
|
|
p.addElement()
|
|
case a.Button:
|
|
p.popUntil(defaultScope, a.Button)
|
|
p.reconstructActiveFormattingElements()
|
|
p.addElement()
|
|
p.framesetOK = false
|
|
case a.A:
|
|
for i := len(p.afe) - 1; i >= 0 && p.afe[i].Type != scopeMarkerNode; i-- {
|
|
if n := p.afe[i]; n.Type == ElementNode && n.DataAtom == a.A {
|
|
p.inBodyEndTagFormatting(a.A, "a")
|
|
p.oe.remove(n)
|
|
p.afe.remove(n)
|
|
break
|
|
}
|
|
}
|
|
p.reconstructActiveFormattingElements()
|
|
p.addFormattingElement()
|
|
case a.B, a.Big, a.Code, a.Em, a.Font, a.I, a.S, a.Small, a.Strike, a.Strong, a.Tt, a.U:
|
|
p.reconstructActiveFormattingElements()
|
|
p.addFormattingElement()
|
|
case a.Nobr:
|
|
p.reconstructActiveFormattingElements()
|
|
if p.elementInScope(defaultScope, a.Nobr) {
|
|
p.inBodyEndTagFormatting(a.Nobr, "nobr")
|
|
p.reconstructActiveFormattingElements()
|
|
}
|
|
p.addFormattingElement()
|
|
case a.Applet, a.Marquee, a.Object:
|
|
p.reconstructActiveFormattingElements()
|
|
p.addElement()
|
|
p.afe = append(p.afe, &scopeMarker)
|
|
p.framesetOK = false
|
|
case a.Table:
|
|
if !p.quirks {
|
|
p.popUntil(buttonScope, a.P)
|
|
}
|
|
p.addElement()
|
|
p.framesetOK = false
|
|
p.im = inTableIM
|
|
return true
|
|
case a.Area, a.Br, a.Embed, a.Img, a.Input, a.Keygen, a.Wbr:
|
|
p.reconstructActiveFormattingElements()
|
|
p.addElement()
|
|
p.oe.pop()
|
|
p.acknowledgeSelfClosingTag()
|
|
if p.tok.DataAtom == a.Input {
|
|
for _, t := range p.tok.Attr {
|
|
if t.Key == "type" {
|
|
if strings.ToLower(t.Val) == "hidden" {
|
|
// Skip setting framesetOK = false
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
}
|
|
p.framesetOK = false
|
|
case a.Param, a.Source, a.Track:
|
|
p.addElement()
|
|
p.oe.pop()
|
|
p.acknowledgeSelfClosingTag()
|
|
case a.Hr:
|
|
p.popUntil(buttonScope, a.P)
|
|
p.addElement()
|
|
p.oe.pop()
|
|
p.acknowledgeSelfClosingTag()
|
|
p.framesetOK = false
|
|
case a.Image:
|
|
p.tok.DataAtom = a.Img
|
|
p.tok.Data = a.Img.String()
|
|
return false
|
|
case a.Textarea:
|
|
p.addElement()
|
|
p.setOriginalIM()
|
|
p.framesetOK = false
|
|
p.im = textIM
|
|
case a.Xmp:
|
|
p.popUntil(buttonScope, a.P)
|
|
p.reconstructActiveFormattingElements()
|
|
p.framesetOK = false
|
|
p.parseGenericRawTextElement()
|
|
case a.Iframe:
|
|
p.framesetOK = false
|
|
p.parseGenericRawTextElement()
|
|
case a.Noembed:
|
|
p.parseGenericRawTextElement()
|
|
case a.Noscript:
|
|
if p.scripting {
|
|
p.parseGenericRawTextElement()
|
|
return true
|
|
}
|
|
p.reconstructActiveFormattingElements()
|
|
p.addElement()
|
|
// Don't let the tokenizer go into raw text mode when scripting is disabled.
|
|
p.tokenizer.NextIsNotRawText()
|
|
case a.Select:
|
|
p.reconstructActiveFormattingElements()
|
|
p.addElement()
|
|
p.framesetOK = false
|
|
p.im = inSelectIM
|
|
return true
|
|
case a.Optgroup, a.Option:
|
|
if p.top().DataAtom == a.Option {
|
|
p.oe.pop()
|
|
}
|
|
p.reconstructActiveFormattingElements()
|
|
p.addElement()
|
|
case a.Rb, a.Rtc:
|
|
if p.elementInScope(defaultScope, a.Ruby) {
|
|
p.generateImpliedEndTags()
|
|
}
|
|
p.addElement()
|
|
case a.Rp, a.Rt:
|
|
if p.elementInScope(defaultScope, a.Ruby) {
|
|
p.generateImpliedEndTags("rtc")
|
|
}
|
|
p.addElement()
|
|
case a.Math, a.Svg:
|
|
p.reconstructActiveFormattingElements()
|
|
if p.tok.DataAtom == a.Math {
|
|
adjustAttributeNames(p.tok.Attr, mathMLAttributeAdjustments)
|
|
} else {
|
|
adjustAttributeNames(p.tok.Attr, svgAttributeAdjustments)
|
|
}
|
|
adjustForeignAttributes(p.tok.Attr)
|
|
p.addElement()
|
|
p.top().Namespace = p.tok.Data
|
|
if p.hasSelfClosingToken {
|
|
p.oe.pop()
|
|
p.acknowledgeSelfClosingTag()
|
|
}
|
|
return true
|
|
case a.Caption, a.Col, a.Colgroup, a.Frame, a.Head, a.Tbody, a.Td, a.Tfoot, a.Th, a.Thead, a.Tr:
|
|
// Ignore the token.
|
|
default:
|
|
p.reconstructActiveFormattingElements()
|
|
p.addElement()
|
|
}
|
|
case EndTagToken:
|
|
switch p.tok.DataAtom {
|
|
case a.Body:
|
|
if p.elementInScope(defaultScope, a.Body) {
|
|
p.im = afterBodyIM
|
|
}
|
|
case a.Html:
|
|
if p.elementInScope(defaultScope, a.Body) {
|
|
p.parseImpliedToken(EndTagToken, a.Body, a.Body.String())
|
|
return false
|
|
}
|
|
return true
|
|
case a.Address, a.Article, a.Aside, a.Blockquote, a.Button, a.Center, a.Details, a.Dialog, a.Dir, a.Div, a.Dl, a.Fieldset, a.Figcaption, a.Figure, a.Footer, a.Header, a.Hgroup, a.Listing, a.Main, a.Menu, a.Nav, a.Ol, a.Pre, a.Section, a.Summary, a.Ul:
|
|
p.popUntil(defaultScope, p.tok.DataAtom)
|
|
case a.Form:
|
|
if p.oe.contains(a.Template) {
|
|
i := p.indexOfElementInScope(defaultScope, a.Form)
|
|
if i == -1 {
|
|
// Ignore the token.
|
|
return true
|
|
}
|
|
p.generateImpliedEndTags()
|
|
if p.oe[i].DataAtom != a.Form {
|
|
// Ignore the token.
|
|
return true
|
|
}
|
|
p.popUntil(defaultScope, a.Form)
|
|
} else {
|
|
node := p.form
|
|
p.form = nil
|
|
i := p.indexOfElementInScope(defaultScope, a.Form)
|
|
if node == nil || i == -1 || p.oe[i] != node {
|
|
// Ignore the token.
|
|
return true
|
|
}
|
|
p.generateImpliedEndTags()
|
|
p.oe.remove(node)
|
|
}
|
|
case a.P:
|
|
if !p.elementInScope(buttonScope, a.P) {
|
|
p.parseImpliedToken(StartTagToken, a.P, a.P.String())
|
|
}
|
|
p.popUntil(buttonScope, a.P)
|
|
case a.Li:
|
|
p.popUntil(listItemScope, a.Li)
|
|
case a.Dd, a.Dt:
|
|
p.popUntil(defaultScope, p.tok.DataAtom)
|
|
case a.H1, a.H2, a.H3, a.H4, a.H5, a.H6:
|
|
p.popUntil(defaultScope, a.H1, a.H2, a.H3, a.H4, a.H5, a.H6)
|
|
case a.A, a.B, a.Big, a.Code, a.Em, a.Font, a.I, a.Nobr, a.S, a.Small, a.Strike, a.Strong, a.Tt, a.U:
|
|
p.inBodyEndTagFormatting(p.tok.DataAtom, p.tok.Data)
|
|
case a.Applet, a.Marquee, a.Object:
|
|
if p.popUntil(defaultScope, p.tok.DataAtom) {
|
|
p.clearActiveFormattingElements()
|
|
}
|
|
case a.Br:
|
|
p.tok.Type = StartTagToken
|
|
return false
|
|
case a.Template:
|
|
return inHeadIM(p)
|
|
default:
|
|
p.inBodyEndTagOther(p.tok.DataAtom, p.tok.Data)
|
|
}
|
|
case CommentToken:
|
|
p.addChild(&Node{
|
|
Type: CommentNode,
|
|
Data: p.tok.Data,
|
|
})
|
|
case ErrorToken:
|
|
// TODO: remove this divergence from the HTML5 spec.
|
|
if len(p.templateStack) > 0 {
|
|
p.im = inTemplateIM
|
|
return false
|
|
}
|
|
for _, e := range p.oe {
|
|
switch e.DataAtom {
|
|
case a.Dd, a.Dt, a.Li, a.Optgroup, a.Option, a.P, a.Rb, a.Rp, a.Rt, a.Rtc, a.Tbody, a.Td, a.Tfoot, a.Th,
|
|
a.Thead, a.Tr, a.Body, a.Html:
|
|
default:
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
func (p *parser) inBodyEndTagFormatting(tagAtom a.Atom, tagName string) {
|
|
// This is the "adoption agency" algorithm, described at
|
|
// https://html.spec.whatwg.org/multipage/syntax.html#adoptionAgency
|
|
|
|
// TODO: this is a fairly literal line-by-line translation of that algorithm.
|
|
// Once the code successfully parses the comprehensive test suite, we should
|
|
// refactor this code to be more idiomatic.
|
|
|
|
// Steps 1-2
|
|
if current := p.oe.top(); current.Data == tagName && p.afe.index(current) == -1 {
|
|
p.oe.pop()
|
|
return
|
|
}
|
|
|
|
// Steps 3-5. The outer loop.
|
|
for i := 0; i < 8; i++ {
|
|
// Step 6. Find the formatting element.
|
|
var formattingElement *Node
|
|
for j := len(p.afe) - 1; j >= 0; j-- {
|
|
if p.afe[j].Type == scopeMarkerNode {
|
|
break
|
|
}
|
|
if p.afe[j].DataAtom == tagAtom {
|
|
formattingElement = p.afe[j]
|
|
break
|
|
}
|
|
}
|
|
if formattingElement == nil {
|
|
p.inBodyEndTagOther(tagAtom, tagName)
|
|
return
|
|
}
|
|
|
|
// Step 7. Ignore the tag if formatting element is not in the stack of open elements.
|
|
feIndex := p.oe.index(formattingElement)
|
|
if feIndex == -1 {
|
|
p.afe.remove(formattingElement)
|
|
return
|
|
}
|
|
// Step 8. Ignore the tag if formatting element is not in the scope.
|
|
if !p.elementInScope(defaultScope, tagAtom) {
|
|
// Ignore the tag.
|
|
return
|
|
}
|
|
|
|
// Step 9. This step is omitted because it's just a parse error but no need to return.
|
|
|
|
// Steps 10-11. Find the furthest block.
|
|
var furthestBlock *Node
|
|
for _, e := range p.oe[feIndex:] {
|
|
if isSpecialElement(e) {
|
|
furthestBlock = e
|
|
break
|
|
}
|
|
}
|
|
if furthestBlock == nil {
|
|
e := p.oe.pop()
|
|
for e != formattingElement {
|
|
e = p.oe.pop()
|
|
}
|
|
p.afe.remove(e)
|
|
return
|
|
}
|
|
|
|
// Steps 12-13. Find the common ancestor and bookmark node.
|
|
commonAncestor := p.oe[feIndex-1]
|
|
bookmark := p.afe.index(formattingElement)
|
|
|
|
// Step 14. The inner loop. Find the lastNode to reparent.
|
|
lastNode := furthestBlock
|
|
node := furthestBlock
|
|
x := p.oe.index(node)
|
|
// Step 14.1.
|
|
j := 0
|
|
for {
|
|
// Step 14.2.
|
|
j++
|
|
// Step. 14.3.
|
|
x--
|
|
node = p.oe[x]
|
|
// Step 14.4. Go to the next step if node is formatting element.
|
|
if node == formattingElement {
|
|
break
|
|
}
|
|
// Step 14.5. Remove node from the list of active formatting elements if
|
|
// inner loop counter is greater than three and node is in the list of
|
|
// active formatting elements.
|
|
if ni := p.afe.index(node); j > 3 && ni > -1 {
|
|
p.afe.remove(node)
|
|
// If any element of the list of active formatting elements is removed,
|
|
// we need to take care whether bookmark should be decremented or not.
|
|
// This is because the value of bookmark may exceed the size of the
|
|
// list by removing elements from the list.
|
|
if ni <= bookmark {
|
|
bookmark--
|
|
}
|
|
continue
|
|
}
|
|
// Step 14.6. Continue the next inner loop if node is not in the list of
|
|
// active formatting elements.
|
|
if p.afe.index(node) == -1 {
|
|
p.oe.remove(node)
|
|
continue
|
|
}
|
|
// Step 14.7.
|
|
clone := node.clone()
|
|
p.afe[p.afe.index(node)] = clone
|
|
p.oe[p.oe.index(node)] = clone
|
|
node = clone
|
|
// Step 14.8.
|
|
if lastNode == furthestBlock {
|
|
bookmark = p.afe.index(node) + 1
|
|
}
|
|
// Step 14.9.
|
|
if lastNode.Parent != nil {
|
|
lastNode.Parent.RemoveChild(lastNode)
|
|
}
|
|
node.AppendChild(lastNode)
|
|
// Step 14.10.
|
|
lastNode = node
|
|
}
|
|
|
|
// Step 15. Reparent lastNode to the common ancestor,
|
|
// or for misnested table nodes, to the foster parent.
|
|
if lastNode.Parent != nil {
|
|
lastNode.Parent.RemoveChild(lastNode)
|
|
}
|
|
switch commonAncestor.DataAtom {
|
|
case a.Table, a.Tbody, a.Tfoot, a.Thead, a.Tr:
|
|
p.fosterParent(lastNode)
|
|
default:
|
|
commonAncestor.AppendChild(lastNode)
|
|
}
|
|
|
|
// Steps 16-18. Reparent nodes from the furthest block's children
|
|
// to a clone of the formatting element.
|
|
clone := formattingElement.clone()
|
|
reparentChildren(clone, furthestBlock)
|
|
furthestBlock.AppendChild(clone)
|
|
|
|
// Step 19. Fix up the list of active formatting elements.
|
|
if oldLoc := p.afe.index(formattingElement); oldLoc != -1 && oldLoc < bookmark {
|
|
// Move the bookmark with the rest of the list.
|
|
bookmark--
|
|
}
|
|
p.afe.remove(formattingElement)
|
|
p.afe.insert(bookmark, clone)
|
|
|
|
// Step 20. Fix up the stack of open elements.
|
|
p.oe.remove(formattingElement)
|
|
p.oe.insert(p.oe.index(furthestBlock)+1, clone)
|
|
}
|
|
}
|
|
|
|
// inBodyEndTagOther performs the "any other end tag" algorithm for inBodyIM.
|
|
// "Any other end tag" handling from 12.2.6.5 The rules for parsing tokens in foreign content
|
|
// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inforeign
|
|
func (p *parser) inBodyEndTagOther(tagAtom a.Atom, tagName string) {
|
|
for i := len(p.oe) - 1; i >= 0; i-- {
|
|
// Two element nodes have the same tag if they have the same Data (a
|
|
// string-typed field). As an optimization, for common HTML tags, each
|
|
// Data string is assigned a unique, non-zero DataAtom (a uint32-typed
|
|
// field), since integer comparison is faster than string comparison.
|
|
// Uncommon (custom) tags get a zero DataAtom.
|
|
//
|
|
// The if condition here is equivalent to (p.oe[i].Data == tagName).
|
|
if (p.oe[i].DataAtom == tagAtom) &&
|
|
((tagAtom != 0) || (p.oe[i].Data == tagName)) {
|
|
p.oe = p.oe[:i]
|
|
break
|
|
}
|
|
if isSpecialElement(p.oe[i]) {
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
// Section 12.2.6.4.8.
|
|
func textIM(p *parser) bool {
|
|
switch p.tok.Type {
|
|
case ErrorToken:
|
|
p.oe.pop()
|
|
case TextToken:
|
|
d := p.tok.Data
|
|
if n := p.oe.top(); n.DataAtom == a.Textarea && n.FirstChild == nil {
|
|
// Ignore a newline at the start of a <textarea> block.
|
|
if d != "" && d[0] == '\r' {
|
|
d = d[1:]
|
|
}
|
|
if d != "" && d[0] == '\n' {
|
|
d = d[1:]
|
|
}
|
|
}
|
|
if d == "" {
|
|
return true
|
|
}
|
|
p.addText(d)
|
|
return true
|
|
case EndTagToken:
|
|
p.oe.pop()
|
|
}
|
|
p.im = p.originalIM
|
|
p.originalIM = nil
|
|
return p.tok.Type == EndTagToken
|
|
}
|
|
|
|
// Section 12.2.6.4.9.
|
|
func inTableIM(p *parser) bool {
|
|
switch p.tok.Type {
|
|
case TextToken:
|
|
p.tok.Data = strings.Replace(p.tok.Data, "\x00", "", -1)
|
|
switch p.oe.top().DataAtom {
|
|
case a.Table, a.Tbody, a.Tfoot, a.Thead, a.Tr:
|
|
if strings.Trim(p.tok.Data, whitespace) == "" {
|
|
p.addText(p.tok.Data)
|
|
return true
|
|
}
|
|
}
|
|
case StartTagToken:
|
|
switch p.tok.DataAtom {
|
|
case a.Caption:
|
|
p.clearStackToContext(tableScope)
|
|
p.afe = append(p.afe, &scopeMarker)
|
|
p.addElement()
|
|
p.im = inCaptionIM
|
|
return true
|
|
case a.Colgroup:
|
|
p.clearStackToContext(tableScope)
|
|
p.addElement()
|
|
p.im = inColumnGroupIM
|
|
return true
|
|
case a.Col:
|
|
p.parseImpliedToken(StartTagToken, a.Colgroup, a.Colgroup.String())
|
|
return false
|
|
case a.Tbody, a.Tfoot, a.Thead:
|
|
p.clearStackToContext(tableScope)
|
|
p.addElement()
|
|
p.im = inTableBodyIM
|
|
return true
|
|
case a.Td, a.Th, a.Tr:
|
|
p.parseImpliedToken(StartTagToken, a.Tbody, a.Tbody.String())
|
|
return false
|
|
case a.Table:
|
|
if p.popUntil(tableScope, a.Table) {
|
|
p.resetInsertionMode()
|
|
return false
|
|
}
|
|
// Ignore the token.
|
|
return true
|
|
case a.Style, a.Script, a.Template:
|
|
return inHeadIM(p)
|
|
case a.Input:
|
|
for _, t := range p.tok.Attr {
|
|
if t.Key == "type" && strings.ToLower(t.Val) == "hidden" {
|
|
p.addElement()
|
|
p.oe.pop()
|
|
return true
|
|
}
|
|
}
|
|
// Otherwise drop down to the default action.
|
|
case a.Form:
|
|
if p.oe.contains(a.Template) || p.form != nil {
|
|
// Ignore the token.
|
|
return true
|
|
}
|
|
p.addElement()
|
|
p.form = p.oe.pop()
|
|
case a.Select:
|
|
p.reconstructActiveFormattingElements()
|
|
switch p.top().DataAtom {
|
|
case a.Table, a.Tbody, a.Tfoot, a.Thead, a.Tr:
|
|
p.fosterParenting = true
|
|
}
|
|
p.addElement()
|
|
p.fosterParenting = false
|
|
p.framesetOK = false
|
|
p.im = inSelectInTableIM
|
|
return true
|
|
}
|
|
case EndTagToken:
|
|
switch p.tok.DataAtom {
|
|
case a.Table:
|
|
if p.popUntil(tableScope, a.Table) {
|
|
p.resetInsertionMode()
|
|
return true
|
|
}
|
|
// Ignore the token.
|
|
return true
|
|
case a.Body, a.Caption, a.Col, a.Colgroup, a.Html, a.Tbody, a.Td, a.Tfoot, a.Th, a.Thead, a.Tr:
|
|
// Ignore the token.
|
|
return true
|
|
case a.Template:
|
|
return inHeadIM(p)
|
|
}
|
|
case CommentToken:
|
|
p.addChild(&Node{
|
|
Type: CommentNode,
|
|
Data: p.tok.Data,
|
|
})
|
|
return true
|
|
case DoctypeToken:
|
|
// Ignore the token.
|
|
return true
|
|
case ErrorToken:
|
|
return inBodyIM(p)
|
|
}
|
|
|
|
p.fosterParenting = true
|
|
defer func() { p.fosterParenting = false }()
|
|
|
|
return inBodyIM(p)
|
|
}
|
|
|
|
// Section 12.2.6.4.11.
|
|
func inCaptionIM(p *parser) bool {
|
|
switch p.tok.Type {
|
|
case StartTagToken:
|
|
switch p.tok.DataAtom {
|
|
case a.Caption, a.Col, a.Colgroup, a.Tbody, a.Td, a.Tfoot, a.Thead, a.Tr:
|
|
if !p.popUntil(tableScope, a.Caption) {
|
|
// Ignore the token.
|
|
return true
|
|
}
|
|
p.clearActiveFormattingElements()
|
|
p.im = inTableIM
|
|
return false
|
|
case a.Select:
|
|
p.reconstructActiveFormattingElements()
|
|
p.addElement()
|
|
p.framesetOK = false
|
|
p.im = inSelectInTableIM
|
|
return true
|
|
}
|
|
case EndTagToken:
|
|
switch p.tok.DataAtom {
|
|
case a.Caption:
|
|
if p.popUntil(tableScope, a.Caption) {
|
|
p.clearActiveFormattingElements()
|
|
p.im = inTableIM
|
|
}
|
|
return true
|
|
case a.Table:
|
|
if !p.popUntil(tableScope, a.Caption) {
|
|
// Ignore the token.
|
|
return true
|
|
}
|
|
p.clearActiveFormattingElements()
|
|
p.im = inTableIM
|
|
return false
|
|
case a.Body, a.Col, a.Colgroup, a.Html, a.Tbody, a.Td, a.Tfoot, a.Th, a.Thead, a.Tr:
|
|
// Ignore the token.
|
|
return true
|
|
}
|
|
}
|
|
return inBodyIM(p)
|
|
}
|
|
|
|
// Section 12.2.6.4.12.
|
|
func inColumnGroupIM(p *parser) bool {
|
|
switch p.tok.Type {
|
|
case TextToken:
|
|
s := strings.TrimLeft(p.tok.Data, whitespace)
|
|
if len(s) < len(p.tok.Data) {
|
|
// Add the initial whitespace to the current node.
|
|
p.addText(p.tok.Data[:len(p.tok.Data)-len(s)])
|
|
if s == "" {
|
|
return true
|
|
}
|
|
p.tok.Data = s
|
|
}
|
|
case CommentToken:
|
|
p.addChild(&Node{
|
|
Type: CommentNode,
|
|
Data: p.tok.Data,
|
|
})
|
|
return true
|
|
case DoctypeToken:
|
|
// Ignore the token.
|
|
return true
|
|
case StartTagToken:
|
|
switch p.tok.DataAtom {
|
|
case a.Html:
|
|
return inBodyIM(p)
|
|
case a.Col:
|
|
p.addElement()
|
|
p.oe.pop()
|
|
p.acknowledgeSelfClosingTag()
|
|
return true
|
|
case a.Template:
|
|
return inHeadIM(p)
|
|
}
|
|
case EndTagToken:
|
|
switch p.tok.DataAtom {
|
|
case a.Colgroup:
|
|
if p.oe.top().DataAtom == a.Colgroup {
|
|
p.oe.pop()
|
|
p.im = inTableIM
|
|
}
|
|
return true
|
|
case a.Col:
|
|
// Ignore the token.
|
|
return true
|
|
case a.Template:
|
|
return inHeadIM(p)
|
|
}
|
|
case ErrorToken:
|
|
return inBodyIM(p)
|
|
}
|
|
if p.oe.top().DataAtom != a.Colgroup {
|
|
return true
|
|
}
|
|
p.oe.pop()
|
|
p.im = inTableIM
|
|
return false
|
|
}
|
|
|
|
// Section 12.2.6.4.13.
|
|
func inTableBodyIM(p *parser) bool {
|
|
switch p.tok.Type {
|
|
case StartTagToken:
|
|
switch p.tok.DataAtom {
|
|
case a.Tr:
|
|
p.clearStackToContext(tableBodyScope)
|
|
p.addElement()
|
|
p.im = inRowIM
|
|
return true
|
|
case a.Td, a.Th:
|
|
p.parseImpliedToken(StartTagToken, a.Tr, a.Tr.String())
|
|
return false
|
|
case a.Caption, a.Col, a.Colgroup, a.Tbody, a.Tfoot, a.Thead:
|
|
if p.popUntil(tableScope, a.Tbody, a.Thead, a.Tfoot) {
|
|
p.im = inTableIM
|
|
return false
|
|
}
|
|
// Ignore the token.
|
|
return true
|
|
}
|
|
case EndTagToken:
|
|
switch p.tok.DataAtom {
|
|
case a.Tbody, a.Tfoot, a.Thead:
|
|
if p.elementInScope(tableScope, p.tok.DataAtom) {
|
|
p.clearStackToContext(tableBodyScope)
|
|
p.oe.pop()
|
|
p.im = inTableIM
|
|
}
|
|
return true
|
|
case a.Table:
|
|
if p.popUntil(tableScope, a.Tbody, a.Thead, a.Tfoot) {
|
|
p.im = inTableIM
|
|
return false
|
|
}
|
|
// Ignore the token.
|
|
return true
|
|
case a.Body, a.Caption, a.Col, a.Colgroup, a.Html, a.Td, a.Th, a.Tr:
|
|
// Ignore the token.
|
|
return true
|
|
}
|
|
case CommentToken:
|
|
p.addChild(&Node{
|
|
Type: CommentNode,
|
|
Data: p.tok.Data,
|
|
})
|
|
return true
|
|
}
|
|
|
|
return inTableIM(p)
|
|
}
|
|
|
|
// Section 12.2.6.4.14.
|
|
func inRowIM(p *parser) bool {
|
|
switch p.tok.Type {
|
|
case StartTagToken:
|
|
switch p.tok.DataAtom {
|
|
case a.Td, a.Th:
|
|
p.clearStackToContext(tableRowScope)
|
|
p.addElement()
|
|
p.afe = append(p.afe, &scopeMarker)
|
|
p.im = inCellIM
|
|
return true
|
|
case a.Caption, a.Col, a.Colgroup, a.Tbody, a.Tfoot, a.Thead, a.Tr:
|
|
if p.popUntil(tableScope, a.Tr) {
|
|
p.im = inTableBodyIM
|
|
return false
|
|
}
|
|
// Ignore the token.
|
|
return true
|
|
}
|
|
case EndTagToken:
|
|
switch p.tok.DataAtom {
|
|
case a.Tr:
|
|
if p.popUntil(tableScope, a.Tr) {
|
|
p.im = inTableBodyIM
|
|
return true
|
|
}
|
|
// Ignore the token.
|
|
return true
|
|
case a.Table:
|
|
if p.popUntil(tableScope, a.Tr) {
|
|
p.im = inTableBodyIM
|
|
return false
|
|
}
|
|
// Ignore the token.
|
|
return true
|
|
case a.Tbody, a.Tfoot, a.Thead:
|
|
if p.elementInScope(tableScope, p.tok.DataAtom) {
|
|
p.parseImpliedToken(EndTagToken, a.Tr, a.Tr.String())
|
|
return false
|
|
}
|
|
// Ignore the token.
|
|
return true
|
|
case a.Body, a.Caption, a.Col, a.Colgroup, a.Html, a.Td, a.Th:
|
|
// Ignore the token.
|
|
return true
|
|
}
|
|
}
|
|
|
|
return inTableIM(p)
|
|
}
|
|
|
|
// Section 12.2.6.4.15.
|
|
func inCellIM(p *parser) bool {
|
|
switch p.tok.Type {
|
|
case StartTagToken:
|
|
switch p.tok.DataAtom {
|
|
case a.Caption, a.Col, a.Colgroup, a.Tbody, a.Td, a.Tfoot, a.Th, a.Thead, a.Tr:
|
|
if p.popUntil(tableScope, a.Td, a.Th) {
|
|
// Close the cell and reprocess.
|
|
p.clearActiveFormattingElements()
|
|
p.im = inRowIM
|
|
return false
|
|
}
|
|
// Ignore the token.
|
|
return true
|
|
case a.Select:
|
|
p.reconstructActiveFormattingElements()
|
|
p.addElement()
|
|
p.framesetOK = false
|
|
p.im = inSelectInTableIM
|
|
return true
|
|
}
|
|
case EndTagToken:
|
|
switch p.tok.DataAtom {
|
|
case a.Td, a.Th:
|
|
if !p.popUntil(tableScope, p.tok.DataAtom) {
|
|
// Ignore the token.
|
|
return true
|
|
}
|
|
p.clearActiveFormattingElements()
|
|
p.im = inRowIM
|
|
return true
|
|
case a.Body, a.Caption, a.Col, a.Colgroup, a.Html:
|
|
// Ignore the token.
|
|
return true
|
|
case a.Table, a.Tbody, a.Tfoot, a.Thead, a.Tr:
|
|
if !p.elementInScope(tableScope, p.tok.DataAtom) {
|
|
// Ignore the token.
|
|
return true
|
|
}
|
|
// Close the cell and reprocess.
|
|
if p.popUntil(tableScope, a.Td, a.Th) {
|
|
p.clearActiveFormattingElements()
|
|
}
|
|
p.im = inRowIM
|
|
return false
|
|
}
|
|
}
|
|
return inBodyIM(p)
|
|
}
|
|
|
|
// Section 12.2.6.4.16.
|
|
func inSelectIM(p *parser) bool {
|
|
switch p.tok.Type {
|
|
case TextToken:
|
|
p.addText(strings.Replace(p.tok.Data, "\x00", "", -1))
|
|
case StartTagToken:
|
|
switch p.tok.DataAtom {
|
|
case a.Html:
|
|
return inBodyIM(p)
|
|
case a.Option:
|
|
if p.top().DataAtom == a.Option {
|
|
p.oe.pop()
|
|
}
|
|
p.addElement()
|
|
case a.Optgroup:
|
|
if p.top().DataAtom == a.Option {
|
|
p.oe.pop()
|
|
}
|
|
if p.top().DataAtom == a.Optgroup {
|
|
p.oe.pop()
|
|
}
|
|
p.addElement()
|
|
case a.Select:
|
|
if !p.popUntil(selectScope, a.Select) {
|
|
// Ignore the token.
|
|
return true
|
|
}
|
|
p.resetInsertionMode()
|
|
case a.Input, a.Keygen, a.Textarea:
|
|
if p.elementInScope(selectScope, a.Select) {
|
|
p.parseImpliedToken(EndTagToken, a.Select, a.Select.String())
|
|
return false
|
|
}
|
|
// In order to properly ignore <textarea>, we need to change the tokenizer mode.
|
|
p.tokenizer.NextIsNotRawText()
|
|
// Ignore the token.
|
|
return true
|
|
case a.Script, a.Template:
|
|
return inHeadIM(p)
|
|
case a.Iframe, a.Noembed, a.Noframes, a.Noscript, a.Plaintext, a.Style, a.Title, a.Xmp:
|
|
// Don't let the tokenizer go into raw text mode when there are raw tags
|
|
// to be ignored. These tags should be ignored from the tokenizer
|
|
// properly.
|
|
p.tokenizer.NextIsNotRawText()
|
|
// Ignore the token.
|
|
return true
|
|
}
|
|
case EndTagToken:
|
|
switch p.tok.DataAtom {
|
|
case a.Option:
|
|
if p.top().DataAtom == a.Option {
|
|
p.oe.pop()
|
|
}
|
|
case a.Optgroup:
|
|
i := len(p.oe) - 1
|
|
if p.oe[i].DataAtom == a.Option {
|
|
i--
|
|
}
|
|
if p.oe[i].DataAtom == a.Optgroup {
|
|
p.oe = p.oe[:i]
|
|
}
|
|
case a.Select:
|
|
if !p.popUntil(selectScope, a.Select) {
|
|
// Ignore the token.
|
|
return true
|
|
}
|
|
p.resetInsertionMode()
|
|
case a.Template:
|
|
return inHeadIM(p)
|
|
}
|
|
case CommentToken:
|
|
p.addChild(&Node{
|
|
Type: CommentNode,
|
|
Data: p.tok.Data,
|
|
})
|
|
case DoctypeToken:
|
|
// Ignore the token.
|
|
return true
|
|
case ErrorToken:
|
|
return inBodyIM(p)
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
// Section 12.2.6.4.17.
|
|
func inSelectInTableIM(p *parser) bool {
|
|
switch p.tok.Type {
|
|
case StartTagToken, EndTagToken:
|
|
switch p.tok.DataAtom {
|
|
case a.Caption, a.Table, a.Tbody, a.Tfoot, a.Thead, a.Tr, a.Td, a.Th:
|
|
if p.tok.Type == EndTagToken && !p.elementInScope(tableScope, p.tok.DataAtom) {
|
|
// Ignore the token.
|
|
return true
|
|
}
|
|
// This is like p.popUntil(selectScope, a.Select), but it also
|
|
// matches <math select>, not just <select>. Matching the MathML
|
|
// tag is arguably incorrect (conceptually), but it mimics what
|
|
// Chromium does.
|
|
for i := len(p.oe) - 1; i >= 0; i-- {
|
|
if n := p.oe[i]; n.DataAtom == a.Select {
|
|
p.oe = p.oe[:i]
|
|
break
|
|
}
|
|
}
|
|
p.resetInsertionMode()
|
|
return false
|
|
}
|
|
}
|
|
return inSelectIM(p)
|
|
}
|
|
|
|
// Section 12.2.6.4.18.
|
|
func inTemplateIM(p *parser) bool {
|
|
switch p.tok.Type {
|
|
case TextToken, CommentToken, DoctypeToken:
|
|
return inBodyIM(p)
|
|
case StartTagToken:
|
|
switch p.tok.DataAtom {
|
|
case a.Base, a.Basefont, a.Bgsound, a.Link, a.Meta, a.Noframes, a.Script, a.Style, a.Template, a.Title:
|
|
return inHeadIM(p)
|
|
case a.Caption, a.Colgroup, a.Tbody, a.Tfoot, a.Thead:
|
|
p.templateStack.pop()
|
|
p.templateStack = append(p.templateStack, inTableIM)
|
|
p.im = inTableIM
|
|
return false
|
|
case a.Col:
|
|
p.templateStack.pop()
|
|
p.templateStack = append(p.templateStack, inColumnGroupIM)
|
|
p.im = inColumnGroupIM
|
|
return false
|
|
case a.Tr:
|
|
p.templateStack.pop()
|
|
p.templateStack = append(p.templateStack, inTableBodyIM)
|
|
p.im = inTableBodyIM
|
|
return false
|
|
case a.Td, a.Th:
|
|
p.templateStack.pop()
|
|
p.templateStack = append(p.templateStack, inRowIM)
|
|
p.im = inRowIM
|
|
return false
|
|
default:
|
|
p.templateStack.pop()
|
|
p.templateStack = append(p.templateStack, inBodyIM)
|
|
p.im = inBodyIM
|
|
return false
|
|
}
|
|
case EndTagToken:
|
|
switch p.tok.DataAtom {
|
|
case a.Template:
|
|
return inHeadIM(p)
|
|
default:
|
|
// Ignore the token.
|
|
return true
|
|
}
|
|
case ErrorToken:
|
|
if !p.oe.contains(a.Template) {
|
|
// Ignore the token.
|
|
return true
|
|
}
|
|
// TODO: remove this divergence from the HTML5 spec.
|
|
//
|
|
// See https://bugs.chromium.org/p/chromium/issues/detail?id=829668
|
|
p.generateImpliedEndTags()
|
|
for i := len(p.oe) - 1; i >= 0; i-- {
|
|
if n := p.oe[i]; n.Namespace == "" && n.DataAtom == a.Template {
|
|
p.oe = p.oe[:i]
|
|
break
|
|
}
|
|
}
|
|
p.clearActiveFormattingElements()
|
|
p.templateStack.pop()
|
|
p.resetInsertionMode()
|
|
return false
|
|
}
|
|
return false
|
|
}
|
|
|
|
// Section 12.2.6.4.19.
|
|
func afterBodyIM(p *parser) bool {
|
|
switch p.tok.Type {
|
|
case ErrorToken:
|
|
// Stop parsing.
|
|
return true
|
|
case TextToken:
|
|
s := strings.TrimLeft(p.tok.Data, whitespace)
|
|
if len(s) == 0 {
|
|
// It was all whitespace.
|
|
return inBodyIM(p)
|
|
}
|
|
case StartTagToken:
|
|
if p.tok.DataAtom == a.Html {
|
|
return inBodyIM(p)
|
|
}
|
|
case EndTagToken:
|
|
if p.tok.DataAtom == a.Html {
|
|
if !p.fragment {
|
|
p.im = afterAfterBodyIM
|
|
}
|
|
return true
|
|
}
|
|
case CommentToken:
|
|
// The comment is attached to the <html> element.
|
|
if len(p.oe) < 1 || p.oe[0].DataAtom != a.Html {
|
|
panic("html: bad parser state: <html> element not found, in the after-body insertion mode")
|
|
}
|
|
p.oe[0].AppendChild(&Node{
|
|
Type: CommentNode,
|
|
Data: p.tok.Data,
|
|
})
|
|
return true
|
|
}
|
|
p.im = inBodyIM
|
|
return false
|
|
}
|
|
|
|
// Section 12.2.6.4.20.
|
|
func inFramesetIM(p *parser) bool {
|
|
switch p.tok.Type {
|
|
case CommentToken:
|
|
p.addChild(&Node{
|
|
Type: CommentNode,
|
|
Data: p.tok.Data,
|
|
})
|
|
case TextToken:
|
|
// Ignore all text but whitespace.
|
|
s := strings.Map(func(c rune) rune {
|
|
switch c {
|
|
case ' ', '\t', '\n', '\f', '\r':
|
|
return c
|
|
}
|
|
return -1
|
|
}, p.tok.Data)
|
|
if s != "" {
|
|
p.addText(s)
|
|
}
|
|
case StartTagToken:
|
|
switch p.tok.DataAtom {
|
|
case a.Html:
|
|
return inBodyIM(p)
|
|
case a.Frameset:
|
|
p.addElement()
|
|
case a.Frame:
|
|
p.addElement()
|
|
p.oe.pop()
|
|
p.acknowledgeSelfClosingTag()
|
|
case a.Noframes:
|
|
return inHeadIM(p)
|
|
}
|
|
case EndTagToken:
|
|
switch p.tok.DataAtom {
|
|
case a.Frameset:
|
|
if p.oe.top().DataAtom != a.Html {
|
|
p.oe.pop()
|
|
if p.oe.top().DataAtom != a.Frameset {
|
|
p.im = afterFramesetIM
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
default:
|
|
// Ignore the token.
|
|
}
|
|
return true
|
|
}
|
|
|
|
// Section 12.2.6.4.21.
|
|
func afterFramesetIM(p *parser) bool {
|
|
switch p.tok.Type {
|
|
case CommentToken:
|
|
p.addChild(&Node{
|
|
Type: CommentNode,
|
|
Data: p.tok.Data,
|
|
})
|
|
case TextToken:
|
|
// Ignore all text but whitespace.
|
|
s := strings.Map(func(c rune) rune {
|
|
switch c {
|
|
case ' ', '\t', '\n', '\f', '\r':
|
|
return c
|
|
}
|
|
return -1
|
|
}, p.tok.Data)
|
|
if s != "" {
|
|
p.addText(s)
|
|
}
|
|
case StartTagToken:
|
|
switch p.tok.DataAtom {
|
|
case a.Html:
|
|
return inBodyIM(p)
|
|
case a.Noframes:
|
|
return inHeadIM(p)
|
|
}
|
|
case EndTagToken:
|
|
switch p.tok.DataAtom {
|
|
case a.Html:
|
|
p.im = afterAfterFramesetIM
|
|
return true
|
|
}
|
|
default:
|
|
// Ignore the token.
|
|
}
|
|
return true
|
|
}
|
|
|
|
// Section 12.2.6.4.22.
|
|
func afterAfterBodyIM(p *parser) bool {
|
|
switch p.tok.Type {
|
|
case ErrorToken:
|
|
// Stop parsing.
|
|
return true
|
|
case TextToken:
|
|
s := strings.TrimLeft(p.tok.Data, whitespace)
|
|
if len(s) == 0 {
|
|
// It was all whitespace.
|
|
return inBodyIM(p)
|
|
}
|
|
case StartTagToken:
|
|
if p.tok.DataAtom == a.Html {
|
|
return inBodyIM(p)
|
|
}
|
|
case CommentToken:
|
|
p.doc.AppendChild(&Node{
|
|
Type: CommentNode,
|
|
Data: p.tok.Data,
|
|
})
|
|
return true
|
|
case DoctypeToken:
|
|
return inBodyIM(p)
|
|
}
|
|
p.im = inBodyIM
|
|
return false
|
|
}
|
|
|
|
// Section 12.2.6.4.23.
|
|
func afterAfterFramesetIM(p *parser) bool {
|
|
switch p.tok.Type {
|
|
case CommentToken:
|
|
p.doc.AppendChild(&Node{
|
|
Type: CommentNode,
|
|
Data: p.tok.Data,
|
|
})
|
|
case TextToken:
|
|
// Ignore all text but whitespace.
|
|
s := strings.Map(func(c rune) rune {
|
|
switch c {
|
|
case ' ', '\t', '\n', '\f', '\r':
|
|
return c
|
|
}
|
|
return -1
|
|
}, p.tok.Data)
|
|
if s != "" {
|
|
p.tok.Data = s
|
|
return inBodyIM(p)
|
|
}
|
|
case StartTagToken:
|
|
switch p.tok.DataAtom {
|
|
case a.Html:
|
|
return inBodyIM(p)
|
|
case a.Noframes:
|
|
return inHeadIM(p)
|
|
}
|
|
case DoctypeToken:
|
|
return inBodyIM(p)
|
|
default:
|
|
// Ignore the token.
|
|
}
|
|
return true
|
|
}
|
|
|
|
func ignoreTheRemainingTokens(p *parser) bool {
|
|
return true
|
|
}
|
|
|
|
const whitespaceOrNUL = whitespace + "\x00"
|
|
|
|
// Section 12.2.6.5
|
|
func parseForeignContent(p *parser) bool {
|
|
switch p.tok.Type {
|
|
case TextToken:
|
|
if p.framesetOK {
|
|
p.framesetOK = strings.TrimLeft(p.tok.Data, whitespaceOrNUL) == ""
|
|
}
|
|
p.tok.Data = strings.Replace(p.tok.Data, "\x00", "\ufffd", -1)
|
|
p.addText(p.tok.Data)
|
|
case CommentToken:
|
|
p.addChild(&Node{
|
|
Type: CommentNode,
|
|
Data: p.tok.Data,
|
|
})
|
|
case StartTagToken:
|
|
if !p.fragment {
|
|
b := breakout[p.tok.Data]
|
|
if p.tok.DataAtom == a.Font {
|
|
loop:
|
|
for _, attr := range p.tok.Attr {
|
|
switch attr.Key {
|
|
case "color", "face", "size":
|
|
b = true
|
|
break loop
|
|
}
|
|
}
|
|
}
|
|
if b {
|
|
for i := len(p.oe) - 1; i >= 0; i-- {
|
|
n := p.oe[i]
|
|
if n.Namespace == "" || htmlIntegrationPoint(n) || mathMLTextIntegrationPoint(n) {
|
|
p.oe = p.oe[:i+1]
|
|
break
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
}
|
|
current := p.adjustedCurrentNode()
|
|
switch current.Namespace {
|
|
case "math":
|
|
adjustAttributeNames(p.tok.Attr, mathMLAttributeAdjustments)
|
|
case "svg":
|
|
// Adjust SVG tag names. The tokenizer lower-cases tag names, but
|
|
// SVG wants e.g. "foreignObject" with a capital second "O".
|
|
if x := svgTagNameAdjustments[p.tok.Data]; x != "" {
|
|
p.tok.DataAtom = a.Lookup([]byte(x))
|
|
p.tok.Data = x
|
|
}
|
|
adjustAttributeNames(p.tok.Attr, svgAttributeAdjustments)
|
|
default:
|
|
panic("html: bad parser state: unexpected namespace")
|
|
}
|
|
adjustForeignAttributes(p.tok.Attr)
|
|
namespace := current.Namespace
|
|
p.addElement()
|
|
p.top().Namespace = namespace
|
|
if namespace != "" {
|
|
// Don't let the tokenizer go into raw text mode in foreign content
|
|
// (e.g. in an SVG <title> tag).
|
|
p.tokenizer.NextIsNotRawText()
|
|
}
|
|
if p.hasSelfClosingToken {
|
|
p.oe.pop()
|
|
p.acknowledgeSelfClosingTag()
|
|
}
|
|
case EndTagToken:
|
|
for i := len(p.oe) - 1; i >= 0; i-- {
|
|
if p.oe[i].Namespace == "" {
|
|
return p.im(p)
|
|
}
|
|
if strings.EqualFold(p.oe[i].Data, p.tok.Data) {
|
|
p.oe = p.oe[:i]
|
|
break
|
|
}
|
|
}
|
|
return true
|
|
default:
|
|
// Ignore the token.
|
|
}
|
|
return true
|
|
}
|
|
|
|
// Section 12.2.4.2.
|
|
func (p *parser) adjustedCurrentNode() *Node {
|
|
if len(p.oe) == 1 && p.fragment && p.context != nil {
|
|
return p.context
|
|
}
|
|
return p.oe.top()
|
|
}
|
|
|
|
// Section 12.2.6.
|
|
func (p *parser) inForeignContent() bool {
|
|
if len(p.oe) == 0 {
|
|
return false
|
|
}
|
|
n := p.adjustedCurrentNode()
|
|
if n.Namespace == "" {
|
|
return false
|
|
}
|
|
if mathMLTextIntegrationPoint(n) {
|
|
if p.tok.Type == StartTagToken && p.tok.DataAtom != a.Mglyph && p.tok.DataAtom != a.Malignmark {
|
|
return false
|
|
}
|
|
if p.tok.Type == TextToken {
|
|
return false
|
|
}
|
|
}
|
|
if n.Namespace == "math" && n.DataAtom == a.AnnotationXml && p.tok.Type == StartTagToken && p.tok.DataAtom == a.Svg {
|
|
return false
|
|
}
|
|
if htmlIntegrationPoint(n) && (p.tok.Type == StartTagToken || p.tok.Type == TextToken) {
|
|
return false
|
|
}
|
|
if p.tok.Type == ErrorToken {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
// parseImpliedToken parses a token as though it had appeared in the parser's
|
|
// input.
|
|
func (p *parser) parseImpliedToken(t TokenType, dataAtom a.Atom, data string) {
|
|
realToken, selfClosing := p.tok, p.hasSelfClosingToken
|
|
p.tok = Token{
|
|
Type: t,
|
|
DataAtom: dataAtom,
|
|
Data: data,
|
|
}
|
|
p.hasSelfClosingToken = false
|
|
p.parseCurrentToken()
|
|
p.tok, p.hasSelfClosingToken = realToken, selfClosing
|
|
}
|
|
|
|
// parseCurrentToken runs the current token through the parsing routines
|
|
// until it is consumed.
|
|
func (p *parser) parseCurrentToken() {
|
|
if p.tok.Type == SelfClosingTagToken {
|
|
p.hasSelfClosingToken = true
|
|
p.tok.Type = StartTagToken
|
|
}
|
|
|
|
consumed := false
|
|
for !consumed {
|
|
if p.inForeignContent() {
|
|
consumed = parseForeignContent(p)
|
|
} else {
|
|
consumed = p.im(p)
|
|
}
|
|
}
|
|
|
|
if p.hasSelfClosingToken {
|
|
// This is a parse error, but ignore it.
|
|
p.hasSelfClosingToken = false
|
|
}
|
|
}
|
|
|
|
func (p *parser) parse() error {
|
|
// Iterate until EOF. Any other error will cause an early return.
|
|
var err error
|
|
for err != io.EOF {
|
|
// CDATA sections are allowed only in foreign content.
|
|
n := p.oe.top()
|
|
p.tokenizer.AllowCDATA(n != nil && n.Namespace != "")
|
|
// Read and parse the next token.
|
|
p.tokenizer.Next()
|
|
p.tok = p.tokenizer.Token()
|
|
if p.tok.Type == ErrorToken {
|
|
err = p.tokenizer.Err()
|
|
if err != nil && err != io.EOF {
|
|
return err
|
|
}
|
|
}
|
|
p.parseCurrentToken()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Parse returns the parse tree for the HTML from the given Reader.
|
|
//
|
|
// It implements the HTML5 parsing algorithm
|
|
// (https://html.spec.whatwg.org/multipage/syntax.html#tree-construction),
|
|
// which is very complicated. The resultant tree can contain implicitly created
|
|
// nodes that have no explicit <tag> listed in r's data, and nodes' parents can
|
|
// differ from the nesting implied by a naive processing of start and end
|
|
// <tag>s. Conversely, explicit <tag>s in r's data can be silently dropped,
|
|
// with no corresponding node in the resulting tree.
|
|
//
|
|
// The input is assumed to be UTF-8 encoded.
|
|
func Parse(r io.Reader) (*Node, error) {
|
|
return ParseWithOptions(r)
|
|
}
|
|
|
|
// ParseFragment parses a fragment of HTML and returns the nodes that were
|
|
// found. If the fragment is the InnerHTML for an existing element, pass that
|
|
// element in context.
|
|
//
|
|
// It has the same intricacies as Parse.
|
|
func ParseFragment(r io.Reader, context *Node) ([]*Node, error) {
|
|
return ParseFragmentWithOptions(r, context)
|
|
}
|
|
|
|
// ParseOption configures a parser.
|
|
type ParseOption func(p *parser)
|
|
|
|
// ParseOptionEnableScripting configures the scripting flag.
|
|
// https://html.spec.whatwg.org/multipage/webappapis.html#enabling-and-disabling-scripting
|
|
//
|
|
// By default, scripting is enabled.
|
|
func ParseOptionEnableScripting(enable bool) ParseOption {
|
|
return func(p *parser) {
|
|
p.scripting = enable
|
|
}
|
|
}
|
|
|
|
// ParseWithOptions is like Parse, with options.
|
|
func ParseWithOptions(r io.Reader, opts ...ParseOption) (*Node, error) {
|
|
p := &parser{
|
|
tokenizer: NewTokenizer(r),
|
|
doc: &Node{
|
|
Type: DocumentNode,
|
|
},
|
|
scripting: true,
|
|
framesetOK: true,
|
|
im: initialIM,
|
|
}
|
|
|
|
for _, f := range opts {
|
|
f(p)
|
|
}
|
|
|
|
if err := p.parse(); err != nil {
|
|
return nil, err
|
|
}
|
|
return p.doc, nil
|
|
}
|
|
|
|
// ParseFragmentWithOptions is like ParseFragment, with options.
|
|
func ParseFragmentWithOptions(r io.Reader, context *Node, opts ...ParseOption) ([]*Node, error) {
|
|
contextTag := ""
|
|
if context != nil {
|
|
if context.Type != ElementNode {
|
|
return nil, errors.New("html: ParseFragment of non-element Node")
|
|
}
|
|
// The next check isn't just context.DataAtom.String() == context.Data because
|
|
// it is valid to pass an element whose tag isn't a known atom. For example,
|
|
// DataAtom == 0 and Data = "tagfromthefuture" is perfectly consistent.
|
|
if context.DataAtom != a.Lookup([]byte(context.Data)) {
|
|
return nil, fmt.Errorf("html: inconsistent Node: DataAtom=%q, Data=%q", context.DataAtom, context.Data)
|
|
}
|
|
contextTag = context.DataAtom.String()
|
|
}
|
|
p := &parser{
|
|
doc: &Node{
|
|
Type: DocumentNode,
|
|
},
|
|
scripting: true,
|
|
fragment: true,
|
|
context: context,
|
|
}
|
|
if context != nil && context.Namespace != "" {
|
|
p.tokenizer = NewTokenizer(r)
|
|
} else {
|
|
p.tokenizer = NewTokenizerFragment(r, contextTag)
|
|
}
|
|
|
|
for _, f := range opts {
|
|
f(p)
|
|
}
|
|
|
|
root := &Node{
|
|
Type: ElementNode,
|
|
DataAtom: a.Html,
|
|
Data: a.Html.String(),
|
|
}
|
|
p.doc.AppendChild(root)
|
|
p.oe = nodeStack{root}
|
|
if context != nil && context.DataAtom == a.Template {
|
|
p.templateStack = append(p.templateStack, inTemplateIM)
|
|
}
|
|
p.resetInsertionMode()
|
|
|
|
for n := context; n != nil; n = n.Parent {
|
|
if n.Type == ElementNode && n.DataAtom == a.Form {
|
|
p.form = n
|
|
break
|
|
}
|
|
}
|
|
|
|
if err := p.parse(); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
parent := p.doc
|
|
if context != nil {
|
|
parent = root
|
|
}
|
|
|
|
var result []*Node
|
|
for c := parent.FirstChild; c != nil; {
|
|
next := c.NextSibling
|
|
parent.RemoveChild(c)
|
|
result = append(result, c)
|
|
c = next
|
|
}
|
|
return result, nil
|
|
}
|