├── example_test.png
├── vendor
    ├── golang.org
    │   └── x
    │   │   └── net
    │   │       └── html
    │   │           ├── charset
    │   │               └── testdata
    │   │               │   ├── UTF-16BE-BOM.html
    │   │               │   ├── UTF-16LE-BOM.html
    │   │               │   ├── README
    │   │               │   ├── No-encoding-declaration.html
    │   │               │   ├── HTTP-charset.html
    │   │               │   ├── meta-charset-attribute.html
    │   │               │   ├── meta-content-attribute.html
    │   │               │   ├── HTTP-vs-meta-charset.html
    │   │               │   ├── UTF-8-BOM-vs-meta-charset.html
    │   │               │   ├── UTF-8-BOM-vs-meta-content.html
    │   │               │   ├── HTTP-vs-UTF-8-BOM.html
    │   │               │   └── HTTP-vs-meta-content.html
    │   │           ├── testdata
    │   │               └── webkit
    │   │               │   ├── pending-spec-changes-plain-text-unsafe.dat
    │   │               │   ├── scripted
    │   │               │       ├── adoption01.dat
    │   │               │       └── webkit01.dat
    │   │               │   ├── adoption02.dat
    │   │               │   ├── inbody01.dat
    │   │               │   ├── isindex.dat
    │   │               │   ├── tests4.dat
    │   │               │   ├── tests24.dat
    │   │               │   ├── tests14.dat
    │   │               │   ├── pending-spec-changes.dat
    │   │               │   ├── README
    │   │               │   ├── tests12.dat
    │   │               │   ├── comments01.dat
    │   │               │   ├── tests17.dat
    │   │               │   ├── webkit02.dat
    │   │               │   ├── adoption01.dat
    │   │               │   ├── tests21.dat
    │   │               │   ├── tests25.dat
    │   │               │   ├── tests23.dat
    │   │               │   ├── tables01.dat
    │   │               │   ├── html5test-com.dat
    │   │               │   ├── tests22.dat
    │   │               │   ├── tests8.dat
    │   │               │   ├── tests5.dat
    │   │               │   ├── entities02.dat
    │   │               │   ├── tests15.dat
    │   │               │   ├── tricky01.dat
    │   │               │   ├── tests18.dat
    │   │               │   ├── scriptdata01.dat
    │   │               │   ├── plain-text-unsafe.dat
    │   │               │   ├── tests3.dat
    │   │               │   └── tests26.dat
    │   │           ├── example_test.go
    │   │           ├── entity_test.go
    │   │           ├── escape_test.go
    │   │           ├── atom
    │   │               ├── atom.go
    │   │               ├── atom_test.go
    │   │               └── table_test.go
    │   │           ├── const.go
    │   │           ├── render_test.go
    │   │           ├── doc.go
    │   │           ├── node_test.go
    │   │           ├── doctype.go
    │   │           └── node.go
    └── github.com
    │   └── mb0
    │       └── diff
    │           ├── README.md
    │           ├── LICENSE
    │           ├── example_test.go
    │           ├── diff_test.go
    │           └── diff.go
├── .gitignore
├── benchmark_test.go
├── LICENSE
├── example_test.go
├── pos.go
├── README.md
├── example_test.html
├── vizhtml
    └── viztree.go
├── nodes.go
├── clean.go
├── treerunes.go
├── fuzz.go
├── htmldiff.go
└── append.go


/example_test.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/documize/html-diff/HEAD/example_test.png


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/charset/testdata/UTF-16BE-BOM.html:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/documize/html-diff/HEAD/vendor/golang.org/x/net/html/charset/testdata/UTF-16BE-BOM.html


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/charset/testdata/UTF-16LE-BOM.html:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/documize/html-diff/HEAD/vendor/golang.org/x/net/html/charset/testdata/UTF-16LE-BOM.html


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/testdata/webkit/pending-spec-changes-plain-text-unsafe.dat:
--------------------------------------------------------------------------------
 1 | #data
 2 | <body><table> filler text 
 3 | #errors
 4 | #document
 5 | | <html>
 6 | |   <head>
 7 | |   <body>
 8 | |     "fillertext"
 9 | |     <table>
10 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/testdata/webkit/scripted/adoption01.dat:
--------------------------------------------------------------------------------
 1 | #data
 2 | <p><b id="A"><script>document.getElementById("A").id = "B"</script></p>TEXT</b>
 3 | #errors
 4 | #document
 5 | | <html>
 6 | |   <head>
 7 | |   <body>
 8 | |     <p>
 9 | |       <b>
10 | |         id="B"
11 | |         <script>
12 | |           "document.getElementById("A").id = "B""
13 | |     <b>
14 | |       id="A"
15 | |       "TEXT"
16 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Compiled Object files, Static and Dynamic libs (Shared Objects)
 2 | *.o
 3 | *.a
 4 | *.so
 5 | 
 6 | # Folders
 7 | _obj
 8 | _test
 9 | testout
10 | fuzz
11 | .vscode
12 | 
13 | # Architecture specific extensions/prefixes
14 | *.[568vq]
15 | [568vq].out
16 | 
17 | *.cgo1.go
18 | *.cgo2.c
19 | _cgo_defun.c
20 | _cgo_gotypes.go
21 | _cgo_export.*
22 | 
23 | _testmain.go
24 | 
25 | *.exe
26 | *.test
27 | *.prof
28 | *.out
29 | *.pprof
30 | *.svg
31 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/charset/testdata/README:
--------------------------------------------------------------------------------
 1 | These test cases come from
 2 | http://www.w3.org/International/tests/repository/html5/the-input-byte-stream/results-basics
 3 | 
 4 | Distributed under both the W3C Test Suite License
 5 | (http://www.w3.org/Consortium/Legal/2008/04-testsuite-license)
 6 | and the W3C 3-clause BSD License
 7 | (http://www.w3.org/Consortium/Legal/2008/03-bsd-license).
 8 | To contribute to a W3C Test Suite, see the policies and contribution
 9 | forms (http://www.w3.org/2004/10/27-testcases).
10 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/testdata/webkit/adoption02.dat:
--------------------------------------------------------------------------------
 1 | #data
 2 | <b>1<i>2<p>3</b>4
 3 | #errors
 4 | #document
 5 | | <html>
 6 | |   <head>
 7 | |   <body>
 8 | |     <b>
 9 | |       "1"
10 | |       <i>
11 | |         "2"
12 | |     <i>
13 | |       <p>
14 | |         <b>
15 | |           "3"
16 | |         "4"
17 | 
18 | #data
19 | <a><div><style></style><address><a>
20 | #errors
21 | #document
22 | | <html>
23 | |   <head>
24 | |   <body>
25 | |     <a>
26 | |     <div>
27 | |       <a>
28 | |         <style>
29 | |       <address>
30 | |         <a>
31 | |         <a>
32 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/testdata/webkit/inbody01.dat:
--------------------------------------------------------------------------------
 1 | #data
 2 | <button>1</foo>
 3 | #errors
 4 | #document
 5 | | <html>
 6 | |   <head>
 7 | |   <body>
 8 | |     <button>
 9 | |       "1"
10 | 
11 | #data
12 | <foo>1<p>2</foo>
13 | #errors
14 | #document
15 | | <html>
16 | |   <head>
17 | |   <body>
18 | |     <foo>
19 | |       "1"
20 | |       <p>
21 | |         "2"
22 | 
23 | #data
24 | <dd>1</foo>
25 | #errors
26 | #document
27 | | <html>
28 | |   <head>
29 | |   <body>
30 | |     <dd>
31 | |       "1"
32 | 
33 | #data
34 | <foo>1<dd>2</foo>
35 | #errors
36 | #document
37 | | <html>
38 | |   <head>
39 | |   <body>
40 | |     <foo>
41 | |       "1"
42 | |       <dd>
43 | |         "2"
44 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/testdata/webkit/scripted/webkit01.dat:
--------------------------------------------------------------------------------
 1 | #data
 2 | 1<script>document.write("2")</script>3
 3 | #errors
 4 | #document
 5 | | <html>
 6 | |   <head>
 7 | |   <body>
 8 | |     "1"
 9 | |     <script>
10 | |       "document.write("2")"
11 | |     "23"
12 | 
13 | #data
14 | 1<script>document.write("<script>document.write('2')</scr"+ "ipt><script>document.write('3')</scr" + "ipt>")</script>4
15 | #errors
16 | #document
17 | | <html>
18 | |   <head>
19 | |   <body>
20 | |     "1"
21 | |     <script>
22 | |       "document.write("<script>document.write('2')</scr"+ "ipt><script>document.write('3')</scr" + "ipt>")"
23 | |     <script>
24 | |       "document.write('2')"
25 | |     "2"
26 | |     <script>
27 | |       "document.write('3')"
28 | |     "34"
29 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/testdata/webkit/isindex.dat:
--------------------------------------------------------------------------------
 1 | #data
 2 | <isindex>
 3 | #errors
 4 | #document
 5 | | <html>
 6 | |   <head>
 7 | |   <body>
 8 | |     <form>
 9 | |       <hr>
10 | |       <label>
11 | |         "This is a searchable index. Enter search keywords: "
12 | |         <input>
13 | |           name="isindex"
14 | |       <hr>
15 | 
16 | #data
17 | <isindex name="A" action="B" prompt="C" foo="D">
18 | #errors
19 | #document
20 | | <html>
21 | |   <head>
22 | |   <body>
23 | |     <form>
24 | |       action="B"
25 | |       <hr>
26 | |       <label>
27 | |         "C"
28 | |         <input>
29 | |           foo="D"
30 | |           name="isindex"
31 | |       <hr>
32 | 
33 | #data
34 | <form><isindex>
35 | #errors
36 | #document
37 | | <html>
38 | |   <head>
39 | |   <body>
40 | |     <form>
41 | 


--------------------------------------------------------------------------------
/vendor/github.com/mb0/diff/README.md:
--------------------------------------------------------------------------------
 1 | diff
 2 | ====
 3 | 
 4 | A difference algorithm package for go.
 5 | 
 6 | The algorithm is described by Eugene Myers in
 7 | ["An O(ND) Difference Algorithm and its Variations"](http://www.xmailserver.org/diff2.pdf).
 8 | 
 9 | Example
10 | -------
11 | You can use diff.Ints, diff.Runes, diff.ByteStrings, and diff.Bytes
12 | 
13 |     diff.Runes([]rune("sögen"), []rune("mögen")) // returns []Changes{{0,0,1,1}}
14 | 
15 | or you can implement diff.Data
16 | 
17 |     type MixedInput struct {
18 |     	A []int
19 |     	B []string
20 |     }
21 |     func (m *MixedInput) Equal(i, j int) bool {
22 |     	return m.A[i] == len(m.B[j])
23 |     }
24 | 
25 | and call
26 | 
27 |     m := &MixedInput{..}
28 |     diff.Diff(len(m.A), len(m.B), m)
29 | 
30 | Also has granularity functions to merge changes that are close by.
31 | 
32 |     diff.Granular(1, diff.ByteStrings("emtire", "umpire")) // returns []Changes{{0,0,3,3}}
33 | 
34 | Documentation at http://godoc.org/github.com/mb0/diff
35 | 


--------------------------------------------------------------------------------
/benchmark_test.go:
--------------------------------------------------------------------------------
 1 | package htmldiff_test
 2 | 
 3 | import (
 4 | 	"strings"
 5 | 	"testing"
 6 | 
 7 | 	"github.com/documize/html-diff"
 8 | )
 9 | 
10 | var cfgBench = &htmldiff.Config{
11 | 	Granularity:  6,
12 | 	InsertedSpan: []htmldiff.Attribute{{Key: "style", Val: "background-color: palegreen; text-decoration: underline;"}},
13 | 	DeletedSpan:  []htmldiff.Attribute{{Key: "style", Val: "background-color: lightpink; text-decoration: line-through;"}},
14 | 	ReplacedSpan: []htmldiff.Attribute{{Key: "style", Val: "background-color: lightskyblue; text-decoration: overline;"}},
15 | 	CleanTags:    []string{"documize"},
16 | }
17 | 
18 | func BenchmarkHTMLdiff(b *testing.B) {
19 | 	bbc := bbcNews1 + bbcNews2
20 | 	bbclc := strings.ToLower(bbc)
21 | 	args := []string{bbc, bbclc}
22 | 	for n := 0; n < b.N; n++ {
23 | 		_, err := cfgBench.HTMLdiff(args) // don't care about the result as we are looking at speed
24 | 		if err != nil {
25 | 			b.Errorf("comparing BBC news with its lower-case self error: %s", err)
26 | 		}
27 | 	}
28 | }
29 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/example_test.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2012 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 | // This example demonstrates parsing HTML data and walking the resulting tree.
 6 | package html_test
 7 | 
 8 | import (
 9 | 	"fmt"
10 | 	"log"
11 | 	"strings"
12 | 
13 | 	"golang.org/x/net/html"
14 | )
15 | 
16 | func ExampleParse() {
17 | 	s := `<p>Links:</p><ul><li><a href="foo">Foo</a><li><a href="/bar/baz">BarBaz</a></ul>`
18 | 	doc, err := html.Parse(strings.NewReader(s))
19 | 	if err != nil {
20 | 		log.Fatal(err)
21 | 	}
22 | 	var f func(*html.Node)
23 | 	f = func(n *html.Node) {
24 | 		if n.Type == html.ElementNode && n.Data == "a" {
25 | 			for _, a := range n.Attr {
26 | 				if a.Key == "href" {
27 | 					fmt.Println(a.Val)
28 | 					break
29 | 				}
30 | 			}
31 | 		}
32 | 		for c := n.FirstChild; c != nil; c = c.NextSibling {
33 | 			f(c)
34 | 		}
35 | 	}
36 | 	f(doc)
37 | 	// Output:
38 | 	// foo
39 | 	// /bar/baz
40 | }
41 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2016 Documize
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/entity_test.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2010 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 html
 6 | 
 7 | import (
 8 | 	"testing"
 9 | 	"unicode/utf8"
10 | )
11 | 
12 | func TestEntityLength(t *testing.T) {
13 | 	// We verify that the length of UTF-8 encoding of each value is <= 1 + len(key).
14 | 	// The +1 comes from the leading "&". This property implies that the length of
15 | 	// unescaped text is <= the length of escaped text.
16 | 	for k, v := range entity {
17 | 		if 1+len(k) < utf8.RuneLen(v) {
18 | 			t.Error("escaped entity &" + k + " is shorter than its UTF-8 encoding " + string(v))
19 | 		}
20 | 		if len(k) > longestEntityWithoutSemicolon && k[len(k)-1] != ';' {
21 | 			t.Errorf("entity name %s is %d characters, but longestEntityWithoutSemicolon=%d", k, len(k), longestEntityWithoutSemicolon)
22 | 		}
23 | 	}
24 | 	for k, v := range entity2 {
25 | 		if 1+len(k) < utf8.RuneLen(v[0])+utf8.RuneLen(v[1]) {
26 | 			t.Error("escaped entity &" + k + " is shorter than its UTF-8 encoding " + string(v[0]) + string(v[1]))
27 | 		}
28 | 	}
29 | }
30 | 


--------------------------------------------------------------------------------
/example_test.go:
--------------------------------------------------------------------------------
 1 | package htmldiff_test
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 
 6 | 	"github.com/documize/html-diff"
 7 | )
 8 | 
 9 | func ExampleHTMLdiff() {
10 | 	previousHTML := `<p>Bullet list:</p><ul><li>first item</li><li>第二</li><li>3rd</li></ul>`
11 | 	latestHTML := `<p>Bullet <b>list:</b></p><ul><li>first item</li><li>number two</li><li>3rd</li></ul>`
12 | 	var cfg = &htmldiff.Config{
13 | 		Granularity:  5,
14 | 		InsertedSpan: []htmldiff.Attribute{{Key: "style", Val: "background-color: palegreen;"}},
15 | 		DeletedSpan:  []htmldiff.Attribute{{Key: "style", Val: "background-color: lightpink;"}},
16 | 		ReplacedSpan: []htmldiff.Attribute{{Key: "style", Val: "background-color: lightskyblue;"}},
17 | 		CleanTags:    []string{""},
18 | 	}
19 | 
20 | 	res, err := cfg.HTMLdiff([]string{previousHTML, latestHTML})
21 | 	if err != nil {
22 | 		fmt.Println(err)
23 | 	}
24 | 	mergedHTML := res[0]
25 | 
26 | 	fmt.Println(mergedHTML)
27 | 	// Output:
28 | 	// <p>Bullet <b><span style="background-color: lightskyblue;">list:</span></b></p><ul><li>first item</li><li><span style="background-color: lightpink;">第二</span><span style="background-color: palegreen;">number two</span></li><li>3rd</li></ul>
29 | }
30 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/testdata/webkit/tests4.dat:
--------------------------------------------------------------------------------
 1 | #data
 2 | direct div content
 3 | #errors
 4 | #document-fragment
 5 | div
 6 | #document
 7 | | "direct div content"
 8 | 
 9 | #data
10 | direct textarea content
11 | #errors
12 | #document-fragment
13 | textarea
14 | #document
15 | | "direct textarea content"
16 | 
17 | #data
18 | textarea content with <em>pseudo</em> <foo>markup
19 | #errors
20 | #document-fragment
21 | textarea
22 | #document
23 | | "textarea content with <em>pseudo</em> <foo>markup"
24 | 
25 | #data
26 | this is &#x0043;DATA inside a <style> element
27 | #errors
28 | #document-fragment
29 | style
30 | #document
31 | | "this is &#x0043;DATA inside a <style> element"
32 | 
33 | #data
34 | </plaintext>
35 | #errors
36 | #document-fragment
37 | plaintext
38 | #document
39 | | "</plaintext>"
40 | 
41 | #data
42 | setting html's innerHTML
43 | #errors
44 | Line: 1 Col: 24 Unexpected EOF in inner html mode.
45 | #document-fragment
46 | html
47 | #document
48 | | <head>
49 | | <body>
50 | |   "setting html's innerHTML"
51 | 
52 | #data
53 | <title>setting head's innerHTML</title>
54 | #errors
55 | #document-fragment
56 | head
57 | #document
58 | | <title>
59 | |   "setting head's innerHTML"
60 | 


--------------------------------------------------------------------------------
/pos.go:
--------------------------------------------------------------------------------
 1 | package htmldiff
 2 | 
 3 | import "golang.org/x/net/html"
 4 | 
 5 | // posTT gives the relative position within one level of a nested container.
 6 | type posTT struct {
 7 | 	nodesBefore int
 8 | 	node        *html.Node
 9 | }
10 | 
11 | // posT gives the relative position within a nested set of containers.
12 | type posT []posTT
13 | 
14 | // getPos returns the relative posion of this node within the enclosing containers, if there are any.
15 | func getPos(n *html.Node) posT {
16 | 	if n == nil {
17 | 		return nil
18 | 	}
19 | 	depth := 0
20 | 	for root := n; inContainer(root); root = root.Parent {
21 | 		depth++
22 | 	}
23 | 	ret := make([]posTT, 0, depth) // for speed
24 | 	for root := n; depth > 0; root = root.Parent {
25 | 		var before int
26 | 		for sib := root.Parent.FirstChild; sib != root; sib = sib.NextSibling {
27 | 			if sib.Type == html.ElementNode {
28 | 				before++
29 | 			}
30 | 		}
31 | 		ret = append(ret, posTT{before, root})
32 | 		depth--
33 | 	}
34 | 	return ret
35 | }
36 | 
37 | func posEqual(a, b posT) bool {
38 | 	if len(a) != len(b) {
39 | 		return false
40 | 	}
41 | 	for i, aa := range a {
42 | 		if aa.nodesBefore != b[i].nodesBefore {
43 | 			return false
44 | 		}
45 | 	}
46 | 	return true
47 | }
48 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # html-diff
 2 | 
 3 | Calculate difference between two HTML snippets and return those differences as a merged HTML snippet showing the changes.
 4 | 
 5 | Usage:
 6 | ```
 7 | 	var cfg = &htmldiff.Config{
 8 | 		Granularity:  5,
 9 | 		InsertedSpan: []htmldiff.Attribute{{Key: "style", Val: "background-color: palegreen;"}},
10 | 		DeletedSpan:  []htmldiff.Attribute{{Key: "style", Val: "background-color: lightpink;"}},
11 | 		ReplacedSpan: []htmldiff.Attribute{{Key: "style", Val: "background-color: lightskyblue;"}},
12 | 		CleanTags:    []string{""},
13 | 	}
14 | 	res, err := cfg.HTMLdiff([]string{previousHTML, latestHTML})
15 | 	mergedHTML := res[0]
16 | ```
17 | ![see example_test.go](example_test.png)
18 | 
19 | Only deals with body HTML, so no headers, only what is within the body element.
20 | 
21 | Requires Go1.5+, with vendoring support. Vendors "github.com/mb0/diff", "golang.org/x/net/html" and "golang.org/x/net/html/atom".
22 | 
23 | Running the tests will create output files in testout/*.html.
24 | 
25 | For fuzz-testing using https://github.com/dvyukov/go-fuzz , the Fuzz() function is in fuzz.go (as at Feb'16 you need to rename the ```vendor``` directory while you fuzz, and go get the dependencies - an issue with "go/importer", see https://github.com/golang/go/issues/13756).
26 | 
27 | Pull requests welcome.
28 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/testdata/webkit/tests24.dat:
--------------------------------------------------------------------------------
 1 | #data
 2 | <!DOCTYPE html>&NotEqualTilde;
 3 | #errors
 4 | #document
 5 | | <!DOCTYPE html>
 6 | | <html>
 7 | |   <head>
 8 | |   <body>
 9 | |     "≂̸"
10 | 
11 | #data
12 | <!DOCTYPE html>&NotEqualTilde;A
13 | #errors
14 | #document
15 | | <!DOCTYPE html>
16 | | <html>
17 | |   <head>
18 | |   <body>
19 | |     "≂̸A"
20 | 
21 | #data
22 | <!DOCTYPE html>&ThickSpace;
23 | #errors
24 | #document
25 | | <!DOCTYPE html>
26 | | <html>
27 | |   <head>
28 | |   <body>
29 | |     "  "
30 | 
31 | #data
32 | <!DOCTYPE html>&ThickSpace;A
33 | #errors
34 | #document
35 | | <!DOCTYPE html>
36 | | <html>
37 | |   <head>
38 | |   <body>
39 | |     "  A"
40 | 
41 | #data
42 | <!DOCTYPE html>&NotSubset;
43 | #errors
44 | #document
45 | | <!DOCTYPE html>
46 | | <html>
47 | |   <head>
48 | |   <body>
49 | |     "⊂⃒"
50 | 
51 | #data
52 | <!DOCTYPE html>&NotSubset;A
53 | #errors
54 | #document
55 | | <!DOCTYPE html>
56 | | <html>
57 | |   <head>
58 | |   <body>
59 | |     "⊂⃒A"
60 | 
61 | #data
62 | <!DOCTYPE html>&Gopf;
63 | #errors
64 | #document
65 | | <!DOCTYPE html>
66 | | <html>
67 | |   <head>
68 | |   <body>
69 | |     "𝔾"
70 | 
71 | #data
72 | <!DOCTYPE html>&Gopf;A
73 | #errors
74 | #document
75 | | <!DOCTYPE html>
76 | | <html>
77 | |   <head>
78 | |   <body>
79 | |     "𝔾A"
80 | 


--------------------------------------------------------------------------------
/vendor/github.com/mb0/diff/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2012 Martin Schnabel. All rights reserved.
 2 | 
 3 | Redistribution and use in source and binary forms, with or without
 4 | modification, are permitted provided that the following conditions are met:
 5 | 
 6 | 1. Redistributions of source code must retain the above copyright notice, this
 7 |    list of conditions and the following disclaimer.
 8 | 2. Redistributions in binary form must reproduce the above copyright notice,
 9 |    this list of conditions and the following disclaimer in the documentation
10 |    and/or other materials provided with the distribution.
11 | 
12 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
13 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
14 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
15 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
16 | OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
17 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
18 | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
19 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
20 | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
21 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
22 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
23 | 


--------------------------------------------------------------------------------
/example_test.html:
--------------------------------------------------------------------------------
 1 | <html>
 2 | 
 3 | <head></head>
 4 | 
 5 | <body>
 6 |     <table border=1 style="font: 15px arial, sans-serif;">
 7 |         <tr><th colspan=3>
 8 |            <b>variables from example_test.go</b>
 9 |        </th></tr>
10 |         <tr>
11 |             <th>previousHTML</th>
12 |             <th>latestHTML</th>
13 |             <th>mergedHTML
14 |             </th>
15 |         </tr>
16 |         <tr>
17 |             <td>
18 |                 <p>Bullet list:</p>
19 |                 <ul>
20 |                     <li>first item</li>
21 |                     <li>第二</li>
22 |                     <li>3rd</li>
23 |                 </ul>
24 |             </td>
25 |             <td>
26 |                 <p>Bullet <b>list:</b></p>
27 |                 <ul>
28 |                     <li>first item</li>
29 |                     <li>number two</li>
30 |                     <li>3rd</li>
31 |                 </ul>
32 |             </td>
33 |             <td>
34 |                 <p>Bullet <b><span style="background-color: lightskyblue;">list:</span></b></p>
35 |                 <ul>
36 |                     <li>first item</li>
37 |                     <li><span style="background-color: lightpink;">第二</span><span style="background-color: palegreen;">number two</span></li>
38 |                     <li>3rd</li>
39 |                 </ul>
40 |             </td>
41 |         </tr>
42 |     </table>
43 | </body>
44 | 
45 | </html>


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/testdata/webkit/tests14.dat:
--------------------------------------------------------------------------------
 1 | #data
 2 | <!DOCTYPE html><html><body><xyz:abc></xyz:abc>
 3 | #errors
 4 | #document
 5 | | <!DOCTYPE html>
 6 | | <html>
 7 | |   <head>
 8 | |   <body>
 9 | |     <xyz:abc>
10 | 
11 | #data
12 | <!DOCTYPE html><html><body><xyz:abc></xyz:abc><span></span>
13 | #errors
14 | #document
15 | | <!DOCTYPE html>
16 | | <html>
17 | |   <head>
18 | |   <body>
19 | |     <xyz:abc>
20 | |     <span>
21 | 
22 | #data
23 | <!DOCTYPE html><html><html abc:def=gh><xyz:abc></xyz:abc>
24 | #errors
25 | 15: Unexpected start tag html
26 | #document
27 | | <!DOCTYPE html>
28 | | <html>
29 | |   abc:def="gh"
30 | |   <head>
31 | |   <body>
32 | |     <xyz:abc>
33 | 
34 | #data
35 | <!DOCTYPE html><html xml:lang=bar><html xml:lang=foo>
36 | #errors
37 | 15: Unexpected start tag html
38 | #document
39 | | <!DOCTYPE html>
40 | | <html>
41 | |   xml:lang="bar"
42 | |   <head>
43 | |   <body>
44 | 
45 | #data
46 | <!DOCTYPE html><html 123=456>
47 | #errors
48 | #document
49 | | <!DOCTYPE html>
50 | | <html>
51 | |   123="456"
52 | |   <head>
53 | |   <body>
54 | 
55 | #data
56 | <!DOCTYPE html><html 123=456><html 789=012>
57 | #errors
58 | #document
59 | | <!DOCTYPE html>
60 | | <html>
61 | |   123="456"
62 | |   789="012"
63 | |   <head>
64 | |   <body>
65 | 
66 | #data
67 | <!DOCTYPE html><html><body 789=012>
68 | #errors
69 | #document
70 | | <!DOCTYPE html>
71 | | <html>
72 | |   <head>
73 | |   <body>
74 | |     789="012"
75 | 


--------------------------------------------------------------------------------
/vendor/github.com/mb0/diff/example_test.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2012 Martin Schnabel. 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 diff_test
 6 | 
 7 | import (
 8 | 	"fmt"
 9 | 	"github.com/mb0/diff"
10 | )
11 | 
12 | // Diff on inputs with different representations
13 | type MixedInput struct {
14 | 	A []int
15 | 	B []string
16 | }
17 | 
18 | var names map[string]int
19 | 
20 | func (m *MixedInput) Equal(a, b int) bool {
21 | 	return m.A[a] == names[m.B[b]]
22 | }
23 | 
24 | func ExampleDiff() {
25 | 	names = map[string]int{
26 | 		"one":   1,
27 | 		"two":   2,
28 | 		"three": 3,
29 | 	}
30 | 
31 | 	m := &MixedInput{
32 | 		[]int{1, 2, 3, 1, 2, 2, 1},
33 | 		[]string{"three", "two", "one", "two", "one", "three"},
34 | 	}
35 | 	changes := diff.Diff(len(m.A), len(m.B), m)
36 | 	for _, c := range changes {
37 | 		fmt.Println("change at", c.A, c.B)
38 | 	}
39 | 	// Output:
40 | 	// change at 0 0
41 | 	// change at 2 2
42 | 	// change at 5 4
43 | 	// change at 7 5
44 | }
45 | 
46 | func ExampleGranular() {
47 | 	a := "hElLo!"
48 | 	b := "hello!"
49 | 	changes := diff.Granular(5, diff.ByteStrings(a, b)) // ignore small gaps in differences
50 | 	for l := len(changes) - 1; l >= 0; l-- {
51 | 		change := changes[l]
52 | 		b = b[:change.B] + "|" + b[change.B:change.B+change.Ins] + "|" + b[change.B+change.Ins:]
53 | 	}
54 | 	fmt.Println(b)
55 | 	// Output:
56 | 	// h|ell|o!
57 | }
58 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/testdata/webkit/pending-spec-changes.dat:
--------------------------------------------------------------------------------
 1 | #data
 2 | <input type="hidden"><frameset>
 3 | #errors
 4 | 21: Start tag seen without seeing a doctype first. Expected “<!DOCTYPE html>”.
 5 | 31: “frameset” start tag seen.
 6 | 31: End of file seen and there were open elements.
 7 | #document
 8 | | <html>
 9 | |   <head>
10 | |   <frameset>
11 | 
12 | #data
13 | <!DOCTYPE html><table><caption><svg>foo</table>bar
14 | #errors
15 | 47: End tag “table” did not match the name of the current open element (“svg”).
16 | 47: “table” closed but “caption” was still open.
17 | 47: End tag “table” seen, but there were open elements.
18 | 36: Unclosed element “svg”.
19 | #document
20 | | <!DOCTYPE html>
21 | | <html>
22 | |   <head>
23 | |   <body>
24 | |     <table>
25 | |       <caption>
26 | |         <svg svg>
27 | |           "foo"
28 | |     "bar"
29 | 
30 | #data
31 | <table><tr><td><svg><desc><td></desc><circle>
32 | #errors
33 | 7: Start tag seen without seeing a doctype first. Expected “<!DOCTYPE html>”.
34 | 30: A table cell was implicitly closed, but there were open elements.
35 | 26: Unclosed element “desc”.
36 | 20: Unclosed element “svg”.
37 | 37: Stray end tag “desc”.
38 | 45: End of file seen and there were open elements.
39 | 45: Unclosed element “circle”.
40 | 7: Unclosed element “table”.
41 | #document
42 | | <html>
43 | |   <head>
44 | |   <body>
45 | |     <table>
46 | |       <tbody>
47 | |         <tr>
48 | |           <td>
49 | |             <svg svg>
50 | |               <svg desc>
51 | |           <td>
52 | |             <circle>
53 | 


--------------------------------------------------------------------------------
/vizhtml/viztree.go:
--------------------------------------------------------------------------------
 1 | // Package vizhtml provides a way to display html node trees for debug purposes.
 2 | package vizhtml
 3 | 
 4 | import (
 5 | 	"strings"
 6 | 
 7 | 	"golang.org/x/net/html"
 8 | )
 9 | 
10 | // Tree provides a text visualisation of the given html.Node tree, one node per line, stopping at the target.
11 | // It is intended for debugging.
12 | func Tree(n, target *html.Node) string {
13 | 	r, _ := vizTree0(n, target, 0, "")
14 | 	return r
15 | }
16 | 
17 | // nodeLevel returns the prefix to show the depth of the node
18 | func nodeLevel(l int) (s string) {
19 | 	for i := 0; i < l; i++ {
20 | 		s += "-"
21 | 	}
22 | 	s += ">"
23 | 	return s
24 | }
25 | 
26 | // vizTree0 is the recursive node tree walker.
27 | func vizTree0(n, target *html.Node, l int, s string) (string, bool) {
28 | 	if n == nil {
29 | 		return s, true
30 | 	}
31 | 	s += nodeLevel(l)
32 | 	switch n.Type {
33 | 	case html.ErrorNode:
34 | 		s += " Error: "
35 | 	case html.TextNode:
36 | 		s += " Text: "
37 | 	case html.DocumentNode:
38 | 		s += "Document: "
39 | 	case html.ElementNode:
40 | 		s += "Element: "
41 | 	case html.CommentNode:
42 | 		s += "Comment: "
43 | 	case html.DoctypeNode:
44 | 		s += "DocType: "
45 | 	}
46 | 	if len(n.Data) > 10 {
47 | 		s += strings.Replace(n.Data[:10], "\n", "", -1)
48 | 	} else {
49 | 		s += strings.Replace(n.Data, "\n", "", -1)
50 | 	}
51 | 	if n == target {
52 | 		return s + " (Target)\n", true
53 | 	}
54 | 	s += "\n"
55 | 	for c := n.FirstChild; c != nil; c = c.NextSibling {
56 | 		var found bool
57 | 		s, found = vizTree0(c, target, l+1, s)
58 | 		if found {
59 | 			return s, true
60 | 		}
61 | 	}
62 | 	return s, false
63 | }
64 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/testdata/webkit/README:
--------------------------------------------------------------------------------
 1 | The *.dat files in this directory are copied from The WebKit Open Source
 2 | Project, specifically $WEBKITROOT/LayoutTests/html5lib/resources.
 3 | WebKit is licensed under a BSD style license.
 4 | http://webkit.org/coding/bsd-license.html says:
 5 | 
 6 | Copyright (C) 2009 Apple Inc. All rights reserved.
 7 | 
 8 | Redistribution and use in source and binary forms, with or without
 9 | modification, are permitted provided that the following conditions are met:
10 | 
11 | 1. Redistributions of source code must retain the above copyright notice,
12 | this list of conditions and the following disclaimer.
13 | 
14 | 2. Redistributions in binary form must reproduce the above copyright notice,
15 | this list of conditions and the following disclaimer in the documentation
16 | and/or other materials provided with the distribution.
17 | 
18 | THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS "AS IS" AND ANY
19 | EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
20 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
21 | DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY
22 | DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
23 | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
24 | LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
25 | ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
27 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 | 
29 | 


--------------------------------------------------------------------------------
/nodes.go:
--------------------------------------------------------------------------------
 1 | package htmldiff
 2 | 
 3 | import (
 4 | 	"golang.org/x/net/html"
 5 | 	"golang.org/x/net/html/atom"
 6 | )
 7 | 
 8 | func copyNode(to, from *html.Node) {
 9 | 	to.Attr = from.Attr
10 | 	to.Data = from.Data
11 | 	to.DataAtom = from.DataAtom
12 | 	to.Namespace = from.Namespace
13 | 	to.Type = from.Type
14 | }
15 | 
16 | func nodeEqual(base, comp *html.Node) bool {
17 | 	return base.Data == comp.Data && nodeEqualExText(base, comp)
18 | }
19 | 
20 | // findBody finds the first body HTML node if it exists in the tree. Required to bypass the page title text.
21 | func findBody(n *html.Node) *html.Node {
22 | 	if n.Type == html.ElementNode && n.DataAtom == atom.Body {
23 | 		return n
24 | 	}
25 | 	for c := n.FirstChild; c != nil; c = c.NextSibling {
26 | 		r := findBody(c)
27 | 		if r != nil {
28 | 			return r
29 | 		}
30 | 	}
31 | 	return nil
32 | }
33 | 
34 | // find the first leaf in the tree that is a text node.
35 | func firstLeaf(n *html.Node) (*html.Node, bool) {
36 | 	if n != nil {
37 | 		switch n.Type {
38 | 		case html.TextNode:
39 | 			return n, true
40 | 		}
41 | 		// no valid node found
42 | 		for c := n.FirstChild; c != nil; c = c.NextSibling {
43 | 			r, ok := firstLeaf(c)
44 | 			if ok {
45 | 				return r, ok
46 | 			}
47 | 		}
48 | 	}
49 | 	return nil, false
50 | }
51 | 
52 | // find if this or any parent is a container element where position is important like a list or table.
53 | func inContainer(n *html.Node) bool {
54 | 	if n == nil {
55 | 		return false
56 | 	}
57 | 	if n.Type == html.ElementNode {
58 | 		switch n.DataAtom {
59 | 		case atom.Body:
60 | 			return false
61 | 		case atom.Td, atom.Th, atom.Tr, atom.Tbody, atom.Thead, atom.Tfoot,
62 | 			atom.Table, atom.Caption, atom.Colgroup, atom.Col, // tables
63 | 			atom.Li, atom.Ul, atom.Ol: // lists
64 | 			return true
65 | 		}
66 | 	}
67 | 	return inContainer(n.Parent)
68 | }
69 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/testdata/webkit/tests12.dat:
--------------------------------------------------------------------------------
 1 | #data
 2 | <!DOCTYPE html><body><p>foo<math><mtext><i>baz</i></mtext><annotation-xml><svg><desc><b>eggs</b></desc><g><foreignObject>spam<TABLE><tr><td><img></td></table></foreignObject></g><g>quux</g></svg></annotation-xml></math>bar
 3 | #errors
 4 | #document
 5 | | <!DOCTYPE html>
 6 | | <html>
 7 | |   <head>
 8 | |   <body>
 9 | |     <p>
10 | |       "foo"
11 | |       <math math>
12 | |         <math mtext>
13 | |           <i>
14 | |             "baz"
15 | |         <math annotation-xml>
16 | |           <svg svg>
17 | |             <svg desc>
18 | |               <b>
19 | |                 "eggs"
20 | |             <svg g>
21 | |               <svg foreignObject>
22 | |                 
23 | |                   "spam"
24 | |                 <table>
25 | |                   <tbody>
26 | |                     <tr>
27 | |                       <td>
28 | |                         <img>
29 | |             <svg g>
30 | |               "quux"
31 | |       "bar"
32 | 
33 | #data
34 | <!DOCTYPE html><body>foo<math><mtext><i>baz</i></mtext><annotation-xml><svg><desc><b>eggs</b></desc><g><foreignObject>spam<TABLE><tr><td><img></td></table></foreignObject></g><g>quux</g></svg></annotation-xml></math>bar
35 | #errors
36 | #document
37 | | <!DOCTYPE html>
38 | | <html>
39 | |   <head>
40 | |   <body>
41 | |     "foo"
42 | |     <math math>
43 | |       <math mtext>
44 | |         <i>
45 | |           "baz"
46 | |       <math annotation-xml>
47 | |         <svg svg>
48 | |           <svg desc>
49 | |             <b>
50 | |               "eggs"
51 | |           <svg g>
52 | |             <svg foreignObject>
53 | |               
54 | |                 "spam"
55 | |               <table>
56 | |                 <tbody>
57 | |                   <tr>
58 | |                     <td>
59 | |                       <img>
60 | |           <svg g>
61 | |             "quux"
62 | |     "bar"
63 | 


--------------------------------------------------------------------------------
/clean.go:
--------------------------------------------------------------------------------
 1 | package htmldiff
 2 | 
 3 | import (
 4 | 	htm "html"
 5 | 	"strings"
 6 | 	"unicode/utf8"
 7 | 
 8 | 	"golang.org/x/net/html"
 9 | 	"golang.org/x/net/html/atom"
10 | )
11 | 
12 | // delAttr() deletes an unwanted attribute.
13 | func delAttr(attr []html.Attribute, ai int) (ret []html.Attribute) {
14 | 	if len(attr) <= 1 || ai >= len(attr) {
15 | 		return nil
16 | 	}
17 | 	return append(attr[:ai], attr[ai+1:]...)
18 | }
19 | 
20 | // clean normalises styles/colspan and removes any CleanTags specified, along with newlines;
21 | // but also makes all the character handling (for example "&#160;" as utf-8) the same.
22 | // It returns the estimated number of treeRunes that will be used.
23 | // TODO more cleaning of the input HTML, as required.
24 | func (c *Config) clean(n *html.Node) int {
25 | 	size := 1
26 | 	switch n.Type {
27 | 	case html.ElementNode:
28 | 		for ai := 0; ai < len(n.Attr); ai++ {
29 | 			a := n.Attr[ai]
30 | 			switch {
31 | 			case strings.ToLower(a.Key) == "style":
32 | 				if strings.TrimSpace(a.Val) == "" { // delete empty styles
33 | 					n.Attr = delAttr(n.Attr, ai)
34 | 					ai--
35 | 				} else { // tidy non-empty styles
36 | 					// TODO there could be more here to make sure the style entries are in the same order etc.
37 | 					n.Attr[ai].Val = strings.Replace(a.Val, " ", "", -1)
38 | 					if !strings.HasSuffix(n.Attr[ai].Val, ";") {
39 | 						n.Attr[ai].Val += ";"
40 | 					}
41 | 				}
42 | 			case n.DataAtom == atom.Td &&
43 | 				strings.ToLower(a.Key) == "colspan" &&
44 | 				strings.TrimSpace(a.Val) == "1":
45 | 				n.Attr = delAttr(n.Attr, ai)
46 | 				ai--
47 | 			}
48 | 		}
49 | 	case html.TextNode:
50 | 		n.Data = htm.UnescapeString(n.Data)
51 | 		size += utf8.RuneCountInString(n.Data) - 1 // len(n.Data) would be faster, but use more memory
52 | 	}
53 | searchChildren:
54 | 	for ch := n.FirstChild; ch != nil; ch = ch.NextSibling {
55 | 		switch ch.Type {
56 | 		case html.ElementNode:
57 | 			for _, rr := range c.CleanTags {
58 | 				if rr == ch.Data {
59 | 					n.RemoveChild(ch)
60 | 					goto searchChildren
61 | 				}
62 | 			}
63 | 		}
64 | 		size += c.clean(ch)
65 | 	}
66 | 	return size
67 | }
68 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/escape_test.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2013 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 html
 6 | 
 7 | import "testing"
 8 | 
 9 | type unescapeTest struct {
10 | 	// A short description of the test case.
11 | 	desc string
12 | 	// The HTML text.
13 | 	html string
14 | 	// The unescaped text.
15 | 	unescaped string
16 | }
17 | 
18 | var unescapeTests = []unescapeTest{
19 | 	// Handle no entities.
20 | 	{
21 | 		"copy",
22 | 		"A\ttext\nstring",
23 | 		"A\ttext\nstring",
24 | 	},
25 | 	// Handle simple named entities.
26 | 	{
27 | 		"simple",
28 | 		"&amp; &gt; &lt;",
29 | 		"& > <",
30 | 	},
31 | 	// Handle hitting the end of the string.
32 | 	{
33 | 		"stringEnd",
34 | 		"&amp &amp",
35 | 		"& &",
36 | 	},
37 | 	// Handle entities with two codepoints.
38 | 	{
39 | 		"multiCodepoint",
40 | 		"text &gesl; blah",
41 | 		"text \u22db\ufe00 blah",
42 | 	},
43 | 	// Handle decimal numeric entities.
44 | 	{
45 | 		"decimalEntity",
46 | 		"Delta = &#916; ",
47 | 		"Delta = Δ ",
48 | 	},
49 | 	// Handle hexadecimal numeric entities.
50 | 	{
51 | 		"hexadecimalEntity",
52 | 		"Lambda = &#x3bb; = &#X3Bb ",
53 | 		"Lambda = λ = λ ",
54 | 	},
55 | 	// Handle numeric early termination.
56 | 	{
57 | 		"numericEnds",
58 | 		"&# &#x &#128;43 &copy = &#169f = &#xa9",
59 | 		"&# &#x €43 © = ©f = ©",
60 | 	},
61 | 	// Handle numeric ISO-8859-1 entity replacements.
62 | 	{
63 | 		"numericReplacements",
64 | 		"Footnote&#x87;",
65 | 		"Footnote‡",
66 | 	},
67 | }
68 | 
69 | func TestUnescape(t *testing.T) {
70 | 	for _, tt := range unescapeTests {
71 | 		unescaped := UnescapeString(tt.html)
72 | 		if unescaped != tt.unescaped {
73 | 			t.Errorf("TestUnescape %s: want %q, got %q", tt.desc, tt.unescaped, unescaped)
74 | 		}
75 | 	}
76 | }
77 | 
78 | func TestUnescapeEscape(t *testing.T) {
79 | 	ss := []string{
80 | 		``,
81 | 		`abc def`,
82 | 		`a & b`,
83 | 		`a&amp;b`,
84 | 		`a &amp b`,
85 | 		`&quot;`,
86 | 		`"`,
87 | 		`"<&>"`,
88 | 		`&quot;&lt;&amp;&gt;&quot;`,
89 | 		`3&5==1 && 0<1, "0&lt;1", a+acute=&aacute;`,
90 | 		`The special characters are: <, >, &, ' and "`,
91 | 	}
92 | 	for _, s := range ss {
93 | 		if got := UnescapeString(EscapeString(s)); got != s {
94 | 			t.Errorf("got %q want %q", got, s)
95 | 		}
96 | 	}
97 | }
98 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/testdata/webkit/comments01.dat:
--------------------------------------------------------------------------------
  1 | #data
  2 | FOO<!-- BAR -->BAZ
  3 | #errors
  4 | #document
  5 | | <html>
  6 | |   <head>
  7 | |   <body>
  8 | |     "FOO"
  9 | |     <!--  BAR  -->
 10 | |     "BAZ"
 11 | 
 12 | #data
 13 | FOO<!-- BAR --!>BAZ
 14 | #errors
 15 | #document
 16 | | <html>
 17 | |   <head>
 18 | |   <body>
 19 | |     "FOO"
 20 | |     <!--  BAR  -->
 21 | |     "BAZ"
 22 | 
 23 | #data
 24 | FOO<!-- BAR --   >BAZ
 25 | #errors
 26 | #document
 27 | | <html>
 28 | |   <head>
 29 | |   <body>
 30 | |     "FOO"
 31 | |     <!--  BAR --   >BAZ -->
 32 | 
 33 | #data
 34 | FOO<!-- BAR -- <QUX> -- MUX -->BAZ
 35 | #errors
 36 | #document
 37 | | <html>
 38 | |   <head>
 39 | |   <body>
 40 | |     "FOO"
 41 | |     <!--  BAR -- <QUX> -- MUX  -->
 42 | |     "BAZ"
 43 | 
 44 | #data
 45 | FOO<!-- BAR -- <QUX> -- MUX --!>BAZ
 46 | #errors
 47 | #document
 48 | | <html>
 49 | |   <head>
 50 | |   <body>
 51 | |     "FOO"
 52 | |     <!--  BAR -- <QUX> -- MUX  -->
 53 | |     "BAZ"
 54 | 
 55 | #data
 56 | FOO<!-- BAR -- <QUX> -- MUX -- >BAZ
 57 | #errors
 58 | #document
 59 | | <html>
 60 | |   <head>
 61 | |   <body>
 62 | |     "FOO"
 63 | |     <!--  BAR -- <QUX> -- MUX -- >BAZ -->
 64 | 
 65 | #data
 66 | FOO<!---->BAZ
 67 | #errors
 68 | #document
 69 | | <html>
 70 | |   <head>
 71 | |   <body>
 72 | |     "FOO"
 73 | |     <!--  -->
 74 | |     "BAZ"
 75 | 
 76 | #data
 77 | FOO<!--->BAZ
 78 | #errors
 79 | #document
 80 | | <html>
 81 | |   <head>
 82 | |   <body>
 83 | |     "FOO"
 84 | |     <!--  -->
 85 | |     "BAZ"
 86 | 
 87 | #data
 88 | FOO<!-->BAZ
 89 | #errors
 90 | #document
 91 | | <html>
 92 | |   <head>
 93 | |   <body>
 94 | |     "FOO"
 95 | |     <!--  -->
 96 | |     "BAZ"
 97 | 
 98 | #data
 99 | <?xml version="1.0">Hi
100 | #errors
101 | #document
102 | | <!-- ?xml version="1.0" -->
103 | | <html>
104 | |   <head>
105 | |   <body>
106 | |     "Hi"
107 | 
108 | #data
109 | <?xml version="1.0">
110 | #errors
111 | #document
112 | | <!-- ?xml version="1.0" -->
113 | | <html>
114 | |   <head>
115 | |   <body>
116 | 
117 | #data
118 | <?xml version
119 | #errors
120 | #document
121 | | <!-- ?xml version -->
122 | | <html>
123 | |   <head>
124 | |   <body>
125 | 
126 | #data
127 | FOO<!----->BAZ
128 | #errors
129 | #document
130 | | <html>
131 | |   <head>
132 | |   <body>
133 | |     "FOO"
134 | |     <!-- - -->
135 | |     "BAZ"
136 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/atom/atom.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2012 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 atom provides integer codes (also known as atoms) for a fixed set of
 6 | // frequently occurring HTML strings: tag names and attribute keys such as "p"
 7 | // and "id".
 8 | //
 9 | // Sharing an atom's name between all elements with the same tag can result in
10 | // fewer string allocations when tokenizing and parsing HTML. Integer
11 | // comparisons are also generally faster than string comparisons.
12 | //
13 | // The value of an atom's particular code is not guaranteed to stay the same
14 | // between versions of this package. Neither is any ordering guaranteed:
15 | // whether atom.H1 < atom.H2 may also change. The codes are not guaranteed to
16 | // be dense. The only guarantees are that e.g. looking up "div" will yield
17 | // atom.Div, calling atom.Div.String will return "div", and atom.Div != 0.
18 | package atom // import "golang.org/x/net/html/atom"
19 | 
20 | // Atom is an integer code for a string. The zero value maps to "".
21 | type Atom uint32
22 | 
23 | // String returns the atom's name.
24 | func (a Atom) String() string {
25 | 	start := uint32(a >> 8)
26 | 	n := uint32(a & 0xff)
27 | 	if start+n > uint32(len(atomText)) {
28 | 		return ""
29 | 	}
30 | 	return atomText[start : start+n]
31 | }
32 | 
33 | func (a Atom) string() string {
34 | 	return atomText[a>>8 : a>>8+a&0xff]
35 | }
36 | 
37 | // fnv computes the FNV hash with an arbitrary starting value h.
38 | func fnv(h uint32, s []byte) uint32 {
39 | 	for i := range s {
40 | 		h ^= uint32(s[i])
41 | 		h *= 16777619
42 | 	}
43 | 	return h
44 | }
45 | 
46 | func match(s string, t []byte) bool {
47 | 	for i, c := range t {
48 | 		if s[i] != c {
49 | 			return false
50 | 		}
51 | 	}
52 | 	return true
53 | }
54 | 
55 | // Lookup returns the atom whose name is s. It returns zero if there is no
56 | // such atom. The lookup is case sensitive.
57 | func Lookup(s []byte) Atom {
58 | 	if len(s) == 0 || len(s) > maxAtomLen {
59 | 		return 0
60 | 	}
61 | 	h := fnv(hash0, s)
62 | 	if a := table[h&uint32(len(table)-1)]; int(a&0xff) == len(s) && match(a.string(), s) {
63 | 		return a
64 | 	}
65 | 	if a := table[(h>>16)&uint32(len(table)-1)]; int(a&0xff) == len(s) && match(a.string(), s) {
66 | 		return a
67 | 	}
68 | 	return 0
69 | }
70 | 
71 | // String returns a string whose contents are equal to s. In that sense, it is
72 | // equivalent to string(s) but may be more efficient.
73 | func String(s []byte) string {
74 | 	if a := Lookup(s); a != 0 {
75 | 		return a.String()
76 | 	}
77 | 	return string(s)
78 | }
79 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/charset/testdata/No-encoding-declaration.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html  lang="en" >
 3 | <head>
 4 |   <title>No encoding declaration</title>
 5 | <link rel='author' title='Richard Ishida' href='mailto:ishida@w3.org'>
 6 | <link rel='help' href='http://www.w3.org/TR/html5/syntax.html#the-input-byte-stream'>
 7 | <link rel="stylesheet" type="text/css" href="./generatedtests.css">
 8 | <script src="http://w3c-test.org/resources/testharness.js"></script>
 9 | <script src="http://w3c-test.org/resources/testharnessreport.js"></script>
10 | <meta name='flags' content='http'>
11 | <meta name="assert" content="A page with no encoding information in HTTP, BOM, XML declaration or meta element will be treated as UTF-8.">
12 | <style type='text/css'>
13 | .test div { width: 50px; }</style>
14 | <link rel="stylesheet" type="text/css" href="the-input-byte-stream/support/encodingtests-utf8.css">
15 | </head>
16 | <body>
17 | No encoding declaration
18 | 
19 | 
20 | <div id='log'></div>
21 | 
22 | 
23 | <div class='test'><div id='box' class='ýäè'>&#xA0;</div></div>
24 | 
25 | 
26 | 
27 | 
28 | 
29 | <div class='description'>
30 | A page with no encoding information in HTTP, BOM, XML declaration or meta element will be treated as UTF-8.
31 | <div class="notes">The test on this page contains a div with a class name that contains the following sequence of bytes: 0xC3 0xBD 0xC3 0xA4 0xC3 0xA8. These represent different sequences of characters in ISO 8859-15, ISO 8859-1 and UTF-8. The external, UTF-8-encoded stylesheet contains a selector <code>.test div.&#x00FD;&#x00E4;&#x00E8;</code>. This matches the sequence of bytes above when they are interpreted as UTF-8. If the class name matches the selector then the test will pass.
32 | </div>
33 | </div>
34 | <div class="nexttest"><div><a href="generate?test=the-input-byte-stream-034">Next test</a></div><div class="doctype">HTML5</div>
35 | the-input-byte-stream-015<a href="/International/tests/html5/the-input-byte-stream/results-basics#basics" target="_blank">Result summary &amp; related tests</a><a href="http://w3c-test.org/framework/details/i18n-html5/the-input-byte-stream-015" target="_blank">Detailed results for this test</a>	<a href="http://www.w3.org/TR/html5/syntax.html#the-input-byte-stream" target="_blank">Link to spec</a>
36 | <div class='prereq'>Assumptions: <ul><li>The test is read from a server that supports HTTP.</li></ul></div>
37 | </div>
38 | <script>
39 | test(function() {
40 | assert_equals(document.getElementById('box').offsetWidth, 100);
41 | }, " ");
42 | </script>
43 | 
44 | </body>
45 | </html>
46 | 
47 | 
48 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/atom/atom_test.go:
--------------------------------------------------------------------------------
  1 | // Copyright 2012 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 atom
  6 | 
  7 | import (
  8 | 	"sort"
  9 | 	"testing"
 10 | )
 11 | 
 12 | func TestKnown(t *testing.T) {
 13 | 	for _, s := range testAtomList {
 14 | 		if atom := Lookup([]byte(s)); atom.String() != s {
 15 | 			t.Errorf("Lookup(%q) = %#x (%q)", s, uint32(atom), atom.String())
 16 | 		}
 17 | 	}
 18 | }
 19 | 
 20 | func TestHits(t *testing.T) {
 21 | 	for _, a := range table {
 22 | 		if a == 0 {
 23 | 			continue
 24 | 		}
 25 | 		got := Lookup([]byte(a.String()))
 26 | 		if got != a {
 27 | 			t.Errorf("Lookup(%q) = %#x, want %#x", a.String(), uint32(got), uint32(a))
 28 | 		}
 29 | 	}
 30 | }
 31 | 
 32 | func TestMisses(t *testing.T) {
 33 | 	testCases := []string{
 34 | 		"",
 35 | 		"\x00",
 36 | 		"\xff",
 37 | 		"A",
 38 | 		"DIV",
 39 | 		"Div",
 40 | 		"dIV",
 41 | 		"aa",
 42 | 		"a\x00",
 43 | 		"ab",
 44 | 		"abb",
 45 | 		"abbr0",
 46 | 		"abbr ",
 47 | 		" abbr",
 48 | 		" a",
 49 | 		"acceptcharset",
 50 | 		"acceptCharset",
 51 | 		"accept_charset",
 52 | 		"h0",
 53 | 		"h1h2",
 54 | 		"h7",
 55 | 		"onClick",
 56 | 		"λ",
 57 | 		// The following string has the same hash (0xa1d7fab7) as "onmouseover".
 58 | 		"\x00\x00\x00\x00\x00\x50\x18\xae\x38\xd0\xb7",
 59 | 	}
 60 | 	for _, tc := range testCases {
 61 | 		got := Lookup([]byte(tc))
 62 | 		if got != 0 {
 63 | 			t.Errorf("Lookup(%q): got %d, want 0", tc, got)
 64 | 		}
 65 | 	}
 66 | }
 67 | 
 68 | func TestForeignObject(t *testing.T) {
 69 | 	const (
 70 | 		afo = Foreignobject
 71 | 		afO = ForeignObject
 72 | 		sfo = "foreignobject"
 73 | 		sfO = "foreignObject"
 74 | 	)
 75 | 	if got := Lookup([]byte(sfo)); got != afo {
 76 | 		t.Errorf("Lookup(%q): got %#v, want %#v", sfo, got, afo)
 77 | 	}
 78 | 	if got := Lookup([]byte(sfO)); got != afO {
 79 | 		t.Errorf("Lookup(%q): got %#v, want %#v", sfO, got, afO)
 80 | 	}
 81 | 	if got := afo.String(); got != sfo {
 82 | 		t.Errorf("Atom(%#v).String(): got %q, want %q", afo, got, sfo)
 83 | 	}
 84 | 	if got := afO.String(); got != sfO {
 85 | 		t.Errorf("Atom(%#v).String(): got %q, want %q", afO, got, sfO)
 86 | 	}
 87 | }
 88 | 
 89 | func BenchmarkLookup(b *testing.B) {
 90 | 	sortedTable := make([]string, 0, len(table))
 91 | 	for _, a := range table {
 92 | 		if a != 0 {
 93 | 			sortedTable = append(sortedTable, a.String())
 94 | 		}
 95 | 	}
 96 | 	sort.Strings(sortedTable)
 97 | 
 98 | 	x := make([][]byte, 1000)
 99 | 	for i := range x {
100 | 		x[i] = []byte(sortedTable[i%len(sortedTable)])
101 | 	}
102 | 
103 | 	b.ResetTimer()
104 | 	for i := 0; i < b.N; i++ {
105 | 		for _, s := range x {
106 | 			Lookup(s)
107 | 		}
108 | 	}
109 | }
110 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/charset/testdata/HTTP-charset.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html  lang="en" >
 3 | <head>
 4 |   <title>HTTP charset</title>
 5 | <link rel='author' title='Richard Ishida' href='mailto:ishida@w3.org'>
 6 | <link rel='help' href='http://www.w3.org/TR/html5/syntax.html#the-input-byte-stream'>
 7 | <link rel="stylesheet" type="text/css" href="./generatedtests.css">
 8 | <script src="http://w3c-test.org/resources/testharness.js"></script>
 9 | <script src="http://w3c-test.org/resources/testharnessreport.js"></script>
10 | <meta name='flags' content='http'>
11 | <meta name="assert" content="The character encoding of a page can be set using the HTTP header charset declaration.">
12 | <style type='text/css'>
13 | .test div { width: 50px; }</style>
14 | <link rel="stylesheet" type="text/css" href="the-input-byte-stream/support/encodingtests-15.css">
15 | </head>
16 | <body>
17 | HTTP charset
18 | 
19 | 
20 | <div id='log'></div>
21 | 
22 | 
23 | <div class='test'><div id='box' class='ýäè'>&#xA0;</div></div>
24 | 
25 | 
26 | 
27 | 
28 | 
29 | <div class='description'>
30 | The character encoding of a page can be set using the HTTP header charset declaration.
31 | <div class="notes">The test contains a div with a class name that contains the following sequence of bytes: 0xC3 0xBD 0xC3 0xA4 0xC3 0xA8. These represent different sequences of characters in ISO 8859-15, ISO 8859-1 and UTF-8. The external, UTF-8-encoded stylesheet contains a selector <code>.test div.&#x00C3;&#x0153;&#x00C3;&#x20AC;&#x00C3;&#x0161;</code>. This matches the sequence of bytes above when they are interpreted as ISO 8859-15. If the class name matches the selector then the test will pass.The only character encoding declaration for this HTML file is in the HTTP header, which sets the encoding to ISO 8859-15.
32 | </div>
33 | </div>
34 | <div class="nexttest"><div><a href="generate?test=the-input-byte-stream-003">Next test</a></div><div class="doctype">HTML5</div>
35 | the-input-byte-stream-001<a href="/International/tests/html5/the-input-byte-stream/results-basics#basics" target="_blank">Result summary &amp; related tests</a><a href="http://w3c-test.org/framework/details/i18n-html5/the-input-byte-stream-001" target="_blank">Detailed results for this test</a>	<a href="http://www.w3.org/TR/html5/syntax.html#the-input-byte-stream" target="_blank">Link to spec</a>
36 | <div class='prereq'>Assumptions: <ul><li>The default encoding for the browser you are testing is not set to ISO 8859-15.</li>
37 | 				<li>The test is read from a server that supports HTTP.</li></ul></div>
38 | </div>
39 | <script>
40 | test(function() {
41 | assert_equals(document.getElementById('box').offsetWidth, 100);
42 | }, " ");
43 | </script>
44 | 
45 | </body>
46 | </html>
47 | 
48 | 
49 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/testdata/webkit/tests17.dat:
--------------------------------------------------------------------------------
  1 | #data
  2 | <!doctype html><table><tbody><select><tr>
  3 | #errors
  4 | #document
  5 | | <!DOCTYPE html>
  6 | | <html>
  7 | |   <head>
  8 | |   <body>
  9 | |     <select>
 10 | |     <table>
 11 | |       <tbody>
 12 | |         <tr>
 13 | 
 14 | #data
 15 | <!doctype html><table><tr><select><td>
 16 | #errors
 17 | #document
 18 | | <!DOCTYPE html>
 19 | | <html>
 20 | |   <head>
 21 | |   <body>
 22 | |     <select>
 23 | |     <table>
 24 | |       <tbody>
 25 | |         <tr>
 26 | |           <td>
 27 | 
 28 | #data
 29 | <!doctype html><table><tr><td><select><td>
 30 | #errors
 31 | #document
 32 | | <!DOCTYPE html>
 33 | | <html>
 34 | |   <head>
 35 | |   <body>
 36 | |     <table>
 37 | |       <tbody>
 38 | |         <tr>
 39 | |           <td>
 40 | |             <select>
 41 | |           <td>
 42 | 
 43 | #data
 44 | <!doctype html><table><tr><th><select><td>
 45 | #errors
 46 | #document
 47 | | <!DOCTYPE html>
 48 | | <html>
 49 | |   <head>
 50 | |   <body>
 51 | |     <table>
 52 | |       <tbody>
 53 | |         <tr>
 54 | |           <th>
 55 | |             <select>
 56 | |           <td>
 57 | 
 58 | #data
 59 | <!doctype html><table><caption><select><tr>
 60 | #errors
 61 | #document
 62 | | <!DOCTYPE html>
 63 | | <html>
 64 | |   <head>
 65 | |   <body>
 66 | |     <table>
 67 | |       <caption>
 68 | |         <select>
 69 | |       <tbody>
 70 | |         <tr>
 71 | 
 72 | #data
 73 | <!doctype html><select><tr>
 74 | #errors
 75 | #document
 76 | | <!DOCTYPE html>
 77 | | <html>
 78 | |   <head>
 79 | |   <body>
 80 | |     <select>
 81 | 
 82 | #data
 83 | <!doctype html><select><td>
 84 | #errors
 85 | #document
 86 | | <!DOCTYPE html>
 87 | | <html>
 88 | |   <head>
 89 | |   <body>
 90 | |     <select>
 91 | 
 92 | #data
 93 | <!doctype html><select><th>
 94 | #errors
 95 | #document
 96 | | <!DOCTYPE html>
 97 | | <html>
 98 | |   <head>
 99 | |   <body>
100 | |     <select>
101 | 
102 | #data
103 | <!doctype html><select><tbody>
104 | #errors
105 | #document
106 | | <!DOCTYPE html>
107 | | <html>
108 | |   <head>
109 | |   <body>
110 | |     <select>
111 | 
112 | #data
113 | <!doctype html><select><thead>
114 | #errors
115 | #document
116 | | <!DOCTYPE html>
117 | | <html>
118 | |   <head>
119 | |   <body>
120 | |     <select>
121 | 
122 | #data
123 | <!doctype html><select><tfoot>
124 | #errors
125 | #document
126 | | <!DOCTYPE html>
127 | | <html>
128 | |   <head>
129 | |   <body>
130 | |     <select>
131 | 
132 | #data
133 | <!doctype html><select><caption>
134 | #errors
135 | #document
136 | | <!DOCTYPE html>
137 | | <html>
138 | |   <head>
139 | |   <body>
140 | |     <select>
141 | 
142 | #data
143 | <!doctype html><table><tr></table>a
144 | #errors
145 | #document
146 | | <!DOCTYPE html>
147 | | <html>
148 | |   <head>
149 | |   <body>
150 | |     <table>
151 | |       <tbody>
152 | |         <tr>
153 | |     "a"
154 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/const.go:
--------------------------------------------------------------------------------
  1 | // Copyright 2011 The Go Authors. All rights reserved.
  2 | // Use of this source code is governed by a BSD-style
  3 | // license that can be found in the LICENSE file.
  4 | 
  5 | package html
  6 | 
  7 | // Section 12.2.3.2 of the HTML5 specification says "The following elements
  8 | // have varying levels of special parsing rules".
  9 | // https://html.spec.whatwg.org/multipage/syntax.html#the-stack-of-open-elements
 10 | var isSpecialElementMap = map[string]bool{
 11 | 	"address":    true,
 12 | 	"applet":     true,
 13 | 	"area":       true,
 14 | 	"article":    true,
 15 | 	"aside":      true,
 16 | 	"base":       true,
 17 | 	"basefont":   true,
 18 | 	"bgsound":    true,
 19 | 	"blockquote": true,
 20 | 	"body":       true,
 21 | 	"br":         true,
 22 | 	"button":     true,
 23 | 	"caption":    true,
 24 | 	"center":     true,
 25 | 	"col":        true,
 26 | 	"colgroup":   true,
 27 | 	"dd":         true,
 28 | 	"details":    true,
 29 | 	"dir":        true,
 30 | 	"div":        true,
 31 | 	"dl":         true,
 32 | 	"dt":         true,
 33 | 	"embed":      true,
 34 | 	"fieldset":   true,
 35 | 	"figcaption": true,
 36 | 	"figure":     true,
 37 | 	"footer":     true,
 38 | 	"form":       true,
 39 | 	"frame":      true,
 40 | 	"frameset":   true,
 41 | 	"h1":         true,
 42 | 	"h2":         true,
 43 | 	"h3":         true,
 44 | 	"h4":         true,
 45 | 	"h5":         true,
 46 | 	"h6":         true,
 47 | 	"head":       true,
 48 | 	"header":     true,
 49 | 	"hgroup":     true,
 50 | 	"hr":         true,
 51 | 	"html":       true,
 52 | 	"iframe":     true,
 53 | 	"img":        true,
 54 | 	"input":      true,
 55 | 	"isindex":    true,
 56 | 	"li":         true,
 57 | 	"link":       true,
 58 | 	"listing":    true,
 59 | 	"marquee":    true,
 60 | 	"menu":       true,
 61 | 	"meta":       true,
 62 | 	"nav":        true,
 63 | 	"noembed":    true,
 64 | 	"noframes":   true,
 65 | 	"noscript":   true,
 66 | 	"object":     true,
 67 | 	"ol":         true,
 68 | 	"p":          true,
 69 | 	"param":      true,
 70 | 	"plaintext":  true,
 71 | 	"pre":        true,
 72 | 	"script":     true,
 73 | 	"section":    true,
 74 | 	"select":     true,
 75 | 	"source":     true,
 76 | 	"style":      true,
 77 | 	"summary":    true,
 78 | 	"table":      true,
 79 | 	"tbody":      true,
 80 | 	"td":         true,
 81 | 	"template":   true,
 82 | 	"textarea":   true,
 83 | 	"tfoot":      true,
 84 | 	"th":         true,
 85 | 	"thead":      true,
 86 | 	"title":      true,
 87 | 	"tr":         true,
 88 | 	"track":      true,
 89 | 	"ul":         true,
 90 | 	"wbr":        true,
 91 | 	"xmp":        true,
 92 | }
 93 | 
 94 | func isSpecialElement(element *Node) bool {
 95 | 	switch element.Namespace {
 96 | 	case "", "html":
 97 | 		return isSpecialElementMap[element.Data]
 98 | 	case "svg":
 99 | 		return element.Data == "foreignObject"
100 | 	}
101 | 	return false
102 | }
103 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/charset/testdata/meta-charset-attribute.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html  lang="en" >
 3 | <head>
 4 |  <meta charset="iso-8859-15"> <title>meta charset attribute</title>
 5 | <link rel='author' title='Richard Ishida' href='mailto:ishida@w3.org'>
 6 | <link rel='help' href='http://www.w3.org/TR/html5/syntax.html#the-input-byte-stream'>
 7 | <link rel="stylesheet" type="text/css" href="./generatedtests.css">
 8 | <script src="http://w3c-test.org/resources/testharness.js"></script>
 9 | <script src="http://w3c-test.org/resources/testharnessreport.js"></script>
10 | <meta name='flags' content='http'>
11 | <meta name="assert" content="The character encoding of the page can be set by a meta element with charset attribute.">
12 | <style type='text/css'>
13 | .test div { width: 50px; }</style>
14 | <link rel="stylesheet" type="text/css" href="the-input-byte-stream/support/encodingtests-15.css">
15 | </head>
16 | <body>
17 | meta charset attribute
18 | 
19 | 
20 | <div id='log'></div>
21 | 
22 | 
23 | <div class='test'><div id='box' class='ýäè'>&#xA0;</div></div>
24 | 
25 | 
26 | 
27 | 
28 | 
29 | <div class='description'>
30 | The character encoding of the page can be set by a meta element with charset attribute.
31 | <div class="notes">The only character encoding declaration for this HTML file is in the charset attribute of the meta element, which declares the encoding to be ISO 8859-15.The test contains a div with a class name that contains the following sequence of bytes: 0xC3 0xBD 0xC3 0xA4 0xC3 0xA8. These represent different sequences of characters in ISO 8859-15, ISO 8859-1 and UTF-8. The external, UTF-8-encoded stylesheet contains a selector <code>.test div.&#x00C3;&#x0153;&#x00C3;&#x20AC;&#x00C3;&#x0161;</code>. This matches the sequence of bytes above when they are interpreted as ISO 8859-15. If the class name matches the selector then the test will pass.
32 | </div>
33 | </div>
34 | <div class="nexttest"><div><a href="generate?test=the-input-byte-stream-015">Next test</a></div><div class="doctype">HTML5</div>
35 | the-input-byte-stream-009<a href="/International/tests/html5/the-input-byte-stream/results-basics#basics" target="_blank">Result summary &amp; related tests</a><a href="http://w3c-test.org/framework/details/i18n-html5/the-input-byte-stream-009" target="_blank">Detailed results for this test</a>	<a href="http://www.w3.org/TR/html5/syntax.html#the-input-byte-stream" target="_blank">Link to spec</a>
36 | <div class='prereq'>Assumptions: <ul><li>The default encoding for the browser you are testing is not set to ISO 8859-15.</li>
37 | 				<li>The test is read from a server that supports HTTP.</li></ul></div>
38 | </div>
39 | <script>
40 | test(function() {
41 | assert_equals(document.getElementById('box').offsetWidth, 100);
42 | }, " ");
43 | </script>
44 | 
45 | </body>
46 | </html>
47 | 
48 | 
49 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/charset/testdata/meta-content-attribute.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html  lang="en" >
 3 | <head>
 4 |  <meta http-equiv="content-type" content="text/html; charset=iso-8859-15"> <title>meta content attribute</title>
 5 | <link rel='author' title='Richard Ishida' href='mailto:ishida@w3.org'>
 6 | <link rel='help' href='http://www.w3.org/TR/html5/syntax.html#the-input-byte-stream'>
 7 | <link rel="stylesheet" type="text/css" href="./generatedtests.css">
 8 | <script src="http://w3c-test.org/resources/testharness.js"></script>
 9 | <script src="http://w3c-test.org/resources/testharnessreport.js"></script>
10 | <meta name='flags' content='http'>
11 | <meta name="assert" content="The character encoding of the page can be set by a meta element with http-equiv and content attributes.">
12 | <style type='text/css'>
13 | .test div { width: 50px; }</style>
14 | <link rel="stylesheet" type="text/css" href="the-input-byte-stream/support/encodingtests-15.css">
15 | </head>
16 | <body>
17 | meta content attribute
18 | 
19 | 
20 | <div id='log'></div>
21 | 
22 | 
23 | <div class='test'><div id='box' class='ýäè'>&#xA0;</div></div>
24 | 
25 | 
26 | 
27 | 
28 | 
29 | <div class='description'>
30 | The character encoding of the page can be set by a meta element with http-equiv and content attributes.
31 | <div class="notes">The only character encoding declaration for this HTML file is in the content attribute of the meta element, which declares the encoding to be ISO 8859-15.The test contains a div with a class name that contains the following sequence of bytes: 0xC3 0xBD 0xC3 0xA4 0xC3 0xA8. These represent different sequences of characters in ISO 8859-15, ISO 8859-1 and UTF-8. The external, UTF-8-encoded stylesheet contains a selector <code>.test div.&#x00C3;&#x0153;&#x00C3;&#x20AC;&#x00C3;&#x0161;</code>. This matches the sequence of bytes above when they are interpreted as ISO 8859-15. If the class name matches the selector then the test will pass.
32 | </div>
33 | </div>
34 | <div class="nexttest"><div><a href="generate?test=the-input-byte-stream-009">Next test</a></div><div class="doctype">HTML5</div>
35 | the-input-byte-stream-007<a href="/International/tests/html5/the-input-byte-stream/results-basics#basics" target="_blank">Result summary &amp; related tests</a><a href="http://w3c-test.org/framework/details/i18n-html5/the-input-byte-stream-007" target="_blank">Detailed results for this test</a>	<a href="http://www.w3.org/TR/html5/syntax.html#the-input-byte-stream" target="_blank">Link to spec</a>
36 | <div class='prereq'>Assumptions: <ul><li>The default encoding for the browser you are testing is not set to ISO 8859-15.</li>
37 | 				<li>The test is read from a server that supports HTTP.</li></ul></div>
38 | </div>
39 | <script>
40 | test(function() {
41 | assert_equals(document.getElementById('box').offsetWidth, 100);
42 | }, " ");
43 | </script>
44 | 
45 | </body>
46 | </html>
47 | 
48 | 
49 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/charset/testdata/HTTP-vs-meta-charset.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html  lang="en" >
 3 | <head>
 4 |  <meta charset="iso-8859-1" > <title>HTTP vs meta charset</title>
 5 | <link rel='author' title='Richard Ishida' href='mailto:ishida@w3.org'>
 6 | <link rel='help' href='http://www.w3.org/TR/html5/syntax.html#the-input-byte-stream'>
 7 | <link rel="stylesheet" type="text/css" href="./generatedtests.css">
 8 | <script src="http://w3c-test.org/resources/testharness.js"></script>
 9 | <script src="http://w3c-test.org/resources/testharnessreport.js"></script>
10 | <meta name='flags' content='http'>
11 | <meta name="assert" content="The HTTP header has a higher precedence than an encoding declaration in a meta charset attribute.">
12 | <style type='text/css'>
13 | .test div { width: 50px; }.test div { width: 90px; }
14 | </style>
15 | <link rel="stylesheet" type="text/css" href="the-input-byte-stream/support/encodingtests-15.css">
16 | </head>
17 | <body>
18 | HTTP vs meta charset
19 | 
20 | 
21 | <div id='log'></div>
22 | 
23 | 
24 | <div class='test'><div id='box' class='ýäè'>&#xA0;</div></div>
25 | 
26 | 
27 | 
28 | 
29 | 
30 | <div class='description'>
31 | The HTTP header has a higher precedence than an encoding declaration in a meta charset attribute.
32 | <div class="notes">The HTTP header attempts to set the character encoding to ISO 8859-15. The page contains an encoding declaration in a meta charset attribute that attempts to set the character encoding to ISO 8859-1.The test contains a div with a class name that contains the following sequence of bytes: 0xC3 0xBD 0xC3 0xA4 0xC3 0xA8. These represent different sequences of characters in ISO 8859-15, ISO 8859-1 and UTF-8. The external, UTF-8-encoded stylesheet contains a selector <code>.test div.&#x00C3;&#x0153;&#x00C3;&#x20AC;&#x00C3;&#x0161;</code>. This matches the sequence of bytes above when they are interpreted as ISO 8859-15. If the class name matches the selector then the test will pass.
33 | </div>
34 | </div>
35 | <div class="nexttest"><div><a href="generate?test=the-input-byte-stream-037">Next test</a></div><div class="doctype">HTML5</div>
36 | the-input-byte-stream-018<a href="/International/tests/html5/the-input-byte-stream/results-basics#precedence" target="_blank">Result summary &amp; related tests</a><a href="http://w3c-test.org/framework/details/i18n-html5/the-input-byte-stream-018" target="_blank">Detailed results for this test</a>	<a href="http://www.w3.org/TR/html5/syntax.html#the-input-byte-stream" target="_blank">Link to spec</a>
37 | <div class='prereq'>Assumptions: <ul><li>The default encoding for the browser you are testing is not set to ISO 8859-15.</li>
38 | 				<li>The test is read from a server that supports HTTP.</li></ul></div>
39 | </div>
40 | <script>
41 | test(function() {
42 | assert_equals(document.getElementById('box').offsetWidth, 100);
43 | }, " ");
44 | </script>
45 | 
46 | </body>
47 | </html>
48 | 
49 | 
50 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/charset/testdata/UTF-8-BOM-vs-meta-charset.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html  lang="en" >
 3 | <head>
 4 |  <meta charset="iso-8859-15"> <title>UTF-8 BOM vs meta charset</title>
 5 | <link rel='author' title='Richard Ishida' href='mailto:ishida@w3.org'>
 6 | <link rel='help' href='http://www.w3.org/TR/html5/syntax.html#the-input-byte-stream'>
 7 | <link rel="stylesheet" type="text/css" href="./generatedtests.css">
 8 | <script src="http://w3c-test.org/resources/testharness.js"></script>
 9 | <script src="http://w3c-test.org/resources/testharnessreport.js"></script>
10 | <meta name='flags' content='http'>
11 | <meta name="assert" content="A page with a UTF-8 BOM will be recognized as UTF-8 even if the meta charset attribute declares a different encoding.">
12 | <style type='text/css'>
13 | .test div { width: 50px; }.test div { width: 90px; }
14 | </style>
15 | <link rel="stylesheet" type="text/css" href="the-input-byte-stream/support/encodingtests-utf8.css">
16 | </head>
17 | <body>
18 | UTF-8 BOM vs meta charset
19 | 
20 | 
21 | <div id='log'></div>
22 | 
23 | 
24 | <div class='test'><div id='box' class='ýäè'>&#xA0;</div></div>
25 | 
26 | 
27 | 
28 | 
29 | 
30 | <div class='description'>
31 | A page with a UTF-8 BOM will be recognized as UTF-8 even if the meta charset attribute declares a different encoding.
32 | <div class="notes">The page contains an encoding declaration in a meta charset attribute that attempts to set the character encoding to ISO 8859-15, but the file starts with a UTF-8 signature.The test contains a div with a class name that contains the following sequence of bytes: 0xC3 0xBD 0xC3 0xA4 0xC3 0xA8. These represent different sequences of characters in ISO 8859-15, ISO 8859-1 and UTF-8. The external, UTF-8-encoded stylesheet contains a selector <code>.test div.&#x00FD;&#x00E4;&#x00E8;</code>. This matches the sequence of bytes above when they are interpreted as UTF-8. If the class name matches the selector then the test will pass.
33 | </div>
34 | </div>
35 | <div class="nexttest"><div><a href="generate?test=the-input-byte-stream-024">Next test</a></div><div class="doctype">HTML5</div>
36 | the-input-byte-stream-038<a href="/International/tests/html5/the-input-byte-stream/results-basics#precedence" target="_blank">Result summary &amp; related tests</a><a href="http://w3c-test.org/framework/details/i18n-html5/the-input-byte-stream-038" target="_blank">Detailed results for this test</a>	<a href="http://www.w3.org/TR/html5/syntax.html#the-input-byte-stream" target="_blank">Link to spec</a>
37 | <div class='prereq'>Assumptions: <ul><li>The default encoding for the browser you are testing is not set to ISO 8859-15.</li>
38 | 				<li>The test is read from a server that supports HTTP.</li></ul></div>
39 | </div>
40 | <script>
41 | test(function() {
42 | assert_equals(document.getElementById('box').offsetWidth, 100);
43 | }, " ");
44 | </script>
45 | 
46 | </body>
47 | </html>
48 | 
49 | 
50 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/charset/testdata/UTF-8-BOM-vs-meta-content.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html  lang="en" >
 3 | <head>
 4 |  <meta http-equiv="content-type" content="text/html; charset=iso-8859-15"> <title>UTF-8 BOM vs meta content</title>
 5 | <link rel='author' title='Richard Ishida' href='mailto:ishida@w3.org'>
 6 | <link rel='help' href='http://www.w3.org/TR/html5/syntax.html#the-input-byte-stream'>
 7 | <link rel="stylesheet" type="text/css" href="./generatedtests.css">
 8 | <script src="http://w3c-test.org/resources/testharness.js"></script>
 9 | <script src="http://w3c-test.org/resources/testharnessreport.js"></script>
10 | <meta name='flags' content='http'>
11 | <meta name="assert" content="A page with a UTF-8 BOM will be recognized as UTF-8 even if the meta content attribute declares a different encoding.">
12 | <style type='text/css'>
13 | .test div { width: 50px; }</style>
14 | <link rel="stylesheet" type="text/css" href="the-input-byte-stream/support/encodingtests-utf8.css">
15 | </head>
16 | <body>
17 | UTF-8 BOM vs meta content
18 | 
19 | 
20 | <div id='log'></div>
21 | 
22 | 
23 | <div class='test'><div id='box' class='ýäè'>&#xA0;</div></div>
24 | 
25 | 
26 | 
27 | 
28 | 
29 | <div class='description'>
30 | A page with a UTF-8 BOM will be recognized as UTF-8 even if the meta content attribute declares a different encoding.
31 | <div class="notes">The page contains an encoding declaration in a meta content attribute that attempts to set the character encoding to ISO 8859-15, but the file starts with a UTF-8 signature.The test contains a div with a class name that contains the following sequence of bytes: 0xC3 0xBD 0xC3 0xA4 0xC3 0xA8. These represent different sequences of characters in ISO 8859-15, ISO 8859-1 and UTF-8. The external, UTF-8-encoded stylesheet contains a selector <code>.test div.&#x00FD;&#x00E4;&#x00E8;</code>. This matches the sequence of bytes above when they are interpreted as UTF-8. If the class name matches the selector then the test will pass.
32 | </div>
33 | </div>
34 | <div class="nexttest"><div><a href="generate?test=the-input-byte-stream-038">Next test</a></div><div class="doctype">HTML5</div>
35 | the-input-byte-stream-037<a href="/International/tests/html5/the-input-byte-stream/results-basics#precedence" target="_blank">Result summary &amp; related tests</a><a href="http://w3c-test.org/framework/details/i18n-html5/the-input-byte-stream-037" target="_blank">Detailed results for this test</a>	<a href="http://www.w3.org/TR/html5/syntax.html#the-input-byte-stream" target="_blank">Link to spec</a>
36 | <div class='prereq'>Assumptions: <ul><li>The default encoding for the browser you are testing is not set to ISO 8859-15.</li>
37 | 				<li>The test is read from a server that supports HTTP.</li></ul></div>
38 | </div>
39 | <script>
40 | test(function() {
41 | assert_equals(document.getElementById('box').offsetWidth, 100);
42 | }, " ");
43 | </script>
44 | 
45 | </body>
46 | </html>
47 | 
48 | 
49 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/charset/testdata/HTTP-vs-UTF-8-BOM.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html  lang="en" >
 3 | <head>
 4 |   <title>HTTP vs UTF-8 BOM</title>
 5 | <link rel='author' title='Richard Ishida' href='mailto:ishida@w3.org'>
 6 | <link rel='help' href='http://www.w3.org/TR/html5/syntax.html#the-input-byte-stream'>
 7 | <link rel="stylesheet" type="text/css" href="./generatedtests.css">
 8 | <script src="http://w3c-test.org/resources/testharness.js"></script>
 9 | <script src="http://w3c-test.org/resources/testharnessreport.js"></script>
10 | <meta name='flags' content='http'>
11 | <meta name="assert" content="A character encoding set in the HTTP header has lower precedence than the UTF-8 signature.">
12 | <style type='text/css'>
13 | .test div { width: 50px; }</style>
14 | <link rel="stylesheet" type="text/css" href="the-input-byte-stream/support/encodingtests-utf8.css">
15 | </head>
16 | <body>
17 | HTTP vs UTF-8 BOM
18 | 
19 | 
20 | <div id='log'></div>
21 | 
22 | 
23 | <div class='test'><div id='box' class='ýäè'>&#xA0;</div></div>
24 | 
25 | 
26 | 
27 | 
28 | 
29 | <div class='description'>
30 | A character encoding set in the HTTP header has lower precedence than the UTF-8 signature.
31 | <div class="notes">The HTTP header attempts to set the character encoding to ISO 8859-15. The page starts with a UTF-8 signature.The test contains a div with a class name that contains the following sequence of bytes: 0xC3 0xBD 0xC3 0xA4 0xC3 0xA8. These represent different sequences of characters in ISO 8859-15, ISO 8859-1 and UTF-8. The external, UTF-8-encoded stylesheet contains a selector <code>.test div.&#x00FD;&#x00E4;&#x00E8;</code>. This matches the sequence of bytes above when they are interpreted as UTF-8. If the class name matches the selector then the test will pass.If the test is unsuccessful, the characters &#x00EF;&#x00BB;&#x00BF; should appear at the top of the page.  These represent the bytes that make up the UTF-8 signature when encountered in the ISO 8859-15 encoding.
32 | </div>
33 | </div>
34 | <div class="nexttest"><div><a href="generate?test=the-input-byte-stream-022">Next test</a></div><div class="doctype">HTML5</div>
35 | the-input-byte-stream-034<a href="/International/tests/html5/the-input-byte-stream/results-basics#precedence" target="_blank">Result summary &amp; related tests</a><a href="http://w3c-test.org/framework/details/i18n-html5/the-input-byte-stream-034" target="_blank">Detailed results for this test</a>	<a href="http://www.w3.org/TR/html5/syntax.html#the-input-byte-stream" target="_blank">Link to spec</a>
36 | <div class='prereq'>Assumptions: <ul><li>The default encoding for the browser you are testing is not set to ISO 8859-15.</li>
37 | 				<li>The test is read from a server that supports HTTP.</li></ul></div>
38 | </div>
39 | <script>
40 | test(function() {
41 | assert_equals(document.getElementById('box').offsetWidth, 100);
42 | }, " ");
43 | </script>
44 | 
45 | </body>
46 | </html>
47 | 
48 | 
49 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/charset/testdata/HTTP-vs-meta-content.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html  lang="en" >
 3 | <head>
 4 |  <meta http-equiv="content-type" content="text/html;charset=iso-8859-1" > <title>HTTP vs meta content</title>
 5 | <link rel='author' title='Richard Ishida' href='mailto:ishida@w3.org'>
 6 | <link rel='help' href='http://www.w3.org/TR/html5/syntax.html#the-input-byte-stream'>
 7 | <link rel="stylesheet" type="text/css" href="./generatedtests.css">
 8 | <script src="http://w3c-test.org/resources/testharness.js"></script>
 9 | <script src="http://w3c-test.org/resources/testharnessreport.js"></script>
10 | <meta name='flags' content='http'>
11 | <meta name="assert" content="The HTTP header has a higher precedence than an encoding declaration in a meta content attribute.">
12 | <style type='text/css'>
13 | .test div { width: 50px; }.test div { width: 90px; }
14 | </style>
15 | <link rel="stylesheet" type="text/css" href="the-input-byte-stream/support/encodingtests-15.css">
16 | </head>
17 | <body>
18 | HTTP vs meta content
19 | 
20 | 
21 | <div id='log'></div>
22 | 
23 | 
24 | <div class='test'><div id='box' class='ýäè'>&#xA0;</div></div>
25 | 
26 | 
27 | 
28 | 
29 | 
30 | <div class='description'>
31 | The HTTP header has a higher precedence than an encoding declaration in a meta content attribute.
32 | <div class="notes">The HTTP header attempts to set the character encoding to ISO 8859-15. The page contains an encoding declaration in a meta content attribute that attempts to set the character encoding to ISO 8859-1.The test contains a div with a class name that contains the following sequence of bytes: 0xC3 0xBD 0xC3 0xA4 0xC3 0xA8. These represent different sequences of characters in ISO 8859-15, ISO 8859-1 and UTF-8. The external, UTF-8-encoded stylesheet contains a selector <code>.test div.&#x00C3;&#x0153;&#x00C3;&#x20AC;&#x00C3;&#x0161;</code>. This matches the sequence of bytes above when they are interpreted as ISO 8859-15. If the class name matches the selector then the test will pass.
33 | </div>
34 | </div>
35 | <div class="nexttest"><div><a href="generate?test=the-input-byte-stream-018">Next test</a></div><div class="doctype">HTML5</div>
36 | the-input-byte-stream-016<a href="/International/tests/html5/the-input-byte-stream/results-basics#precedence" target="_blank">Result summary &amp; related tests</a><a href="http://w3c-test.org/framework/details/i18n-html5/the-input-byte-stream-016" target="_blank">Detailed results for this test</a>	<a href="http://www.w3.org/TR/html5/syntax.html#the-input-byte-stream" target="_blank">Link to spec</a>
37 | <div class='prereq'>Assumptions: <ul><li>The default encoding for the browser you are testing is not set to ISO 8859-15.</li>
38 | 				<li>The test is read from a server that supports HTTP.</li></ul></div>
39 | </div>
40 | <script>
41 | test(function() {
42 | assert_equals(document.getElementById('box').offsetWidth, 100);
43 | }, " ");
44 | </script>
45 | 
46 | </body>
47 | </html>
48 | 
49 | 
50 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/testdata/webkit/webkit02.dat:
--------------------------------------------------------------------------------
  1 | #data
  2 | <foo bar=qux/>
  3 | #errors
  4 | #document
  5 | | <html>
  6 | |   <head>
  7 | |   <body>
  8 | |     <foo>
  9 | |       bar="qux/"
 10 | 
 11 | #data
 12 | <noscript><strong>A</strong></noscript><span>B</span>
 13 | #errors
 14 | #document
 15 | | <html>
 16 | |   <head>
 17 | |   <body>
 18 | |     
 19 | |       id="status"
 20 | |       <noscript>
 21 | |         "<strong>A</strong>"
 22 | |       <span>
 23 | |         "B"
 24 | 
 25 | #data
 26 | <div><sarcasm><div></div></sarcasm></div>
 27 | #errors
 28 | #document
 29 | | <html>
 30 | |   <head>
 31 | |   <body>
 32 | |     <div>
 33 | |       <sarcasm>
 34 | |         <div>
 35 | 
 36 | #data
 37 | <html><body><img src="" border="0" alt="><div>A</div></body></html>
 38 | #errors
 39 | #document
 40 | | <html>
 41 | |   <head>
 42 | |   <body>
 43 | 
 44 | #data
 45 | <table><td></tbody>A
 46 | #errors
 47 | #document
 48 | | <html>
 49 | |   <head>
 50 | |   <body>
 51 | |     "A"
 52 | |     <table>
 53 | |       <tbody>
 54 | |         <tr>
 55 | |           <td>
 56 | 
 57 | #data
 58 | <table><td></thead>A
 59 | #errors
 60 | #document
 61 | | <html>
 62 | |   <head>
 63 | |   <body>
 64 | |     <table>
 65 | |       <tbody>
 66 | |         <tr>
 67 | |           <td>
 68 | |             "A"
 69 | 
 70 | #data
 71 | <table><td></tfoot>A
 72 | #errors
 73 | #document
 74 | | <html>
 75 | |   <head>
 76 | |   <body>
 77 | |     <table>
 78 | |       <tbody>
 79 | |         <tr>
 80 | |           <td>
 81 | |             "A"
 82 | 
 83 | #data
 84 | <table><thead><td></tbody>A
 85 | #errors
 86 | #document
 87 | | <html>
 88 | |   <head>
 89 | |   <body>
 90 | |     <table>
 91 | |       <thead>
 92 | |         <tr>
 93 | |           <td>
 94 | |             "A"
 95 | 
 96 | #data
 97 | <legend>test</legend>
 98 | #errors
 99 | #document
100 | | <html>
101 | |   <head>
102 | |   <body>
103 | |     <legend>
104 | |       "test"
105 | 
106 | #data
107 | <table><input>
108 | #errors
109 | #document
110 | | <html>
111 | |   <head>
112 | |   <body>
113 | |     <input>
114 | |     <table>
115 | 
116 | #data
117 | <b><em><dcell><postfield><postfield><postfield><postfield><missing_glyph><missing_glyph><missing_glyph><missing_glyph><hkern><aside></b></em>
118 | #errors
119 | #document-fragment
120 | div
121 | #document
122 | | <b>
123 | |   <em>
124 | |     <dcell>
125 | |       <postfield>
126 | |         <postfield>
127 | |           <postfield>
128 | |             <postfield>
129 | |               <missing_glyph>
130 | |                 <missing_glyph>
131 | |                   <missing_glyph>
132 | |                     <missing_glyph>
133 | |                       <hkern>
134 | | <aside>
135 | |   <em>
136 | |     <b>
137 | 
138 | #data
139 | <isindex action="x">
140 | #errors
141 | #document-fragment
142 | table
143 | #document
144 | | <form>
145 | |   action="x"
146 | | <hr>
147 | | <label>
148 | |   "This is a searchable index. Enter search keywords: "
149 | |   <input>
150 | |     name="isindex"
151 | | <hr>
152 | 
153 | #data
154 | <option><XH<optgroup></optgroup>
155 | #errors
156 | #document-fragment
157 | select
158 | #document
159 | | <option>
160 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/testdata/webkit/adoption01.dat:
--------------------------------------------------------------------------------
  1 | #data
  2 | <a></a>
  3 | #errors
  4 | #document
  5 | | <html>
  6 | |   <head>
  7 | |   <body>
  8 | |     <a>
  9 | |     
 10 | |       <a>
 11 | 
 12 | #data
 13 | <a>12</a>3
 14 | #errors
 15 | #document
 16 | | <html>
 17 | |   <head>
 18 | |   <body>
 19 | |     <a>
 20 | |       "1"
 21 | |     
 22 | |       <a>
 23 | |         "2"
 24 | |       "3"
 25 | 
 26 | #data
 27 | <a>1<button>2</a>3</button>
 28 | #errors
 29 | #document
 30 | | <html>
 31 | |   <head>
 32 | |   <body>
 33 | |     <a>
 34 | |       "1"
 35 | |     <button>
 36 | |       <a>
 37 | |         "2"
 38 | |       "3"
 39 | 
 40 | #data
 41 | <a>1<b>2</a>3</b>
 42 | #errors
 43 | #document
 44 | | <html>
 45 | |   <head>
 46 | |   <body>
 47 | |     <a>
 48 | |       "1"
 49 | |       <b>
 50 | |         "2"
 51 | |     <b>
 52 | |       "3"
 53 | 
 54 | #data
 55 | <a>1<div>2<div>3</a>4</div>5</div>
 56 | #errors
 57 | #document
 58 | | <html>
 59 | |   <head>
 60 | |   <body>
 61 | |     <a>
 62 | |       "1"
 63 | |     <div>
 64 | |       <a>
 65 | |         "2"
 66 | |       <div>
 67 | |         <a>
 68 | |           "3"
 69 | |         "4"
 70 | |       "5"
 71 | 
 72 | #data
 73 | <table><a>12</a>3
 74 | #errors
 75 | #document
 76 | | <html>
 77 | |   <head>
 78 | |   <body>
 79 | |     <a>
 80 | |       "1"
 81 | |     
 82 | |       <a>
 83 | |         "2"
 84 | |       "3"
 85 | |     <table>
 86 | 
 87 | #data
 88 | <b><b><a></a>
 89 | #errors
 90 | #document
 91 | | <html>
 92 | |   <head>
 93 | |   <body>
 94 | |     <b>
 95 | |       <b>
 96 | |         <a>
 97 | |         
 98 | |           <a>
 99 | 
100 | #data
101 | <b><a><b></a>
102 | #errors
103 | #document
104 | | <html>
105 | |   <head>
106 | |   <body>
107 | |     <b>
108 | |       <a>
109 | |         <b>
110 | |       <b>
111 | |         
112 | |           <a>
113 | 
114 | #data
115 | <a><b><b></a>
116 | #errors
117 | #document
118 | | <html>
119 | |   <head>
120 | |   <body>
121 | |     <a>
122 | |       <b>
123 | |         <b>
124 | |     <b>
125 | |       <b>
126 | |         
127 | |           <a>
128 | 
129 | #data
130 | 1<s id="A">2<b id="B">34</s>5</b>
131 | #errors
132 | #document
133 | | <html>
134 | |   <head>
135 | |   <body>
136 | |     
137 | |       "1"
138 | |       <s>
139 | |         id="A"
140 | |         "2"
141 | |         <b>
142 | |           id="B"
143 | |           "3"
144 | |     <s>
145 | |       id="A"
146 | |       <b>
147 | |         id="B"
148 | |         "4"
149 | |     <b>
150 | |       id="B"
151 | |       "5"
152 | 
153 | #data
154 | <table><a>1<td>2</td>3</table>
155 | #errors
156 | #document
157 | | <html>
158 | |   <head>
159 | |   <body>
160 | |     <a>
161 | |       "1"
162 | |     <a>
163 | |       "3"
164 | |     <table>
165 | |       <tbody>
166 | |         <tr>
167 | |           <td>
168 | |             "2"
169 | 
170 | #data
171 | <table>A<td>B</td>C</table>
172 | #errors
173 | #document
174 | | <html>
175 | |   <head>
176 | |   <body>
177 | |     "AC"
178 | |     <table>
179 | |       <tbody>
180 | |         <tr>
181 | |           <td>
182 | |             "B"
183 | 
184 | #data
185 | <a><svg><tr><input></a>
186 | #errors
187 | #document
188 | | <html>
189 | |   <head>
190 | |   <body>
191 | |     <a>
192 | |       <svg svg>
193 | |         <svg tr>
194 | |           <svg input>
195 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/render_test.go:
--------------------------------------------------------------------------------
  1 | // Copyright 2010 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 html
  6 | 
  7 | import (
  8 | 	"bytes"
  9 | 	"testing"
 10 | )
 11 | 
 12 | func TestRenderer(t *testing.T) {
 13 | 	nodes := [...]*Node{
 14 | 		0: {
 15 | 			Type: ElementNode,
 16 | 			Data: "html",
 17 | 		},
 18 | 		1: {
 19 | 			Type: ElementNode,
 20 | 			Data: "head",
 21 | 		},
 22 | 		2: {
 23 | 			Type: ElementNode,
 24 | 			Data: "body",
 25 | 		},
 26 | 		3: {
 27 | 			Type: TextNode,
 28 | 			Data: "0<1",
 29 | 		},
 30 | 		4: {
 31 | 			Type: ElementNode,
 32 | 			Data: "p",
 33 | 			Attr: []Attribute{
 34 | 				{
 35 | 					Key: "id",
 36 | 					Val: "A",
 37 | 				},
 38 | 				{
 39 | 					Key: "foo",
 40 | 					Val: `abc"def`,
 41 | 				},
 42 | 			},
 43 | 		},
 44 | 		5: {
 45 | 			Type: TextNode,
 46 | 			Data: "2",
 47 | 		},
 48 | 		6: {
 49 | 			Type: ElementNode,
 50 | 			Data: "b",
 51 | 			Attr: []Attribute{
 52 | 				{
 53 | 					Key: "empty",
 54 | 					Val: "",
 55 | 				},
 56 | 			},
 57 | 		},
 58 | 		7: {
 59 | 			Type: TextNode,
 60 | 			Data: "3",
 61 | 		},
 62 | 		8: {
 63 | 			Type: ElementNode,
 64 | 			Data: "i",
 65 | 			Attr: []Attribute{
 66 | 				{
 67 | 					Key: "backslash",
 68 | 					Val: `\`,
 69 | 				},
 70 | 			},
 71 | 		},
 72 | 		9: {
 73 | 			Type: TextNode,
 74 | 			Data: "&4",
 75 | 		},
 76 | 		10: {
 77 | 			Type: TextNode,
 78 | 			Data: "5",
 79 | 		},
 80 | 		11: {
 81 | 			Type: ElementNode,
 82 | 			Data: "blockquote",
 83 | 		},
 84 | 		12: {
 85 | 			Type: ElementNode,
 86 | 			Data: "br",
 87 | 		},
 88 | 		13: {
 89 | 			Type: TextNode,
 90 | 			Data: "6",
 91 | 		},
 92 | 	}
 93 | 
 94 | 	// Build a tree out of those nodes, based on a textual representation.
 95 | 	// Only the ".\t"s are significant. The trailing HTML-like text is
 96 | 	// just commentary. The "0:" prefixes are for easy cross-reference with
 97 | 	// the nodes array.
 98 | 	treeAsText := [...]string{
 99 | 		0: `<html>`,
100 | 		1: `.	<head>`,
101 | 		2: `.	<body>`,
102 | 		3: `.	.	"0&lt;1"`,
103 | 		4: `.	.	`,
104 | 		5: `.	.	.	"2"`,
105 | 		6: `.	.	.	<b empty="">`,
106 | 		7: `.	.	.	.	"3"`,
107 | 		8: `.	.	.	<i backslash="\">`,
108 | 		9: `.	.	.	.	"&amp;4"`,
109 | 		10: `.	.	"5"`,
110 | 		11: `.	.	<blockquote>`,
111 | 		12: `.	.	`,
112 | 		13: `.	.	"6"`,
113 | 	}
114 | 	if len(nodes) != len(treeAsText) {
115 | 		t.Fatal("len(nodes) != len(treeAsText)")
116 | 	}
117 | 	var stack [8]*Node
118 | 	for i, line := range treeAsText {
119 | 		level := 0
120 | 		for line[0] == '.' {
121 | 			// Strip a leading ".\t".
122 | 			line = line[2:]
123 | 			level++
124 | 		}
125 | 		n := nodes[i]
126 | 		if level == 0 {
127 | 			if stack[0] != nil {
128 | 				t.Fatal("multiple root nodes")
129 | 			}
130 | 			stack[0] = n
131 | 		} else {
132 | 			stack[level-1].AppendChild(n)
133 | 			stack[level] = n
134 | 			for i := level + 1; i < len(stack); i++ {
135 | 				stack[i] = nil
136 | 			}
137 | 		}
138 | 		// At each stage of tree construction, we check all nodes for consistency.
139 | 		for j, m := range nodes {
140 | 			if err := checkNodeConsistency(m); err != nil {
141 | 				t.Fatalf("i=%d, j=%d: %v", i, j, err)
142 | 			}
143 | 		}
144 | 	}
145 | 
146 | 	want := `<html><head></head><body>0&lt;1` +
147 | 		`2<b empty="">3</b><i backslash="\">&amp;4</i>` +
148 | 		`5<blockquote></blockquote>6</body></html>`
149 | 	b := new(bytes.Buffer)
150 | 	if err := Render(b, nodes[0]); err != nil {
151 | 		t.Fatal(err)
152 | 	}
153 | 	if got := b.String(); got != want {
154 | 		t.Errorf("got vs want:\n%s\n%s\n", got, want)
155 | 	}
156 | }
157 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/testdata/webkit/tests21.dat:
--------------------------------------------------------------------------------
  1 | #data
  2 | <svg><![CDATA[foo]]>
  3 | #errors
  4 | #document
  5 | | <html>
  6 | |   <head>
  7 | |   <body>
  8 | |     <svg svg>
  9 | |       "foo"
 10 | 
 11 | #data
 12 | <math><![CDATA[foo]]>
 13 | #errors
 14 | #document
 15 | | <html>
 16 | |   <head>
 17 | |   <body>
 18 | |     <math math>
 19 | |       "foo"
 20 | 
 21 | #data
 22 | <div><![CDATA[foo]]>
 23 | #errors
 24 | #document
 25 | | <html>
 26 | |   <head>
 27 | |   <body>
 28 | |     <div>
 29 | |       <!-- [CDATA[foo]] -->
 30 | 
 31 | #data
 32 | <svg><![CDATA[foo
 33 | #errors
 34 | #document
 35 | | <html>
 36 | |   <head>
 37 | |   <body>
 38 | |     <svg svg>
 39 | |       "foo"
 40 | 
 41 | #data
 42 | <svg><![CDATA[foo
 43 | #errors
 44 | #document
 45 | | <html>
 46 | |   <head>
 47 | |   <body>
 48 | |     <svg svg>
 49 | |       "foo"
 50 | 
 51 | #data
 52 | <svg><![CDATA[
 53 | #errors
 54 | #document
 55 | | <html>
 56 | |   <head>
 57 | |   <body>
 58 | |     <svg svg>
 59 | 
 60 | #data
 61 | <svg><![CDATA[]]>
 62 | #errors
 63 | #document
 64 | | <html>
 65 | |   <head>
 66 | |   <body>
 67 | |     <svg svg>
 68 | 
 69 | #data
 70 | <svg><![CDATA[]] >]]>
 71 | #errors
 72 | #document
 73 | | <html>
 74 | |   <head>
 75 | |   <body>
 76 | |     <svg svg>
 77 | |       "]] >"
 78 | 
 79 | #data
 80 | <svg><![CDATA[]] >]]>
 81 | #errors
 82 | #document
 83 | | <html>
 84 | |   <head>
 85 | |   <body>
 86 | |     <svg svg>
 87 | |       "]] >"
 88 | 
 89 | #data
 90 | <svg><![CDATA[]]
 91 | #errors
 92 | #document
 93 | | <html>
 94 | |   <head>
 95 | |   <body>
 96 | |     <svg svg>
 97 | |       "]]"
 98 | 
 99 | #data
100 | <svg><![CDATA[]
101 | #errors
102 | #document
103 | | <html>
104 | |   <head>
105 | |   <body>
106 | |     <svg svg>
107 | |       "]"
108 | 
109 | #data
110 | <svg><![CDATA[]>a
111 | #errors
112 | #document
113 | | <html>
114 | |   <head>
115 | |   <body>
116 | |     <svg svg>
117 | |       "]>a"
118 | 
119 | #data
120 | <svg><foreignObject><div><![CDATA[foo]]>
121 | #errors
122 | #document
123 | | <html>
124 | |   <head>
125 | |   <body>
126 | |     <svg svg>
127 | |       <svg foreignObject>
128 | |         <div>
129 | |           <!-- [CDATA[foo]] -->
130 | 
131 | #data
132 | <svg><![CDATA[<svg>]]>
133 | #errors
134 | #document
135 | | <html>
136 | |   <head>
137 | |   <body>
138 | |     <svg svg>
139 | |       "<svg>"
140 | 
141 | #data
142 | <svg><![CDATA[</svg>a]]>
143 | #errors
144 | #document
145 | | <html>
146 | |   <head>
147 | |   <body>
148 | |     <svg svg>
149 | |       "</svg>a"
150 | 
151 | #data
152 | <svg><![CDATA[<svg>a
153 | #errors
154 | #document
155 | | <html>
156 | |   <head>
157 | |   <body>
158 | |     <svg svg>
159 | |       "<svg>a"
160 | 
161 | #data
162 | <svg><![CDATA[</svg>a
163 | #errors
164 | #document
165 | | <html>
166 | |   <head>
167 | |   <body>
168 | |     <svg svg>
169 | |       "</svg>a"
170 | 
171 | #data
172 | <svg><![CDATA[<svg>]]><path>
173 | #errors
174 | #document
175 | | <html>
176 | |   <head>
177 | |   <body>
178 | |     <svg svg>
179 | |       "<svg>"
180 | |       <svg path>
181 | 
182 | #data
183 | <svg><![CDATA[<svg>]]></path>
184 | #errors
185 | #document
186 | | <html>
187 | |   <head>
188 | |   <body>
189 | |     <svg svg>
190 | |       "<svg>"
191 | 
192 | #data
193 | <svg><![CDATA[<svg>]]><!--path-->
194 | #errors
195 | #document
196 | | <html>
197 | |   <head>
198 | |   <body>
199 | |     <svg svg>
200 | |       "<svg>"
201 | |       <!-- path -->
202 | 
203 | #data
204 | <svg><![CDATA[<svg>]]>path
205 | #errors
206 | #document
207 | | <html>
208 | |   <head>
209 | |   <body>
210 | |     <svg svg>
211 | |       "<svg>path"
212 | 
213 | #data
214 | <svg><![CDATA[<!--svg-->]]>
215 | #errors
216 | #document
217 | | <html>
218 | |   <head>
219 | |   <body>
220 | |     <svg svg>
221 | |       "<!--svg-->"
222 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/testdata/webkit/tests25.dat:
--------------------------------------------------------------------------------
  1 | #data
  2 | <!DOCTYPE html><body><foo>A
  3 | #errors
  4 | #document
  5 | | <!DOCTYPE html>
  6 | | <html>
  7 | |   <head>
  8 | |   <body>
  9 | |     <foo>
 10 | |       "A"
 11 | 
 12 | #data
 13 | <!DOCTYPE html><body><area>A
 14 | #errors
 15 | #document
 16 | | <!DOCTYPE html>
 17 | | <html>
 18 | |   <head>
 19 | |   <body>
 20 | |     <area>
 21 | |     "A"
 22 | 
 23 | #data
 24 | <!DOCTYPE html><body><base>A
 25 | #errors
 26 | #document
 27 | | <!DOCTYPE html>
 28 | | <html>
 29 | |   <head>
 30 | |   <body>
 31 | |     <base>
 32 | |     "A"
 33 | 
 34 | #data
 35 | <!DOCTYPE html><body><basefont>A
 36 | #errors
 37 | #document
 38 | | <!DOCTYPE html>
 39 | | <html>
 40 | |   <head>
 41 | |   <body>
 42 | |     <basefont>
 43 | |     "A"
 44 | 
 45 | #data
 46 | <!DOCTYPE html><body><bgsound>A
 47 | #errors
 48 | #document
 49 | | <!DOCTYPE html>
 50 | | <html>
 51 | |   <head>
 52 | |   <body>
 53 | |     <bgsound>
 54 | |     "A"
 55 | 
 56 | #data
 57 | <!DOCTYPE html><body>A
 58 | #errors
 59 | #document
 60 | | <!DOCTYPE html>
 61 | | <html>
 62 | |   <head>
 63 | |   <body>
 64 | |     
 65 | |     "A"
 66 | 
 67 | #data
 68 | <!DOCTYPE html><body><col>A
 69 | #errors
 70 | 26: Stray start tag “col”.
 71 | #document
 72 | | <!DOCTYPE html>
 73 | | <html>
 74 | |   <head>
 75 | |   <body>
 76 | |     "A"
 77 | 
 78 | #data
 79 | <!DOCTYPE html><body><command>A
 80 | #errors
 81 | #document
 82 | | <!DOCTYPE html>
 83 | | <html>
 84 | |   <head>
 85 | |   <body>
 86 | |     <command>
 87 | |     "A"
 88 | 
 89 | #data
 90 | <!DOCTYPE html><body><embed>A
 91 | #errors
 92 | #document
 93 | | <!DOCTYPE html>
 94 | | <html>
 95 | |   <head>
 96 | |   <body>
 97 | |     <embed>
 98 | |     "A"
 99 | 
100 | #data
101 | <!DOCTYPE html><body><frame>A
102 | #errors
103 | 26: Stray start tag “frame”.
104 | #document
105 | | <!DOCTYPE html>
106 | | <html>
107 | |   <head>
108 | |   <body>
109 | |     "A"
110 | 
111 | #data
112 | <!DOCTYPE html><body><hr>A
113 | #errors
114 | #document
115 | | <!DOCTYPE html>
116 | | <html>
117 | |   <head>
118 | |   <body>
119 | |     <hr>
120 | |     "A"
121 | 
122 | #data
123 | <!DOCTYPE html><body><img>A
124 | #errors
125 | #document
126 | | <!DOCTYPE html>
127 | | <html>
128 | |   <head>
129 | |   <body>
130 | |     <img>
131 | |     "A"
132 | 
133 | #data
134 | <!DOCTYPE html><body><input>A
135 | #errors
136 | #document
137 | | <!DOCTYPE html>
138 | | <html>
139 | |   <head>
140 | |   <body>
141 | |     <input>
142 | |     "A"
143 | 
144 | #data
145 | <!DOCTYPE html><body><keygen>A
146 | #errors
147 | #document
148 | | <!DOCTYPE html>
149 | | <html>
150 | |   <head>
151 | |   <body>
152 | |     <keygen>
153 | |     "A"
154 | 
155 | #data
156 | <!DOCTYPE html><body><link>A
157 | #errors
158 | #document
159 | | <!DOCTYPE html>
160 | | <html>
161 | |   <head>
162 | |   <body>
163 | |     <link>
164 | |     "A"
165 | 
166 | #data
167 | <!DOCTYPE html><body><meta>A
168 | #errors
169 | #document
170 | | <!DOCTYPE html>
171 | | <html>
172 | |   <head>
173 | |   <body>
174 | |     <meta>
175 | |     "A"
176 | 
177 | #data
178 | <!DOCTYPE html><body><param>A
179 | #errors
180 | #document
181 | | <!DOCTYPE html>
182 | | <html>
183 | |   <head>
184 | |   <body>
185 | |     <param>
186 | |     "A"
187 | 
188 | #data
189 | <!DOCTYPE html><body><source>A
190 | #errors
191 | #document
192 | | <!DOCTYPE html>
193 | | <html>
194 | |   <head>
195 | |   <body>
196 | |     <source>
197 | |     "A"
198 | 
199 | #data
200 | <!DOCTYPE html><body><track>A
201 | #errors
202 | #document
203 | | <!DOCTYPE html>
204 | | <html>
205 | |   <head>
206 | |   <body>
207 | |     <track>
208 | |     "A"
209 | 
210 | #data
211 | <!DOCTYPE html><body><wbr>A
212 | #errors
213 | #document
214 | | <!DOCTYPE html>
215 | | <html>
216 | |   <head>
217 | |   <body>
218 | |     <wbr>
219 | |     "A"
220 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/testdata/webkit/tests23.dat:
--------------------------------------------------------------------------------
  1 | #data
  2 | <font size=4><font color=red><font size=4><font size=4><font size=4><font size=4><font size=4><font color=red>X
  3 | #errors
  4 | 3: Start tag seen without seeing a doctype first. Expected “<!DOCTYPE html>”.
  5 | 116: Unclosed elements.
  6 | 117: End of file seen and there were open elements.
  7 | #document
  8 | | <html>
  9 | |   <head>
 10 | |   <body>
 11 | |     
 12 | |       <font>
 13 | |         size="4"
 14 | |         <font>
 15 | |           color="red"
 16 | |           <font>
 17 | |             size="4"
 18 | |             <font>
 19 | |               size="4"
 20 | |               <font>
 21 | |                 size="4"
 22 | |                 <font>
 23 | |                   size="4"
 24 | |                   <font>
 25 | |                     size="4"
 26 | |                     <font>
 27 | |                       color="red"
 28 | |     
 29 | |       <font>
 30 | |         color="red"
 31 | |         <font>
 32 | |           size="4"
 33 | |           <font>
 34 | |             size="4"
 35 | |             <font>
 36 | |               size="4"
 37 | |               <font>
 38 | |                 color="red"
 39 | |                 "X"
 40 | 
 41 | #data
 42 | <font size=4><font size=4><font size=4><font size=4>X
 43 | #errors
 44 | #document
 45 | | <html>
 46 | |   <head>
 47 | |   <body>
 48 | |     
 49 | |       <font>
 50 | |         size="4"
 51 | |         <font>
 52 | |           size="4"
 53 | |           <font>
 54 | |             size="4"
 55 | |             <font>
 56 | |               size="4"
 57 | |     
 58 | |       <font>
 59 | |         size="4"
 60 | |         <font>
 61 | |           size="4"
 62 | |           <font>
 63 | |             size="4"
 64 | |             "X"
 65 | 
 66 | #data
 67 | <font size=4><font size=4><font size=4><font size="5"><font size=4>X
 68 | #errors
 69 | #document
 70 | | <html>
 71 | |   <head>
 72 | |   <body>
 73 | |     
 74 | |       <font>
 75 | |         size="4"
 76 | |         <font>
 77 | |           size="4"
 78 | |           <font>
 79 | |             size="4"
 80 | |             <font>
 81 | |               size="5"
 82 | |               <font>
 83 | |                 size="4"
 84 | |     
 85 | |       <font>
 86 | |         size="4"
 87 | |         <font>
 88 | |           size="4"
 89 | |           <font>
 90 | |             size="5"
 91 | |             <font>
 92 | |               size="4"
 93 | |               "X"
 94 | 
 95 | #data
 96 | <font size=4 id=a><font size=4 id=b><font size=4><font size=4>X
 97 | #errors
 98 | #document
 99 | | <html>
100 | |   <head>
101 | |   <body>
102 | |     
103 | |       <font>
104 | |         id="a"
105 | |         size="4"
106 | |         <font>
107 | |           id="b"
108 | |           size="4"
109 | |           <font>
110 | |             size="4"
111 | |             <font>
112 | |               size="4"
113 | |     
114 | |       <font>
115 | |         id="a"
116 | |         size="4"
117 | |         <font>
118 | |           id="b"
119 | |           size="4"
120 | |           <font>
121 | |             size="4"
122 | |             <font>
123 | |               size="4"
124 | |               "X"
125 | 
126 | #data
127 | <b id=a><b id=a><b id=a><b><object><b id=a><b id=a>X</object>Y
128 | #errors
129 | #document
130 | | <html>
131 | |   <head>
132 | |   <body>
133 | |     
134 | |       <b>
135 | |         id="a"
136 | |         <b>
137 | |           id="a"
138 | |           <b>
139 | |             id="a"
140 | |             <b>
141 | |               <object>
142 | |                 <b>
143 | |                   id="a"
144 | |                   <b>
145 | |                     id="a"
146 | |                     "X"
147 | |     
148 | |       <b>
149 | |         id="a"
150 | |         <b>
151 | |           id="a"
152 | |           <b>
153 | |             id="a"
154 | |             <b>
155 | |               "Y"
156 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/doc.go:
--------------------------------------------------------------------------------
  1 | // Copyright 2010 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 | /*
  6 | Package html implements an HTML5-compliant tokenizer and parser.
  7 | 
  8 | Tokenization is done by creating a Tokenizer for an io.Reader r. It is the
  9 | caller's responsibility to ensure that r provides UTF-8 encoded HTML.
 10 | 
 11 | 	z := html.NewTokenizer(r)
 12 | 
 13 | Given a Tokenizer z, the HTML is tokenized by repeatedly calling z.Next(),
 14 | which parses the next token and returns its type, or an error:
 15 | 
 16 | 	for {
 17 | 		tt := z.Next()
 18 | 		if tt == html.ErrorToken {
 19 | 			// ...
 20 | 			return ...
 21 | 		}
 22 | 		// Process the current token.
 23 | 	}
 24 | 
 25 | There are two APIs for retrieving the current token. The high-level API is to
 26 | call Token; the low-level API is to call Text or TagName / TagAttr. Both APIs
 27 | allow optionally calling Raw after Next but before Token, Text, TagName, or
 28 | TagAttr. In EBNF notation, the valid call sequence per token is:
 29 | 
 30 | 	Next {Raw} [ Token | Text | TagName {TagAttr} ]
 31 | 
 32 | Token returns an independent data structure that completely describes a token.
 33 | Entities (such as "&lt;") are unescaped, tag names and attribute keys are
 34 | lower-cased, and attributes are collected into a []Attribute. For example:
 35 | 
 36 | 	for {
 37 | 		if z.Next() == html.ErrorToken {
 38 | 			// Returning io.EOF indicates success.
 39 | 			return z.Err()
 40 | 		}
 41 | 		emitToken(z.Token())
 42 | 	}
 43 | 
 44 | The low-level API performs fewer allocations and copies, but the contents of
 45 | the []byte values returned by Text, TagName and TagAttr may change on the next
 46 | call to Next. For example, to extract an HTML page's anchor text:
 47 | 
 48 | 	depth := 0
 49 | 	for {
 50 | 		tt := z.Next()
 51 | 		switch tt {
 52 | 		case ErrorToken:
 53 | 			return z.Err()
 54 | 		case TextToken:
 55 | 			if depth > 0 {
 56 | 				// emitBytes should copy the []byte it receives,
 57 | 				// if it doesn't process it immediately.
 58 | 				emitBytes(z.Text())
 59 | 			}
 60 | 		case StartTagToken, EndTagToken:
 61 | 			tn, _ := z.TagName()
 62 | 			if len(tn) == 1 && tn[0] == 'a' {
 63 | 				if tt == StartTagToken {
 64 | 					depth++
 65 | 				} else {
 66 | 					depth--
 67 | 				}
 68 | 			}
 69 | 		}
 70 | 	}
 71 | 
 72 | Parsing is done by calling Parse with an io.Reader, which returns the root of
 73 | the parse tree (the document element) as a *Node. It is the caller's
 74 | responsibility to ensure that the Reader provides UTF-8 encoded HTML. For
 75 | example, to process each anchor node in depth-first order:
 76 | 
 77 | 	doc, err := html.Parse(r)
 78 | 	if err != nil {
 79 | 		// ...
 80 | 	}
 81 | 	var f func(*html.Node)
 82 | 	f = func(n *html.Node) {
 83 | 		if n.Type == html.ElementNode && n.Data == "a" {
 84 | 			// Do something with n...
 85 | 		}
 86 | 		for c := n.FirstChild; c != nil; c = c.NextSibling {
 87 | 			f(c)
 88 | 		}
 89 | 	}
 90 | 	f(doc)
 91 | 
 92 | The relevant specifications include:
 93 | https://html.spec.whatwg.org/multipage/syntax.html and
 94 | https://html.spec.whatwg.org/multipage/syntax.html#tokenization
 95 | */
 96 | package html // import "golang.org/x/net/html"
 97 | 
 98 | // The tokenization algorithm implemented by this package is not a line-by-line
 99 | // transliteration of the relatively verbose state-machine in the WHATWG
100 | // specification. A more direct approach is used instead, where the program
101 | // counter implies the state, such as whether it is tokenizing a tag or a text
102 | // node. Specification compliance is verified by checking expected and actual
103 | // outputs over a test suite rather than aiming for algorithmic fidelity.
104 | 
105 | // TODO(nigeltao): Does a DOM API belong in this package or a separate one?
106 | // TODO(nigeltao): How does parsing interact with a JavaScript engine?
107 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/testdata/webkit/tables01.dat:
--------------------------------------------------------------------------------
  1 | #data
  2 | <table><th>
  3 | #errors
  4 | #document
  5 | | <html>
  6 | |   <head>
  7 | |   <body>
  8 | |     <table>
  9 | |       <tbody>
 10 | |         <tr>
 11 | |           <th>
 12 | 
 13 | #data
 14 | <table><td>
 15 | #errors
 16 | #document
 17 | | <html>
 18 | |   <head>
 19 | |   <body>
 20 | |     <table>
 21 | |       <tbody>
 22 | |         <tr>
 23 | |           <td>
 24 | 
 25 | #data
 26 | <table><col foo='bar'>
 27 | #errors
 28 | #document
 29 | | <html>
 30 | |   <head>
 31 | |   <body>
 32 | |     <table>
 33 | |       <colgroup>
 34 | |         <col>
 35 | |           foo="bar"
 36 | 
 37 | #data
 38 | <table><colgroup></html>foo
 39 | #errors
 40 | #document
 41 | | <html>
 42 | |   <head>
 43 | |   <body>
 44 | |     "foo"
 45 | |     <table>
 46 | |       <colgroup>
 47 | 
 48 | #data
 49 | <table></table>foo
 50 | #errors
 51 | #document
 52 | | <html>
 53 | |   <head>
 54 | |   <body>
 55 | |     <table>
 56 | |     
 57 | |       "foo"
 58 | 
 59 | #data
 60 | <table></body></caption></col></colgroup></html></tbody></td></tfoot></th></thead></tr><td>
 61 | #errors
 62 | #document
 63 | | <html>
 64 | |   <head>
 65 | |   <body>
 66 | |     <table>
 67 | |       <tbody>
 68 | |         <tr>
 69 | |           <td>
 70 | 
 71 | #data
 72 | <table><select><option>3</select></table>
 73 | #errors
 74 | #document
 75 | | <html>
 76 | |   <head>
 77 | |   <body>
 78 | |     <select>
 79 | |       <option>
 80 | |         "3"
 81 | |     <table>
 82 | 
 83 | #data
 84 | <table><select><table></table></select></table>
 85 | #errors
 86 | #document
 87 | | <html>
 88 | |   <head>
 89 | |   <body>
 90 | |     <select>
 91 | |     <table>
 92 | |     <table>
 93 | 
 94 | #data
 95 | <table><select></table>
 96 | #errors
 97 | #document
 98 | | <html>
 99 | |   <head>
100 | |   <body>
101 | |     <select>
102 | |     <table>
103 | 
104 | #data
105 | <table><select><option>A<tr><td>B</td></tr></table>
106 | #errors
107 | #document
108 | | <html>
109 | |   <head>
110 | |   <body>
111 | |     <select>
112 | |       <option>
113 | |         "A"
114 | |     <table>
115 | |       <tbody>
116 | |         <tr>
117 | |           <td>
118 | |             "B"
119 | 
120 | #data
121 | <table><td></body></caption></col></colgroup></html>foo
122 | #errors
123 | #document
124 | | <html>
125 | |   <head>
126 | |   <body>
127 | |     <table>
128 | |       <tbody>
129 | |         <tr>
130 | |           <td>
131 | |             "foo"
132 | 
133 | #data
134 | <table><td>A</table>B
135 | #errors
136 | #document
137 | | <html>
138 | |   <head>
139 | |   <body>
140 | |     <table>
141 | |       <tbody>
142 | |         <tr>
143 | |           <td>
144 | |             "A"
145 | |     "B"
146 | 
147 | #data
148 | <table><tr><caption>
149 | #errors
150 | #document
151 | | <html>
152 | |   <head>
153 | |   <body>
154 | |     <table>
155 | |       <tbody>
156 | |         <tr>
157 | |       <caption>
158 | 
159 | #data
160 | <table><tr></body></caption></col></colgroup></html></td></th><td>foo
161 | #errors
162 | #document
163 | | <html>
164 | |   <head>
165 | |   <body>
166 | |     <table>
167 | |       <tbody>
168 | |         <tr>
169 | |           <td>
170 | |             "foo"
171 | 
172 | #data
173 | <table><td><tr>
174 | #errors
175 | #document
176 | | <html>
177 | |   <head>
178 | |   <body>
179 | |     <table>
180 | |       <tbody>
181 | |         <tr>
182 | |           <td>
183 | |         <tr>
184 | 
185 | #data
186 | <table><td><button><td>
187 | #errors
188 | #document
189 | | <html>
190 | |   <head>
191 | |   <body>
192 | |     <table>
193 | |       <tbody>
194 | |         <tr>
195 | |           <td>
196 | |             <button>
197 | |           <td>
198 | 
199 | #data
200 | <table><tr><td><svg><desc><td>
201 | #errors
202 | #document
203 | | <html>
204 | |   <head>
205 | |   <body>
206 | |     <table>
207 | |       <tbody>
208 | |         <tr>
209 | |           <td>
210 | |             <svg svg>
211 | |               <svg desc>
212 | |           <td>
213 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/testdata/webkit/html5test-com.dat:
--------------------------------------------------------------------------------
  1 | #data
  2 | <div<div>
  3 | #errors
  4 | #document
  5 | | <html>
  6 | |   <head>
  7 | |   <body>
  8 | |     <div<div>
  9 | 
 10 | #data
 11 | <div foo<bar=''>
 12 | #errors
 13 | #document
 14 | | <html>
 15 | |   <head>
 16 | |   <body>
 17 | |     <div>
 18 | |       foo<bar=""
 19 | 
 20 | #data
 21 | <div foo=`bar`>
 22 | #errors
 23 | #document
 24 | | <html>
 25 | |   <head>
 26 | |   <body>
 27 | |     <div>
 28 | |       foo="`bar`"
 29 | 
 30 | #data
 31 | <div \"foo=''>
 32 | #errors
 33 | #document
 34 | | <html>
 35 | |   <head>
 36 | |   <body>
 37 | |     <div>
 38 | |       \"foo=""
 39 | 
 40 | #data
 41 | <a href='\nbar'></a>
 42 | #errors
 43 | #document
 44 | | <html>
 45 | |   <head>
 46 | |   <body>
 47 | |     <a>
 48 | |       href="\nbar"
 49 | 
 50 | #data
 51 | <!DOCTYPE html>
 52 | #errors
 53 | #document
 54 | | <!DOCTYPE html>
 55 | | <html>
 56 | |   <head>
 57 | |   <body>
 58 | 
 59 | #data
 60 | &lang;&rang;
 61 | #errors
 62 | #document
 63 | | <html>
 64 | |   <head>
 65 | |   <body>
 66 | |     "⟨⟩"
 67 | 
 68 | #data
 69 | &apos;
 70 | #errors
 71 | #document
 72 | | <html>
 73 | |   <head>
 74 | |   <body>
 75 | |     "'"
 76 | 
 77 | #data
 78 | &ImaginaryI;
 79 | #errors
 80 | #document
 81 | | <html>
 82 | |   <head>
 83 | |   <body>
 84 | |     "ⅈ"
 85 | 
 86 | #data
 87 | &Kopf;
 88 | #errors
 89 | #document
 90 | | <html>
 91 | |   <head>
 92 | |   <body>
 93 | |     "𝕂"
 94 | 
 95 | #data
 96 | &notinva;
 97 | #errors
 98 | #document
 99 | | <html>
100 | |   <head>
101 | |   <body>
102 | |     "∉"
103 | 
104 | #data
105 | <?import namespace="foo" implementation="#bar">
106 | #errors
107 | #document
108 | | <!-- ?import namespace="foo" implementation="#bar" -->
109 | | <html>
110 | |   <head>
111 | |   <body>
112 | 
113 | #data
114 | <!--foo--bar-->
115 | #errors
116 | #document
117 | | <!-- foo--bar -->
118 | | <html>
119 | |   <head>
120 | |   <body>
121 | 
122 | #data
123 | <![CDATA[x]]>
124 | #errors
125 | #document
126 | | <!-- [CDATA[x]] -->
127 | | <html>
128 | |   <head>
129 | |   <body>
130 | 
131 | #data
132 | <textarea><!--</textarea>--></textarea>
133 | #errors
134 | #document
135 | | <html>
136 | |   <head>
137 | |   <body>
138 | |     <textarea>
139 | |       "<!--"
140 | |     "-->"
141 | 
142 | #data
143 | <textarea><!--</textarea>-->
144 | #errors
145 | #document
146 | | <html>
147 | |   <head>
148 | |   <body>
149 | |     <textarea>
150 | |       "<!--"
151 | |     "-->"
152 | 
153 | #data
154 | <style><!--</style>--></style>
155 | #errors
156 | #document
157 | | <html>
158 | |   <head>
159 | |     <style>
160 | |       "<!--"
161 | |   <body>
162 | |     "-->"
163 | 
164 | #data
165 | <style><!--</style>-->
166 | #errors
167 | #document
168 | | <html>
169 | |   <head>
170 | |     <style>
171 | |       "<!--"
172 | |   <body>
173 | |     "-->"
174 | 
175 | #data
176 | <ul><li>A </li> <li>B</li></ul>
177 | #errors
178 | #document
179 | | <html>
180 | |   <head>
181 | |   <body>
182 | |     <ul>
183 | |       <li>
184 | |         "A "
185 | |       " "
186 | |       <li>
187 | |         "B"
188 | 
189 | #data
190 | <table><form><input type=hidden><input></form><div></div></table>
191 | #errors
192 | #document
193 | | <html>
194 | |   <head>
195 | |   <body>
196 | |     <input>
197 | |     <div>
198 | |     <table>
199 | |       <form>
200 | |       <input>
201 | |         type="hidden"
202 | 
203 | #data
204 | <i>A<b>B</i>C</b>D
205 | #errors
206 | #document
207 | | <html>
208 | |   <head>
209 | |   <body>
210 | |     <i>
211 | |       "A"
212 | |       <b>
213 | |         "B"
214 | |     <b>
215 | |     
216 | |       <b>
217 | |         <i>
218 | |         "C"
219 | |       "D"
220 | 
221 | #data
222 | <div></div>
223 | #errors
224 | #document
225 | | <html>
226 | |   <head>
227 | |   <body>
228 | |     <div>
229 | 
230 | #data
231 | <svg></svg>
232 | #errors
233 | #document
234 | | <html>
235 | |   <head>
236 | |   <body>
237 | |     <svg svg>
238 | 
239 | #data
240 | <math></math>
241 | #errors
242 | #document
243 | | <html>
244 | |   <head>
245 | |   <body>
246 | |     <math math>
247 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/testdata/webkit/tests22.dat:
--------------------------------------------------------------------------------
  1 | #data
  2 | <a><b><big><em><strong><div>X</a>
  3 | #errors
  4 | #document
  5 | | <html>
  6 | |   <head>
  7 | |   <body>
  8 | |     <a>
  9 | |       <b>
 10 | |         <big>
 11 | |           <em>
 12 | |             <strong>
 13 | |     <big>
 14 | |       <em>
 15 | |         <strong>
 16 | |           <div>
 17 | |             <a>
 18 | |               "X"
 19 | 
 20 | #data
 21 | <a><b><div id=1><div id=2><div id=3><div id=4><div id=5><div id=6><div id=7><div id=8>A</a>
 22 | #errors
 23 | #document
 24 | | <html>
 25 | |   <head>
 26 | |   <body>
 27 | |     <a>
 28 | |       <b>
 29 | |     <b>
 30 | |       <div>
 31 | |         id="1"
 32 | |         <a>
 33 | |         <div>
 34 | |           id="2"
 35 | |           <a>
 36 | |           <div>
 37 | |             id="3"
 38 | |             <a>
 39 | |             <div>
 40 | |               id="4"
 41 | |               <a>
 42 | |               <div>
 43 | |                 id="5"
 44 | |                 <a>
 45 | |                 <div>
 46 | |                   id="6"
 47 | |                   <a>
 48 | |                   <div>
 49 | |                     id="7"
 50 | |                     <a>
 51 | |                     <div>
 52 | |                       id="8"
 53 | |                       <a>
 54 | |                         "A"
 55 | 
 56 | #data
 57 | <a><b><div id=1><div id=2><div id=3><div id=4><div id=5><div id=6><div id=7><div id=8><div id=9>A</a>
 58 | #errors
 59 | #document
 60 | | <html>
 61 | |   <head>
 62 | |   <body>
 63 | |     <a>
 64 | |       <b>
 65 | |     <b>
 66 | |       <div>
 67 | |         id="1"
 68 | |         <a>
 69 | |         <div>
 70 | |           id="2"
 71 | |           <a>
 72 | |           <div>
 73 | |             id="3"
 74 | |             <a>
 75 | |             <div>
 76 | |               id="4"
 77 | |               <a>
 78 | |               <div>
 79 | |                 id="5"
 80 | |                 <a>
 81 | |                 <div>
 82 | |                   id="6"
 83 | |                   <a>
 84 | |                   <div>
 85 | |                     id="7"
 86 | |                     <a>
 87 | |                     <div>
 88 | |                       id="8"
 89 | |                       <a>
 90 | |                         <div>
 91 | |                           id="9"
 92 | |                           "A"
 93 | 
 94 | #data
 95 | <a><b><div id=1><div id=2><div id=3><div id=4><div id=5><div id=6><div id=7><div id=8><div id=9><div id=10>A</a>
 96 | #errors
 97 | #document
 98 | | <html>
 99 | |   <head>
100 | |   <body>
101 | |     <a>
102 | |       <b>
103 | |     <b>
104 | |       <div>
105 | |         id="1"
106 | |         <a>
107 | |         <div>
108 | |           id="2"
109 | |           <a>
110 | |           <div>
111 | |             id="3"
112 | |             <a>
113 | |             <div>
114 | |               id="4"
115 | |               <a>
116 | |               <div>
117 | |                 id="5"
118 | |                 <a>
119 | |                 <div>
120 | |                   id="6"
121 | |                   <a>
122 | |                   <div>
123 | |                     id="7"
124 | |                     <a>
125 | |                     <div>
126 | |                       id="8"
127 | |                       <a>
128 | |                         <div>
129 | |                           id="9"
130 | |                           <div>
131 | |                             id="10"
132 | |                             "A"
133 | 
134 | #data
135 | <cite><b><cite><i><cite><i><cite><i><div>X</b>TEST
136 | #errors
137 | Line: 1 Col: 6 Unexpected start tag (cite). Expected DOCTYPE.
138 | Line: 1 Col: 46 End tag (b) violates step 1, paragraph 3 of the adoption agency algorithm.
139 | Line: 1 Col: 50 Expected closing tag. Unexpected end of file.
140 | #document
141 | | <html>
142 | |   <head>
143 | |   <body>
144 | |     <cite>
145 | |       <b>
146 | |         <cite>
147 | |           <i>
148 | |             <cite>
149 | |               <i>
150 | |                 <cite>
151 | |                   <i>
152 | |       <i>
153 | |         <i>
154 | |           <div>
155 | |             <b>
156 | |               "X"
157 | |             "TEST"
158 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/testdata/webkit/tests8.dat:
--------------------------------------------------------------------------------
  1 | #data
  2 | <div>
  3 | <div></div>
  4 | </span>x
  5 | #errors
  6 | Line: 1 Col: 5 Unexpected start tag (div). Expected DOCTYPE.
  7 | Line: 3 Col: 7 Unexpected end tag (span). Ignored.
  8 | Line: 3 Col: 8 Expected closing tag. Unexpected end of file.
  9 | #document
 10 | | <html>
 11 | |   <head>
 12 | |   <body>
 13 | |     <div>
 14 | |       "
 15 | "
 16 | |       <div>
 17 | |       "
 18 | x"
 19 | 
 20 | #data
 21 | <div>x<div></div>
 22 | </span>x
 23 | #errors
 24 | Line: 1 Col: 5 Unexpected start tag (div). Expected DOCTYPE.
 25 | Line: 2 Col: 7 Unexpected end tag (span). Ignored.
 26 | Line: 2 Col: 8 Expected closing tag. Unexpected end of file.
 27 | #document
 28 | | <html>
 29 | |   <head>
 30 | |   <body>
 31 | |     <div>
 32 | |       "x"
 33 | |       <div>
 34 | |       "
 35 | x"
 36 | 
 37 | #data
 38 | <div>x<div></div>x</span>x
 39 | #errors
 40 | Line: 1 Col: 5 Unexpected start tag (div). Expected DOCTYPE.
 41 | Line: 1 Col: 25 Unexpected end tag (span). Ignored.
 42 | Line: 1 Col: 26 Expected closing tag. Unexpected end of file.
 43 | #document
 44 | | <html>
 45 | |   <head>
 46 | |   <body>
 47 | |     <div>
 48 | |       "x"
 49 | |       <div>
 50 | |       "xx"
 51 | 
 52 | #data
 53 | <div>x<div></div>y</span>z
 54 | #errors
 55 | Line: 1 Col: 5 Unexpected start tag (div). Expected DOCTYPE.
 56 | Line: 1 Col: 25 Unexpected end tag (span). Ignored.
 57 | Line: 1 Col: 26 Expected closing tag. Unexpected end of file.
 58 | #document
 59 | | <html>
 60 | |   <head>
 61 | |   <body>
 62 | |     <div>
 63 | |       "x"
 64 | |       <div>
 65 | |       "yz"
 66 | 
 67 | #data
 68 | <table><div>x<div></div>x</span>x
 69 | #errors
 70 | Line: 1 Col: 7 Unexpected start tag (table). Expected DOCTYPE.
 71 | Line: 1 Col: 12 Unexpected start tag (div) in table context caused voodoo mode.
 72 | Line: 1 Col: 18 Unexpected start tag (div) in table context caused voodoo mode.
 73 | Line: 1 Col: 24 Unexpected end tag (div) in table context caused voodoo mode.
 74 | Line: 1 Col: 32 Unexpected end tag (span) in table context caused voodoo mode.
 75 | Line: 1 Col: 32 Unexpected end tag (span). Ignored.
 76 | Line: 1 Col: 33 Unexpected end of file. Expected table content.
 77 | #document
 78 | | <html>
 79 | |   <head>
 80 | |   <body>
 81 | |     <div>
 82 | |       "x"
 83 | |       <div>
 84 | |       "xx"
 85 | |     <table>
 86 | 
 87 | #data
 88 | x<table>x
 89 | #errors
 90 | Line: 1 Col: 1 Unexpected non-space characters. Expected DOCTYPE.
 91 | Line: 1 Col: 9 Unexpected non-space characters in table context caused voodoo mode.
 92 | Line: 1 Col: 9 Unexpected end of file. Expected table content.
 93 | #document
 94 | | <html>
 95 | |   <head>
 96 | |   <body>
 97 | |     "xx"
 98 | |     <table>
 99 | 
100 | #data
101 | x<table><table>x
102 | #errors
103 | Line: 1 Col: 1 Unexpected non-space characters. Expected DOCTYPE.
104 | Line: 1 Col: 15 Unexpected start tag (table) implies end tag (table).
105 | Line: 1 Col: 16 Unexpected non-space characters in table context caused voodoo mode.
106 | Line: 1 Col: 16 Unexpected end of file. Expected table content.
107 | #document
108 | | <html>
109 | |   <head>
110 | |   <body>
111 | |     "x"
112 | |     <table>
113 | |     "x"
114 | |     <table>
115 | 
116 | #data
117 | <b>a<div></div><div></b>y
118 | #errors
119 | Line: 1 Col: 3 Unexpected start tag (b). Expected DOCTYPE.
120 | Line: 1 Col: 24 End tag (b) violates step 1, paragraph 3 of the adoption agency algorithm.
121 | Line: 1 Col: 25 Expected closing tag. Unexpected end of file.
122 | #document
123 | | <html>
124 | |   <head>
125 | |   <body>
126 | |     <b>
127 | |       "a"
128 | |       <div>
129 | |     <div>
130 | |       <b>
131 | |       "y"
132 | 
133 | #data
134 | <a><div><p></a>
135 | #errors
136 | Line: 1 Col: 3 Unexpected start tag (a). Expected DOCTYPE.
137 | Line: 1 Col: 15 End tag (a) violates step 1, paragraph 3 of the adoption agency algorithm.
138 | Line: 1 Col: 15 End tag (a) violates step 1, paragraph 3 of the adoption agency algorithm.
139 | Line: 1 Col: 15 Expected closing tag. Unexpected end of file.
140 | #document
141 | | <html>
142 | |   <head>
143 | |   <body>
144 | |     <a>
145 | |     <div>
146 | |       <a>
147 | |       <p>
148 | |         <a>
149 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/testdata/webkit/tests5.dat:
--------------------------------------------------------------------------------
  1 | #data
  2 | <style> <!-- </style>x
  3 | #errors
  4 | Line: 1 Col: 7 Unexpected start tag (style). Expected DOCTYPE.
  5 | Line: 1 Col: 22 Unexpected end of file. Expected end tag (style).
  6 | #document
  7 | | <html>
  8 | |   <head>
  9 | |     <style>
 10 | |       " <!-- "
 11 | |   <body>
 12 | |     "x"
 13 | 
 14 | #data
 15 | <style> <!-- </style> --> </style>x
 16 | #errors
 17 | Line: 1 Col: 7 Unexpected start tag (style). Expected DOCTYPE.
 18 | #document
 19 | | <html>
 20 | |   <head>
 21 | |     <style>
 22 | |       " <!-- "
 23 | |     " "
 24 | |   <body>
 25 | |     "--> x"
 26 | 
 27 | #data
 28 | <style> <!--> </style>x
 29 | #errors
 30 | Line: 1 Col: 7 Unexpected start tag (style). Expected DOCTYPE.
 31 | #document
 32 | | <html>
 33 | |   <head>
 34 | |     <style>
 35 | |       " <!--> "
 36 | |   <body>
 37 | |     "x"
 38 | 
 39 | #data
 40 | <style> <!---> </style>x
 41 | #errors
 42 | Line: 1 Col: 7 Unexpected start tag (style). Expected DOCTYPE.
 43 | #document
 44 | | <html>
 45 | |   <head>
 46 | |     <style>
 47 | |       " <!---> "
 48 | |   <body>
 49 | |     "x"
 50 | 
 51 | #data
 52 | <iframe> <!---> </iframe>x
 53 | #errors
 54 | Line: 1 Col: 8 Unexpected start tag (iframe). Expected DOCTYPE.
 55 | #document
 56 | | <html>
 57 | |   <head>
 58 | |   <body>
 59 | |     <iframe>
 60 | |       " <!---> "
 61 | |     "x"
 62 | 
 63 | #data
 64 | <iframe> <!--- </iframe>->x</iframe> --> </iframe>x
 65 | #errors
 66 | Line: 1 Col: 8 Unexpected start tag (iframe). Expected DOCTYPE.
 67 | #document
 68 | | <html>
 69 | |   <head>
 70 | |   <body>
 71 | |     <iframe>
 72 | |       " <!--- "
 73 | |     "->x --> x"
 74 | 
 75 | #data
 76 | <script> <!-- </script> --> </script>x
 77 | #errors
 78 | Line: 1 Col: 8 Unexpected start tag (script). Expected DOCTYPE.
 79 | #document
 80 | | <html>
 81 | |   <head>
 82 | |     <script>
 83 | |       " <!-- "
 84 | |     " "
 85 | |   <body>
 86 | |     "--> x"
 87 | 
 88 | #data
 89 | <title> <!-- </title> --> </title>x
 90 | #errors
 91 | Line: 1 Col: 7 Unexpected start tag (title). Expected DOCTYPE.
 92 | #document
 93 | | <html>
 94 | |   <head>
 95 | |     <title>
 96 | |       " <!-- "
 97 | |     " "
 98 | |   <body>
 99 | |     "--> x"
100 | 
101 | #data
102 | <textarea> <!--- </textarea>->x</textarea> --> </textarea>x
103 | #errors
104 | Line: 1 Col: 10 Unexpected start tag (textarea). Expected DOCTYPE.
105 | #document
106 | | <html>
107 | |   <head>
108 | |   <body>
109 | |     <textarea>
110 | |       " <!--- "
111 | |     "->x --> x"
112 | 
113 | #data
114 | <style> <!</-- </style>x
115 | #errors
116 | Line: 1 Col: 7 Unexpected start tag (style). Expected DOCTYPE.
117 | #document
118 | | <html>
119 | |   <head>
120 | |     <style>
121 | |       " <!</-- "
122 | |   <body>
123 | |     "x"
124 | 
125 | #data
126 | <p><xmp></xmp>
127 | #errors
128 | XXX: Unknown
129 | #document
130 | | <html>
131 | |   <head>
132 | |   <body>
133 | |     <p>
134 | |     <xmp>
135 | 
136 | #data
137 | <xmp> <!-- > --> </xmp>
138 | #errors
139 | Line: 1 Col: 5 Unexpected start tag (xmp). Expected DOCTYPE.
140 | #document
141 | | <html>
142 | |   <head>
143 | |   <body>
144 | |     <xmp>
145 | |       " <!-- > --> "
146 | 
147 | #data
148 | <title>&amp;</title>
149 | #errors
150 | Line: 1 Col: 7 Unexpected start tag (title). Expected DOCTYPE.
151 | #document
152 | | <html>
153 | |   <head>
154 | |     <title>
155 | |       "&"
156 | |   <body>
157 | 
158 | #data
159 | <title><!--&amp;--></title>
160 | #errors
161 | Line: 1 Col: 7 Unexpected start tag (title). Expected DOCTYPE.
162 | #document
163 | | <html>
164 | |   <head>
165 | |     <title>
166 | |       "<!--&-->"
167 | |   <body>
168 | 
169 | #data
170 | <title><!--</title>
171 | #errors
172 | Line: 1 Col: 7 Unexpected start tag (title). Expected DOCTYPE.
173 | Line: 1 Col: 19 Unexpected end of file. Expected end tag (title).
174 | #document
175 | | <html>
176 | |   <head>
177 | |     <title>
178 | |       "<!--"
179 | |   <body>
180 | 
181 | #data
182 | <noscript><!--</noscript>--></noscript>
183 | #errors
184 | Line: 1 Col: 10 Unexpected start tag (noscript). Expected DOCTYPE.
185 | #document
186 | | <html>
187 | |   <head>
188 | |     <noscript>
189 | |       "<!--"
190 | |   <body>
191 | |     "-->"
192 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/testdata/webkit/entities02.dat:
--------------------------------------------------------------------------------
  1 | #data
  2 | <div bar="ZZ&gt;YY"></div>
  3 | #errors
  4 | #document
  5 | | <html>
  6 | |   <head>
  7 | |   <body>
  8 | |     <div>
  9 | |       bar="ZZ>YY"
 10 | 
 11 | #data
 12 | <div bar="ZZ&"></div>
 13 | #errors
 14 | #document
 15 | | <html>
 16 | |   <head>
 17 | |   <body>
 18 | |     <div>
 19 | |       bar="ZZ&"
 20 | 
 21 | #data
 22 | <div bar='ZZ&'></div>
 23 | #errors
 24 | #document
 25 | | <html>
 26 | |   <head>
 27 | |   <body>
 28 | |     <div>
 29 | |       bar="ZZ&"
 30 | 
 31 | #data
 32 | <div bar=ZZ&></div>
 33 | #errors
 34 | #document
 35 | | <html>
 36 | |   <head>
 37 | |   <body>
 38 | |     <div>
 39 | |       bar="ZZ&"
 40 | 
 41 | #data
 42 | <div bar="ZZ&gt=YY"></div>
 43 | #errors
 44 | #document
 45 | | <html>
 46 | |   <head>
 47 | |   <body>
 48 | |     <div>
 49 | |       bar="ZZ&gt=YY"
 50 | 
 51 | #data
 52 | <div bar="ZZ&gt0YY"></div>
 53 | #errors
 54 | #document
 55 | | <html>
 56 | |   <head>
 57 | |   <body>
 58 | |     <div>
 59 | |       bar="ZZ&gt0YY"
 60 | 
 61 | #data
 62 | <div bar="ZZ&gt9YY"></div>
 63 | #errors
 64 | #document
 65 | | <html>
 66 | |   <head>
 67 | |   <body>
 68 | |     <div>
 69 | |       bar="ZZ&gt9YY"
 70 | 
 71 | #data
 72 | <div bar="ZZ&gtaYY"></div>
 73 | #errors
 74 | #document
 75 | | <html>
 76 | |   <head>
 77 | |   <body>
 78 | |     <div>
 79 | |       bar="ZZ&gtaYY"
 80 | 
 81 | #data
 82 | <div bar="ZZ&gtZYY"></div>
 83 | #errors
 84 | #document
 85 | | <html>
 86 | |   <head>
 87 | |   <body>
 88 | |     <div>
 89 | |       bar="ZZ&gtZYY"
 90 | 
 91 | #data
 92 | <div bar="ZZ&gt YY"></div>
 93 | #errors
 94 | #document
 95 | | <html>
 96 | |   <head>
 97 | |   <body>
 98 | |     <div>
 99 | |       bar="ZZ> YY"
100 | 
101 | #data
102 | <div bar="ZZ&gt"></div>
103 | #errors
104 | #document
105 | | <html>
106 | |   <head>
107 | |   <body>
108 | |     <div>
109 | |       bar="ZZ>"
110 | 
111 | #data
112 | <div bar='ZZ&gt'></div>
113 | #errors
114 | #document
115 | | <html>
116 | |   <head>
117 | |   <body>
118 | |     <div>
119 | |       bar="ZZ>"
120 | 
121 | #data
122 | <div bar=ZZ&gt></div>
123 | #errors
124 | #document
125 | | <html>
126 | |   <head>
127 | |   <body>
128 | |     <div>
129 | |       bar="ZZ>"
130 | 
131 | #data
132 | <div bar="ZZ&pound_id=23"></div>
133 | #errors
134 | #document
135 | | <html>
136 | |   <head>
137 | |   <body>
138 | |     <div>
139 | |       bar="ZZ£_id=23"
140 | 
141 | #data
142 | <div bar="ZZ&prod_id=23"></div>
143 | #errors
144 | #document
145 | | <html>
146 | |   <head>
147 | |   <body>
148 | |     <div>
149 | |       bar="ZZ&prod_id=23"
150 | 
151 | #data
152 | <div bar="ZZ&pound;_id=23"></div>
153 | #errors
154 | #document
155 | | <html>
156 | |   <head>
157 | |   <body>
158 | |     <div>
159 | |       bar="ZZ£_id=23"
160 | 
161 | #data
162 | <div bar="ZZ&prod;_id=23"></div>
163 | #errors
164 | #document
165 | | <html>
166 | |   <head>
167 | |   <body>
168 | |     <div>
169 | |       bar="ZZ∏_id=23"
170 | 
171 | #data
172 | <div bar="ZZ&pound=23"></div>
173 | #errors
174 | #document
175 | | <html>
176 | |   <head>
177 | |   <body>
178 | |     <div>
179 | |       bar="ZZ&pound=23"
180 | 
181 | #data
182 | <div bar="ZZ&prod=23"></div>
183 | #errors
184 | #document
185 | | <html>
186 | |   <head>
187 | |   <body>
188 | |     <div>
189 | |       bar="ZZ&prod=23"
190 | 
191 | #data
192 | <div>ZZ&pound_id=23</div>
193 | #errors
194 | #document
195 | | <html>
196 | |   <head>
197 | |   <body>
198 | |     <div>
199 | |       "ZZ£_id=23"
200 | 
201 | #data
202 | <div>ZZ&prod_id=23</div>
203 | #errors
204 | #document
205 | | <html>
206 | |   <head>
207 | |   <body>
208 | |     <div>
209 | |       "ZZ&prod_id=23"
210 | 
211 | #data
212 | <div>ZZ&pound;_id=23</div>
213 | #errors
214 | #document
215 | | <html>
216 | |   <head>
217 | |   <body>
218 | |     <div>
219 | |       "ZZ£_id=23"
220 | 
221 | #data
222 | <div>ZZ&prod;_id=23</div>
223 | #errors
224 | #document
225 | | <html>
226 | |   <head>
227 | |   <body>
228 | |     <div>
229 | |       "ZZ∏_id=23"
230 | 
231 | #data
232 | <div>ZZ&pound=23</div>
233 | #errors
234 | #document
235 | | <html>
236 | |   <head>
237 | |   <body>
238 | |     <div>
239 | |       "ZZ£=23"
240 | 
241 | #data
242 | <div>ZZ&prod=23</div>
243 | #errors
244 | #document
245 | | <html>
246 | |   <head>
247 | |   <body>
248 | |     <div>
249 | |       "ZZ&prod=23"
250 | 


--------------------------------------------------------------------------------
/treerunes.go:
--------------------------------------------------------------------------------
  1 | package htmldiff
  2 | 
  3 | import (
  4 | 	"github.com/mb0/diff"
  5 | 
  6 | 	"golang.org/x/net/html"
  7 | )
  8 | 
  9 | // treeRune holds an individual rune in the HTML along with the node it is in and, for convienience, its position (if in a container).
 10 | type treeRune struct {
 11 | 	leaf   *html.Node
 12 | 	letter rune
 13 | 	pos    posT
 14 | }
 15 | 
 16 | // diffData is a type that exists in order to provide a diff.Data interface. It holds the two sets of treeRunes to difference.
 17 | type diffData struct {
 18 | 	a, b *[]treeRune
 19 | }
 20 | 
 21 | // Equal exists to fulfill the diff.Data interface.
 22 | // NOTE: this is usually the most called function in the package!
 23 | func (dd diffData) Equal(i, j int) bool {
 24 | 	if (*dd.a)[i].letter != (*dd.b)[j].letter {
 25 | 		return false
 26 | 	}
 27 | 	if !posEqual((*dd.a)[i].pos, (*dd.b)[j].pos) {
 28 | 		return false
 29 | 	}
 30 | 	return nodeBranchesEqual((*dd.a)[i].leaf, (*dd.b)[j].leaf)
 31 | }
 32 | 
 33 | // nodeBranchesEqual checks that two leaves come from branches that can be compared.
 34 | func nodeBranchesEqual(leafA, leafB *html.Node) bool {
 35 | 	if !nodeEqualExText(leafA, leafB) {
 36 | 		return false
 37 | 	}
 38 | 	if leafA.Parent == nil && leafB.Parent == nil {
 39 | 		return true // at the top of the tree
 40 | 	}
 41 | 	if leafA.Parent != nil && leafB.Parent != nil {
 42 | 		return nodeEqualExText(leafA.Parent, leafB.Parent) // go up to the next level
 43 | 	}
 44 | 	return false // one of the leaves has a parent, the other does not
 45 | }
 46 | 
 47 | // attrEqual checks that the attributes of two nodes are the same.
 48 | func attrEqual(base, comp *html.Node) bool {
 49 | 	if len(comp.Attr) != len(base.Attr) {
 50 | 		return false
 51 | 	}
 52 | 	for a := range comp.Attr {
 53 | 		if comp.Attr[a].Key != base.Attr[a].Key ||
 54 | 			comp.Attr[a].Namespace != base.Attr[a].Namespace ||
 55 | 			comp.Attr[a].Val != base.Attr[a].Val {
 56 | 			return false
 57 | 		}
 58 | 	}
 59 | 	return true
 60 | }
 61 | 
 62 | // compares nodes excluding their text
 63 | func nodeEqualExText(base, comp *html.Node) bool {
 64 | 	if comp.DataAtom != base.DataAtom ||
 65 | 		comp.Namespace != base.Namespace ||
 66 | 		comp.Type != base.Type {
 67 | 		return false
 68 | 	}
 69 | 	return attrEqual(base, comp)
 70 | }
 71 | 
 72 | // renders a tree of nodes into a slice of treeRunes.
 73 | func renderTreeRunes(n *html.Node, tr *[]treeRune) {
 74 | 	p := getPos(n)
 75 | 	if n.FirstChild == nil { // it is a leaf node
 76 | 		switch n.Type {
 77 | 		case html.TextNode:
 78 | 			if len(n.Data) == 0 {
 79 | 				*tr = append(*tr, treeRune{leaf: n, letter: '\u200b' /* zero-width space */, pos: p}) // make sure we catch the node, even if no data
 80 | 			} else {
 81 | 				for _, r := range []rune(n.Data) {
 82 | 					*tr = append(*tr, treeRune{leaf: n, letter: r, pos: p})
 83 | 				}
 84 | 			}
 85 | 		default:
 86 | 			*tr = append(*tr, treeRune{leaf: n, letter: 0, pos: p})
 87 | 		}
 88 | 	} else {
 89 | 		for c := n.FirstChild; c != nil; c = c.NextSibling {
 90 | 			renderTreeRunes(c, tr)
 91 | 		}
 92 | 	}
 93 | }
 94 | 
 95 | // wrapper for diff.Granular() -- should only concatanate changes for similar text nodes
 96 | func granular(gran int, dd diffData, changes []diff.Change) []diff.Change {
 97 | 	ret := make([]diff.Change, 0, len(changes))
 98 | 	startSame := 0
 99 | 	changeCount := 0
100 | 	lastAleaf, lastBleaf := (*dd.a)[0].leaf, (*dd.b)[0].leaf
101 | 	for c, cc := range changes {
102 | 		if cc.A < len(*dd.a) && cc.B < len(*dd.b) &&
103 | 			lastAleaf.Type == html.TextNode && lastBleaf.Type == html.TextNode &&
104 | 			(*dd.a)[cc.A].leaf == lastAleaf && (*dd.b)[cc.B].leaf == lastBleaf &&
105 | 			nodeEqualExText(lastAleaf, lastBleaf) { // TODO is this last constraint required?
106 | 			// do nothing yet, queue it up until there is a difference
107 | 			changeCount++
108 | 		} else { // no match
109 | 			if changeCount > 0 { // flush
110 | 				ret = append(ret, diff.Granular(gran, changes[startSame:startSame+changeCount])...)
111 | 			}
112 | 			ret = append(ret, cc)
113 | 			startSame = c + 1 // the one after this
114 | 			changeCount = 0
115 | 			if cc.A < len(*dd.a) && cc.B < len(*dd.b) {
116 | 				lastAleaf, lastBleaf = (*dd.a)[cc.A].leaf, (*dd.b)[cc.B].leaf
117 | 			}
118 | 		}
119 | 	}
120 | 	if changeCount > 0 { // flush
121 | 		ret = append(ret, diff.Granular(gran, changes[startSame:])...)
122 | 	}
123 | 	return ret
124 | }
125 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/node_test.go:
--------------------------------------------------------------------------------
  1 | // Copyright 2010 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 html
  6 | 
  7 | import (
  8 | 	"fmt"
  9 | )
 10 | 
 11 | // checkTreeConsistency checks that a node and its descendants are all
 12 | // consistent in their parent/child/sibling relationships.
 13 | func checkTreeConsistency(n *Node) error {
 14 | 	return checkTreeConsistency1(n, 0)
 15 | }
 16 | 
 17 | func checkTreeConsistency1(n *Node, depth int) error {
 18 | 	if depth == 1e4 {
 19 | 		return fmt.Errorf("html: tree looks like it contains a cycle")
 20 | 	}
 21 | 	if err := checkNodeConsistency(n); err != nil {
 22 | 		return err
 23 | 	}
 24 | 	for c := n.FirstChild; c != nil; c = c.NextSibling {
 25 | 		if err := checkTreeConsistency1(c, depth+1); err != nil {
 26 | 			return err
 27 | 		}
 28 | 	}
 29 | 	return nil
 30 | }
 31 | 
 32 | // checkNodeConsistency checks that a node's parent/child/sibling relationships
 33 | // are consistent.
 34 | func checkNodeConsistency(n *Node) error {
 35 | 	if n == nil {
 36 | 		return nil
 37 | 	}
 38 | 
 39 | 	nParent := 0
 40 | 	for p := n.Parent; p != nil; p = p.Parent {
 41 | 		nParent++
 42 | 		if nParent == 1e4 {
 43 | 			return fmt.Errorf("html: parent list looks like an infinite loop")
 44 | 		}
 45 | 	}
 46 | 
 47 | 	nForward := 0
 48 | 	for c := n.FirstChild; c != nil; c = c.NextSibling {
 49 | 		nForward++
 50 | 		if nForward == 1e6 {
 51 | 			return fmt.Errorf("html: forward list of children looks like an infinite loop")
 52 | 		}
 53 | 		if c.Parent != n {
 54 | 			return fmt.Errorf("html: inconsistent child/parent relationship")
 55 | 		}
 56 | 	}
 57 | 
 58 | 	nBackward := 0
 59 | 	for c := n.LastChild; c != nil; c = c.PrevSibling {
 60 | 		nBackward++
 61 | 		if nBackward == 1e6 {
 62 | 			return fmt.Errorf("html: backward list of children looks like an infinite loop")
 63 | 		}
 64 | 		if c.Parent != n {
 65 | 			return fmt.Errorf("html: inconsistent child/parent relationship")
 66 | 		}
 67 | 	}
 68 | 
 69 | 	if n.Parent != nil {
 70 | 		if n.Parent == n {
 71 | 			return fmt.Errorf("html: inconsistent parent relationship")
 72 | 		}
 73 | 		if n.Parent == n.FirstChild {
 74 | 			return fmt.Errorf("html: inconsistent parent/first relationship")
 75 | 		}
 76 | 		if n.Parent == n.LastChild {
 77 | 			return fmt.Errorf("html: inconsistent parent/last relationship")
 78 | 		}
 79 | 		if n.Parent == n.PrevSibling {
 80 | 			return fmt.Errorf("html: inconsistent parent/prev relationship")
 81 | 		}
 82 | 		if n.Parent == n.NextSibling {
 83 | 			return fmt.Errorf("html: inconsistent parent/next relationship")
 84 | 		}
 85 | 
 86 | 		parentHasNAsAChild := false
 87 | 		for c := n.Parent.FirstChild; c != nil; c = c.NextSibling {
 88 | 			if c == n {
 89 | 				parentHasNAsAChild = true
 90 | 				break
 91 | 			}
 92 | 		}
 93 | 		if !parentHasNAsAChild {
 94 | 			return fmt.Errorf("html: inconsistent parent/child relationship")
 95 | 		}
 96 | 	}
 97 | 
 98 | 	if n.PrevSibling != nil && n.PrevSibling.NextSibling != n {
 99 | 		return fmt.Errorf("html: inconsistent prev/next relationship")
100 | 	}
101 | 	if n.NextSibling != nil && n.NextSibling.PrevSibling != n {
102 | 		return fmt.Errorf("html: inconsistent next/prev relationship")
103 | 	}
104 | 
105 | 	if (n.FirstChild == nil) != (n.LastChild == nil) {
106 | 		return fmt.Errorf("html: inconsistent first/last relationship")
107 | 	}
108 | 	if n.FirstChild != nil && n.FirstChild == n.LastChild {
109 | 		// We have a sole child.
110 | 		if n.FirstChild.PrevSibling != nil || n.FirstChild.NextSibling != nil {
111 | 			return fmt.Errorf("html: inconsistent sole child's sibling relationship")
112 | 		}
113 | 	}
114 | 
115 | 	seen := map[*Node]bool{}
116 | 
117 | 	var last *Node
118 | 	for c := n.FirstChild; c != nil; c = c.NextSibling {
119 | 		if seen[c] {
120 | 			return fmt.Errorf("html: inconsistent repeated child")
121 | 		}
122 | 		seen[c] = true
123 | 		last = c
124 | 	}
125 | 	if last != n.LastChild {
126 | 		return fmt.Errorf("html: inconsistent last relationship")
127 | 	}
128 | 
129 | 	var first *Node
130 | 	for c := n.LastChild; c != nil; c = c.PrevSibling {
131 | 		if !seen[c] {
132 | 			return fmt.Errorf("html: inconsistent missing child")
133 | 		}
134 | 		delete(seen, c)
135 | 		first = c
136 | 	}
137 | 	if first != n.FirstChild {
138 | 		return fmt.Errorf("html: inconsistent first relationship")
139 | 	}
140 | 
141 | 	if len(seen) != 0 {
142 | 		return fmt.Errorf("html: inconsistent forwards/backwards child list")
143 | 	}
144 | 
145 | 	return nil
146 | }
147 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/testdata/webkit/tests15.dat:
--------------------------------------------------------------------------------
  1 | #data
  2 | <!DOCTYPE html><p><b><i><u></p> <p>X
  3 | #errors
  4 | Line: 1 Col: 31 Unexpected end tag (p). Ignored.
  5 | Line: 1 Col: 36 Expected closing tag. Unexpected end of file.
  6 | #document
  7 | | <!DOCTYPE html>
  8 | | <html>
  9 | |   <head>
 10 | |   <body>
 11 | |     <p>
 12 | |       <b>
 13 | |         <i>
 14 | |           <u>
 15 | |     <b>
 16 | |       <i>
 17 | |         <u>
 18 | |           " "
 19 | |           <p>
 20 | |             "X"
 21 | 
 22 | #data
 23 | <p><b><i><u></p>
 24 | <p>X
 25 | #errors
 26 | Line: 1 Col: 3 Unexpected start tag (p). Expected DOCTYPE.
 27 | Line: 1 Col: 16 Unexpected end tag (p). Ignored.
 28 | Line: 2 Col: 4 Expected closing tag. Unexpected end of file.
 29 | #document
 30 | | <html>
 31 | |   <head>
 32 | |   <body>
 33 | |     <p>
 34 | |       <b>
 35 | |         <i>
 36 | |           <u>
 37 | |     <b>
 38 | |       <i>
 39 | |         <u>
 40 | |           "
 41 | "
 42 | |           <p>
 43 | |             "X"
 44 | 
 45 | #data
 46 | <!doctype html></html> <head>
 47 | #errors
 48 | Line: 1 Col: 22 Unexpected end tag (html) after the (implied) root element.
 49 | #document
 50 | | <!DOCTYPE html>
 51 | | <html>
 52 | |   <head>
 53 | |   <body>
 54 | |     " "
 55 | 
 56 | #data
 57 | <!doctype html></body><meta>
 58 | #errors
 59 | Line: 1 Col: 22 Unexpected end tag (body) after the (implied) root element.
 60 | #document
 61 | | <!DOCTYPE html>
 62 | | <html>
 63 | |   <head>
 64 | |   <body>
 65 | |     <meta>
 66 | 
 67 | #data
 68 | <html></html><!-- foo -->
 69 | #errors
 70 | Line: 1 Col: 6 Unexpected start tag (html). Expected DOCTYPE.
 71 | Line: 1 Col: 13 Unexpected end tag (html) after the (implied) root element.
 72 | #document
 73 | | <html>
 74 | |   <head>
 75 | |   <body>
 76 | | <!--  foo  -->
 77 | 
 78 | #data
 79 | <!doctype html></body><title>X</title>
 80 | #errors
 81 | Line: 1 Col: 22 Unexpected end tag (body) after the (implied) root element.
 82 | #document
 83 | | <!DOCTYPE html>
 84 | | <html>
 85 | |   <head>
 86 | |   <body>
 87 | |     <title>
 88 | |       "X"
 89 | 
 90 | #data
 91 | <!doctype html><table> X<meta></table>
 92 | #errors
 93 | Line: 1 Col: 24 Unexpected non-space characters in table context caused voodoo mode.
 94 | Line: 1 Col: 30 Unexpected start tag (meta) in table context caused voodoo mode.
 95 | #document
 96 | | <!DOCTYPE html>
 97 | | <html>
 98 | |   <head>
 99 | |   <body>
100 | |     " X"
101 | |     <meta>
102 | |     <table>
103 | 
104 | #data
105 | <!doctype html><table> x</table>
106 | #errors
107 | Line: 1 Col: 24 Unexpected non-space characters in table context caused voodoo mode.
108 | #document
109 | | <!DOCTYPE html>
110 | | <html>
111 | |   <head>
112 | |   <body>
113 | |     " x"
114 | |     <table>
115 | 
116 | #data
117 | <!doctype html><table> x </table>
118 | #errors
119 | Line: 1 Col: 25 Unexpected non-space characters in table context caused voodoo mode.
120 | #document
121 | | <!DOCTYPE html>
122 | | <html>
123 | |   <head>
124 | |   <body>
125 | |     " x "
126 | |     <table>
127 | 
128 | #data
129 | <!doctype html><table><tr> x</table>
130 | #errors
131 | Line: 1 Col: 28 Unexpected non-space characters in table context caused voodoo mode.
132 | #document
133 | | <!DOCTYPE html>
134 | | <html>
135 | |   <head>
136 | |   <body>
137 | |     " x"
138 | |     <table>
139 | |       <tbody>
140 | |         <tr>
141 | 
142 | #data
143 | <!doctype html><table>X<style> <tr>x </style> </table>
144 | #errors
145 | Line: 1 Col: 23 Unexpected non-space characters in table context caused voodoo mode.
146 | #document
147 | | <!DOCTYPE html>
148 | | <html>
149 | |   <head>
150 | |   <body>
151 | |     "X"
152 | |     <table>
153 | |       <style>
154 | |         " <tr>x "
155 | |       " "
156 | 
157 | #data
158 | <!doctype html><div><table><a>foo</a> <tr><td>bar</td> </tr></table></div>
159 | #errors
160 | Line: 1 Col: 30 Unexpected start tag (a) in table context caused voodoo mode.
161 | Line: 1 Col: 37 Unexpected end tag (a) in table context caused voodoo mode.
162 | #document
163 | | <!DOCTYPE html>
164 | | <html>
165 | |   <head>
166 | |   <body>
167 | |     <div>
168 | |       <a>
169 | |         "foo"
170 | |       <table>
171 | |         " "
172 | |         <tbody>
173 | |           <tr>
174 | |             <td>
175 | |               "bar"
176 | |             " "
177 | 
178 | #data
179 | <frame></frame></frame><frameset><frame><frameset><frame></frameset><noframes></frameset><noframes>
180 | #errors
181 | 6: Start tag seen without seeing a doctype first. Expected “<!DOCTYPE html>”.
182 | 13: Stray start tag “frame”.
183 | 21: Stray end tag “frame”.
184 | 29: Stray end tag “frame”.
185 | 39: “frameset” start tag after “body” already open.
186 | 105: End of file seen inside an [R]CDATA element.
187 | 105: End of file seen and there were open elements.
188 | XXX: These errors are wrong, please fix me!
189 | #document
190 | | <html>
191 | |   <head>
192 | |   <frameset>
193 | |     <frame>
194 | |     <frameset>
195 | |       <frame>
196 | |     <noframes>
197 | |       "</frameset><noframes>"
198 | 
199 | #data
200 | <!DOCTYPE html><object></html>
201 | #errors
202 | 1: Expected closing tag. Unexpected end of file
203 | #document
204 | | <!DOCTYPE html>
205 | | <html>
206 | |   <head>
207 | |   <body>
208 | |     <object>
209 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/testdata/webkit/tricky01.dat:
--------------------------------------------------------------------------------
  1 | #data
  2 | <b><p>Bold </b> Not bold</p>
  3 | Also not bold.
  4 | #errors
  5 | #document
  6 | | <html>
  7 | |   <head>
  8 | |   <body>
  9 | |     <b>
 10 | |     <p>
 11 | |       <b>
 12 | |         "Bold "
 13 | |       " Not bold"
 14 | |     "
 15 | Also not bold."
 16 | 
 17 | #data
 18 | <html>
 19 | <font color=red><i>Italic and Red<p>Italic and Red </font> Just italic.</p> Italic only.</i> Plain
 20 | <p>I should not be red. <font color=red>Red. <i>Italic and red.</p>
 21 | <p>Italic and red. </i> Red.</font> I should not be red.</p>
 22 | <b>Bold <i>Bold and italic</b> Only Italic </i> Plain
 23 | #errors
 24 | #document
 25 | | <html>
 26 | |   <head>
 27 | |   <body>
 28 | |     <font>
 29 | |       color="red"
 30 | |       <i>
 31 | |         "Italic and Red"
 32 | |     <i>
 33 | |       <p>
 34 | |         <font>
 35 | |           color="red"
 36 | |           "Italic and Red "
 37 | |         " Just italic."
 38 | |       " Italic only."
 39 | |     " Plain
 40 | "
 41 | |     <p>
 42 | |       "I should not be red. "
 43 | |       <font>
 44 | |         color="red"
 45 | |         "Red. "
 46 | |         <i>
 47 | |           "Italic and red."
 48 | |     <font>
 49 | |       color="red"
 50 | |       <i>
 51 | |         "
 52 | "
 53 | |     <p>
 54 | |       <font>
 55 | |         color="red"
 56 | |         <i>
 57 | |           "Italic and red. "
 58 | |         " Red."
 59 | |       " I should not be red."
 60 | |     "
 61 | "
 62 | |     <b>
 63 | |       "Bold "
 64 | |       <i>
 65 | |         "Bold and italic"
 66 | |     <i>
 67 | |       " Only Italic "
 68 | |     " Plain"
 69 | 
 70 | #data
 71 | <html><body>
 72 | <p><font size="7">First paragraph.</p>
 73 | <p>Second paragraph.</p></font>
 74 | <b><p><i>Bold and Italic</b> Italic</p>
 75 | #errors
 76 | #document
 77 | | <html>
 78 | |   <head>
 79 | |   <body>
 80 | |     "
 81 | "
 82 | |     <p>
 83 | |       <font>
 84 | |         size="7"
 85 | |         "First paragraph."
 86 | |     <font>
 87 | |       size="7"
 88 | |       "
 89 | "
 90 | |       <p>
 91 | |         "Second paragraph."
 92 | |     "
 93 | "
 94 | |     <b>
 95 | |     <p>
 96 | |       <b>
 97 | |         <i>
 98 | |           "Bold and Italic"
 99 | |       <i>
100 | |         " Italic"
101 | 
102 | #data
103 | <html>
104 | <dl>
105 | <dt><b>Boo
106 | <dd>Goo?
107 | </dl>
108 | </html>
109 | #errors
110 | #document
111 | | <html>
112 | |   <head>
113 | |   <body>
114 | |     <dl>
115 | |       "
116 | "
117 | |       <dt>
118 | |         <b>
119 | |           "Boo
120 | "
121 | |       <dd>
122 | |         <b>
123 | |           "Goo?
124 | "
125 | |     <b>
126 | |       "
127 | "
128 | 
129 | #data
130 | <html><body>
131 | <label><a><div>Hello<div>World</div></a></label>  
132 | </body></html>
133 | #errors
134 | #document
135 | | <html>
136 | |   <head>
137 | |   <body>
138 | |     "
139 | "
140 | |     <label>
141 | |       <a>
142 | |       <div>
143 | |         <a>
144 | |           "Hello"
145 | |           <div>
146 | |             "World"
147 | |         "  
148 | "
149 | 
150 | #data
151 | <table><center> <font>a</center> <img> <tr><td> </td> </tr> </table>
152 | #errors
153 | #document
154 | | <html>
155 | |   <head>
156 | |   <body>
157 | |     <center>
158 | |       " "
159 | |       <font>
160 | |         "a"
161 | |     <font>
162 | |       <img>
163 | |       " "
164 | |     <table>
165 | |       " "
166 | |       <tbody>
167 | |         <tr>
168 | |           <td>
169 | |             " "
170 | |           " "
171 | |         " "
172 | 
173 | #data
174 | <table><tr><p><a><p>You should see this text.
175 | #errors
176 | #document
177 | | <html>
178 | |   <head>
179 | |   <body>
180 | |     <p>
181 | |       <a>
182 | |     <p>
183 | |       <a>
184 | |         "You should see this text."
185 | |     <table>
186 | |       <tbody>
187 | |         <tr>
188 | 
189 | #data
190 | <TABLE>
191 | <TR>
192 | <CENTER><CENTER><TD></TD></TR><TR>
193 | <FONT>
194 | <TABLE><tr></tr></TABLE>
195 | </P>
196 | <a></font><font></a>
197 | This page contains an insanely badly-nested tag sequence.
198 | #errors
199 | #document
200 | | <html>
201 | |   <head>
202 | |   <body>
203 | |     <center>
204 | |       <center>
205 | |     <font>
206 | |       "
207 | "
208 | |     <table>
209 | |       "
210 | "
211 | |       <tbody>
212 | |         <tr>
213 | |           "
214 | "
215 | |           <td>
216 | |         <tr>
217 | |           "
218 | "
219 | |     <table>
220 | |       <tbody>
221 | |         <tr>
222 | |     <font>
223 | |       "
224 | "
225 | |       <p>
226 | |       "
227 | "
228 | |       <a>
229 | |     <a>
230 | |       <font>
231 | |     <font>
232 | |       "
233 | This page contains an insanely badly-nested tag sequence."
234 | 
235 | #data
236 | <html>
237 | <body>
238 | <b><nobr><div>This text is in a div inside a nobr</nobr>More text that should not be in the nobr, i.e., the
239 | nobr should have closed the div inside it implicitly. </b><pre>A pre tag outside everything else.</pre>
240 | </body>
241 | </html>
242 | #errors
243 | #document
244 | | <html>
245 | |   <head>
246 | |   <body>
247 | |     "
248 | "
249 | |     <b>
250 | |       <nobr>
251 | |     <div>
252 | |       <b>
253 | |         <nobr>
254 | |           "This text is in a div inside a nobr"
255 | |         "More text that should not be in the nobr, i.e., the
256 | nobr should have closed the div inside it implicitly. "
257 | |       <pre>
258 | |         "A pre tag outside everything else."
259 | |       "
260 | 
261 | "
262 | 


--------------------------------------------------------------------------------
/fuzz.go:
--------------------------------------------------------------------------------
  1 | // +build gofuzz
  2 | 
  3 | package htmldiff
  4 | 
  5 | import (
  6 | 	"strings"
  7 | 	"unicode/utf8"
  8 | 
  9 | 	"golang.org/x/net/html"
 10 | )
 11 | 
 12 | type fuzzCfg struct {
 13 | 	cfg *Config
 14 | 	cmp []string
 15 | }
 16 | 
 17 | func baseFuzzCfg() *fuzzCfg {
 18 | 	return &fuzzCfg{
 19 | 		cfg: &Config{
 20 | 			Granularity:  0,
 21 | 			InsertedSpan: []html.Attribute{{Key: "style", Val: "background-color: palegreen; text-decoration: underline;"}},
 22 | 			DeletedSpan:  []html.Attribute{{Key: "style", Val: "background-color: lightpink; text-decoration: line-through;"}},
 23 | 			ReplacedSpan: []html.Attribute{{Key: "style", Val: "background-color: lightskyblue; text-decoration: overline;"}},
 24 | 			CleanTags:    nil,
 25 | 		},
 26 | 	}
 27 | }
 28 | 
 29 | type fuzzer func(*fuzzCfg, []byte, uint)
 30 | 
 31 | var fuzzers = []fuzzer{fuz0, fuz1, fuz2, fuz3, fuz4, fuz5, fuz6 /*, fuz7 */}
 32 | 
 33 | // Fuzz is the test function for https://github.com/dvyukov/go-fuzz
 34 | func Fuzz(data []byte) int {
 35 | 	fcfg := baseFuzzCfg()
 36 | 	seed := uint1(&data)
 37 | 	fuzzers[int(seed)%len(fuzzers)](fcfg, data, seed/uint(len(fuzzers)))
 38 | 	if _, err := fcfg.cfg.HTMLdiff(fcfg.cmp); err != nil {
 39 | 		return 0
 40 | 	}
 41 | 	return 1
 42 | }
 43 | 
 44 | func fuz0(fcfg *fuzzCfg, data []byte, seed uint) {
 45 | 	raw := string(data)
 46 | 	var x0, x1 string
 47 | 	for i, r := range raw {
 48 | 		if r != utf8.RuneError {
 49 | 			x0 += string(r)
 50 | 			switch i % 4 {
 51 | 			case 0:
 52 | 			case 1:
 53 | 				x1 += string(r)
 54 | 				x1 += string(r)
 55 | 			default:
 56 | 				x1 += string(r)
 57 | 			}
 58 | 		}
 59 | 	}
 60 | 	fcfg.cmp = []string{x0, x1}
 61 | }
 62 | 
 63 | func fuz1(fcfg *fuzzCfg, data []byte, seed uint) {
 64 | 	fcfg.cfg.Granularity = int(seed)
 65 | 	fcfg.cmp = []string{string(data), strings.ToUpper(string(data))}
 66 | }
 67 | 
 68 | func fuz2(fcfg *fuzzCfg, data []byte, seed uint) {
 69 | 	fcfg.cfg.Granularity = int(seed)
 70 | 	for ct := int(seed) / 2; ct > 0; ct-- {
 71 | 		fcfg.cfg.CleanTags = append(fcfg.cfg.CleanTags, str5(&data))
 72 | 	}
 73 | 	n := int(seed) + 1
 74 | 	h := make([]string, 0, n)
 75 | 	xx := ""
 76 | 	l := len(data) / int(n)
 77 | 	for n--; n >= 0; n-- {
 78 | 		x := strMax(&data, l)
 79 | 		h = append(h, x)
 80 | 		if len(x) > 0 {
 81 | 			xx = x
 82 | 		}
 83 | 	}
 84 | 	fcfg.cmp = append([]string{xx}, h...)
 85 | }
 86 | 
 87 | func fuz3(fcfg *fuzzCfg, data []byte, seed uint) {
 88 | 	fcfg.cfg.Granularity = int(seed)
 89 | 	raw := string(data)
 90 | 	var x0, x1 string
 91 | 	for i, r := range raw {
 92 | 		if r != utf8.RuneError {
 93 | 			x0 += string(r)
 94 | 			switch i % 2 {
 95 | 			case 0:
 96 | 				x0 += string(r)
 97 | 			case 1:
 98 | 				x1 += string(r)
 99 | 			}
100 | 		}
101 | 	}
102 | 	fcfg.cmp = []string{x0, x1}
103 | }
104 | 
105 | func fuz4(fcfg *fuzzCfg, data []byte, seed uint) {
106 | 	raw := string(data)
107 | 	x, y := "", ""
108 | 	for _, r := range raw {
109 | 		if r != utf8.RuneError {
110 | 			x += string(r)
111 | 			y = string(r) + y
112 | 		}
113 | 	}
114 | 	fcfg.cfg.Granularity = len(x) % int(seed+1)
115 | 	fcfg.cmp = []string{x, y}
116 | }
117 | 
118 | func fuz5(fcfg *fuzzCfg, data []byte, seed uint) {
119 | 	raw := string(data)
120 | 	x := ""
121 | 	for _, r := range raw {
122 | 		if r != utf8.RuneError {
123 | 			x += string(r)
124 | 		}
125 | 	}
126 | 	fcfg.cfg.Granularity = len(x) % int(seed+1)
127 | 	fcfg.cmp = []string{x, strings.ToLower(x)}
128 | }
129 | 
130 | func fuz6(fcfg *fuzzCfg, data []byte, seed uint) {
131 | 	raw := string(data)
132 | 	x := ""
133 | 	for _, r := range raw {
134 | 		if r != utf8.RuneError {
135 | 			x += string(r)
136 | 		}
137 | 	}
138 | 	fcfg.cmp = []string{x, strings.ToTitle(x)}
139 | }
140 | 
141 | /* file decode time is too long
142 | func fuz7(fcfg *fuzzCfg, data []byte, seed uint) {
143 | 	dir := ".." + string(os.PathSeparator) + "testin" // should be running in the fuzz directory
144 | 	files, err := ioutil.ReadDir(dir)
145 | 	if err != nil {
146 | 		return
147 | 	}
148 | tryAgain:
149 | 	file := files[int(seed)%len(files)]
150 | 	baseHTML := ""
151 | 	fn := file.Name()
152 | 	var dat []byte
153 | 	if !strings.HasSuffix(fn, ".html") || fn == "google.html" {
154 | 		seed++
155 | 		goto tryAgain
156 | 	}
157 | 	ffn := dir + string(os.PathSeparator) + fn
158 | 	dat, err = ioutil.ReadFile(ffn)
159 | 	if err != nil {
160 | 		return
161 | 	}
162 | 	baseHTML = string(dat)
163 | 
164 | 	ptr := (int(seed) + len(dat)/2) % len(dat)
165 | 	dat[ptr] = byte(seed) & 0x7f
166 | 	for x, xx := range dat {
167 | 		ptr = (ptr + x + int(xx)) % len(dat)
168 | 		dat[ptr] = xx & 0x7f
169 | 	}
170 | 	fcfg.cmp = []string{baseHTML, string(dat)}
171 | }
172 | */
173 | 
174 | func uint1(data *[]byte) uint {
175 | 	if len(*data) < 1 {
176 | 		return 0
177 | 	}
178 | 	r := (*data)[0]
179 | 	*data = (*data)[1:]
180 | 	return uint(r)
181 | }
182 | 
183 | func str5(data *[]byte) string {
184 | 	if len(*data) < 1 {
185 | 		return ""
186 | 	}
187 | 	l := int((*data)[0])%5 + 1
188 | 	if len(*data) <= l {
189 | 		return ""
190 | 	}
191 | 	raw := string((*data)[1 : l+1])
192 | 	*data = (*data)[l:]
193 | 	s := ""
194 | 	for _, r := range raw {
195 | 		if r != utf8.RuneError {
196 | 			s += string(r)
197 | 		}
198 | 	}
199 | 	return s
200 | }
201 | 
202 | var tags = []string{"u", "p", "i", "b", "div"}
203 | 
204 | func strMax(data *[]byte, limit int) string {
205 | 	s := ""
206 | 	for max := limit; len(s) < limit && max > 0; max-- {
207 | 		txt := str5(data)
208 | 		tag := tags[uint1(data)%uint(len(tags))]
209 | 		s += "<" + tag + ">" + txt + "</" + tag + ">"
210 | 	}
211 | 	return s
212 | }
213 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/testdata/webkit/tests18.dat:
--------------------------------------------------------------------------------
  1 | #data
  2 | <!doctype html><plaintext></plaintext>
  3 | #errors
  4 | #document
  5 | | <!DOCTYPE html>
  6 | | <html>
  7 | |   <head>
  8 | |   <body>
  9 | |     <plaintext>
 10 | |       "</plaintext>"
 11 | 
 12 | #data
 13 | <!doctype html><table><plaintext></plaintext>
 14 | #errors
 15 | #document
 16 | | <!DOCTYPE html>
 17 | | <html>
 18 | |   <head>
 19 | |   <body>
 20 | |     <plaintext>
 21 | |       "</plaintext>"
 22 | |     <table>
 23 | 
 24 | #data
 25 | <!doctype html><table><tbody><plaintext></plaintext>
 26 | #errors
 27 | #document
 28 | | <!DOCTYPE html>
 29 | | <html>
 30 | |   <head>
 31 | |   <body>
 32 | |     <plaintext>
 33 | |       "</plaintext>"
 34 | |     <table>
 35 | |       <tbody>
 36 | 
 37 | #data
 38 | <!doctype html><table><tbody><tr><plaintext></plaintext>
 39 | #errors
 40 | #document
 41 | | <!DOCTYPE html>
 42 | | <html>
 43 | |   <head>
 44 | |   <body>
 45 | |     <plaintext>
 46 | |       "</plaintext>"
 47 | |     <table>
 48 | |       <tbody>
 49 | |         <tr>
 50 | 
 51 | #data
 52 | <!doctype html><table><tbody><tr><plaintext></plaintext>
 53 | #errors
 54 | #document
 55 | | <!DOCTYPE html>
 56 | | <html>
 57 | |   <head>
 58 | |   <body>
 59 | |     <plaintext>
 60 | |       "</plaintext>"
 61 | |     <table>
 62 | |       <tbody>
 63 | |         <tr>
 64 | 
 65 | #data
 66 | <!doctype html><table><td><plaintext></plaintext>
 67 | #errors
 68 | #document
 69 | | <!DOCTYPE html>
 70 | | <html>
 71 | |   <head>
 72 | |   <body>
 73 | |     <table>
 74 | |       <tbody>
 75 | |         <tr>
 76 | |           <td>
 77 | |             <plaintext>
 78 | |               "</plaintext>"
 79 | 
 80 | #data
 81 | <!doctype html><table><caption><plaintext></plaintext>
 82 | #errors
 83 | #document
 84 | | <!DOCTYPE html>
 85 | | <html>
 86 | |   <head>
 87 | |   <body>
 88 | |     <table>
 89 | |       <caption>
 90 | |         <plaintext>
 91 | |           "</plaintext>"
 92 | 
 93 | #data
 94 | <!doctype html><table><tr><style></script></style>abc
 95 | #errors
 96 | #document
 97 | | <!DOCTYPE html>
 98 | | <html>
 99 | |   <head>
100 | |   <body>
101 | |     "abc"
102 | |     <table>
103 | |       <tbody>
104 | |         <tr>
105 | |           <style>
106 | |             "</script>"
107 | 
108 | #data
109 | <!doctype html><table><tr><script></style></script>abc
110 | #errors
111 | #document
112 | | <!DOCTYPE html>
113 | | <html>
114 | |   <head>
115 | |   <body>
116 | |     "abc"
117 | |     <table>
118 | |       <tbody>
119 | |         <tr>
120 | |           <script>
121 | |             "</style>"
122 | 
123 | #data
124 | <!doctype html><table><caption><style></script></style>abc
125 | #errors
126 | #document
127 | | <!DOCTYPE html>
128 | | <html>
129 | |   <head>
130 | |   <body>
131 | |     <table>
132 | |       <caption>
133 | |         <style>
134 | |           "</script>"
135 | |         "abc"
136 | 
137 | #data
138 | <!doctype html><table><td><style></script></style>abc
139 | #errors
140 | #document
141 | | <!DOCTYPE html>
142 | | <html>
143 | |   <head>
144 | |   <body>
145 | |     <table>
146 | |       <tbody>
147 | |         <tr>
148 | |           <td>
149 | |             <style>
150 | |               "</script>"
151 | |             "abc"
152 | 
153 | #data
154 | <!doctype html><select><script></style></script>abc
155 | #errors
156 | #document
157 | | <!DOCTYPE html>
158 | | <html>
159 | |   <head>
160 | |   <body>
161 | |     <select>
162 | |       <script>
163 | |         "</style>"
164 | |       "abc"
165 | 
166 | #data
167 | <!doctype html><table><select><script></style></script>abc
168 | #errors
169 | #document
170 | | <!DOCTYPE html>
171 | | <html>
172 | |   <head>
173 | |   <body>
174 | |     <select>
175 | |       <script>
176 | |         "</style>"
177 | |       "abc"
178 | |     <table>
179 | 
180 | #data
181 | <!doctype html><table><tr><select><script></style></script>abc
182 | #errors
183 | #document
184 | | <!DOCTYPE html>
185 | | <html>
186 | |   <head>
187 | |   <body>
188 | |     <select>
189 | |       <script>
190 | |         "</style>"
191 | |       "abc"
192 | |     <table>
193 | |       <tbody>
194 | |         <tr>
195 | 
196 | #data
197 | <!doctype html><frameset></frameset><noframes>abc
198 | #errors
199 | #document
200 | | <!DOCTYPE html>
201 | | <html>
202 | |   <head>
203 | |   <frameset>
204 | |   <noframes>
205 | |     "abc"
206 | 
207 | #data
208 | <!doctype html><frameset></frameset><noframes>abc</noframes><!--abc-->
209 | #errors
210 | #document
211 | | <!DOCTYPE html>
212 | | <html>
213 | |   <head>
214 | |   <frameset>
215 | |   <noframes>
216 | |     "abc"
217 | |   <!-- abc -->
218 | 
219 | #data
220 | <!doctype html><frameset></frameset></html><noframes>abc
221 | #errors
222 | #document
223 | | <!DOCTYPE html>
224 | | <html>
225 | |   <head>
226 | |   <frameset>
227 | |   <noframes>
228 | |     "abc"
229 | 
230 | #data
231 | <!doctype html><frameset></frameset></html><noframes>abc</noframes><!--abc-->
232 | #errors
233 | #document
234 | | <!DOCTYPE html>
235 | | <html>
236 | |   <head>
237 | |   <frameset>
238 | |   <noframes>
239 | |     "abc"
240 | | <!-- abc -->
241 | 
242 | #data
243 | <!doctype html><table><tr></tbody><tfoot>
244 | #errors
245 | #document
246 | | <!DOCTYPE html>
247 | | <html>
248 | |   <head>
249 | |   <body>
250 | |     <table>
251 | |       <tbody>
252 | |         <tr>
253 | |       <tfoot>
254 | 
255 | #data
256 | <!doctype html><table><td><svg></svg>abc<td>
257 | #errors
258 | #document
259 | | <!DOCTYPE html>
260 | | <html>
261 | |   <head>
262 | |   <body>
263 | |     <table>
264 | |       <tbody>
265 | |         <tr>
266 | |           <td>
267 | |             <svg svg>
268 | |             "abc"
269 | |           <td>
270 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/doctype.go:
--------------------------------------------------------------------------------
  1 | // Copyright 2011 The Go Authors. All rights reserved.
  2 | // Use of this source code is governed by a BSD-style
  3 | // license that can be found in the LICENSE file.
  4 | 
  5 | package html
  6 | 
  7 | import (
  8 | 	"strings"
  9 | )
 10 | 
 11 | // parseDoctype parses the data from a DoctypeToken into a name,
 12 | // public identifier, and system identifier. It returns a Node whose Type
 13 | // is DoctypeNode, whose Data is the name, and which has attributes
 14 | // named "system" and "public" for the two identifiers if they were present.
 15 | // quirks is whether the document should be parsed in "quirks mode".
 16 | func parseDoctype(s string) (n *Node, quirks bool) {
 17 | 	n = &Node{Type: DoctypeNode}
 18 | 
 19 | 	// Find the name.
 20 | 	space := strings.IndexAny(s, whitespace)
 21 | 	if space == -1 {
 22 | 		space = len(s)
 23 | 	}
 24 | 	n.Data = s[:space]
 25 | 	// The comparison to "html" is case-sensitive.
 26 | 	if n.Data != "html" {
 27 | 		quirks = true
 28 | 	}
 29 | 	n.Data = strings.ToLower(n.Data)
 30 | 	s = strings.TrimLeft(s[space:], whitespace)
 31 | 
 32 | 	if len(s) < 6 {
 33 | 		// It can't start with "PUBLIC" or "SYSTEM".
 34 | 		// Ignore the rest of the string.
 35 | 		return n, quirks || s != ""
 36 | 	}
 37 | 
 38 | 	key := strings.ToLower(s[:6])
 39 | 	s = s[6:]
 40 | 	for key == "public" || key == "system" {
 41 | 		s = strings.TrimLeft(s, whitespace)
 42 | 		if s == "" {
 43 | 			break
 44 | 		}
 45 | 		quote := s[0]
 46 | 		if quote != '"' && quote != '\'' {
 47 | 			break
 48 | 		}
 49 | 		s = s[1:]
 50 | 		q := strings.IndexRune(s, rune(quote))
 51 | 		var id string
 52 | 		if q == -1 {
 53 | 			id = s
 54 | 			s = ""
 55 | 		} else {
 56 | 			id = s[:q]
 57 | 			s = s[q+1:]
 58 | 		}
 59 | 		n.Attr = append(n.Attr, Attribute{Key: key, Val: id})
 60 | 		if key == "public" {
 61 | 			key = "system"
 62 | 		} else {
 63 | 			key = ""
 64 | 		}
 65 | 	}
 66 | 
 67 | 	if key != "" || s != "" {
 68 | 		quirks = true
 69 | 	} else if len(n.Attr) > 0 {
 70 | 		if n.Attr[0].Key == "public" {
 71 | 			public := strings.ToLower(n.Attr[0].Val)
 72 | 			switch public {
 73 | 			case "-//w3o//dtd w3 html strict 3.0//en//", "-/w3d/dtd html 4.0 transitional/en", "html":
 74 | 				quirks = true
 75 | 			default:
 76 | 				for _, q := range quirkyIDs {
 77 | 					if strings.HasPrefix(public, q) {
 78 | 						quirks = true
 79 | 						break
 80 | 					}
 81 | 				}
 82 | 			}
 83 | 			// The following two public IDs only cause quirks mode if there is no system ID.
 84 | 			if len(n.Attr) == 1 && (strings.HasPrefix(public, "-//w3c//dtd html 4.01 frameset//") ||
 85 | 				strings.HasPrefix(public, "-//w3c//dtd html 4.01 transitional//")) {
 86 | 				quirks = true
 87 | 			}
 88 | 		}
 89 | 		if lastAttr := n.Attr[len(n.Attr)-1]; lastAttr.Key == "system" &&
 90 | 			strings.ToLower(lastAttr.Val) == "http://www.ibm.com/data/dtd/v11/ibmxhtml1-transitional.dtd" {
 91 | 			quirks = true
 92 | 		}
 93 | 	}
 94 | 
 95 | 	return n, quirks
 96 | }
 97 | 
 98 | // quirkyIDs is a list of public doctype identifiers that cause a document
 99 | // to be interpreted in quirks mode. The identifiers should be in lower case.
100 | var quirkyIDs = []string{
101 | 	"+//silmaril//dtd html pro v0r11 19970101//",
102 | 	"-//advasoft ltd//dtd html 3.0 aswedit + extensions//",
103 | 	"-//as//dtd html 3.0 aswedit + extensions//",
104 | 	"-//ietf//dtd html 2.0 level 1//",
105 | 	"-//ietf//dtd html 2.0 level 2//",
106 | 	"-//ietf//dtd html 2.0 strict level 1//",
107 | 	"-//ietf//dtd html 2.0 strict level 2//",
108 | 	"-//ietf//dtd html 2.0 strict//",
109 | 	"-//ietf//dtd html 2.0//",
110 | 	"-//ietf//dtd html 2.1e//",
111 | 	"-//ietf//dtd html 3.0//",
112 | 	"-//ietf//dtd html 3.2 final//",
113 | 	"-//ietf//dtd html 3.2//",
114 | 	"-//ietf//dtd html 3//",
115 | 	"-//ietf//dtd html level 0//",
116 | 	"-//ietf//dtd html level 1//",
117 | 	"-//ietf//dtd html level 2//",
118 | 	"-//ietf//dtd html level 3//",
119 | 	"-//ietf//dtd html strict level 0//",
120 | 	"-//ietf//dtd html strict level 1//",
121 | 	"-//ietf//dtd html strict level 2//",
122 | 	"-//ietf//dtd html strict level 3//",
123 | 	"-//ietf//dtd html strict//",
124 | 	"-//ietf//dtd html//",
125 | 	"-//metrius//dtd metrius presentational//",
126 | 	"-//microsoft//dtd internet explorer 2.0 html strict//",
127 | 	"-//microsoft//dtd internet explorer 2.0 html//",
128 | 	"-//microsoft//dtd internet explorer 2.0 tables//",
129 | 	"-//microsoft//dtd internet explorer 3.0 html strict//",
130 | 	"-//microsoft//dtd internet explorer 3.0 html//",
131 | 	"-//microsoft//dtd internet explorer 3.0 tables//",
132 | 	"-//netscape comm. corp.//dtd html//",
133 | 	"-//netscape comm. corp.//dtd strict html//",
134 | 	"-//o'reilly and associates//dtd html 2.0//",
135 | 	"-//o'reilly and associates//dtd html extended 1.0//",
136 | 	"-//o'reilly and associates//dtd html extended relaxed 1.0//",
137 | 	"-//softquad software//dtd hotmetal pro 6.0::19990601::extensions to html 4.0//",
138 | 	"-//softquad//dtd hotmetal pro 4.0::19971010::extensions to html 4.0//",
139 | 	"-//spyglass//dtd html 2.0 extended//",
140 | 	"-//sq//dtd html 2.0 hotmetal + extensions//",
141 | 	"-//sun microsystems corp.//dtd hotjava html//",
142 | 	"-//sun microsystems corp.//dtd hotjava strict html//",
143 | 	"-//w3c//dtd html 3 1995-03-24//",
144 | 	"-//w3c//dtd html 3.2 draft//",
145 | 	"-//w3c//dtd html 3.2 final//",
146 | 	"-//w3c//dtd html 3.2//",
147 | 	"-//w3c//dtd html 3.2s draft//",
148 | 	"-//w3c//dtd html 4.0 frameset//",
149 | 	"-//w3c//dtd html 4.0 transitional//",
150 | 	"-//w3c//dtd html experimental 19960712//",
151 | 	"-//w3c//dtd html experimental 970421//",
152 | 	"-//w3c//dtd w3 html//",
153 | 	"-//w3o//dtd w3 html 3.0//",
154 | 	"-//webtechs//dtd mozilla html 2.0//",
155 | 	"-//webtechs//dtd mozilla html//",
156 | }
157 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/node.go:
--------------------------------------------------------------------------------
  1 | // Copyright 2011 The Go Authors. All rights reserved.
  2 | // Use of this source code is governed by a BSD-style
  3 | // license that can be found in the LICENSE file.
  4 | 
  5 | package html
  6 | 
  7 | import (
  8 | 	"golang.org/x/net/html/atom"
  9 | )
 10 | 
 11 | // A NodeType is the type of a Node.
 12 | type NodeType uint32
 13 | 
 14 | const (
 15 | 	ErrorNode NodeType = iota
 16 | 	TextNode
 17 | 	DocumentNode
 18 | 	ElementNode
 19 | 	CommentNode
 20 | 	DoctypeNode
 21 | 	scopeMarkerNode
 22 | )
 23 | 
 24 | // Section 12.2.3.3 says "scope markers are inserted when entering applet
 25 | // elements, buttons, object elements, marquees, table cells, and table
 26 | // captions, and are used to prevent formatting from 'leaking'".
 27 | var scopeMarker = Node{Type: scopeMarkerNode}
 28 | 
 29 | // A Node consists of a NodeType and some Data (tag name for element nodes,
 30 | // content for text) and are part of a tree of Nodes. Element nodes may also
 31 | // have a Namespace and contain a slice of Attributes. Data is unescaped, so
 32 | // that it looks like "a<b" rather than "a&lt;b". For element nodes, DataAtom
 33 | // is the atom for Data, or zero if Data is not a known tag name.
 34 | //
 35 | // An empty Namespace implies a "http://www.w3.org/1999/xhtml" namespace.
 36 | // Similarly, "math" is short for "http://www.w3.org/1998/Math/MathML", and
 37 | // "svg" is short for "http://www.w3.org/2000/svg".
 38 | type Node struct {
 39 | 	Parent, FirstChild, LastChild, PrevSibling, NextSibling *Node
 40 | 
 41 | 	Type      NodeType
 42 | 	DataAtom  atom.Atom
 43 | 	Data      string
 44 | 	Namespace string
 45 | 	Attr      []Attribute
 46 | }
 47 | 
 48 | // InsertBefore inserts newChild as a child of n, immediately before oldChild
 49 | // in the sequence of n's children. oldChild may be nil, in which case newChild
 50 | // is appended to the end of n's children.
 51 | //
 52 | // It will panic if newChild already has a parent or siblings.
 53 | func (n *Node) InsertBefore(newChild, oldChild *Node) {
 54 | 	if newChild.Parent != nil || newChild.PrevSibling != nil || newChild.NextSibling != nil {
 55 | 		panic("html: InsertBefore called for an attached child Node")
 56 | 	}
 57 | 	var prev, next *Node
 58 | 	if oldChild != nil {
 59 | 		prev, next = oldChild.PrevSibling, oldChild
 60 | 	} else {
 61 | 		prev = n.LastChild
 62 | 	}
 63 | 	if prev != nil {
 64 | 		prev.NextSibling = newChild
 65 | 	} else {
 66 | 		n.FirstChild = newChild
 67 | 	}
 68 | 	if next != nil {
 69 | 		next.PrevSibling = newChild
 70 | 	} else {
 71 | 		n.LastChild = newChild
 72 | 	}
 73 | 	newChild.Parent = n
 74 | 	newChild.PrevSibling = prev
 75 | 	newChild.NextSibling = next
 76 | }
 77 | 
 78 | // AppendChild adds a node c as a child of n.
 79 | //
 80 | // It will panic if c already has a parent or siblings.
 81 | func (n *Node) AppendChild(c *Node) {
 82 | 	if c.Parent != nil || c.PrevSibling != nil || c.NextSibling != nil {
 83 | 		panic("html: AppendChild called for an attached child Node")
 84 | 	}
 85 | 	last := n.LastChild
 86 | 	if last != nil {
 87 | 		last.NextSibling = c
 88 | 	} else {
 89 | 		n.FirstChild = c
 90 | 	}
 91 | 	n.LastChild = c
 92 | 	c.Parent = n
 93 | 	c.PrevSibling = last
 94 | }
 95 | 
 96 | // RemoveChild removes a node c that is a child of n. Afterwards, c will have
 97 | // no parent and no siblings.
 98 | //
 99 | // It will panic if c's parent is not n.
100 | func (n *Node) RemoveChild(c *Node) {
101 | 	if c.Parent != n {
102 | 		panic("html: RemoveChild called for a non-child Node")
103 | 	}
104 | 	if n.FirstChild == c {
105 | 		n.FirstChild = c.NextSibling
106 | 	}
107 | 	if c.NextSibling != nil {
108 | 		c.NextSibling.PrevSibling = c.PrevSibling
109 | 	}
110 | 	if n.LastChild == c {
111 | 		n.LastChild = c.PrevSibling
112 | 	}
113 | 	if c.PrevSibling != nil {
114 | 		c.PrevSibling.NextSibling = c.NextSibling
115 | 	}
116 | 	c.Parent = nil
117 | 	c.PrevSibling = nil
118 | 	c.NextSibling = nil
119 | }
120 | 
121 | // reparentChildren reparents all of src's child nodes to dst.
122 | func reparentChildren(dst, src *Node) {
123 | 	for {
124 | 		child := src.FirstChild
125 | 		if child == nil {
126 | 			break
127 | 		}
128 | 		src.RemoveChild(child)
129 | 		dst.AppendChild(child)
130 | 	}
131 | }
132 | 
133 | // clone returns a new node with the same type, data and attributes.
134 | // The clone has no parent, no siblings and no children.
135 | func (n *Node) clone() *Node {
136 | 	m := &Node{
137 | 		Type:     n.Type,
138 | 		DataAtom: n.DataAtom,
139 | 		Data:     n.Data,
140 | 		Attr:     make([]Attribute, len(n.Attr)),
141 | 	}
142 | 	copy(m.Attr, n.Attr)
143 | 	return m
144 | }
145 | 
146 | // nodeStack is a stack of nodes.
147 | type nodeStack []*Node
148 | 
149 | // pop pops the stack. It will panic if s is empty.
150 | func (s *nodeStack) pop() *Node {
151 | 	i := len(*s)
152 | 	n := (*s)[i-1]
153 | 	*s = (*s)[:i-1]
154 | 	return n
155 | }
156 | 
157 | // top returns the most recently pushed node, or nil if s is empty.
158 | func (s *nodeStack) top() *Node {
159 | 	if i := len(*s); i > 0 {
160 | 		return (*s)[i-1]
161 | 	}
162 | 	return nil
163 | }
164 | 
165 | // index returns the index of the top-most occurrence of n in the stack, or -1
166 | // if n is not present.
167 | func (s *nodeStack) index(n *Node) int {
168 | 	for i := len(*s) - 1; i >= 0; i-- {
169 | 		if (*s)[i] == n {
170 | 			return i
171 | 		}
172 | 	}
173 | 	return -1
174 | }
175 | 
176 | // insert inserts a node at the given index.
177 | func (s *nodeStack) insert(i int, n *Node) {
178 | 	(*s) = append(*s, nil)
179 | 	copy((*s)[i+1:], (*s)[i:])
180 | 	(*s)[i] = n
181 | }
182 | 
183 | // remove removes a node from the stack. It is a no-op if n is not present.
184 | func (s *nodeStack) remove(n *Node) {
185 | 	i := s.index(n)
186 | 	if i == -1 {
187 | 		return
188 | 	}
189 | 	copy((*s)[i:], (*s)[i+1:])
190 | 	j := len(*s) - 1
191 | 	(*s)[j] = nil
192 | 	*s = (*s)[:j]
193 | }
194 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/testdata/webkit/scriptdata01.dat:
--------------------------------------------------------------------------------
  1 | #data
  2 | FOO<script>'Hello'</script>BAR
  3 | #errors
  4 | #document
  5 | | <html>
  6 | |   <head>
  7 | |   <body>
  8 | |     "FOO"
  9 | |     <script>
 10 | |       "'Hello'"
 11 | |     "BAR"
 12 | 
 13 | #data
 14 | FOO<script></script>BAR
 15 | #errors
 16 | #document
 17 | | <html>
 18 | |   <head>
 19 | |   <body>
 20 | |     "FOO"
 21 | |     <script>
 22 | |     "BAR"
 23 | 
 24 | #data
 25 | FOO<script></script >BAR
 26 | #errors
 27 | #document
 28 | | <html>
 29 | |   <head>
 30 | |   <body>
 31 | |     "FOO"
 32 | |     <script>
 33 | |     "BAR"
 34 | 
 35 | #data
 36 | FOO<script></script/>BAR
 37 | #errors
 38 | #document
 39 | | <html>
 40 | |   <head>
 41 | |   <body>
 42 | |     "FOO"
 43 | |     <script>
 44 | |     "BAR"
 45 | 
 46 | #data
 47 | FOO<script></script/ >BAR
 48 | #errors
 49 | #document
 50 | | <html>
 51 | |   <head>
 52 | |   <body>
 53 | |     "FOO"
 54 | |     <script>
 55 | |     "BAR"
 56 | 
 57 | #data
 58 | FOO<script type="text/plain"></scriptx>BAR
 59 | #errors
 60 | #document
 61 | | <html>
 62 | |   <head>
 63 | |   <body>
 64 | |     "FOO"
 65 | |     <script>
 66 | |       type="text/plain"
 67 | |       "</scriptx>BAR"
 68 | 
 69 | #data
 70 | FOO<script></script foo=">" dd>BAR
 71 | #errors
 72 | #document
 73 | | <html>
 74 | |   <head>
 75 | |   <body>
 76 | |     "FOO"
 77 | |     <script>
 78 | |     "BAR"
 79 | 
 80 | #data
 81 | FOO<script>'<'</script>BAR
 82 | #errors
 83 | #document
 84 | | <html>
 85 | |   <head>
 86 | |   <body>
 87 | |     "FOO"
 88 | |     <script>
 89 | |       "'<'"
 90 | |     "BAR"
 91 | 
 92 | #data
 93 | FOO<script>'<!'</script>BAR
 94 | #errors
 95 | #document
 96 | | <html>
 97 | |   <head>
 98 | |   <body>
 99 | |     "FOO"
100 | |     <script>
101 | |       "'<!'"
102 | |     "BAR"
103 | 
104 | #data
105 | FOO<script>'<!-'</script>BAR
106 | #errors
107 | #document
108 | | <html>
109 | |   <head>
110 | |   <body>
111 | |     "FOO"
112 | |     <script>
113 | |       "'<!-'"
114 | |     "BAR"
115 | 
116 | #data
117 | FOO<script>'<!--'</script>BAR
118 | #errors
119 | #document
120 | | <html>
121 | |   <head>
122 | |   <body>
123 | |     "FOO"
124 | |     <script>
125 | |       "'<!--'"
126 | |     "BAR"
127 | 
128 | #data
129 | FOO<script>'<!---'</script>BAR
130 | #errors
131 | #document
132 | | <html>
133 | |   <head>
134 | |   <body>
135 | |     "FOO"
136 | |     <script>
137 | |       "'<!---'"
138 | |     "BAR"
139 | 
140 | #data
141 | FOO<script>'<!-->'</script>BAR
142 | #errors
143 | #document
144 | | <html>
145 | |   <head>
146 | |   <body>
147 | |     "FOO"
148 | |     <script>
149 | |       "'<!-->'"
150 | |     "BAR"
151 | 
152 | #data
153 | FOO<script>'<!-->'</script>BAR
154 | #errors
155 | #document
156 | | <html>
157 | |   <head>
158 | |   <body>
159 | |     "FOO"
160 | |     <script>
161 | |       "'<!-->'"
162 | |     "BAR"
163 | 
164 | #data
165 | FOO<script>'<!-- potato'</script>BAR
166 | #errors
167 | #document
168 | | <html>
169 | |   <head>
170 | |   <body>
171 | |     "FOO"
172 | |     <script>
173 | |       "'<!-- potato'"
174 | |     "BAR"
175 | 
176 | #data
177 | FOO<script>'<!-- <sCrIpt'</script>BAR
178 | #errors
179 | #document
180 | | <html>
181 | |   <head>
182 | |   <body>
183 | |     "FOO"
184 | |     <script>
185 | |       "'<!-- <sCrIpt'"
186 | |     "BAR"
187 | 
188 | #data
189 | FOO<script type="text/plain">'<!-- <sCrIpt>'</script>BAR
190 | #errors
191 | #document
192 | | <html>
193 | |   <head>
194 | |   <body>
195 | |     "FOO"
196 | |     <script>
197 | |       type="text/plain"
198 | |       "'<!-- <sCrIpt>'</script>BAR"
199 | 
200 | #data
201 | FOO<script type="text/plain">'<!-- <sCrIpt> -'</script>BAR
202 | #errors
203 | #document
204 | | <html>
205 | |   <head>
206 | |   <body>
207 | |     "FOO"
208 | |     <script>
209 | |       type="text/plain"
210 | |       "'<!-- <sCrIpt> -'</script>BAR"
211 | 
212 | #data
213 | FOO<script type="text/plain">'<!-- <sCrIpt> --'</script>BAR
214 | #errors
215 | #document
216 | | <html>
217 | |   <head>
218 | |   <body>
219 | |     "FOO"
220 | |     <script>
221 | |       type="text/plain"
222 | |       "'<!-- <sCrIpt> --'</script>BAR"
223 | 
224 | #data
225 | FOO<script>'<!-- <sCrIpt> -->'</script>BAR
226 | #errors
227 | #document
228 | | <html>
229 | |   <head>
230 | |   <body>
231 | |     "FOO"
232 | |     <script>
233 | |       "'<!-- <sCrIpt> -->'"
234 | |     "BAR"
235 | 
236 | #data
237 | FOO<script type="text/plain">'<!-- <sCrIpt> --!>'</script>BAR
238 | #errors
239 | #document
240 | | <html>
241 | |   <head>
242 | |   <body>
243 | |     "FOO"
244 | |     <script>
245 | |       type="text/plain"
246 | |       "'<!-- <sCrIpt> --!>'</script>BAR"
247 | 
248 | #data
249 | FOO<script type="text/plain">'<!-- <sCrIpt> -- >'</script>BAR
250 | #errors
251 | #document
252 | | <html>
253 | |   <head>
254 | |   <body>
255 | |     "FOO"
256 | |     <script>
257 | |       type="text/plain"
258 | |       "'<!-- <sCrIpt> -- >'</script>BAR"
259 | 
260 | #data
261 | FOO<script type="text/plain">'<!-- <sCrIpt '</script>BAR
262 | #errors
263 | #document
264 | | <html>
265 | |   <head>
266 | |   <body>
267 | |     "FOO"
268 | |     <script>
269 | |       type="text/plain"
270 | |       "'<!-- <sCrIpt '</script>BAR"
271 | 
272 | #data
273 | FOO<script type="text/plain">'<!-- <sCrIpt/'</script>BAR
274 | #errors
275 | #document
276 | | <html>
277 | |   <head>
278 | |   <body>
279 | |     "FOO"
280 | |     <script>
281 | |       type="text/plain"
282 | |       "'<!-- <sCrIpt/'</script>BAR"
283 | 
284 | #data
285 | FOO<script type="text/plain">'<!-- <sCrIpt\'</script>BAR
286 | #errors
287 | #document
288 | | <html>
289 | |   <head>
290 | |   <body>
291 | |     "FOO"
292 | |     <script>
293 | |       type="text/plain"
294 | |       "'<!-- <sCrIpt\'"
295 | |     "BAR"
296 | 
297 | #data
298 | FOO<script type="text/plain">'<!-- <sCrIpt/'</script>BAR</script>QUX
299 | #errors
300 | #document
301 | | <html>
302 | |   <head>
303 | |   <body>
304 | |     "FOO"
305 | |     <script>
306 | |       type="text/plain"
307 | |       "'<!-- <sCrIpt/'</script>BAR"
308 | |     "QUX"
309 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/atom/table_test.go:
--------------------------------------------------------------------------------
  1 | // generated by go run gen.go -test; DO NOT EDIT
  2 | 
  3 | package atom
  4 | 
  5 | var testAtomList = []string{
  6 | 	"a",
  7 | 	"abbr",
  8 | 	"abbr",
  9 | 	"accept",
 10 | 	"accept-charset",
 11 | 	"accesskey",
 12 | 	"action",
 13 | 	"address",
 14 | 	"align",
 15 | 	"alt",
 16 | 	"annotation",
 17 | 	"annotation-xml",
 18 | 	"applet",
 19 | 	"area",
 20 | 	"article",
 21 | 	"aside",
 22 | 	"async",
 23 | 	"audio",
 24 | 	"autocomplete",
 25 | 	"autofocus",
 26 | 	"autoplay",
 27 | 	"b",
 28 | 	"base",
 29 | 	"basefont",
 30 | 	"bdi",
 31 | 	"bdo",
 32 | 	"bgsound",
 33 | 	"big",
 34 | 	"blink",
 35 | 	"blockquote",
 36 | 	"body",
 37 | 	"br",
 38 | 	"button",
 39 | 	"canvas",
 40 | 	"caption",
 41 | 	"center",
 42 | 	"challenge",
 43 | 	"charset",
 44 | 	"checked",
 45 | 	"cite",
 46 | 	"cite",
 47 | 	"class",
 48 | 	"code",
 49 | 	"col",
 50 | 	"colgroup",
 51 | 	"color",
 52 | 	"cols",
 53 | 	"colspan",
 54 | 	"command",
 55 | 	"command",
 56 | 	"content",
 57 | 	"contenteditable",
 58 | 	"contextmenu",
 59 | 	"controls",
 60 | 	"coords",
 61 | 	"crossorigin",
 62 | 	"data",
 63 | 	"data",
 64 | 	"datalist",
 65 | 	"datetime",
 66 | 	"dd",
 67 | 	"default",
 68 | 	"defer",
 69 | 	"del",
 70 | 	"desc",
 71 | 	"details",
 72 | 	"dfn",
 73 | 	"dialog",
 74 | 	"dir",
 75 | 	"dirname",
 76 | 	"disabled",
 77 | 	"div",
 78 | 	"dl",
 79 | 	"download",
 80 | 	"draggable",
 81 | 	"dropzone",
 82 | 	"dt",
 83 | 	"em",
 84 | 	"embed",
 85 | 	"enctype",
 86 | 	"face",
 87 | 	"fieldset",
 88 | 	"figcaption",
 89 | 	"figure",
 90 | 	"font",
 91 | 	"footer",
 92 | 	"for",
 93 | 	"foreignObject",
 94 | 	"foreignobject",
 95 | 	"form",
 96 | 	"form",
 97 | 	"formaction",
 98 | 	"formenctype",
 99 | 	"formmethod",
100 | 	"formnovalidate",
101 | 	"formtarget",
102 | 	"frame",
103 | 	"frameset",
104 | 	"h1",
105 | 	"h2",
106 | 	"h3",
107 | 	"h4",
108 | 	"h5",
109 | 	"h6",
110 | 	"head",
111 | 	"header",
112 | 	"headers",
113 | 	"height",
114 | 	"hgroup",
115 | 	"hidden",
116 | 	"high",
117 | 	"hr",
118 | 	"href",
119 | 	"hreflang",
120 | 	"html",
121 | 	"http-equiv",
122 | 	"i",
123 | 	"icon",
124 | 	"id",
125 | 	"iframe",
126 | 	"image",
127 | 	"img",
128 | 	"input",
129 | 	"inputmode",
130 | 	"ins",
131 | 	"isindex",
132 | 	"ismap",
133 | 	"itemid",
134 | 	"itemprop",
135 | 	"itemref",
136 | 	"itemscope",
137 | 	"itemtype",
138 | 	"kbd",
139 | 	"keygen",
140 | 	"keytype",
141 | 	"kind",
142 | 	"label",
143 | 	"label",
144 | 	"lang",
145 | 	"legend",
146 | 	"li",
147 | 	"link",
148 | 	"list",
149 | 	"listing",
150 | 	"loop",
151 | 	"low",
152 | 	"malignmark",
153 | 	"manifest",
154 | 	"map",
155 | 	"mark",
156 | 	"marquee",
157 | 	"math",
158 | 	"max",
159 | 	"maxlength",
160 | 	"media",
161 | 	"mediagroup",
162 | 	"menu",
163 | 	"menuitem",
164 | 	"meta",
165 | 	"meter",
166 | 	"method",
167 | 	"mglyph",
168 | 	"mi",
169 | 	"min",
170 | 	"minlength",
171 | 	"mn",
172 | 	"mo",
173 | 	"ms",
174 | 	"mtext",
175 | 	"multiple",
176 | 	"muted",
177 | 	"name",
178 | 	"nav",
179 | 	"nobr",
180 | 	"noembed",
181 | 	"noframes",
182 | 	"noscript",
183 | 	"novalidate",
184 | 	"object",
185 | 	"ol",
186 | 	"onabort",
187 | 	"onafterprint",
188 | 	"onautocomplete",
189 | 	"onautocompleteerror",
190 | 	"onbeforeprint",
191 | 	"onbeforeunload",
192 | 	"onblur",
193 | 	"oncancel",
194 | 	"oncanplay",
195 | 	"oncanplaythrough",
196 | 	"onchange",
197 | 	"onclick",
198 | 	"onclose",
199 | 	"oncontextmenu",
200 | 	"oncuechange",
201 | 	"ondblclick",
202 | 	"ondrag",
203 | 	"ondragend",
204 | 	"ondragenter",
205 | 	"ondragleave",
206 | 	"ondragover",
207 | 	"ondragstart",
208 | 	"ondrop",
209 | 	"ondurationchange",
210 | 	"onemptied",
211 | 	"onended",
212 | 	"onerror",
213 | 	"onfocus",
214 | 	"onhashchange",
215 | 	"oninput",
216 | 	"oninvalid",
217 | 	"onkeydown",
218 | 	"onkeypress",
219 | 	"onkeyup",
220 | 	"onlanguagechange",
221 | 	"onload",
222 | 	"onloadeddata",
223 | 	"onloadedmetadata",
224 | 	"onloadstart",
225 | 	"onmessage",
226 | 	"onmousedown",
227 | 	"onmousemove",
228 | 	"onmouseout",
229 | 	"onmouseover",
230 | 	"onmouseup",
231 | 	"onmousewheel",
232 | 	"onoffline",
233 | 	"ononline",
234 | 	"onpagehide",
235 | 	"onpageshow",
236 | 	"onpause",
237 | 	"onplay",
238 | 	"onplaying",
239 | 	"onpopstate",
240 | 	"onprogress",
241 | 	"onratechange",
242 | 	"onreset",
243 | 	"onresize",
244 | 	"onscroll",
245 | 	"onseeked",
246 | 	"onseeking",
247 | 	"onselect",
248 | 	"onshow",
249 | 	"onsort",
250 | 	"onstalled",
251 | 	"onstorage",
252 | 	"onsubmit",
253 | 	"onsuspend",
254 | 	"ontimeupdate",
255 | 	"ontoggle",
256 | 	"onunload",
257 | 	"onvolumechange",
258 | 	"onwaiting",
259 | 	"open",
260 | 	"optgroup",
261 | 	"optimum",
262 | 	"option",
263 | 	"output",
264 | 	"p",
265 | 	"param",
266 | 	"pattern",
267 | 	"ping",
268 | 	"placeholder",
269 | 	"plaintext",
270 | 	"poster",
271 | 	"pre",
272 | 	"preload",
273 | 	"progress",
274 | 	"prompt",
275 | 	"public",
276 | 	"q",
277 | 	"radiogroup",
278 | 	"readonly",
279 | 	"rel",
280 | 	"required",
281 | 	"reversed",
282 | 	"rows",
283 | 	"rowspan",
284 | 	"rp",
285 | 	"rt",
286 | 	"ruby",
287 | 	"s",
288 | 	"samp",
289 | 	"sandbox",
290 | 	"scope",
291 | 	"scoped",
292 | 	"script",
293 | 	"seamless",
294 | 	"section",
295 | 	"select",
296 | 	"selected",
297 | 	"shape",
298 | 	"size",
299 | 	"sizes",
300 | 	"small",
301 | 	"sortable",
302 | 	"sorted",
303 | 	"source",
304 | 	"spacer",
305 | 	"span",
306 | 	"span",
307 | 	"spellcheck",
308 | 	"src",
309 | 	"srcdoc",
310 | 	"srclang",
311 | 	"start",
312 | 	"step",
313 | 	"strike",
314 | 	"strong",
315 | 	"style",
316 | 	"style",
317 | 	"sub",
318 | 	"summary",
319 | 	"sup",
320 | 	"svg",
321 | 	"system",
322 | 	"tabindex",
323 | 	"table",
324 | 	"target",
325 | 	"tbody",
326 | 	"td",
327 | 	"template",
328 | 	"textarea",
329 | 	"tfoot",
330 | 	"th",
331 | 	"thead",
332 | 	"time",
333 | 	"title",
334 | 	"title",
335 | 	"tr",
336 | 	"track",
337 | 	"translate",
338 | 	"tt",
339 | 	"type",
340 | 	"typemustmatch",
341 | 	"u",
342 | 	"ul",
343 | 	"usemap",
344 | 	"value",
345 | 	"var",
346 | 	"video",
347 | 	"wbr",
348 | 	"width",
349 | 	"wrap",
350 | 	"xmp",
351 | }
352 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/testdata/webkit/plain-text-unsafe.dat:
--------------------------------------------------------------------------------
  1 | #data
  2 | FOO&#x000D;ZOO
  3 | #errors
  4 | #document
  5 | | <html>
  6 | |   <head>
  7 | |   <body>
  8 | |     "FOOZOO"
  9 | 
 10 | #data
 11 | <html> <frameset></frameset>
 12 | #errors
 13 | #document
 14 | | <html>
 15 | |   <head>
 16 | |   <frameset>
 17 | 
 18 | #data
 19 | <html>   <frameset></frameset>
 20 | #errors
 21 | #document
 22 | | <html>
 23 | |   <head>
 24 | |   <frameset>
 25 | 
 26 | #data
 27 | <html>a a<frameset></frameset>
 28 | #errors
 29 | #document
 30 | | <html>
 31 | |   <head>
 32 | |   <body>
 33 | |     "aa"
 34 | 
 35 | #data
 36 | <html>  <frameset></frameset>
 37 | #errors
 38 | #document
 39 | | <html>
 40 | |   <head>
 41 | |   <frameset>
 42 | 
 43 | #data
 44 | <html> 
 45 |  <frameset></frameset>
 46 | #errors
 47 | #document
 48 | | <html>
 49 | |   <head>
 50 | |   <frameset>
 51 | 
 52 | #data
 53 | <html><select> 
 54 | #errors
 55 | #document
 56 | | <html>
 57 | |   <head>
 58 | |   <body>
 59 | |     <select>
 60 | 
 61 | #data
 62 |  
 63 | #errors
 64 | #document
 65 | | <html>
 66 | |   <head>
 67 | |   <body>
 68 | 
 69 | #data
 70 | <body> 
 71 | #errors
 72 | #document
 73 | | <html>
 74 | |   <head>
 75 | |   <body>
 76 | 
 77 | #data
 78 | <plaintext> filler text 
 79 | #errors
 80 | #document
 81 | | <html>
 82 | |   <head>
 83 | |   <body>
 84 | |     <plaintext>
 85 | |       "�filler�text�"
 86 | 
 87 | #data
 88 | <svg><![CDATA[ filler text ]]>
 89 | #errors
 90 | #document
 91 | | <html>
 92 | |   <head>
 93 | |   <body>
 94 | |     <svg svg>
 95 | |       "�filler�text�"
 96 | 
 97 | #data
 98 | <body><! >
 99 | #errors
100 | #document
101 | | <html>
102 | |   <head>
103 | |   <body>
104 | |     <!-- � -->
105 | 
106 | #data
107 | <body><! filler text>
108 | #errors
109 | #document
110 | | <html>
111 | |   <head>
112 | |   <body>
113 | |     <!-- �filler�text -->
114 | 
115 | #data
116 | <body><svg><foreignObject> filler text
117 | #errors
118 | #document
119 | | <html>
120 | |   <head>
121 | |   <body>
122 | |     <svg svg>
123 | |       <svg foreignObject>
124 | |         "fillertext"
125 | 
126 | #data
127 | <svg> filler text
128 | #errors
129 | #document
130 | | <html>
131 | |   <head>
132 | |   <body>
133 | |     <svg svg>
134 | |       "�filler�text"
135 | 
136 | #data
137 | <svg> <frameset>
138 | #errors
139 | #document
140 | | <html>
141 | |   <head>
142 | |   <body>
143 | |     <svg svg>
144 | |       "�"
145 | |       <svg frameset>
146 | 
147 | #data
148 | <svg>  <frameset>
149 | #errors
150 | #document
151 | | <html>
152 | |   <head>
153 | |   <body>
154 | |     <svg svg>
155 | |       "� "
156 | |       <svg frameset>
157 | 
158 | #data
159 | <svg> a<frameset>
160 | #errors
161 | #document
162 | | <html>
163 | |   <head>
164 | |   <body>
165 | |     <svg svg>
166 | |       "�a"
167 | |       <svg frameset>
168 | 
169 | #data
170 | <svg> </svg><frameset>
171 | #errors
172 | #document
173 | | <html>
174 | |   <head>
175 | |   <frameset>
176 | 
177 | #data
178 | <svg>  </svg><frameset>
179 | #errors
180 | #document
181 | | <html>
182 | |   <head>
183 | |   <frameset>
184 | 
185 | #data
186 | <svg> a</svg><frameset>
187 | #errors
188 | #document
189 | | <html>
190 | |   <head>
191 | |   <body>
192 | |     <svg svg>
193 | |       "�a"
194 | 
195 | #data
196 | <svg><path></path></svg><frameset>
197 | #errors
198 | #document
199 | | <html>
200 | |   <head>
201 | |   <frameset>
202 | 
203 | #data
204 | <svg><p><frameset>
205 | #errors
206 | #document
207 | | <html>
208 | |   <head>
209 | |   <frameset>
210 | 
211 | #data
212 | <!DOCTYPE html><pre>
213 | 
214 | A</pre>
215 | #errors
216 | #document
217 | | <!DOCTYPE html>
218 | | <html>
219 | |   <head>
220 | |   <body>
221 | |     <pre>
222 | |       "
223 | A"
224 | 
225 | #data
226 | <!DOCTYPE html><pre>A</pre>
227 | #errors
228 | #document
229 | | <!DOCTYPE html>
230 | | <html>
231 | |   <head>
232 | |   <body>
233 | |     <pre>
234 | |       "
235 | A"
236 | 
237 | #data
238 | <!DOCTYPE html><pre>A</pre>
239 | #errors
240 | #document
241 | | <!DOCTYPE html>
242 | | <html>
243 | |   <head>
244 | |   <body>
245 | |     <pre>
246 | |       "A"
247 | 
248 | #data
249 | <!DOCTYPE html><table><tr><td><math><mtext> a
250 | #errors
251 | 44: Saw U+0000 in stream.
252 | 45: End of file in a foreign namespace context.
253 | #document
254 | | <!DOCTYPE html>
255 | | <html>
256 | |   <head>
257 | |   <body>
258 | |     <table>
259 | |       <tbody>
260 | |         <tr>
261 | |           <td>
262 | |             <math math>
263 | |               <math mtext>
264 | |                 "a"
265 | 
266 | #data
267 | <!DOCTYPE html><table><tr><td><svg><foreignObject> a
268 | #errors
269 | 44: Saw U+0000 in stream.
270 | 45: End of file in a foreign namespace context.
271 | #document
272 | | <!DOCTYPE html>
273 | | <html>
274 | |   <head>
275 | |   <body>
276 | |     <table>
277 | |       <tbody>
278 | |         <tr>
279 | |           <td>
280 | |             <svg svg>
281 | |               <svg foreignObject>
282 | |                 "a"
283 | 
284 | #data
285 | <!DOCTYPE html><math><mi>a b
286 | #errors
287 | #document
288 | | <!DOCTYPE html>
289 | | <html>
290 | |   <head>
291 | |   <body>
292 | |     <math math>
293 | |       <math mi>
294 | |         "ab"
295 | 
296 | #data
297 | <!DOCTYPE html><math><mo>a b
298 | #errors
299 | #document
300 | | <!DOCTYPE html>
301 | | <html>
302 | |   <head>
303 | |   <body>
304 | |     <math math>
305 | |       <math mo>
306 | |         "ab"
307 | 
308 | #data
309 | <!DOCTYPE html><math><mn>a b
310 | #errors
311 | #document
312 | | <!DOCTYPE html>
313 | | <html>
314 | |   <head>
315 | |   <body>
316 | |     <math math>
317 | |       <math mn>
318 | |         "ab"
319 | 
320 | #data
321 | <!DOCTYPE html><math><ms>a b
322 | #errors
323 | #document
324 | | <!DOCTYPE html>
325 | | <html>
326 | |   <head>
327 | |   <body>
328 | |     <math math>
329 | |       <math ms>
330 | |         "ab"
331 | 
332 | #data
333 | <!DOCTYPE html><math><mtext>a b
334 | #errors
335 | #document
336 | | <!DOCTYPE html>
337 | | <html>
338 | |   <head>
339 | |   <body>
340 | |     <math math>
341 | |       <math mtext>
342 | |         "ab"
343 | 


--------------------------------------------------------------------------------
/vendor/github.com/mb0/diff/diff_test.go:
--------------------------------------------------------------------------------
  1 | // Copyright 2012 Martin Schnabel. 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 diff_test
  6 | 
  7 | import (
  8 | 	"github.com/mb0/diff"
  9 | 	"testing"
 10 | )
 11 | 
 12 | type testcase struct {
 13 | 	name string
 14 | 	a, b []int
 15 | 	res  []diff.Change
 16 | }
 17 | 
 18 | var tests = []testcase{
 19 | 	{"shift",
 20 | 		[]int{1, 2, 3},
 21 | 		[]int{0, 1, 2, 3},
 22 | 		[]diff.Change{{0, 0, 0, 1}},
 23 | 	},
 24 | 	{"push",
 25 | 		[]int{1, 2, 3},
 26 | 		[]int{1, 2, 3, 4},
 27 | 		[]diff.Change{{3, 3, 0, 1}},
 28 | 	},
 29 | 	{"unshift",
 30 | 		[]int{0, 1, 2, 3},
 31 | 		[]int{1, 2, 3},
 32 | 		[]diff.Change{{0, 0, 1, 0}},
 33 | 	},
 34 | 	{"pop",
 35 | 		[]int{1, 2, 3, 4},
 36 | 		[]int{1, 2, 3},
 37 | 		[]diff.Change{{3, 3, 1, 0}},
 38 | 	},
 39 | 	{"all changed",
 40 | 		[]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
 41 | 		[]int{10, 11, 12, 13, 14},
 42 | 		[]diff.Change{
 43 | 			{0, 0, 10, 5},
 44 | 		},
 45 | 	},
 46 | 	{"all same",
 47 | 		[]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
 48 | 		[]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
 49 | 		[]diff.Change{},
 50 | 	},
 51 | 	{"wrap",
 52 | 		[]int{1},
 53 | 		[]int{0, 1, 2, 3},
 54 | 		[]diff.Change{
 55 | 			{0, 0, 0, 1},
 56 | 			{1, 2, 0, 2},
 57 | 		},
 58 | 	},
 59 | 	{"snake",
 60 | 		[]int{0, 1, 2, 3, 4, 5},
 61 | 		[]int{1, 2, 3, 4, 5, 6},
 62 | 		[]diff.Change{
 63 | 			{0, 0, 1, 0},
 64 | 			{6, 5, 0, 1},
 65 | 		},
 66 | 	},
 67 | 	// note: input is ambiguous
 68 | 	// first two traces differ from fig.1
 69 | 	// it still is a lcs and ses path
 70 | 	{"paper fig. 1",
 71 | 		[]int{1, 2, 3, 1, 2, 2, 1},
 72 | 		[]int{3, 2, 1, 2, 1, 3},
 73 | 		[]diff.Change{
 74 | 			{0, 0, 1, 1},
 75 | 			{2, 2, 1, 0},
 76 | 			{5, 4, 1, 0},
 77 | 			{7, 5, 0, 1},
 78 | 		},
 79 | 	},
 80 | }
 81 | 
 82 | func TestDiffAB(t *testing.T) {
 83 | 	for _, test := range tests {
 84 | 		res := diff.Ints(test.a, test.b)
 85 | 		if len(res) != len(test.res) {
 86 | 			t.Error(test.name, "expected length", len(test.res), "for", res)
 87 | 			continue
 88 | 		}
 89 | 		for i, c := range test.res {
 90 | 			if c != res[i] {
 91 | 				t.Error(test.name, "expected ", c, "got", res[i])
 92 | 			}
 93 | 		}
 94 | 	}
 95 | }
 96 | 
 97 | func TestDiffBA(t *testing.T) {
 98 | 	// interesting: fig.1 Diff(b, a) results in the same path as `diff -d a b`
 99 | 	tests[len(tests)-1].res = []diff.Change{
100 | 		{0, 0, 2, 0},
101 | 		{3, 1, 1, 0},
102 | 		{5, 2, 0, 1},
103 | 		{7, 5, 0, 1},
104 | 	}
105 | 	for _, test := range tests {
106 | 		res := diff.Ints(test.b, test.a)
107 | 		if len(res) != len(test.res) {
108 | 			t.Error(test.name, "expected length", len(test.res), "for", res)
109 | 			continue
110 | 		}
111 | 		for i, c := range test.res {
112 | 			// flip change data also
113 | 			rc := diff.Change{c.B, c.A, c.Ins, c.Del}
114 | 			if rc != res[i] {
115 | 				t.Error(test.name, "expected ", rc, "got", res[i])
116 | 			}
117 | 		}
118 | 	}
119 | }
120 | 
121 | func diffsEqual(a, b []diff.Change) bool {
122 | 	if len(a) != len(b) {
123 | 		return false
124 | 	}
125 | 	for i := 0; i < len(a); i++ {
126 | 		if a[i] != b[i] {
127 | 			return false
128 | 		}
129 | 	}
130 | 	return true
131 | }
132 | 
133 | func TestGranularStrings(t *testing.T) {
134 | 	a := "abcdefghijklmnopqrstuvwxyza"
135 | 	b := "AbCdeFghiJklmnOpqrstUvwxyzab"
136 | 	// each iteration of i increases granularity and will absorb one more lower-letter-followed-by-upper-letters sequence
137 | 	changesI := [][]diff.Change{
138 | 		{{0, 0, 1, 1}, {2, 2, 1, 1}, {5, 5, 1, 1}, {9, 9, 1, 1}, {14, 14, 1, 1}, {20, 20, 1, 1}, {27, 27, 0, 1}},
139 | 		{{0, 0, 3, 3}, {5, 5, 1, 1}, {9, 9, 1, 1}, {14, 14, 1, 1}, {20, 20, 1, 1}, {27, 27, 0, 1}},
140 | 		{{0, 0, 6, 6}, {9, 9, 1, 1}, {14, 14, 1, 1}, {20, 20, 1, 1}, {27, 27, 0, 1}},
141 | 		{{0, 0, 10, 10}, {14, 14, 1, 1}, {20, 20, 1, 1}, {27, 27, 0, 1}},
142 | 		{{0, 0, 15, 15}, {20, 20, 1, 1}, {27, 27, 0, 1}},
143 | 		{{0, 0, 21, 21}, {27, 27, 0, 1}},
144 | 		{{0, 0, 27, 28}},
145 | 	}
146 | 	for i := 0; i < len(changesI); i++ {
147 | 		diffs := diff.Granular(i, diff.ByteStrings(a, b))
148 | 		if !diffsEqual(diffs, changesI[i]) {
149 | 			t.Errorf("expected %v, got %v", diffs, changesI[i])
150 | 		}
151 | 	}
152 | }
153 | 
154 | func TestDiffRunes(t *testing.T) {
155 | 	a := []rune("brown fox jumps over the lazy dog")
156 | 	b := []rune("brwn faax junps ovver the lay dago")
157 | 	res := diff.Runes(a, b)
158 | 	echange := []diff.Change{
159 | 		{2, 2, 1, 0},
160 | 		{7, 6, 1, 2},
161 | 		{12, 12, 1, 1},
162 | 		{18, 18, 0, 1},
163 | 		{27, 28, 1, 0},
164 | 		{31, 31, 0, 2},
165 | 		{32, 34, 1, 0},
166 | 	}
167 | 	for i, c := range res {
168 | 		t.Log(c)
169 | 		if c != echange[i] {
170 | 			t.Error("expected", echange[i], "got", c)
171 | 		}
172 | 	}
173 | }
174 | 
175 | func TestDiffByteStrings(t *testing.T) {
176 | 	a := "brown fox jumps over the lazy dog"
177 | 	b := "brwn faax junps ovver the lay dago"
178 | 	res := diff.ByteStrings(a, b)
179 | 	echange := []diff.Change{
180 | 		{2, 2, 1, 0},
181 | 		{7, 6, 1, 2},
182 | 		{12, 12, 1, 1},
183 | 		{18, 18, 0, 1},
184 | 		{27, 28, 1, 0},
185 | 		{31, 31, 0, 2},
186 | 		{32, 34, 1, 0},
187 | 	}
188 | 	for i, c := range res {
189 | 		t.Log(c)
190 | 		if c != echange[i] {
191 | 			t.Error("expected", echange[i], "got", c)
192 | 		}
193 | 	}
194 | }
195 | 
196 | type ints struct{ a, b []int }
197 | 
198 | func (d *ints) Equal(i, j int) bool { return d.a[i] == d.b[j] }
199 | func BenchmarkDiff(b *testing.B) {
200 | 	t := tests[len(tests)-1]
201 | 	d := &ints{t.a, t.b}
202 | 	n, m := len(d.a), len(d.b)
203 | 	for i := 0; i < b.N; i++ {
204 | 		diff.Diff(n, m, d)
205 | 	}
206 | }
207 | 
208 | func BenchmarkInts(b *testing.B) {
209 | 	t := tests[len(tests)-1]
210 | 	d1 := t.a
211 | 	d2 := t.b
212 | 	for i := 0; i < b.N; i++ {
213 | 		diff.Ints(d1, d2)
214 | 	}
215 | }
216 | 
217 | func BenchmarkDiffRunes(b *testing.B) {
218 | 	d1 := []rune("1231221")
219 | 	d2 := []rune("321213")
220 | 	for i := 0; i < b.N; i++ {
221 | 		diff.Runes(d1, d2)
222 | 	}
223 | }
224 | 
225 | func BenchmarkDiffBytes(b *testing.B) {
226 | 	d1 := []byte("lorem ipsum dolor sit amet consectetur")
227 | 	d2 := []byte("lorem lovesum daenerys targaryen ami consecteture")
228 | 	for i := 0; i < b.N; i++ {
229 | 		diff.Bytes(d1, d2)
230 | 	}
231 | }
232 | 
233 | func BenchmarkDiffByteStrings(b *testing.B) {
234 | 	d1 := "lorem ipsum dolor sit amet consectetur"
235 | 	d2 := "lorem lovesum daenerys targaryen ami consecteture"
236 | 	for i := 0; i < b.N; i++ {
237 | 		diff.ByteStrings(d1, d2)
238 | 	}
239 | }
240 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/testdata/webkit/tests3.dat:
--------------------------------------------------------------------------------
  1 | #data
  2 | <head></head><style></style>
  3 | #errors
  4 | Line: 1 Col: 6 Unexpected start tag (head). Expected DOCTYPE.
  5 | Line: 1 Col: 20 Unexpected start tag (style) that can be in head. Moved.
  6 | #document
  7 | | <html>
  8 | |   <head>
  9 | |     <style>
 10 | |   <body>
 11 | 
 12 | #data
 13 | <head></head><script></script>
 14 | #errors
 15 | Line: 1 Col: 6 Unexpected start tag (head). Expected DOCTYPE.
 16 | Line: 1 Col: 21 Unexpected start tag (script) that can be in head. Moved.
 17 | #document
 18 | | <html>
 19 | |   <head>
 20 | |     <script>
 21 | |   <body>
 22 | 
 23 | #data
 24 | <head></head><!-- --><style></style><!-- --><script></script>
 25 | #errors
 26 | Line: 1 Col: 6 Unexpected start tag (head). Expected DOCTYPE.
 27 | Line: 1 Col: 28 Unexpected start tag (style) that can be in head. Moved.
 28 | #document
 29 | | <html>
 30 | |   <head>
 31 | |     <style>
 32 | |     <script>
 33 | |   <!--   -->
 34 | |   <!--   -->
 35 | |   <body>
 36 | 
 37 | #data
 38 | <head></head><!-- -->x<style></style><!-- --><script></script>
 39 | #errors
 40 | Line: 1 Col: 6 Unexpected start tag (head). Expected DOCTYPE.
 41 | #document
 42 | | <html>
 43 | |   <head>
 44 | |   <!--   -->
 45 | |   <body>
 46 | |     "x"
 47 | |     <style>
 48 | |     <!--   -->
 49 | |     <script>
 50 | 
 51 | #data
 52 | <!DOCTYPE html><html><head></head><body><pre>
 53 | </pre></body></html>
 54 | #errors
 55 | #document
 56 | | <!DOCTYPE html>
 57 | | <html>
 58 | |   <head>
 59 | |   <body>
 60 | |     <pre>
 61 | 
 62 | #data
 63 | <!DOCTYPE html><html><head></head><body><pre>
 64 | foo</pre></body></html>
 65 | #errors
 66 | #document
 67 | | <!DOCTYPE html>
 68 | | <html>
 69 | |   <head>
 70 | |   <body>
 71 | |     <pre>
 72 | |       "foo"
 73 | 
 74 | #data
 75 | <!DOCTYPE html><html><head></head><body><pre>
 76 | 
 77 | foo</pre></body></html>
 78 | #errors
 79 | #document
 80 | | <!DOCTYPE html>
 81 | | <html>
 82 | |   <head>
 83 | |   <body>
 84 | |     <pre>
 85 | |       "
 86 | foo"
 87 | 
 88 | #data
 89 | <!DOCTYPE html><html><head></head><body><pre>
 90 | foo
 91 | </pre></body></html>
 92 | #errors
 93 | #document
 94 | | <!DOCTYPE html>
 95 | | <html>
 96 | |   <head>
 97 | |   <body>
 98 | |     <pre>
 99 | |       "foo
100 | "
101 | 
102 | #data
103 | <!DOCTYPE html><html><head></head><body><pre>x</pre><span>
104 | </span></body></html>
105 | #errors
106 | #document
107 | | <!DOCTYPE html>
108 | | <html>
109 | |   <head>
110 | |   <body>
111 | |     <pre>
112 | |       "x"
113 | |     <span>
114 | |       "
115 | "
116 | 
117 | #data
118 | <!DOCTYPE html><html><head></head><body><pre>x
119 | y</pre></body></html>
120 | #errors
121 | #document
122 | | <!DOCTYPE html>
123 | | <html>
124 | |   <head>
125 | |   <body>
126 | |     <pre>
127 | |       "x
128 | y"
129 | 
130 | #data
131 | <!DOCTYPE html><html><head></head><body><pre>x<div>
132 | y</pre></body></html>
133 | #errors
134 | Line: 2 Col: 7 End tag (pre) seen too early. Expected other end tag.
135 | #document
136 | | <!DOCTYPE html>
137 | | <html>
138 | |   <head>
139 | |   <body>
140 | |     <pre>
141 | |       "x"
142 | |       <div>
143 | |         "
144 | y"
145 | 
146 | #data
147 | <!DOCTYPE html><pre>&#x0a;&#x0a;A</pre>
148 | #errors
149 | #document
150 | | <!DOCTYPE html>
151 | | <html>
152 | |   <head>
153 | |   <body>
154 | |     <pre>
155 | |       "
156 | A"
157 | 
158 | #data
159 | <!DOCTYPE html><HTML><META><HEAD></HEAD></HTML>
160 | #errors
161 | Line: 1 Col: 33 Unexpected start tag head in existing head. Ignored.
162 | #document
163 | | <!DOCTYPE html>
164 | | <html>
165 | |   <head>
166 | |     <meta>
167 | |   <body>
168 | 
169 | #data
170 | <!DOCTYPE html><HTML><HEAD><head></HEAD></HTML>
171 | #errors
172 | Line: 1 Col: 33 Unexpected start tag head in existing head. Ignored.
173 | #document
174 | | <!DOCTYPE html>
175 | | <html>
176 | |   <head>
177 | |   <body>
178 | 
179 | #data
180 | <textarea>foo<span>bar</span><i>baz
181 | #errors
182 | Line: 1 Col: 10 Unexpected start tag (textarea). Expected DOCTYPE.
183 | Line: 1 Col: 35 Expected closing tag. Unexpected end of file.
184 | #document
185 | | <html>
186 | |   <head>
187 | |   <body>
188 | |     <textarea>
189 | |       "foo<span>bar</span><i>baz"
190 | 
191 | #data
192 | <title>foo<span>bar</em><i>baz
193 | #errors
194 | Line: 1 Col: 7 Unexpected start tag (title). Expected DOCTYPE.
195 | Line: 1 Col: 30 Unexpected end of file. Expected end tag (title).
196 | #document
197 | | <html>
198 | |   <head>
199 | |     <title>
200 | |       "foo<span>bar</em><i>baz"
201 | |   <body>
202 | 
203 | #data
204 | <!DOCTYPE html><textarea>
205 | </textarea>
206 | #errors
207 | #document
208 | | <!DOCTYPE html>
209 | | <html>
210 | |   <head>
211 | |   <body>
212 | |     <textarea>
213 | 
214 | #data
215 | <!DOCTYPE html><textarea>
216 | foo</textarea>
217 | #errors
218 | #document
219 | | <!DOCTYPE html>
220 | | <html>
221 | |   <head>
222 | |   <body>
223 | |     <textarea>
224 | |       "foo"
225 | 
226 | #data
227 | <!DOCTYPE html><textarea>
228 | 
229 | foo</textarea>
230 | #errors
231 | #document
232 | | <!DOCTYPE html>
233 | | <html>
234 | |   <head>
235 | |   <body>
236 | |     <textarea>
237 | |       "
238 | foo"
239 | 
240 | #data
241 | <!DOCTYPE html><html><head></head><body><ul><li><div><p><li></ul></body></html>
242 | #errors
243 | Line: 1 Col: 60 Missing end tag (div, li).
244 | #document
245 | | <!DOCTYPE html>
246 | | <html>
247 | |   <head>
248 | |   <body>
249 | |     <ul>
250 | |       <li>
251 | |         <div>
252 | |           <p>
253 | |       <li>
254 | 
255 | #data
256 | <!doctype html><nobr><nobr><nobr>
257 | #errors
258 | Line: 1 Col: 27 Unexpected start tag (nobr) implies end tag (nobr).
259 | Line: 1 Col: 33 Unexpected start tag (nobr) implies end tag (nobr).
260 | Line: 1 Col: 33 Expected closing tag. Unexpected end of file.
261 | #document
262 | | <!DOCTYPE html>
263 | | <html>
264 | |   <head>
265 | |   <body>
266 | |     <nobr>
267 | |     <nobr>
268 | |     <nobr>
269 | 
270 | #data
271 | <!doctype html><nobr><nobr></nobr><nobr>
272 | #errors
273 | Line: 1 Col: 27 Unexpected start tag (nobr) implies end tag (nobr).
274 | Line: 1 Col: 40 Expected closing tag. Unexpected end of file.
275 | #document
276 | | <!DOCTYPE html>
277 | | <html>
278 | |   <head>
279 | |   <body>
280 | |     <nobr>
281 | |     <nobr>
282 | |     <nobr>
283 | 
284 | #data
285 | <!doctype html><html><body><p><table></table></body></html>
286 | #errors
287 | Not known
288 | #document
289 | | <!DOCTYPE html>
290 | | <html>
291 | |   <head>
292 | |   <body>
293 | |     <p>
294 | |     <table>
295 | 
296 | #data
297 | <p><table></table>
298 | #errors
299 | Not known
300 | #document
301 | | <html>
302 | |   <head>
303 | |   <body>
304 | |     <p>
305 | |       <table>
306 | 


--------------------------------------------------------------------------------
/htmldiff.go:
--------------------------------------------------------------------------------
  1 | package htmldiff
  2 | 
  3 | import (
  4 | 	"bytes"
  5 | 	"errors"
  6 | 	"strings"
  7 | 	"time"
  8 | 
  9 | 	"github.com/mb0/diff"
 10 | 
 11 | 	"golang.org/x/net/html"
 12 | )
 13 | 
 14 | // Attribute exists so that this package does not export html.Attribute, to allow vendoring of "golang.org/x/net/html".
 15 | type Attribute struct {
 16 | 	Namespace, Key, Val string
 17 | }
 18 | 
 19 | // return the "golang.org/x/net/html" version of a slice of Attribute
 20 | func convertAttributes(atts []Attribute) []html.Attribute {
 21 | 	ret := make([]html.Attribute, 0, len(atts))
 22 | 	for _, a := range atts {
 23 | 		ret = append(ret, html.Attribute{
 24 | 			Namespace: a.Namespace,
 25 | 			Key:       a.Key,
 26 | 			Val:       a.Val,
 27 | 		})
 28 | 	}
 29 | 	return ret
 30 | }
 31 | 
 32 | // Config describes the way that HTMLdiff works.
 33 | type Config struct {
 34 | 	Granularity                             int         // how many letters to put together for a change, if possible
 35 | 	InsertedSpan, DeletedSpan, ReplacedSpan []Attribute // the attributes for the span tags wrapping changes
 36 | 	CleanTags                               []string    // HTML tags to clean from the input
 37 | }
 38 | 
 39 | // HTMLdiff finds all the differences in the versions of HTML snippits,
 40 | // versions[0] is the original, all other versions are the edits to be compared.
 41 | // The resulting merged HTML snippits are as many as there are edits to compare.
 42 | func (c *Config) HTMLdiff(versions []string) ([]string, error) {
 43 | 	if len(versions) < 2 {
 44 | 		return nil, errors.New("there must be at least two versions to diff, the 0th element is the base")
 45 | 	}
 46 | 	parallelErrors := make(chan error, len(versions))
 47 | 	sourceTrees := make([]*html.Node, len(versions))
 48 | 	sourceTreeRunes := make([]*[]treeRune, len(versions))
 49 | 	firstLeaves := make([]int, len(versions))
 50 | 	for v, vv := range versions {
 51 | 		go func(v int, vv string) {
 52 | 			var err error
 53 | 			sourceTrees[v], err = html.Parse(strings.NewReader(vv))
 54 | 			if err == nil {
 55 | 				tr := make([]treeRune, 0, c.clean(sourceTrees[v]))
 56 | 				sourceTreeRunes[v] = &tr
 57 | 				renderTreeRunes(sourceTrees[v], &tr)
 58 | 				leaf1, ok := firstLeaf(findBody(sourceTrees[v]))
 59 | 				if leaf1 == nil || !ok {
 60 | 					firstLeaves[v] = 0 // could be wrong, but correct for simple examples
 61 | 				} else {
 62 | 					for x, y := range tr {
 63 | 						if y.leaf == leaf1 {
 64 | 							firstLeaves[v] = x
 65 | 							break
 66 | 						}
 67 | 					}
 68 | 				}
 69 | 			}
 70 | 			parallelErrors <- err
 71 | 		}(v, vv)
 72 | 	}
 73 | 	for range versions {
 74 | 		if err := <-parallelErrors; err != nil {
 75 | 			return nil, err
 76 | 		}
 77 | 	}
 78 | 
 79 | 	// now all the input trees are buit, we can do the merge
 80 | 	mergedHTMLs := make([]string, len(versions)-1)
 81 | 
 82 | 	for m := range mergedHTMLs {
 83 | 		go func(m int) {
 84 | 			treeRuneLimit := 250000 // from initial testing
 85 | 			if len(*sourceTreeRunes[0]) > treeRuneLimit || len(*sourceTreeRunes[m+1]) > treeRuneLimit {
 86 | 				parallelErrors <- errors.New("input data too large")
 87 | 				return
 88 | 			}
 89 | 			dd := diffData{a: sourceTreeRunes[0], b: sourceTreeRunes[m+1]}
 90 | 			var changes []diff.Change
 91 | 			ch := make(chan []diff.Change)
 92 | 			go func(ch chan []diff.Change) {
 93 | 				ch <- diff.Diff(len(*sourceTreeRunes[0]), len(*sourceTreeRunes[m+1]), dd)
 94 | 			}(ch)
 95 | 			to := time.After(time.Second * 3)
 96 | 			select {
 97 | 			case <-to:
 98 | 				parallelErrors <- errors.New("diff.Diff() took too long")
 99 | 				go func(ch chan []diff.Change) {
100 | 					<-ch // make sure the timed-out diff cleans-up
101 | 				}(ch)
102 | 				return
103 | 			case changes = <-ch:
104 | 				// we have the diff
105 | 				go func(to <-chan time.Time) {
106 | 					<-to // make sure we don't leak the timer goroutine
107 | 				}(to)
108 | 			}
109 | 			changes = granular(c.Granularity, dd, changes)
110 | 			mergedTree, err := c.walkChanges(changes, sourceTreeRunes[0], sourceTreeRunes[m+1], firstLeaves[0], firstLeaves[m+1])
111 | 			if err != nil {
112 | 				parallelErrors <- err
113 | 				return
114 | 			}
115 | 			var mergedHTMLbuff bytes.Buffer
116 | 			err = html.Render(&mergedHTMLbuff, mergedTree)
117 | 			if err != nil {
118 | 				parallelErrors <- err
119 | 				return
120 | 			}
121 | 			mergedHTML := mergedHTMLbuff.Bytes()
122 | 			pfx := []byte("<html><head></head><body>")
123 | 			sfx := []byte("</body></html>")
124 | 			if bytes.HasPrefix(mergedHTML, pfx) && bytes.HasSuffix(mergedHTML, sfx) {
125 | 				mergedHTML = bytes.TrimSuffix(bytes.TrimPrefix(mergedHTML, pfx), sfx)
126 | 				mergedHTMLs[m] = string(mergedHTML)
127 | 				parallelErrors <- nil
128 | 				return
129 | 			}
130 | 			parallelErrors <- errors.New("correct render wrapper HTML not found: " + string(mergedHTML))
131 | 		}(m)
132 | 	}
133 | 	for range mergedHTMLs {
134 | 		if err := <-parallelErrors; err != nil {
135 | 			return nil, err
136 | 		}
137 | 	}
138 | 	return mergedHTMLs, nil
139 | }
140 | 
141 | // walkChanges goes through the changes identified by diff, identifies where a change is a repacement,
142 | // then appends the changes to the output set. Once that set is complete, after ctx.flush(),
143 | // they are finally resorted (to re-order those in containers) and written out using ctx.sortAndWrite().
144 | func (c *Config) walkChanges(changes []diff.Change, ap, bp *[]treeRune, aIdx, bIdx int) (*html.Node, error) {
145 | 	mergedTree, err := html.Parse(strings.NewReader("<html><head></head><body></body></html>"))
146 | 	if err != nil {
147 | 		return nil, err
148 | 	}
149 | 	a := *ap
150 | 	b := *bp
151 | 	ctx := &appendContext{c: c, target: mergedTree}
152 | 	for _, change := range changes {
153 | 		for aIdx < change.A && bIdx < change.B {
154 | 			ctx.append('=', a, aIdx)
155 | 			aIdx++
156 | 			bIdx++
157 | 		}
158 | 		if change.Del == change.Ins && change.Del > 0 {
159 | 			for i := 0; i < change.Del; i++ {
160 | 				if aIdx+i >= len(a) || bIdx+i >= len(b) {
161 | 					goto textDifferent // defensive after fuzz testing
162 | 				}
163 | 				if a[aIdx+i].letter != b[bIdx+i].letter {
164 | 					goto textDifferent
165 | 				}
166 | 			}
167 | 			for i := 0; i < change.Del; i++ {
168 | 				ctx.append('~', b, bIdx)
169 | 				aIdx++
170 | 				bIdx++
171 | 			}
172 | 			goto textSame
173 | 		}
174 | 	textDifferent:
175 | 		for i := 0; i < change.Del; i++ {
176 | 			ctx.append('-', a, aIdx)
177 | 			aIdx++
178 | 		}
179 | 		for i := 0; i < change.Ins; i++ {
180 | 			ctx.append('+', b, bIdx)
181 | 			bIdx++
182 | 		}
183 | 	textSame:
184 | 	}
185 | 	for aIdx < len(a) && bIdx < len(b) {
186 | 		ctx.append('=', a, aIdx)
187 | 		aIdx++
188 | 		bIdx++
189 | 	}
190 | 	ctx.flush()
191 | 	ctx.sortAndWrite()
192 | 	return mergedTree, nil
193 | }
194 | 


--------------------------------------------------------------------------------
/vendor/github.com/mb0/diff/diff.go:
--------------------------------------------------------------------------------
  1 | // Copyright 2012 Martin Schnabel. 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 diff implements a difference algorithm.
  6 | // The algorithm is described in "An O(ND) Difference Algorithm and its Variations", Eugene Myers, Algorithmica Vol. 1 No. 2, 1986, pp. 251-266.
  7 | package diff
  8 | 
  9 | // A type that satisfies diff.Data can be diffed by this package.
 10 | // It typically has two sequences A and B of comparable elements.
 11 | type Data interface {
 12 | 	// Equal returns whether the elements at i and j are considered equal.
 13 | 	Equal(i, j int) bool
 14 | }
 15 | 
 16 | // ByteStrings returns the differences of two strings in bytes.
 17 | func ByteStrings(a, b string) []Change {
 18 | 	return Diff(len(a), len(b), &strings{a, b})
 19 | }
 20 | 
 21 | type strings struct{ a, b string }
 22 | 
 23 | func (d *strings) Equal(i, j int) bool { return d.a[i] == d.b[j] }
 24 | 
 25 | // Bytes returns the difference of two byte slices
 26 | func Bytes(a, b []byte) []Change {
 27 | 	return Diff(len(a), len(b), &bytes{a, b})
 28 | }
 29 | 
 30 | type bytes struct{ a, b []byte }
 31 | 
 32 | func (d *bytes) Equal(i, j int) bool { return d.a[i] == d.b[j] }
 33 | 
 34 | // Ints returns the difference of two int slices
 35 | func Ints(a, b []int) []Change {
 36 | 	return Diff(len(a), len(b), &ints{a, b})
 37 | }
 38 | 
 39 | type ints struct{ a, b []int }
 40 | 
 41 | func (d *ints) Equal(i, j int) bool { return d.a[i] == d.b[j] }
 42 | 
 43 | // Runes returns the difference of two rune slices
 44 | func Runes(a, b []rune) []Change {
 45 | 	return Diff(len(a), len(b), &runes{a, b})
 46 | }
 47 | 
 48 | type runes struct{ a, b []rune }
 49 | 
 50 | func (d *runes) Equal(i, j int) bool { return d.a[i] == d.b[j] }
 51 | 
 52 | // Granular merges neighboring changes smaller than the specified granularity.
 53 | // The changes must be ordered by ascending positions as returned by this package.
 54 | func Granular(granularity int, changes []Change) []Change {
 55 | 	if len(changes) == 0 {
 56 | 		return changes
 57 | 	}
 58 | 	gap := 0
 59 | 	for i := 1; i < len(changes); i++ {
 60 | 		curr := changes[i]
 61 | 		prev := changes[i-gap-1]
 62 | 		// same as curr.B-(prev.B+prev.Ins); consistency is key
 63 | 		if curr.A-(prev.A+prev.Del) <= granularity {
 64 | 			// merge changes:
 65 | 			curr = Change{
 66 | 				A: prev.A, B: prev.B, // start at same spot
 67 | 				Del: curr.A - prev.A + curr.Del, // from first to end of second
 68 | 				Ins: curr.B - prev.B + curr.Ins, // from first to end of second
 69 | 			}
 70 | 			gap++
 71 | 		}
 72 | 		changes[i-gap] = curr
 73 | 	}
 74 | 	return changes[:len(changes)-gap]
 75 | }
 76 | 
 77 | // Diff returns the differences of data.
 78 | // data.Equal is called repeatedly with 0<=i<n and 0<=j<m
 79 | func Diff(n, m int, data Data) []Change {
 80 | 	c := &context{data: data}
 81 | 	if n > m {
 82 | 		c.flags = make([]byte, n)
 83 | 	} else {
 84 | 		c.flags = make([]byte, m)
 85 | 	}
 86 | 	c.max = n + m + 1
 87 | 	c.compare(0, 0, n, m)
 88 | 	return c.result(n, m)
 89 | }
 90 | 
 91 | // A Change contains one or more deletions or inserts
 92 | // at one position in two sequences.
 93 | type Change struct {
 94 | 	A, B int // position in input a and b
 95 | 	Del  int // delete Del elements from input a
 96 | 	Ins  int // insert Ins elements from input b
 97 | }
 98 | 
 99 | type context struct {
100 | 	data  Data
101 | 	flags []byte // element bits 1 delete, 2 insert
102 | 	max   int
103 | 	// forward and reverse d-path endpoint x components
104 | 	forward, reverse []int
105 | }
106 | 
107 | func (c *context) compare(aoffset, boffset, alimit, blimit int) {
108 | 	// eat common prefix
109 | 	for aoffset < alimit && boffset < blimit && c.data.Equal(aoffset, boffset) {
110 | 		aoffset++
111 | 		boffset++
112 | 	}
113 | 	// eat common suffix
114 | 	for alimit > aoffset && blimit > boffset && c.data.Equal(alimit-1, blimit-1) {
115 | 		alimit--
116 | 		blimit--
117 | 	}
118 | 	// both equal or b inserts
119 | 	if aoffset == alimit {
120 | 		for boffset < blimit {
121 | 			c.flags[boffset] |= 2
122 | 			boffset++
123 | 		}
124 | 		return
125 | 	}
126 | 	// a deletes
127 | 	if boffset == blimit {
128 | 		for aoffset < alimit {
129 | 			c.flags[aoffset] |= 1
130 | 			aoffset++
131 | 		}
132 | 		return
133 | 	}
134 | 	x, y := c.findMiddleSnake(aoffset, boffset, alimit, blimit)
135 | 	c.compare(aoffset, boffset, x, y)
136 | 	c.compare(x, y, alimit, blimit)
137 | }
138 | 
139 | func (c *context) findMiddleSnake(aoffset, boffset, alimit, blimit int) (int, int) {
140 | 	// midpoints
141 | 	fmid := aoffset - boffset
142 | 	rmid := alimit - blimit
143 | 	// correct offset in d-path slices
144 | 	foff := c.max - fmid
145 | 	roff := c.max - rmid
146 | 	isodd := (rmid-fmid)&1 != 0
147 | 	maxd := (alimit - aoffset + blimit - boffset + 2) / 2
148 | 	// allocate when first used
149 | 	if c.forward == nil {
150 | 		c.forward = make([]int, 2*c.max)
151 | 		c.reverse = make([]int, 2*c.max)
152 | 	}
153 | 	c.forward[c.max+1] = aoffset
154 | 	c.reverse[c.max-1] = alimit
155 | 	var x, y int
156 | 	for d := 0; d <= maxd; d++ {
157 | 		// forward search
158 | 		for k := fmid - d; k <= fmid+d; k += 2 {
159 | 			if k == fmid-d || k != fmid+d && c.forward[foff+k+1] > c.forward[foff+k-1] {
160 | 				x = c.forward[foff+k+1] // down
161 | 			} else {
162 | 				x = c.forward[foff+k-1] + 1 // right
163 | 			}
164 | 			y = x - k
165 | 			for x < alimit && y < blimit && c.data.Equal(x, y) {
166 | 				x++
167 | 				y++
168 | 			}
169 | 			c.forward[foff+k] = x
170 | 			if isodd && k > rmid-d && k < rmid+d {
171 | 				if c.reverse[roff+k] <= c.forward[foff+k] {
172 | 					return x, x - k
173 | 				}
174 | 			}
175 | 		}
176 | 		// reverse search x,y correspond to u,v
177 | 		for k := rmid - d; k <= rmid+d; k += 2 {
178 | 			if k == rmid+d || k != rmid-d && c.reverse[roff+k-1] < c.reverse[roff+k+1] {
179 | 				x = c.reverse[roff+k-1] // up
180 | 			} else {
181 | 				x = c.reverse[roff+k+1] - 1 // left
182 | 			}
183 | 			y = x - k
184 | 			for x > aoffset && y > boffset && c.data.Equal(x-1, y-1) {
185 | 				x--
186 | 				y--
187 | 			}
188 | 			c.reverse[roff+k] = x
189 | 			if !isodd && k >= fmid-d && k <= fmid+d {
190 | 				if c.reverse[roff+k] <= c.forward[foff+k] {
191 | 					// lookup opposite end
192 | 					x = c.forward[foff+k]
193 | 					return x, x - k
194 | 				}
195 | 			}
196 | 		}
197 | 	}
198 | 	panic("should never be reached")
199 | }
200 | 
201 | func (c *context) result(n, m int) (res []Change) {
202 | 	var x, y int
203 | 	for x < n || y < m {
204 | 		if x < n && y < m && c.flags[x]&1 == 0 && c.flags[y]&2 == 0 {
205 | 			x++
206 | 			y++
207 | 		} else {
208 | 			a := x
209 | 			b := y
210 | 			for x < n && (y >= m || c.flags[x]&1 != 0) {
211 | 				x++
212 | 			}
213 | 			for y < m && (x >= n || c.flags[y]&2 != 0) {
214 | 				y++
215 | 			}
216 | 			if a < x || b < y {
217 | 				res = append(res, Change{a, b, x - a, y - b})
218 | 			}
219 | 		}
220 | 	}
221 | 	return
222 | }
223 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/net/html/testdata/webkit/tests26.dat:
--------------------------------------------------------------------------------
  1 | #data
  2 | <!DOCTYPE html><body><a href='#1'><nobr>1<nobr></a><br><a href='#2'><nobr>2<nobr></a><br><a href='#3'><nobr>3<nobr></a>
  3 | #errors
  4 | #document
  5 | | <!DOCTYPE html>
  6 | | <html>
  7 | |   <head>
  8 | |   <body>
  9 | |     <a>
 10 | |       href="#1"
 11 | |       <nobr>
 12 | |         "1"
 13 | |       <nobr>
 14 | |     <nobr>
 15 | |       <br>
 16 | |       <a>
 17 | |         href="#2"
 18 | |     <a>
 19 | |       href="#2"
 20 | |       <nobr>
 21 | |         "2"
 22 | |       <nobr>
 23 | |     <nobr>
 24 | |       <br>
 25 | |       <a>
 26 | |         href="#3"
 27 | |     <a>
 28 | |       href="#3"
 29 | |       <nobr>
 30 | |         "3"
 31 | |       <nobr>
 32 | 
 33 | #data
 34 | <!DOCTYPE html><body><b><nobr>1<nobr></b><i><nobr>2<nobr></i>3
 35 | #errors
 36 | #document
 37 | | <!DOCTYPE html>
 38 | | <html>
 39 | |   <head>
 40 | |   <body>
 41 | |     <b>
 42 | |       <nobr>
 43 | |         "1"
 44 | |       <nobr>
 45 | |     <nobr>
 46 | |       <i>
 47 | |     <i>
 48 | |       <nobr>
 49 | |         "2"
 50 | |       <nobr>
 51 | |     <nobr>
 52 | |       "3"
 53 | 
 54 | #data
 55 | <!DOCTYPE html><body><b><nobr>1<table><nobr></b><i><nobr>2<nobr></i>3
 56 | #errors
 57 | #document
 58 | | <!DOCTYPE html>
 59 | | <html>
 60 | |   <head>
 61 | |   <body>
 62 | |     <b>
 63 | |       <nobr>
 64 | |         "1"
 65 | |         <nobr>
 66 | |           <i>
 67 | |         <i>
 68 | |           <nobr>
 69 | |             "2"
 70 | |           <nobr>
 71 | |         <nobr>
 72 | |           "3"
 73 | |         <table>
 74 | 
 75 | #data
 76 | <!DOCTYPE html><body><b><nobr>1<table><tr><td><nobr></b><i><nobr>2<nobr></i>3
 77 | #errors
 78 | #document
 79 | | <!DOCTYPE html>
 80 | | <html>
 81 | |   <head>
 82 | |   <body>
 83 | |     <b>
 84 | |       <nobr>
 85 | |         "1"
 86 | |         <table>
 87 | |           <tbody>
 88 | |             <tr>
 89 | |               <td>
 90 | |                 <nobr>
 91 | |                   <i>
 92 | |                 <i>
 93 | |                   <nobr>
 94 | |                     "2"
 95 | |                   <nobr>
 96 | |                 <nobr>
 97 | |                   "3"
 98 | 
 99 | #data
100 | <!DOCTYPE html><body><b><nobr>1<div><nobr></b><i><nobr>2<nobr></i>3
101 | #errors
102 | #document
103 | | <!DOCTYPE html>
104 | | <html>
105 | |   <head>
106 | |   <body>
107 | |     <b>
108 | |       <nobr>
109 | |         "1"
110 | |     <div>
111 | |       <b>
112 | |         <nobr>
113 | |         <nobr>
114 | |       <nobr>
115 | |         <i>
116 | |       <i>
117 | |         <nobr>
118 | |           "2"
119 | |         <nobr>
120 | |       <nobr>
121 | |         "3"
122 | 
123 | #data
124 | <!DOCTYPE html><body><b><nobr>1<nobr></b><div><i><nobr>2<nobr></i>3
125 | #errors
126 | #document
127 | | <!DOCTYPE html>
128 | | <html>
129 | |   <head>
130 | |   <body>
131 | |     <b>
132 | |       <nobr>
133 | |         "1"
134 | |       <nobr>
135 | |     <div>
136 | |       <nobr>
137 | |         <i>
138 | |       <i>
139 | |         <nobr>
140 | |           "2"
141 | |         <nobr>
142 | |       <nobr>
143 | |         "3"
144 | 
145 | #data
146 | <!DOCTYPE html><body><b><nobr>1<nobr><ins></b><i><nobr>
147 | #errors
148 | #document
149 | | <!DOCTYPE html>
150 | | <html>
151 | |   <head>
152 | |   <body>
153 | |     <b>
154 | |       <nobr>
155 | |         "1"
156 | |       <nobr>
157 | |         <ins>
158 | |     <nobr>
159 | |       <i>
160 | |     <i>
161 | |       <nobr>
162 | 
163 | #data
164 | <!DOCTYPE html><body><b><nobr>1<ins><nobr></b><i>2
165 | #errors
166 | #document
167 | | <!DOCTYPE html>
168 | | <html>
169 | |   <head>
170 | |   <body>
171 | |     <b>
172 | |       <nobr>
173 | |         "1"
174 | |         <ins>
175 | |       <nobr>
176 | |     <nobr>
177 | |       <i>
178 | |         "2"
179 | 
180 | #data
181 | <!DOCTYPE html><body><b>1<nobr></b><i><nobr>2</i>
182 | #errors
183 | #document
184 | | <!DOCTYPE html>
185 | | <html>
186 | |   <head>
187 | |   <body>
188 | |     <b>
189 | |       "1"
190 | |       <nobr>
191 | |     <nobr>
192 | |       <i>
193 | |     <i>
194 | |       <nobr>
195 | |         "2"
196 | 
197 | #data
198 | <p><code x</code></p>
199 | 
200 | #errors
201 | #document
202 | | <html>
203 | |   <head>
204 | |   <body>
205 | |     <p>
206 | |       <code>
207 | |         code=""
208 | |         x<=""
209 | |     <code>
210 | |       code=""
211 | |       x<=""
212 | |       "
213 | "
214 | 
215 | #data
216 | <!DOCTYPE html><svg><foreignObject><p><i></p>a
217 | #errors
218 | 45: End tag “p” seen, but there were open elements.
219 | 41: Unclosed element “i”.
220 | 46: End of file seen and there were open elements.
221 | 35: Unclosed element “foreignObject”.
222 | 20: Unclosed element “svg”.
223 | #document
224 | | <!DOCTYPE html>
225 | | <html>
226 | |   <head>
227 | |   <body>
228 | |     <svg svg>
229 | |       <svg foreignObject>
230 | |         <p>
231 | |           <i>
232 | |         <i>
233 | |           "a"
234 | 
235 | #data
236 | <!DOCTYPE html><table><tr><td><svg><foreignObject><p><i></p>a
237 | #errors
238 | 56: End tag “p” seen, but there were open elements.
239 | 52: Unclosed element “i”.
240 | 57: End of file seen and there were open elements.
241 | 46: Unclosed element “foreignObject”.
242 | 31: Unclosed element “svg”.
243 | 22: Unclosed element “table”.
244 | #document
245 | | <!DOCTYPE html>
246 | | <html>
247 | |   <head>
248 | |   <body>
249 | |     <table>
250 | |       <tbody>
251 | |         <tr>
252 | |           <td>
253 | |             <svg svg>
254 | |               <svg foreignObject>
255 | |                 <p>
256 | |                   <i>
257 | |                 <i>
258 | |                   "a"
259 | 
260 | #data
261 | <!DOCTYPE html><math><mtext><p><i></p>a
262 | #errors
263 | 38: End tag “p” seen, but there were open elements.
264 | 34: Unclosed element “i”.
265 | 39: End of file in a foreign namespace context.
266 | #document
267 | | <!DOCTYPE html>
268 | | <html>
269 | |   <head>
270 | |   <body>
271 | |     <math math>
272 | |       <math mtext>
273 | |         <p>
274 | |           <i>
275 | |         <i>
276 | |           "a"
277 | 
278 | #data
279 | <!DOCTYPE html><table><tr><td><math><mtext><p><i></p>a
280 | #errors
281 | 53: End tag “p” seen, but there were open elements.
282 | 49: Unclosed element “i”.
283 | 54: End of file in a foreign namespace context.
284 | #document
285 | | <!DOCTYPE html>
286 | | <html>
287 | |   <head>
288 | |   <body>
289 | |     <table>
290 | |       <tbody>
291 | |         <tr>
292 | |           <td>
293 | |             <math math>
294 | |               <math mtext>
295 | |                 <p>
296 | |                   <i>
297 | |                 <i>
298 | |                   "a"
299 | 
300 | #data
301 | <!DOCTYPE html><body><div><!/div>a
302 | #errors
303 | 29: Bogus comment.
304 | 34: End of file seen and there were open elements.
305 | 26: Unclosed element “div”.
306 | #document
307 | | <!DOCTYPE html>
308 | | <html>
309 | |   <head>
310 | |   <body>
311 | |     <div>
312 | |       <!-- /div -->
313 | |       "a"
314 | 


--------------------------------------------------------------------------------
/append.go:
--------------------------------------------------------------------------------
  1 | package htmldiff
  2 | 
  3 | import (
  4 | 	"sort"
  5 | 
  6 | 	"golang.org/x/net/html"
  7 | 	"golang.org/x/net/html/atom"
  8 | )
  9 | 
 10 | // the things we need to know while appending.
 11 | type appendContext struct {
 12 | 	c                             *Config
 13 | 	target, targetBody, lastProto *html.Node
 14 | 	lastText                      string
 15 | 	lastAction                    rune
 16 | 	lastPos                       posT
 17 | 	editList                      []editEntry
 18 | }
 19 | 
 20 | // an individual edit action.
 21 | type editEntry struct {
 22 | 	action  rune
 23 | 	text    string
 24 | 	proto   *html.Node
 25 | 	pos     posT
 26 | 	origSeq int
 27 | }
 28 | 
 29 | // Len is part of sort.Interface.
 30 | func (ap *appendContext) Len() int {
 31 | 	return len(ap.editList)
 32 | }
 33 | 
 34 | // Swap is part of sort.Interface.
 35 | func (ap *appendContext) Swap(i, j int) {
 36 | 	ap.editList[i], ap.editList[j] = ap.editList[j], ap.editList[i]
 37 | }
 38 | 
 39 | // Less is part of sort.Interface.
 40 | func (ap *appendContext) Less(i, j int) bool {
 41 | 	if len(ap.editList[i].pos) > 0 && len(ap.editList[j].pos) > 0 { // if both are in containers
 42 | 		ii := len(ap.editList[i].pos) - 1
 43 | 		jj := len(ap.editList[j].pos) - 1
 44 | 		for ii > 0 && jj > 0 {
 45 | 			if ap.editList[i].pos[ii].nodesBefore < ap.editList[j].pos[jj].nodesBefore {
 46 | 				return true
 47 | 			}
 48 | 			if ap.editList[i].pos[ii].nodesBefore > ap.editList[j].pos[jj].nodesBefore {
 49 | 				return false
 50 | 			}
 51 | 			ii--
 52 | 			jj--
 53 | 		}
 54 | 	}
 55 | 	return ap.editList[i].origSeq < ap.editList[j].origSeq
 56 | }
 57 | 
 58 | // append a treeRune at location idx to the output, group similar runes together to before calling append0().
 59 | func (ap *appendContext) append(action rune, trs []treeRune, idx int) {
 60 | 	if idx >= len(trs) { // defending error found by fuzz testing
 61 | 		return
 62 | 	}
 63 | 	tr := trs[idx]
 64 | 	if tr.leaf == nil {
 65 | 		return
 66 | 	}
 67 | 	// return if we should not be appending this type of node
 68 | 	switch tr.leaf.Type {
 69 | 	case html.DocumentNode:
 70 | 		return
 71 | 	case html.ElementNode:
 72 | 		switch tr.leaf.DataAtom {
 73 | 		case atom.Html:
 74 | 			return
 75 | 		}
 76 | 	}
 77 | 	var text string
 78 | 	if tr.letter > 0 {
 79 | 		text = string(tr.letter)
 80 | 	}
 81 | 	if ap.lastProto == tr.leaf && ap.lastAction == action && tr.leaf.Type == html.TextNode && text != "" && posEqual(ap.lastPos, tr.pos) {
 82 | 		ap.lastText += text
 83 | 		return
 84 | 	}
 85 | 	ap.flush0(action, tr.leaf, tr.pos)
 86 | 	if tr.leaf.Type == html.TextNode { // reload the buffer
 87 | 		ap.lastText = text
 88 | 		return
 89 | 	}
 90 | 	ap.append0(action, "", tr.leaf, tr.pos)
 91 | }
 92 | 
 93 | func (ap *appendContext) flush() {
 94 | 	ap.flush0(0, nil, nil)
 95 | }
 96 | 
 97 | func (ap *appendContext) flush0(action rune, proto *html.Node, pos posT) {
 98 | 	if ap.lastText != "" {
 99 | 		ap.append0(ap.lastAction, ap.lastText, ap.lastProto, ap.lastPos) // flush the buffer
100 | 	}
101 | 	// reset the buffer
102 | 	ap.lastProto = proto
103 | 	ap.lastAction = action
104 | 	ap.lastPos = pos
105 | 	ap.lastText = ""
106 | }
107 | 
108 | // append0 builds up the editList of things to do.
109 | func (ap *appendContext) append0(action rune, text string, proto *html.Node, pos posT) {
110 | 	os := len(ap.editList)
111 | 	ap.editList = append(ap.editList, editEntry{action, text, proto, pos, os})
112 | }
113 | 
114 | // Sort the editList before using append1 on all the sorted edits.
115 | // Sorting is required in order to get edits inside containers in the right order.
116 | func (ap *appendContext) sortAndWrite() {
117 | 	sort.Stable(ap)
118 | 	for _, e := range ap.editList {
119 | 		ap.append1(e.action, e.text, e.proto, e.pos)
120 | 	}
121 | }
122 | 
123 | // append1 actually appends to the merged HTML node tree.
124 | func (ap *appendContext) append1(action rune, text string, proto *html.Node, pos posT) {
125 | 	if proto == nil {
126 | 		return
127 | 	}
128 | 	appendPoint, protoAncestor := ap.lastMatchingLeaf(proto, action, pos)
129 | 	if appendPoint == nil || protoAncestor == nil {
130 | 		return
131 | 	}
132 | 	if appendPoint.DataAtom != protoAncestor.DataAtom {
133 | 		return
134 | 	}
135 | 	newLeaf := new(html.Node)
136 | 	copyNode(newLeaf, proto)
137 | 	if proto.Type == html.TextNode {
138 | 		newLeaf.Data = text
139 | 	}
140 | 	if action != '=' {
141 | 		insertNode := &html.Node{
142 | 			Type:     html.ElementNode,
143 | 			DataAtom: atom.Span,
144 | 			Data:     "span",
145 | 		}
146 | 		switch action {
147 | 		case '+':
148 | 			insertNode.Attr = convertAttributes(ap.c.InsertedSpan)
149 | 		case '-':
150 | 			insertNode.Attr = convertAttributes(ap.c.DeletedSpan)
151 | 		case '~':
152 | 			insertNode.Attr = convertAttributes(ap.c.ReplacedSpan)
153 | 		}
154 | 		insertNode.AppendChild(newLeaf)
155 | 		newLeaf = insertNode
156 | 	}
157 | 	for proto = proto.Parent; proto != nil && proto != protoAncestor; proto = proto.Parent {
158 | 		above := new(html.Node)
159 | 		copyNode(above, proto)
160 | 		above.AppendChild(newLeaf)
161 | 		newLeaf = above
162 | 	}
163 | 	appendPoint.AppendChild(newLeaf)
164 | }
165 | 
166 | // find the append point in the merged HTML and from where to copy in the source.
167 | func (ap *appendContext) lastMatchingLeaf(proto *html.Node, action rune, pos posT) (appendPoint, protoAncestor *html.Node) {
168 | 	if ap.targetBody == nil {
169 | 		ap.targetBody = findBody(ap.target)
170 | 	}
171 | 	candidates := []*html.Node{}
172 | 	for cand := ap.target; cand != nil; cand = cand.LastChild {
173 | 		candidates = append([]*html.Node{cand}, candidates...)
174 | 	}
175 | 	candidates = append(candidates, ap.targetBody) // longstop
176 | 	for cni, can := range candidates {
177 | 		_ = cni
178 | 		gpa := getPos(can) // what we are building
179 | 		for anc := proto; anc.Parent != nil; anc = anc.Parent {
180 | 			if anc.Type == html.ElementNode && anc.DataAtom == atom.Html {
181 | 				break
182 | 			}
183 | 			gpb := getPos(anc) // what we are adding in
184 | 			if ap.leavesEqual(can, anc, action, gpa, gpb) {
185 | 				return can, anc
186 | 			}
187 | 		}
188 | 	}
189 | 	return ap.targetBody, proto
190 | }
191 | 
192 | // are two leaves of a node-tree equal?
193 | func (ap *appendContext) leavesEqual(a, b *html.Node, action rune, gpa, gpb posT) bool {
194 | 	if a == b {
195 | 		return true
196 | 	}
197 | 	if a == nil || b == nil {
198 | 		return false
199 | 	}
200 | 	if a.Type != html.ElementNode || b.Type != html.ElementNode {
201 | 		return false // they must both be element nodes to do a comparison
202 | 	}
203 | 	if a.DataAtom == atom.Body && b.DataAtom == atom.Body {
204 | 		return true // body nodes are always equal
205 | 	}
206 | 	if !nodeEqual(a, b) {
207 | 		return false
208 | 	}
209 | 	if len(gpa) != len(gpb) {
210 | 		return false
211 | 	}
212 | 	for i := 0; i < len(gpb); i++ {
213 | 		if gpa[i].nodesBefore < gpb[i].nodesBefore {
214 | 			return false
215 | 		}
216 | 		if gpa[i].node.DataAtom != gpb[i].node.DataAtom {
217 | 			return false
218 | 		}
219 | 	}
220 | 	return true
221 | }
222 | 


--------------------------------------------------------------------------------