soup/lookbook
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Add vendor directory and update vendorHash to null

Browse source
This commit is contained in:
soup 2026-01-17 22:29:54 -05:00
parent 523831cb8d
commit 1e5424c844
Signed by: soup
SSH key fingerprint: SHA256:GYxje8eQkJ6HZKzVWDdyOUF1TyDiprruGhE0Ym8qYDY
778 changed files with 407919 additions and 1 deletions
Download patch file Download diff file Expand all files Collapse all files

27
vendor/golang.org/x/net/LICENSE generated vendored Normal file
View file

@ -0,0 +1,27 @@
Copyright 2009 The Go Authors.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following disclaimer
in the documentation and/or other materials provided with the
distribution.
* Neither the name of Google LLC nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

22
vendor/golang.org/x/net/PATENTS generated vendored Normal file
View file

@ -0,0 +1,22 @@
Additional IP Rights Grant (Patents)
"This implementation" means the copyrightable works distributed by
Google as part of the Go project.
Google hereby grants to You a perpetual, worldwide, non-exclusive,
no-charge, royalty-free, irrevocable (except as stated in this section)
patent license to make, have made, use, offer to sell, sell, import,
transfer and otherwise run, modify and propagate the contents of this
implementation of Go, where such license applies only to those patent
claims, both currently owned or controlled by Google and acquired in
the future, licensable by Google that are necessarily infringed by this
implementation of Go. This grant does not include claims that would be
infringed only as a consequence of further modification of this
implementation. If you or your agent or exclusive licensee institute or
order or agree to the institution of patent litigation against any
entity (including a cross-claim or counterclaim in a lawsuit) alleging
that this implementation of Go or any code incorporated within this
implementation of Go constitutes direct or contributory patent
infringement, or inducement of patent infringement, then any patent
rights granted to you under this License for this implementation of Go
shall terminate as of the date such litigation is filed.

78
vendor/golang.org/x/net/html/atom/atom.go generated vendored Normal file
View file

@ -0,0 +1,78 @@
// Copyright 2012 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Package atom provides integer codes (also known as atoms) for a fixed set of
// frequently occurring HTML strings: tag names and attribute keys such as "p"
// and "id".
//
// Sharing an atom's name between all elements with the same tag can result in
// fewer string allocations when tokenizing and parsing HTML. Integer
// comparisons are also generally faster than string comparisons.
//
// The value of an atom's particular code is not guaranteed to stay the same
// between versions of this package. Neither is any ordering guaranteed:
// whether atom.H1 < atom.H2 may also change. The codes are not guaranteed to
// be dense. The only guarantees are that e.g. looking up "div" will yield
// atom.Div, calling atom.Div.String will return "div", and atom.Div != 0.
package atom // import "golang.org/x/net/html/atom"
// Atom is an integer code for a string. The zero value maps to "".
type Atom uint32
// String returns the atom's name.
func (a Atom) String() string {
start := uint32(a >> 8)
n := uint32(a & 0xff)
if start+n > uint32(len(atomText)) {
return ""
}
return atomText[start : start+n]
}
func (a Atom) string() string {
return atomText[a>>8 : a>>8+a&0xff]
}
// fnv computes the FNV hash with an arbitrary starting value h.
func fnv(h uint32, s []byte) uint32 {
for i := range s {
h ^= uint32(s[i])
h *= 16777619
}
return h
}
func match(s string, t []byte) bool {
for i, c := range t {
if s[i] != c {
return false
}
}
return true
}
// Lookup returns the atom whose name is s. It returns zero if there is no
// such atom. The lookup is case sensitive.
func Lookup(s []byte) Atom {
if len(s) == 0 || len(s) > maxAtomLen {
return 0
}
h := fnv(hash0, s)
if a := table[h&uint32(len(table)-1)]; int(a&0xff) == len(s) && match(a.string(), s) {
return a
}
if a := table[(h>>16)&uint32(len(table)-1)]; int(a&0xff) == len(s) && match(a.string(), s) {
return a
}
return 0
}
// String returns a string whose contents are equal to s. In that sense, it is
// equivalent to string(s) but may be more efficient.
func String(s []byte) string {
if a := Lookup(s); a != 0 {
return a.String()
}
return string(s)
}

785
vendor/golang.org/x/net/html/atom/table.go generated vendored Normal file
View file

@ -0,0 +1,785 @@
// Code generated by go generate gen.go; DO NOT EDIT.
//go:generate go run gen.go
package atom
const (
A Atom = 0x1
Abbr Atom = 0x4
Accept Atom = 0x1a06
AcceptCharset Atom = 0x1a0e
Accesskey Atom = 0x2c09
Acronym Atom = 0xaa07
Action Atom = 0x26506
Address Atom = 0x6f107
Align Atom = 0xb105
Allowfullscreen Atom = 0x3280f
Allowpaymentrequest Atom = 0xc113
Allowusermedia Atom = 0xdd0e
Alt Atom = 0xf303
Annotation Atom = 0x1c90a
AnnotationXml Atom = 0x1c90e
Applet Atom = 0x30806
Area Atom = 0x35004
Article Atom = 0x3f607
As Atom = 0x3c02
Aside Atom = 0x10705
Async Atom = 0xff05
Audio Atom = 0x11505
Autocomplete Atom = 0x26b0c
Autofocus Atom = 0x12109
Autoplay Atom = 0x13c08
B Atom = 0x101
Base Atom = 0x3b04
Basefont Atom = 0x3b08
Bdi Atom = 0xba03
Bdo Atom = 0x14b03
Bgsound Atom = 0x15e07
Big Atom = 0x17003
Blink Atom = 0x17305
Blockquote Atom = 0x1870a
Body Atom = 0x2804
Br Atom = 0x202
Button Atom = 0x19106
Canvas Atom = 0x10306
Caption Atom = 0x22407
Center Atom = 0x21306
Challenge Atom = 0x28e09
Charset Atom = 0x2107
Checked Atom = 0x5b507
Cite Atom = 0x19c04
Class Atom = 0x55805
Code Atom = 0x5ee04
Col Atom = 0x1ab03
Colgroup Atom = 0x1ab08
Color Atom = 0x1bf05
Cols Atom = 0x1c404
Colspan Atom = 0x1c407
Command Atom = 0x1d707
Content Atom = 0x57b07
Contenteditable Atom = 0x57b0f
Contextmenu Atom = 0x37a0b
Controls Atom = 0x1de08
Coords Atom = 0x1f006
Crossorigin Atom = 0x1fa0b
Data Atom = 0x49904
Datalist Atom = 0x49908
Datetime Atom = 0x2ab08
Dd Atom = 0x2bf02
Default Atom = 0x10a07
Defer Atom = 0x5f005
Del Atom = 0x44c03
Desc Atom = 0x55504
Details Atom = 0x7207
Dfn Atom = 0x8703
Dialog Atom = 0xbb06
Dir Atom = 0x9303
Dirname Atom = 0x9307
Disabled Atom = 0x16408
Div Atom = 0x16b03
Dl Atom = 0x5d602
Download Atom = 0x45d08
Draggable Atom = 0x17a09
Dropzone Atom = 0x3ff08
Dt Atom = 0x64002
Em Atom = 0x6e02
Embed Atom = 0x6e05
Enctype Atom = 0x28007
Face Atom = 0x21104
Fieldset Atom = 0x21908
Figcaption Atom = 0x2210a
Figure Atom = 0x23b06
Font Atom = 0x3f04
Footer Atom = 0xf606
For Atom = 0x24703
ForeignObject Atom = 0x2470d
Foreignobject Atom = 0x2540d
Form Atom = 0x26104
Formaction Atom = 0x2610a
Formenctype Atom = 0x27c0b
Formmethod Atom = 0x2970a
Formnovalidate Atom = 0x2a10e
Formtarget Atom = 0x2b30a
Frame Atom = 0x8b05
Frameset Atom = 0x8b08
H1 Atom = 0x15c02
H2 Atom = 0x56102
H3 Atom = 0x2cd02
H4 Atom = 0x2fc02
H5 Atom = 0x33f02
H6 Atom = 0x34902
Head Atom = 0x32004
Header Atom = 0x32006
Headers Atom = 0x32007
Height Atom = 0x5206
Hgroup Atom = 0x64206
Hidden Atom = 0x2bd06
High Atom = 0x2ca04
Hr Atom = 0x15702
Href Atom = 0x2cf04
Hreflang Atom = 0x2cf08
Html Atom = 0x5604
HttpEquiv Atom = 0x2d70a
I Atom = 0x601
Icon Atom = 0x57a04
Id Atom = 0x10902
Iframe Atom = 0x2eb06
Image Atom = 0x2f105
Img Atom = 0x2f603
Input Atom = 0x44505
Inputmode Atom = 0x44509
Ins Atom = 0x20303
Integrity Atom = 0x23209
Is Atom = 0x16502
Isindex Atom = 0x2fe07
Ismap Atom = 0x30505
Itemid Atom = 0x38506
Itemprop Atom = 0x19d08
Itemref Atom = 0x3c707
Itemscope Atom = 0x66f09
Itemtype Atom = 0x30e08
Kbd Atom = 0xb903
Keygen Atom = 0x3206
Keytype Atom = 0xd607
Kind Atom = 0x17704
Label Atom = 0x5905
Lang Atom = 0x2d304
Legend Atom = 0x18106
Li Atom = 0xb202
Link Atom = 0x17404
List Atom = 0x49d04
Listing Atom = 0x49d07
Loop Atom = 0x5d04
Low Atom = 0xc303
Main Atom = 0x1004
Malignmark Atom = 0xb00a
Manifest Atom = 0x6d508
Map Atom = 0x30703
Mark Atom = 0xb604
Marquee Atom = 0x31607
Math Atom = 0x31d04
Max Atom = 0x33703
Maxlength Atom = 0x33709
Media Atom = 0xe605
Mediagroup Atom = 0xe60a
Menu Atom = 0x38104
Menuitem Atom = 0x38108
Meta Atom = 0x4ac04
Meter Atom = 0x9805
Method Atom = 0x29b06
Mglyph Atom = 0x2f706
Mi Atom = 0x34102
Min Atom = 0x34103
Minlength Atom = 0x34109
Mn Atom = 0x2a402
Mo Atom = 0xa402
Ms Atom = 0x67202
Mtext Atom = 0x34b05
Multiple Atom = 0x35908
Muted Atom = 0x36105
Name Atom = 0x9604
Nav Atom = 0x1303
Nobr Atom = 0x3704
Noembed Atom = 0x6c07
Noframes Atom = 0x8908
Nomodule Atom = 0xa208
Nonce Atom = 0x1a605
Noscript Atom = 0x2c208
Novalidate Atom = 0x2a50a
Object Atom = 0x25b06
Ol Atom = 0x13702
Onabort Atom = 0x19507
Onafterprint Atom = 0x2290c
Onautocomplete Atom = 0x2690e
Onautocompleteerror Atom = 0x26913
Onauxclick Atom = 0x6140a
Onbeforeprint Atom = 0x69c0d
Onbeforeunload Atom = 0x6e50e
Onblur Atom = 0x1ea06
Oncancel Atom = 0x11908
Oncanplay Atom = 0x14d09
Oncanplaythrough Atom = 0x14d10
Onchange Atom = 0x41508
Onclick Atom = 0x2e407
Onclose Atom = 0x36607
Oncontextmenu Atom = 0x3780d
Oncopy Atom = 0x38b06
Oncuechange Atom = 0x3910b
Oncut Atom = 0x39c05
Ondblclick Atom = 0x3a10a
Ondrag Atom = 0x3ab06
Ondragend Atom = 0x3ab09
Ondragenter Atom = 0x3b40b
Ondragexit Atom = 0x3bf0a
Ondragleave Atom = 0x3d90b
Ondragover Atom = 0x3e40a
Ondragstart Atom = 0x3ee0b
Ondrop Atom = 0x3fd06
Ondurationchange Atom = 0x40d10
Onemptied Atom = 0x40409
Onended Atom = 0x41d07
Onerror Atom = 0x42407
Onfocus Atom = 0x42b07
Onhashchange Atom = 0x4370c
Oninput Atom = 0x44307
Oninvalid Atom = 0x44f09
Onkeydown Atom = 0x45809
Onkeypress Atom = 0x4650a
Onkeyup Atom = 0x47407
Onlanguagechange Atom = 0x48110
Onload Atom = 0x49106
Onloadeddata Atom = 0x4910c
Onloadedmetadata Atom = 0x4a410
Onloadend Atom = 0x4ba09
Onloadstart Atom = 0x4c30b
Onmessage Atom = 0x4ce09
Onmessageerror Atom = 0x4ce0e
Onmousedown Atom = 0x4dc0b
Onmouseenter Atom = 0x4e70c
Onmouseleave Atom = 0x4f30c
Onmousemove Atom = 0x4ff0b
Onmouseout Atom = 0x50a0a
Onmouseover Atom = 0x5170b
Onmouseup Atom = 0x52209
Onmousewheel Atom = 0x5300c
Onoffline Atom = 0x53c09
Ononline Atom = 0x54508
Onpagehide Atom = 0x54d0a
Onpageshow Atom = 0x5630a
Onpaste Atom = 0x56f07
Onpause Atom = 0x58a07
Onplay Atom = 0x59406
Onplaying Atom = 0x59409
Onpopstate Atom = 0x59d0a
Onprogress Atom = 0x5a70a
Onratechange Atom = 0x5bc0c
Onrejectionhandled Atom = 0x5c812
Onreset Atom = 0x5da07
Onresize Atom = 0x5e108
Onscroll Atom = 0x5f508
Onsecuritypolicyviolation Atom = 0x5fd19
Onseeked Atom = 0x61e08
Onseeking Atom = 0x62609
Onselect Atom = 0x62f08
Onshow Atom = 0x63906
Onsort Atom = 0x64d06
Onstalled Atom = 0x65709
Onstorage Atom = 0x66009
Onsubmit Atom = 0x66908
Onsuspend Atom = 0x67909
Ontimeupdate Atom = 0x400c
Ontoggle Atom = 0x68208
Onunhandledrejection Atom = 0x68a14
Onunload Atom = 0x6a908
Onvolumechange Atom = 0x6b10e
Onwaiting Atom = 0x6bf09
Onwheel Atom = 0x6c807
Open Atom = 0x1a304
Optgroup Atom = 0x5f08
Optimum Atom = 0x6cf07
Option Atom = 0x6e106
Output Atom = 0x51106
P Atom = 0xc01
Param Atom = 0xc05
Pattern Atom = 0x6607
Picture Atom = 0x7b07
Ping Atom = 0xef04
Placeholder Atom = 0x1310b
Plaintext Atom = 0x1b209
Playsinline Atom = 0x1400b
Poster Atom = 0x64706
Pre Atom = 0x46a03
Preload Atom = 0x47a07
Progress Atom = 0x5a908
Prompt Atom = 0x52a06
Public Atom = 0x57606
Q Atom = 0xcf01
Radiogroup Atom = 0x30a
Rb Atom = 0x3a02
Readonly Atom = 0x35108
Referrerpolicy Atom = 0x3cb0e
Rel Atom = 0x47b03
Required Atom = 0x23f08
Reversed Atom = 0x8008
Rows Atom = 0x9c04
Rowspan Atom = 0x9c07
Rp Atom = 0x22f02
Rt Atom = 0x19a02
Rtc Atom = 0x19a03
Ruby Atom = 0xfb04
S Atom = 0x2501
Samp Atom = 0x7804
Sandbox Atom = 0x12907
Scope Atom = 0x67305
Scoped Atom = 0x67306
Script Atom = 0x2c406
Seamless Atom = 0x36b08
Search Atom = 0x55c06
Section Atom = 0x1e507
Select Atom = 0x63106
Selected Atom = 0x63108
Shape Atom = 0x1f505
Size Atom = 0x5e504
Sizes Atom = 0x5e505
Slot Atom = 0x20504
Small Atom = 0x32605
Sortable Atom = 0x64f08
Sorted Atom = 0x37206
Source Atom = 0x43106
Spacer Atom = 0x46e06
Span Atom = 0x9f04
Spellcheck Atom = 0x5b00a
Src Atom = 0x5e903
Srcdoc Atom = 0x5e906
Srclang Atom = 0x6f707
Srcset Atom = 0x6fe06
Start Atom = 0x3f405
Step Atom = 0x57304
Strike Atom = 0xd206
Strong Atom = 0x6db06
Style Atom = 0x70405
Sub Atom = 0x66b03
Summary Atom = 0x70907
Sup Atom = 0x71003
Svg Atom = 0x71303
System Atom = 0x71606
Tabindex Atom = 0x4b208
Table Atom = 0x58505
Target Atom = 0x2b706
Tbody Atom = 0x2705
Td Atom = 0x9202
Template Atom = 0x71908
Textarea Atom = 0x34c08
Tfoot Atom = 0xf505
Th Atom = 0x15602
Thead Atom = 0x31f05
Time Atom = 0x4204
Title Atom = 0x11005
Tr Atom = 0xcc02
Track Atom = 0x1ba05
Translate Atom = 0x20809
Tt Atom = 0x6802
Type Atom = 0xd904
Typemustmatch Atom = 0x2830d
U Atom = 0xb01
Ul Atom = 0xa702
Updateviacache Atom = 0x460e
Usemap Atom = 0x58e06
Value Atom = 0x1505
Var Atom = 0x16d03
Video Atom = 0x2e005
Wbr Atom = 0x56c03
Width Atom = 0x63e05
Workertype Atom = 0x7210a
Wrap Atom = 0x72b04
Xmp Atom = 0x12f03
)
const hash0 = 0x84f70e16
const maxAtomLen = 25
var table = [1 << 9]Atom{
0x1: 0x3ff08, // dropzone
0x2: 0x3b08, // basefont
0x3: 0x23209, // integrity
0x4: 0x43106, // source
0x5: 0x2c09, // accesskey
0x6: 0x1a06, // accept
0x7: 0x6c807, // onwheel
0xb: 0x47407, // onkeyup
0xc: 0x32007, // headers
0xd: 0x67306, // scoped
0xe: 0x67909, // onsuspend
0xf: 0x8908, // noframes
0x10: 0x1fa0b, // crossorigin
0x11: 0x2e407, // onclick
0x12: 0x3f405, // start
0x13: 0x37a0b, // contextmenu
0x14: 0x5e903, // src
0x15: 0x1c404, // cols
0x16: 0xbb06, // dialog
0x17: 0x47a07, // preload
0x18: 0x3c707, // itemref
0x1b: 0x2f105, // image
0x1d: 0x4ba09, // onloadend
0x1e: 0x45d08, // download
0x1f: 0x46a03, // pre
0x23: 0x2970a, // formmethod
0x24: 0x71303, // svg
0x25: 0xcf01, // q
0x26: 0x64002, // dt
0x27: 0x1de08, // controls
0x2a: 0x2804, // body
0x2b: 0xd206, // strike
0x2c: 0x3910b, // oncuechange
0x2d: 0x4c30b, // onloadstart
0x2e: 0x2fe07, // isindex
0x2f: 0xb202, // li
0x30: 0x1400b, // playsinline
0x31: 0x34102, // mi
0x32: 0x30806, // applet
0x33: 0x4ce09, // onmessage
0x35: 0x13702, // ol
0x36: 0x1a304, // open
0x39: 0x14d09, // oncanplay
0x3a: 0x6bf09, // onwaiting
0x3b: 0x11908, // oncancel
0x3c: 0x6a908, // onunload
0x3e: 0x53c09, // onoffline
0x3f: 0x1a0e, // accept-charset
0x40: 0x32004, // head
0x42: 0x3ab09, // ondragend
0x43: 0x1310b, // placeholder
0x44: 0x2b30a, // formtarget
0x45: 0x2540d, // foreignobject
0x47: 0x400c, // ontimeupdate
0x48: 0xdd0e, // allowusermedia
0x4a: 0x69c0d, // onbeforeprint
0x4b: 0x5604, // html
0x4c: 0x9f04, // span
0x4d: 0x64206, // hgroup
0x4e: 0x16408, // disabled
0x4f: 0x4204, // time
0x51: 0x42b07, // onfocus
0x53: 0xb00a, // malignmark
0x55: 0x4650a, // onkeypress
0x56: 0x55805, // class
0x57: 0x1ab08, // colgroup
0x58: 0x33709, // maxlength
0x59: 0x5a908, // progress
0x5b: 0x70405, // style
0x5c: 0x2a10e, // formnovalidate
0x5e: 0x38b06, // oncopy
0x60: 0x26104, // form
0x61: 0xf606, // footer
0x64: 0x30a, // radiogroup
0x66: 0xfb04, // ruby
0x67: 0x4ff0b, // onmousemove
0x68: 0x19d08, // itemprop
0x69: 0x2d70a, // http-equiv
0x6a: 0x15602, // th
0x6c: 0x6e02, // em
0x6d: 0x38108, // menuitem
0x6e: 0x63106, // select
0x6f: 0x48110, // onlanguagechange
0x70: 0x31f05, // thead
0x71: 0x15c02, // h1
0x72: 0x5e906, // srcdoc
0x75: 0x9604, // name
0x76: 0x19106, // button
0x77: 0x55504, // desc
0x78: 0x17704, // kind
0x79: 0x1bf05, // color
0x7c: 0x58e06, // usemap
0x7d: 0x30e08, // itemtype
0x7f: 0x6d508, // manifest
0x81: 0x5300c, // onmousewheel
0x82: 0x4dc0b, // onmousedown
0x84: 0xc05, // param
0x85: 0x2e005, // video
0x86: 0x4910c, // onloadeddata
0x87: 0x6f107, // address
0x8c: 0xef04, // ping
0x8d: 0x24703, // for
0x8f: 0x62f08, // onselect
0x90: 0x30703, // map
0x92: 0xc01, // p
0x93: 0x8008, // reversed
0x94: 0x54d0a, // onpagehide
0x95: 0x3206, // keygen
0x96: 0x34109, // minlength
0x97: 0x3e40a, // ondragover
0x98: 0x42407, // onerror
0x9a: 0x2107, // charset
0x9b: 0x29b06, // method
0x9c: 0x101, // b
0x9d: 0x68208, // ontoggle
0x9e: 0x2bd06, // hidden
0xa0: 0x3f607, // article
0xa2: 0x63906, // onshow
0xa3: 0x64d06, // onsort
0xa5: 0x57b0f, // contenteditable
0xa6: 0x66908, // onsubmit
0xa8: 0x44f09, // oninvalid
0xaa: 0x202, // br
0xab: 0x10902, // id
0xac: 0x5d04, // loop
0xad: 0x5630a, // onpageshow
0xb0: 0x2cf04, // href
0xb2: 0x2210a, // figcaption
0xb3: 0x2690e, // onautocomplete
0xb4: 0x49106, // onload
0xb6: 0x9c04, // rows
0xb7: 0x1a605, // nonce
0xb8: 0x68a14, // onunhandledrejection
0xbb: 0x21306, // center
0xbc: 0x59406, // onplay
0xbd: 0x33f02, // h5
0xbe: 0x49d07, // listing
0xbf: 0x57606, // public
0xc2: 0x23b06, // figure
0xc3: 0x57a04, // icon
0xc4: 0x1ab03, // col
0xc5: 0x47b03, // rel
0xc6: 0xe605, // media
0xc7: 0x12109, // autofocus
0xc8: 0x19a02, // rt
0xca: 0x2d304, // lang
0xcc: 0x49908, // datalist
0xce: 0x2eb06, // iframe
0xcf: 0x36105, // muted
0xd0: 0x6140a, // onauxclick
0xd2: 0x3c02, // as
0xd6: 0x3fd06, // ondrop
0xd7: 0x1c90a, // annotation
0xd8: 0x21908, // fieldset
0xdb: 0x2cf08, // hreflang
0xdc: 0x4e70c, // onmouseenter
0xdd: 0x2a402, // mn
0xde: 0xe60a, // mediagroup
0xdf: 0x9805, // meter
0xe0: 0x56c03, // wbr
0xe2: 0x63e05, // width
0xe3: 0x2290c, // onafterprint
0xe4: 0x30505, // ismap
0xe5: 0x1505, // value
0xe7: 0x1303, // nav
0xe8: 0x54508, // ononline
0xe9: 0xb604, // mark
0xea: 0xc303, // low
0xeb: 0x3ee0b, // ondragstart
0xef: 0x12f03, // xmp
0xf0: 0x22407, // caption
0xf1: 0xd904, // type
0xf2: 0x70907, // summary
0xf3: 0x6802, // tt
0xf4: 0x20809, // translate
0xf5: 0x1870a, // blockquote
0xf8: 0x15702, // hr
0xfa: 0x2705, // tbody
0xfc: 0x7b07, // picture
0xfd: 0x5206, // height
0xfe: 0x19c04, // cite
0xff: 0x2501, // s
0x101: 0xff05, // async
0x102: 0x56f07, // onpaste
0x103: 0x19507, // onabort
0x104: 0x2b706, // target
0x105: 0x14b03, // bdo
0x106: 0x1f006, // coords
0x107: 0x5e108, // onresize
0x108: 0x71908, // template
0x10a: 0x3a02, // rb
0x10b: 0x2a50a, // novalidate
0x10c: 0x460e, // updateviacache
0x10d: 0x71003, // sup
0x10e: 0x6c07, // noembed
0x10f: 0x16b03, // div
0x110: 0x6f707, // srclang
0x111: 0x17a09, // draggable
0x112: 0x67305, // scope
0x113: 0x5905, // label
0x114: 0x22f02, // rp
0x115: 0x23f08, // required
0x116: 0x3780d, // oncontextmenu
0x117: 0x5e504, // size
0x118: 0x5b00a, // spellcheck
0x119: 0x3f04, // font
0x11a: 0x9c07, // rowspan
0x11b: 0x10a07, // default
0x11d: 0x44307, // oninput
0x11e: 0x38506, // itemid
0x11f: 0x5ee04, // code
0x120: 0xaa07, // acronym
0x121: 0x3b04, // base
0x125: 0x2470d, // foreignObject
0x126: 0x2ca04, // high
0x127: 0x3cb0e, // referrerpolicy
0x128: 0x33703, // max
0x129: 0x59d0a, // onpopstate
0x12a: 0x2fc02, // h4
0x12b: 0x4ac04, // meta
0x12c: 0x17305, // blink
0x12e: 0x5f508, // onscroll
0x12f: 0x59409, // onplaying
0x130: 0xc113, // allowpaymentrequest
0x131: 0x19a03, // rtc
0x132: 0x72b04, // wrap
0x134: 0x8b08, // frameset
0x135: 0x32605, // small
0x137: 0x32006, // header
0x138: 0x40409, // onemptied
0x139: 0x34902, // h6
0x13a: 0x35908, // multiple
0x13c: 0x52a06, // prompt
0x13f: 0x28e09, // challenge
0x141: 0x4370c, // onhashchange
0x142: 0x57b07, // content
0x143: 0x1c90e, // annotation-xml
0x144: 0x36607, // onclose
0x145: 0x14d10, // oncanplaythrough
0x148: 0x5170b, // onmouseover
0x149: 0x64f08, // sortable
0x14a: 0xa402, // mo
0x14b: 0x2cd02, // h3
0x14c: 0x2c406, // script
0x14d: 0x41d07, // onended
0x14f: 0x64706, // poster
0x150: 0x7210a, // workertype
0x153: 0x1f505, // shape
0x154: 0x4, // abbr
0x155: 0x1, // a
0x156: 0x2bf02, // dd
0x157: 0x71606, // system
0x158: 0x4ce0e, // onmessageerror
0x159: 0x36b08, // seamless
0x15a: 0x2610a, // formaction
0x15b: 0x6e106, // option
0x15c: 0x31d04, // math
0x15d: 0x62609, // onseeking
0x15e: 0x39c05, // oncut
0x15f: 0x44c03, // del
0x160: 0x11005, // title
0x161: 0x11505, // audio
0x162: 0x63108, // selected
0x165: 0x3b40b, // ondragenter
0x166: 0x46e06, // spacer
0x167: 0x4a410, // onloadedmetadata
0x168: 0x44505, // input
0x16a: 0x58505, // table
0x16b: 0x41508, // onchange
0x16e: 0x5f005, // defer
0x171: 0x50a0a, // onmouseout
0x172: 0x20504, // slot
0x175: 0x3704, // nobr
0x177: 0x1d707, // command
0x17a: 0x7207, // details
0x17b: 0x38104, // menu
0x17c: 0xb903, // kbd
0x17d: 0x57304, // step
0x17e: 0x20303, // ins
0x17f: 0x13c08, // autoplay
0x182: 0x34103, // min
0x183: 0x17404, // link
0x185: 0x40d10, // ondurationchange
0x186: 0x9202, // td
0x187: 0x8b05, // frame
0x18a: 0x2ab08, // datetime
0x18b: 0x44509, // inputmode
0x18c: 0x35108, // readonly
0x18d: 0x21104, // face
0x18f: 0x5e505, // sizes
0x191: 0x4b208, // tabindex
0x192: 0x6db06, // strong
0x193: 0xba03, // bdi
0x194: 0x6fe06, // srcset
0x196: 0x67202, // ms
0x197: 0x5b507, // checked
0x198: 0xb105, // align
0x199: 0x1e507, // section
0x19b: 0x6e05, // embed
0x19d: 0x15e07, // bgsound
0x1a2: 0x49d04, // list
0x1a3: 0x61e08, // onseeked
0x1a4: 0x66009, // onstorage
0x1a5: 0x2f603, // img
0x1a6: 0xf505, // tfoot
0x1a9: 0x26913, // onautocompleteerror
0x1aa: 0x5fd19, // onsecuritypolicyviolation
0x1ad: 0x9303, // dir
0x1ae: 0x9307, // dirname
0x1b0: 0x5a70a, // onprogress
0x1b2: 0x65709, // onstalled
0x1b5: 0x66f09, // itemscope
0x1b6: 0x49904, // data
0x1b7: 0x3d90b, // ondragleave
0x1b8: 0x56102, // h2
0x1b9: 0x2f706, // mglyph
0x1ba: 0x16502, // is
0x1bb: 0x6e50e, // onbeforeunload
0x1bc: 0x2830d, // typemustmatch
0x1bd: 0x3ab06, // ondrag
0x1be: 0x5da07, // onreset
0x1c0: 0x51106, // output
0x1c1: 0x12907, // sandbox
0x1c2: 0x1b209, // plaintext
0x1c4: 0x34c08, // textarea
0x1c7: 0xd607, // keytype
0x1c8: 0x34b05, // mtext
0x1c9: 0x6b10e, // onvolumechange
0x1ca: 0x1ea06, // onblur
0x1cb: 0x58a07, // onpause
0x1cd: 0x5bc0c, // onratechange
0x1ce: 0x10705, // aside
0x1cf: 0x6cf07, // optimum
0x1d1: 0x45809, // onkeydown
0x1d2: 0x1c407, // colspan
0x1d3: 0x1004, // main
0x1d4: 0x66b03, // sub
0x1d5: 0x25b06, // object
0x1d6: 0x55c06, // search
0x1d7: 0x37206, // sorted
0x1d8: 0x17003, // big
0x1d9: 0xb01, // u
0x1db: 0x26b0c, // autocomplete
0x1dc: 0xcc02, // tr
0x1dd: 0xf303, // alt
0x1df: 0x7804, // samp
0x1e0: 0x5c812, // onrejectionhandled
0x1e1: 0x4f30c, // onmouseleave
0x1e2: 0x28007, // enctype
0x1e3: 0xa208, // nomodule
0x1e5: 0x3280f, // allowfullscreen
0x1e6: 0x5f08, // optgroup
0x1e8: 0x27c0b, // formenctype
0x1e9: 0x18106, // legend
0x1ea: 0x10306, // canvas
0x1eb: 0x6607, // pattern
0x1ec: 0x2c208, // noscript
0x1ed: 0x601, // i
0x1ee: 0x5d602, // dl
0x1ef: 0xa702, // ul
0x1f2: 0x52209, // onmouseup
0x1f4: 0x1ba05, // track
0x1f7: 0x3a10a, // ondblclick
0x1f8: 0x3bf0a, // ondragexit
0x1fa: 0x8703, // dfn
0x1fc: 0x26506, // action
0x1fd: 0x35004, // area
0x1fe: 0x31607, // marquee
0x1ff: 0x16d03, // var
}
const atomText = "abbradiogrouparamainavalueaccept-charsetbodyaccesskeygenobrb" +
"asefontimeupdateviacacheightmlabelooptgroupatternoembedetail" +
"sampictureversedfnoframesetdirnameterowspanomoduleacronymali" +
"gnmarkbdialogallowpaymentrequestrikeytypeallowusermediagroup" +
"ingaltfooterubyasyncanvasidefaultitleaudioncancelautofocusan" +
"dboxmplaceholderautoplaysinlinebdoncanplaythrough1bgsoundisa" +
"bledivarbigblinkindraggablegendblockquotebuttonabortcitempro" +
"penoncecolgrouplaintextrackcolorcolspannotation-xmlcommandco" +
"ntrolsectionblurcoordshapecrossoriginslotranslatefacenterfie" +
"ldsetfigcaptionafterprintegrityfigurequiredforeignObjectfore" +
"ignobjectformactionautocompleteerrorformenctypemustmatchalle" +
"ngeformmethodformnovalidatetimeformtargethiddenoscripthigh3h" +
"reflanghttp-equivideonclickiframeimageimglyph4isindexismappl" +
"etitemtypemarqueematheadersmallowfullscreenmaxlength5minleng" +
"th6mtextareadonlymultiplemutedoncloseamlessortedoncontextmen" +
"uitemidoncopyoncuechangeoncutondblclickondragendondragentero" +
"ndragexitemreferrerpolicyondragleaveondragoverondragstarticl" +
"eondropzonemptiedondurationchangeonendedonerroronfocusourceo" +
"nhashchangeoninputmodeloninvalidonkeydownloadonkeypresspacer" +
"onkeyupreloadonlanguagechangeonloadeddatalistingonloadedmeta" +
"databindexonloadendonloadstartonmessageerroronmousedownonmou" +
"seenteronmouseleaveonmousemoveonmouseoutputonmouseoveronmous" +
"eupromptonmousewheelonofflineononlineonpagehidesclassearch2o" +
"npageshowbronpastepublicontenteditableonpausemaponplayingonp" +
"opstateonprogresspellcheckedonratechangeonrejectionhandledon" +
"resetonresizesrcdocodeferonscrollonsecuritypolicyviolationau" +
"xclickonseekedonseekingonselectedonshowidthgrouposteronsorta" +
"bleonstalledonstorageonsubmitemscopedonsuspendontoggleonunha" +
"ndledrejectionbeforeprintonunloadonvolumechangeonwaitingonwh" +
"eeloptimumanifestrongoptionbeforeunloaddressrclangsrcsetstyl" +
"esummarysupsvgsystemplateworkertypewrap"

111
vendor/golang.org/x/net/html/const.go generated vendored Normal file
View file

@ -0,0 +1,111 @@
// Copyright 2011 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package html
// Section 12.2.4.2 of the HTML5 specification says "The following elements
// have varying levels of special parsing rules".
// https://html.spec.whatwg.org/multipage/syntax.html#the-stack-of-open-elements
var isSpecialElementMap = map[string]bool{
"address": true,
"applet": true,
"area": true,
"article": true,
"aside": true,
"base": true,
"basefont": true,
"bgsound": true,
"blockquote": true,
"body": true,
"br": true,
"button": true,
"caption": true,
"center": true,
"col": true,
"colgroup": true,
"dd": true,
"details": true,
"dir": true,
"div": true,
"dl": true,
"dt": true,
"embed": true,
"fieldset": true,
"figcaption": true,
"figure": true,
"footer": true,
"form": true,
"frame": true,
"frameset": true,
"h1": true,
"h2": true,
"h3": true,
"h4": true,
"h5": true,
"h6": true,
"head": true,
"header": true,
"hgroup": true,
"hr": true,
"html": true,
"iframe": true,
"img": true,
"input": true,
"keygen": true, // "keygen" has been removed from the spec, but are kept here for backwards compatibility.
"li": true,
"link": true,
"listing": true,
"main": true,
"marquee": true,
"menu": true,
"meta": true,
"nav": true,
"noembed": true,
"noframes": true,
"noscript": true,
"object": true,
"ol": true,
"p": true,
"param": true,
"plaintext": true,
"pre": true,
"script": true,
"section": true,
"select": true,
"source": true,
"style": true,
"summary": true,
"table": true,
"tbody": true,
"td": true,
"template": true,
"textarea": true,
"tfoot": true,
"th": true,
"thead": true,
"title": true,
"tr": true,
"track": true,
"ul": true,
"wbr": true,
"xmp": true,
}
func isSpecialElement(element *Node) bool {
switch element.Namespace {
case "", "html":
return isSpecialElementMap[element.Data]
case "math":
switch element.Data {
case "mi", "mo", "mn", "ms", "mtext", "annotation-xml":
return true
}
case "svg":
switch element.Data {
case "foreignObject", "desc", "title":
return true
}
}
return false
}

122
vendor/golang.org/x/net/html/doc.go generated vendored Normal file
View file

@ -0,0 +1,122 @@
// Copyright 2010 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
/*
Package html implements an HTML5-compliant tokenizer and parser.
Tokenization is done by creating a Tokenizer for an io.Reader r. It is the
caller's responsibility to ensure that r provides UTF-8 encoded HTML.
z := html.NewTokenizer(r)
Given a Tokenizer z, the HTML is tokenized by repeatedly calling z.Next(),
which parses the next token and returns its type, or an error:
for {
tt := z.Next()
if tt == html.ErrorToken {
// ...
return ...
}
// Process the current token.
}
There are two APIs for retrieving the current token. The high-level API is to
call Token; the low-level API is to call Text or TagName / TagAttr. Both APIs
allow optionally calling Raw after Next but before Token, Text, TagName, or
TagAttr. In EBNF notation, the valid call sequence per token is:
Next {Raw} [ Token | Text | TagName {TagAttr} ]
Token returns an independent data structure that completely describes a token.
Entities (such as "&lt;") are unescaped, tag names and attribute keys are
lower-cased, and attributes are collected into a []Attribute. For example:
for {
if z.Next() == html.ErrorToken {
// Returning io.EOF indicates success.
return z.Err()
}
emitToken(z.Token())
}
The low-level API performs fewer allocations and copies, but the contents of
the []byte values returned by Text, TagName and TagAttr may change on the next
call to Next. For example, to extract an HTML page's anchor text:
depth := 0
for {
tt := z.Next()
switch tt {
case html.ErrorToken:
return z.Err()
case html.TextToken:
if depth > 0 {
// emitBytes should copy the []byte it receives,
// if it doesn't process it immediately.
emitBytes(z.Text())
}
case html.StartTagToken, html.EndTagToken:
tn, _ := z.TagName()
if len(tn) == 1 && tn[0] == 'a' {
if tt == html.StartTagToken {
depth++
} else {
depth--
}
}
}
}
Parsing is done by calling Parse with an io.Reader, which returns the root of
the parse tree (the document element) as a *Node. It is the caller's
responsibility to ensure that the Reader provides UTF-8 encoded HTML. For
example, to process each anchor node in depth-first order:
doc, err := html.Parse(r)
if err != nil {
// ...
}
for n := range doc.Descendants() {
if n.Type == html.ElementNode && n.Data == "a" {
// Do something with n...
}
}
The relevant specifications include:
https://html.spec.whatwg.org/multipage/syntax.html and
https://html.spec.whatwg.org/multipage/syntax.html#tokenization
# Security Considerations
Care should be taken when parsing and interpreting HTML, whether full documents
or fragments, within the framework of the HTML specification, especially with
regard to untrusted inputs.
This package provides both a tokenizer and a parser, which implement the
tokenization, and tokenization and tree construction stages of the WHATWG HTML
parsing specification respectively. While the tokenizer parses and normalizes
individual HTML tokens, only the parser constructs the DOM tree from the
tokenized HTML, as described in the tree construction stage of the
specification, dynamically modifying or extending the document's DOM tree.
If your use case requires semantically well-formed HTML documents, as defined by
the WHATWG specification, the parser should be used rather than the tokenizer.
In security contexts, if trust decisions are being made using the tokenized or
parsed content, the input must be re-serialized (for instance by using Render or
Token.String) in order for those trust decisions to hold, as the process of
tokenization or parsing may alter the content.
*/
package html // import "golang.org/x/net/html"
// The tokenization algorithm implemented by this package is not a line-by-line
// transliteration of the relatively verbose state-machine in the WHATWG
// specification. A more direct approach is used instead, where the program
// counter implies the state, such as whether it is tokenizing a tag or a text
// node. Specification compliance is verified by checking expected and actual
// outputs over a test suite rather than aiming for algorithmic fidelity.
// TODO(nigeltao): Does a DOM API belong in this package or a separate one?
// TODO(nigeltao): How does parsing interact with a JavaScript engine?

156
vendor/golang.org/x/net/html/doctype.go generated vendored Normal file
View file

@ -0,0 +1,156 @@
// Copyright 2011 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package html
import (
"strings"
)
// parseDoctype parses the data from a DoctypeToken into a name,
// public identifier, and system identifier. It returns a Node whose Type
// is DoctypeNode, whose Data is the name, and which has attributes
// named "system" and "public" for the two identifiers if they were present.
// quirks is whether the document should be parsed in "quirks mode".
func parseDoctype(s string) (n *Node, quirks bool) {
n = &Node{Type: DoctypeNode}
// Find the name.
space := strings.IndexAny(s, whitespace)
if space == -1 {
space = len(s)
}
n.Data = s[:space]
// The comparison to "html" is case-sensitive.
if n.Data != "html" {
quirks = true
}
n.Data = strings.ToLower(n.Data)
s = strings.TrimLeft(s[space:], whitespace)
if len(s) < 6 {
// It can't start with "PUBLIC" or "SYSTEM".
// Ignore the rest of the string.
return n, quirks || s != ""
}
key := strings.ToLower(s[:6])
s = s[6:]
for key == "public" || key == "system" {
s = strings.TrimLeft(s, whitespace)
if s == "" {
break
}
quote := s[0]
if quote != '"' && quote != '\'' {
break
}
s = s[1:]
q := strings.IndexRune(s, rune(quote))
var id string
if q == -1 {
id = s
s = ""
} else {
id = s[:q]
s = s[q+1:]
}
n.Attr = append(n.Attr, Attribute{Key: key, Val: id})
if key == "public" {
key = "system"
} else {
key = ""
}
}
if key != "" || s != "" {
quirks = true
} else if len(n.Attr) > 0 {
if n.Attr[0].Key == "public" {
public := strings.ToLower(n.Attr[0].Val)
switch public {
case "-//w3o//dtd w3 html strict 3.0//en//", "-/w3d/dtd html 4.0 transitional/en", "html":
quirks = true
default:
for _, q := range quirkyIDs {
if strings.HasPrefix(public, q) {
quirks = true
break
}
}
}
// The following two public IDs only cause quirks mode if there is no system ID.
if len(n.Attr) == 1 && (strings.HasPrefix(public, "-//w3c//dtd html 4.01 frameset//") ||
strings.HasPrefix(public, "-//w3c//dtd html 4.01 transitional//")) {
quirks = true
}
}
if lastAttr := n.Attr[len(n.Attr)-1]; lastAttr.Key == "system" &&
strings.EqualFold(lastAttr.Val, "http://www.ibm.com/data/dtd/v11/ibmxhtml1-transitional.dtd") {
quirks = true
}
}
return n, quirks
}
// quirkyIDs is a list of public doctype identifiers that cause a document
// to be interpreted in quirks mode. The identifiers should be in lower case.
var quirkyIDs = []string{
"+//silmaril//dtd html pro v0r11 19970101//",
"-//advasoft ltd//dtd html 3.0 aswedit + extensions//",
"-//as//dtd html 3.0 aswedit + extensions//",
"-//ietf//dtd html 2.0 level 1//",
"-//ietf//dtd html 2.0 level 2//",
"-//ietf//dtd html 2.0 strict level 1//",
"-//ietf//dtd html 2.0 strict level 2//",
"-//ietf//dtd html 2.0 strict//",
"-//ietf//dtd html 2.0//",
"-//ietf//dtd html 2.1e//",
"-//ietf//dtd html 3.0//",
"-//ietf//dtd html 3.2 final//",
"-//ietf//dtd html 3.2//",
"-//ietf//dtd html 3//",
"-//ietf//dtd html level 0//",
"-//ietf//dtd html level 1//",
"-//ietf//dtd html level 2//",
"-//ietf//dtd html level 3//",
"-//ietf//dtd html strict level 0//",
"-//ietf//dtd html strict level 1//",
"-//ietf//dtd html strict level 2//",
"-//ietf//dtd html strict level 3//",
"-//ietf//dtd html strict//",
"-//ietf//dtd html//",
"-//metrius//dtd metrius presentational//",
"-//microsoft//dtd internet explorer 2.0 html strict//",
"-//microsoft//dtd internet explorer 2.0 html//",
"-//microsoft//dtd internet explorer 2.0 tables//",
"-//microsoft//dtd internet explorer 3.0 html strict//",
"-//microsoft//dtd internet explorer 3.0 html//",
"-//microsoft//dtd internet explorer 3.0 tables//",
"-//netscape comm. corp.//dtd html//",
"-//netscape comm. corp.//dtd strict html//",
"-//o'reilly and associates//dtd html 2.0//",
"-//o'reilly and associates//dtd html extended 1.0//",
"-//o'reilly and associates//dtd html extended relaxed 1.0//",
"-//softquad software//dtd hotmetal pro 6.0::19990601::extensions to html 4.0//",
"-//softquad//dtd hotmetal pro 4.0::19971010::extensions to html 4.0//",
"-//spyglass//dtd html 2.0 extended//",
"-//sq//dtd html 2.0 hotmetal + extensions//",
"-//sun microsystems corp.//dtd hotjava html//",
"-//sun microsystems corp.//dtd hotjava strict html//",
"-//w3c//dtd html 3 1995-03-24//",
"-//w3c//dtd html 3.2 draft//",
"-//w3c//dtd html 3.2 final//",
"-//w3c//dtd html 3.2//",
"-//w3c//dtd html 3.2s draft//",
"-//w3c//dtd html 4.0 frameset//",
"-//w3c//dtd html 4.0 transitional//",
"-//w3c//dtd html experimental 19960712//",
"-//w3c//dtd html experimental 970421//",
"-//w3c//dtd w3 html//",
"-//w3o//dtd w3 html 3.0//",
"-//webtechs//dtd mozilla html 2.0//",
"-//webtechs//dtd mozilla html//",
}

2253
vendor/golang.org/x/net/html/entity.go generated vendored Normal file
View file

File diff suppressed because it is too large Load diff

339
vendor/golang.org/x/net/html/escape.go generated vendored Normal file
View file

@ -0,0 +1,339 @@
// Copyright 2010 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package html
import (
"bytes"
"strings"
"unicode/utf8"
)
// These replacements permit compatibility with old numeric entities that
// assumed Windows-1252 encoding.
// https://html.spec.whatwg.org/multipage/syntax.html#consume-a-character-reference
var replacementTable = [...]rune{
'\u20AC', // First entry is what 0x80 should be replaced with.
'\u0081',
'\u201A',
'\u0192',
'\u201E',
'\u2026',
'\u2020',
'\u2021',
'\u02C6',
'\u2030',
'\u0160',
'\u2039',
'\u0152',
'\u008D',
'\u017D',
'\u008F',
'\u0090',
'\u2018',
'\u2019',
'\u201C',
'\u201D',
'\u2022',
'\u2013',
'\u2014',
'\u02DC',
'\u2122',
'\u0161',
'\u203A',
'\u0153',
'\u009D',
'\u017E',
'\u0178', // Last entry is 0x9F.
// 0x00->'\uFFFD' is handled programmatically.
// 0x0D->'\u000D' is a no-op.
}
// unescapeEntity reads an entity like "&lt;" from b[src:] and writes the
// corresponding "<" to b[dst:], returning the incremented dst and src cursors.
// Precondition: b[src] == '&' && dst <= src.
// attribute should be true if parsing an attribute value.
func unescapeEntity(b []byte, dst, src int, attribute bool) (dst1, src1 int) {
// https://html.spec.whatwg.org/multipage/syntax.html#consume-a-character-reference
// i starts at 1 because we already know that s[0] == '&'.
i, s := 1, b[src:]
if len(s) <= 1 {
b[dst] = b[src]
return dst + 1, src + 1
}
if s[i] == '#' {
if len(s) <= 3 { // We need to have at least "&#.".
b[dst] = b[src]
return dst + 1, src + 1
}
i++
c := s[i]
hex := false
if c == 'x' || c == 'X' {
hex = true
i++
}
x := '\x00'
for i < len(s) {
c = s[i]
i++
if hex {
if '0' <= c && c <= '9' {
x = 16*x + rune(c) - '0'
continue
} else if 'a' <= c && c <= 'f' {
x = 16*x + rune(c) - 'a' + 10
continue
} else if 'A' <= c && c <= 'F' {
x = 16*x + rune(c) - 'A' + 10
continue
}
} else if '0' <= c && c <= '9' {
x = 10*x + rune(c) - '0'
continue
}
if c != ';' {
i--
}
break
}
if i <= 3 { // No characters matched.
b[dst] = b[src]
return dst + 1, src + 1
}
if 0x80 <= x && x <= 0x9F {
// Replace characters from Windows-1252 with UTF-8 equivalents.
x = replacementTable[x-0x80]
} else if x == 0 || (0xD800 <= x && x <= 0xDFFF) || x > 0x10FFFF {
// Replace invalid characters with the replacement character.
x = '\uFFFD'
}
return dst + utf8.EncodeRune(b[dst:], x), src + i
}
// Consume the maximum number of characters possible, with the
// consumed characters matching one of the named references.
for i < len(s) {
c := s[i]
i++
// Lower-cased characters are more common in entities, so we check for them first.
if 'a' <= c && c <= 'z' || 'A' <= c && c <= 'Z' || '0' <= c && c <= '9' {
continue
}
if c != ';' {
i--
}
break
}
entityName := string(s[1:i])
if entityName == "" {
// No-op.
} else if attribute && entityName[len(entityName)-1] != ';' && len(s) > i && s[i] == '=' {
// No-op.
} else if x := entity[entityName]; x != 0 {
return dst + utf8.EncodeRune(b[dst:], x), src + i
} else if x := entity2[entityName]; x[0] != 0 {
dst1 := dst + utf8.EncodeRune(b[dst:], x[0])
return dst1 + utf8.EncodeRune(b[dst1:], x[1]), src + i
} else if !attribute {
maxLen := len(entityName) - 1
if maxLen > longestEntityWithoutSemicolon {
maxLen = longestEntityWithoutSemicolon
}
for j := maxLen; j > 1; j-- {
if x := entity[entityName[:j]]; x != 0 {
return dst + utf8.EncodeRune(b[dst:], x), src + j + 1
}
}
}
dst1, src1 = dst+i, src+i
copy(b[dst:dst1], b[src:src1])
return dst1, src1
}
// unescape unescapes b's entities in-place, so that "a&lt;b" becomes "a<b".
// attribute should be true if parsing an attribute value.
func unescape(b []byte, attribute bool) []byte {
for i, c := range b {
if c == '&' {
dst, src := unescapeEntity(b, i, i, attribute)
for src < len(b) {
c := b[src]
if c == '&' {
dst, src = unescapeEntity(b, dst, src, attribute)
} else {
b[dst] = c
dst, src = dst+1, src+1
}
}
return b[0:dst]
}
}
return b
}
// lower lower-cases the A-Z bytes in b in-place, so that "aBc" becomes "abc".
func lower(b []byte) []byte {
for i, c := range b {
if 'A' <= c && c <= 'Z' {
b[i] = c + 'a' - 'A'
}
}
return b
}
// escapeComment is like func escape but escapes its input bytes less often.
// Per https://github.com/golang/go/issues/58246 some HTML comments are (1)
// meaningful and (2) contain angle brackets that we'd like to avoid escaping
// unless we have to.
//
// "We have to" includes the '&' byte, since that introduces other escapes.
//
// It also includes those bytes (not including EOF) that would otherwise end
// the comment. Per the summary table at the bottom of comment_test.go, this is
// the '>' byte that, per above, we'd like to avoid escaping unless we have to.
//
// Studying the summary table (and T actions in its '>' column) closely, we
// only need to escape in states 43, 44, 49, 51 and 52. State 43 is at the
// start of the comment data. State 52 is after a '!'. The other three states
// are after a '-'.
//
// Our algorithm is thus to escape every '&' and to escape '>' if and only if:
// - The '>' is after a '!' or '-' (in the unescaped data) or
// - The '>' is at the start of the comment data (after the opening "<!--").
func escapeComment(w writer, s string) error {
// When modifying this function, consider manually increasing the
// maxSuffixLen constant in func TestComments, from 6 to e.g. 9 or more.
// That increase should only be temporary, not committed, as it
// exponentially affects the test running time.
if len(s) == 0 {
return nil
}
// Loop:
// - Grow j such that s[i:j] does not need escaping.
// - If s[j] does need escaping, output s[i:j] and an escaped s[j],
// resetting i and j to point past that s[j] byte.
i := 0
for j := 0; j < len(s); j++ {
escaped := ""
switch s[j] {
case '&':
escaped = "&amp;"
case '>':
if j > 0 {
if prev := s[j-1]; (prev != '!') && (prev != '-') {
continue
}
}
escaped = "&gt;"
default:
continue
}
if i < j {
if _, err := w.WriteString(s[i:j]); err != nil {
return err
}
}
if _, err := w.WriteString(escaped); err != nil {
return err
}
i = j + 1
}
if i < len(s) {
if _, err := w.WriteString(s[i:]); err != nil {
return err
}
}
return nil
}
// escapeCommentString is to EscapeString as escapeComment is to escape.
func escapeCommentString(s string) string {
if strings.IndexAny(s, "&>") == -1 {
return s
}
var buf bytes.Buffer
escapeComment(&buf, s)
return buf.String()
}
const escapedChars = "&'<>\"\r"
func escape(w writer, s string) error {
i := strings.IndexAny(s, escapedChars)
for i != -1 {
if _, err := w.WriteString(s[:i]); err != nil {
return err
}
var esc string
switch s[i] {
case '&':
esc = "&amp;"
case '\'':
// "&#39;" is shorter than "&apos;" and apos was not in HTML until HTML5.
esc = "&#39;"
case '<':
esc = "&lt;"
case '>':
esc = "&gt;"
case '"':
// "&#34;" is shorter than "&quot;".
esc = "&#34;"
case '\r':
esc = "&#13;"
default:
panic("unrecognized escape character")
}
s = s[i+1:]
if _, err := w.WriteString(esc); err != nil {
return err
}
i = strings.IndexAny(s, escapedChars)
}
_, err := w.WriteString(s)
return err
}
// EscapeString escapes special characters like "<" to become "&lt;". It
// escapes only five such characters: <, >, &, ' and ".
// UnescapeString(EscapeString(s)) == s always holds, but the converse isn't
// always true.
func EscapeString(s string) string {
if strings.IndexAny(s, escapedChars) == -1 {
return s
}
var buf bytes.Buffer
escape(&buf, s)
return buf.String()
}
// UnescapeString unescapes entities like "&lt;" to become "<". It unescapes a
// larger range of entities than EscapeString escapes. For example, "&aacute;"
// unescapes to "á", as does "&#225;" and "&xE1;".
// UnescapeString(EscapeString(s)) == s always holds, but the converse isn't
// always true.
func UnescapeString(s string) string {
for _, c := range s {
if c == '&' {
return string(unescape([]byte(s), false))
}
}
return s
}

221
vendor/golang.org/x/net/html/foreign.go generated vendored Normal file
View file

@ -0,0 +1,221 @@
// Copyright 2011 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package html
import (
"strings"
)
func adjustAttributeNames(aa []Attribute, nameMap map[string]string) {
for i := range aa {
if newName, ok := nameMap[aa[i].Key]; ok {
aa[i].Key = newName
}
}
}
func adjustForeignAttributes(aa []Attribute) {
for i, a := range aa {
if a.Key == "" || a.Key[0] != 'x' {
continue
}
switch a.Key {
case "xlink:actuate", "xlink:arcrole", "xlink:href", "xlink:role", "xlink:show",
"xlink:title", "xlink:type", "xml:base", "xml:lang", "xml:space", "xmlns:xlink":
j := strings.Index(a.Key, ":")
aa[i].Namespace = a.Key[:j]
aa[i].Key = a.Key[j+1:]
}
}
}
func htmlIntegrationPoint(n *Node) bool {
if n.Type != ElementNode {
return false
}
switch n.Namespace {
case "math":
if n.Data == "annotation-xml" {
for _, a := range n.Attr {
if a.Key == "encoding" {
if strings.EqualFold(a.Val, "text/html") || strings.EqualFold(a.Val, "application/xhtml+xml") {
return true
}
}
}
}
case "svg":
switch n.Data {
case "desc", "foreignObject", "title":
return true
}
}
return false
}
func mathMLTextIntegrationPoint(n *Node) bool {
if n.Namespace != "math" {
return false
}
switch n.Data {
case "mi", "mo", "mn", "ms", "mtext":
return true
}
return false
}
// Section 12.2.6.5.
var breakout = map[string]bool{
"b": true,
"big": true,
"blockquote": true,
"body": true,
"br": true,
"center": true,
"code": true,
"dd": true,
"div": true,
"dl": true,
"dt": true,
"em": true,
"embed": true,
"h1": true,
"h2": true,
"h3": true,
"h4": true,
"h5": true,
"h6": true,
"head": true,
"hr": true,
"i": true,
"img": true,
"li": true,
"listing": true,
"menu": true,
"meta": true,
"nobr": true,
"ol": true,
"p": true,
"pre": true,
"ruby": true,
"s": true,
"small": true,
"span": true,
"strong": true,
"strike": true,
"sub": true,
"sup": true,
"table": true,
"tt": true,
"u": true,
"ul": true,
"var": true,
}
// Section 12.2.6.5.
var svgTagNameAdjustments = map[string]string{
"altglyph": "altGlyph",
"altglyphdef": "altGlyphDef",
"altglyphitem": "altGlyphItem",
"animatecolor": "animateColor",
"animatemotion": "animateMotion",
"animatetransform": "animateTransform",
"clippath": "clipPath",
"feblend": "feBlend",
"fecolormatrix": "feColorMatrix",
"fecomponenttransfer": "feComponentTransfer",
"fecomposite": "feComposite",
"feconvolvematrix": "feConvolveMatrix",
"fediffuselighting": "feDiffuseLighting",
"fedisplacementmap": "feDisplacementMap",
"fedistantlight": "feDistantLight",
"feflood": "feFlood",
"fefunca": "feFuncA",
"fefuncb": "feFuncB",
"fefuncg": "feFuncG",
"fefuncr": "feFuncR",
"fegaussianblur": "feGaussianBlur",
"feimage": "feImage",
"femerge": "feMerge",
"femergenode": "feMergeNode",
"femorphology": "feMorphology",
"feoffset": "feOffset",
"fepointlight": "fePointLight",
"fespecularlighting": "feSpecularLighting",
"fespotlight": "feSpotLight",
"fetile": "feTile",
"feturbulence": "feTurbulence",
"foreignobject": "foreignObject",
"glyphref": "glyphRef",
"lineargradient": "linearGradient",
"radialgradient": "radialGradient",
"textpath": "textPath",
}
// Section 12.2.6.1
var mathMLAttributeAdjustments = map[string]string{
"definitionurl": "definitionURL",
}
var svgAttributeAdjustments = map[string]string{
"attributename": "attributeName",
"attributetype": "attributeType",
"basefrequency": "baseFrequency",
"baseprofile": "baseProfile",
"calcmode": "calcMode",
"clippathunits": "clipPathUnits",
"diffuseconstant": "diffuseConstant",
"edgemode": "edgeMode",
"filterunits": "filterUnits",
"glyphref": "glyphRef",
"gradienttransform": "gradientTransform",
"gradientunits": "gradientUnits",
"kernelmatrix": "kernelMatrix",
"kernelunitlength": "kernelUnitLength",
"keypoints": "keyPoints",
"keysplines": "keySplines",
"keytimes": "keyTimes",
"lengthadjust": "lengthAdjust",
"limitingconeangle": "limitingConeAngle",
"markerheight": "markerHeight",
"markerunits": "markerUnits",
"markerwidth": "markerWidth",
"maskcontentunits": "maskContentUnits",
"maskunits": "maskUnits",
"numoctaves": "numOctaves",
"pathlength": "pathLength",
"patterncontentunits": "patternContentUnits",
"patterntransform": "patternTransform",
"patternunits": "patternUnits",
"pointsatx": "pointsAtX",
"pointsaty": "pointsAtY",
"pointsatz": "pointsAtZ",
"preservealpha": "preserveAlpha",
"preserveaspectratio": "preserveAspectRatio",
"primitiveunits": "primitiveUnits",
"refx": "refX",
"refy": "refY",
"repeatcount": "repeatCount",
"repeatdur": "repeatDur",
"requiredextensions": "requiredExtensions",
"requiredfeatures": "requiredFeatures",
"specularconstant": "specularConstant",
"specularexponent": "specularExponent",
"spreadmethod": "spreadMethod",
"startoffset": "startOffset",
"stddeviation": "stdDeviation",
"stitchtiles": "stitchTiles",
"surfacescale": "surfaceScale",
"systemlanguage": "systemLanguage",
"tablevalues": "tableValues",
"targetx": "targetX",
"targety": "targetY",
"textlength": "textLength",
"viewbox": "viewBox",
"viewtarget": "viewTarget",
"xchannelselector": "xChannelSelector",
"ychannelselector": "yChannelSelector",
"zoomandpan": "zoomAndPan",
}

56
vendor/golang.org/x/net/html/iter.go generated vendored Normal file
View file

@ -0,0 +1,56 @@
// Copyright 2024 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
//go:build go1.23
package html
import "iter"
// Ancestors returns an iterator over the ancestors of n, starting with n.Parent.
//
// Mutating a Node or its parents while iterating may have unexpected results.
func (n *Node) Ancestors() iter.Seq[*Node] {
_ = n.Parent // eager nil check
return func(yield func(*Node) bool) {
for p := n.Parent; p != nil && yield(p); p = p.Parent {
}
}
}
// ChildNodes returns an iterator over the immediate children of n,
// starting with n.FirstChild.
//
// Mutating a Node or its children while iterating may have unexpected results.
func (n *Node) ChildNodes() iter.Seq[*Node] {
_ = n.FirstChild // eager nil check
return func(yield func(*Node) bool) {
for c := n.FirstChild; c != nil && yield(c); c = c.NextSibling {
}
}
}
// Descendants returns an iterator over all nodes recursively beneath
// n, excluding n itself. Nodes are visited in depth-first preorder.
//
// Mutating a Node or its descendants while iterating may have unexpected results.
func (n *Node) Descendants() iter.Seq[*Node] {
_ = n.FirstChild // eager nil check
return func(yield func(*Node) bool) {
n.descendants(yield)
}
}
func (n *Node) descendants(yield func(*Node) bool) bool {
for c := range n.ChildNodes() {
if !yield(c) || !c.descendants(yield) {
return false
}
}
return true
}

229
vendor/golang.org/x/net/html/node.go generated vendored Normal file
View file

@ -0,0 +1,229 @@
// Copyright 2011 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package html
import (
"golang.org/x/net/html/atom"
)
// A NodeType is the type of a Node.
type NodeType uint32
const (
ErrorNode NodeType = iota
TextNode
DocumentNode
ElementNode
CommentNode
DoctypeNode
// RawNode nodes are not returned by the parser, but can be part of the
// Node tree passed to func Render to insert raw HTML (without escaping).
// If so, this package makes no guarantee that the rendered HTML is secure
// (from e.g. Cross Site Scripting attacks) or well-formed.
RawNode
scopeMarkerNode
)
// Section 12.2.4.3 says "The markers are inserted when entering applet,
// object, marquee, template, td, th, and caption elements, and are used
// to prevent formatting from "leaking" into applet, object, marquee,
// template, td, th, and caption elements".
var scopeMarker = Node{Type: scopeMarkerNode}
// A Node consists of a NodeType and some Data (tag name for element nodes,
// content for text) and are part of a tree of Nodes. Element nodes may also
// have a Namespace and contain a slice of Attributes. Data is unescaped, so
// that it looks like "a<b" rather than "a&lt;b". For element nodes, DataAtom
// is the atom for Data, or zero if Data is not a known tag name.
//
// Node trees may be navigated using the link fields (Parent,
// FirstChild, and so on) or a range loop over iterators such as
// [Node.Descendants].
//
// An empty Namespace implies a "http://www.w3.org/1999/xhtml" namespace.
// Similarly, "math" is short for "http://www.w3.org/1998/Math/MathML", and
// "svg" is short for "http://www.w3.org/2000/svg".
type Node struct {
Parent, FirstChild, LastChild, PrevSibling, NextSibling *Node
Type NodeType
DataAtom atom.Atom
Data string
Namespace string
Attr []Attribute
}
// InsertBefore inserts newChild as a child of n, immediately before oldChild
// in the sequence of n's children. oldChild may be nil, in which case newChild
// is appended to the end of n's children.
//
// It will panic if newChild already has a parent or siblings.
func (n *Node) InsertBefore(newChild, oldChild *Node) {
if newChild.Parent != nil || newChild.PrevSibling != nil || newChild.NextSibling != nil {
panic("html: InsertBefore called for an attached child Node")
}
var prev, next *Node
if oldChild != nil {
prev, next = oldChild.PrevSibling, oldChild
} else {
prev = n.LastChild
}
if prev != nil {
prev.NextSibling = newChild
} else {
n.FirstChild = newChild
}
if next != nil {
next.PrevSibling = newChild
} else {
n.LastChild = newChild
}
newChild.Parent = n
newChild.PrevSibling = prev
newChild.NextSibling = next
}
// AppendChild adds a node c as a child of n.
//
// It will panic if c already has a parent or siblings.
func (n *Node) AppendChild(c *Node) {
if c.Parent != nil || c.PrevSibling != nil || c.NextSibling != nil {
panic("html: AppendChild called for an attached child Node")
}
last := n.LastChild
if last != nil {
last.NextSibling = c
} else {
n.FirstChild = c
}
n.LastChild = c
c.Parent = n
c.PrevSibling = last
}
// RemoveChild removes a node c that is a child of n. Afterwards, c will have
// no parent and no siblings.
//
// It will panic if c's parent is not n.
func (n *Node) RemoveChild(c *Node) {
if c.Parent != n {
panic("html: RemoveChild called for a non-child Node")
}
if n.FirstChild == c {
n.FirstChild = c.NextSibling
}
if c.NextSibling != nil {
c.NextSibling.PrevSibling = c.PrevSibling
}
if n.LastChild == c {
n.LastChild = c.PrevSibling
}
if c.PrevSibling != nil {
c.PrevSibling.NextSibling = c.NextSibling
}
c.Parent = nil
c.PrevSibling = nil
c.NextSibling = nil
}
// reparentChildren reparents all of src's child nodes to dst.
func reparentChildren(dst, src *Node) {
for {
child := src.FirstChild
if child == nil {
break
}
src.RemoveChild(child)
dst.AppendChild(child)
}
}
// clone returns a new node with the same type, data and attributes.
// The clone has no parent, no siblings and no children.
func (n *Node) clone() *Node {
m := &Node{
Type: n.Type,
DataAtom: n.DataAtom,
Data: n.Data,
Attr: make([]Attribute, len(n.Attr)),
}
copy(m.Attr, n.Attr)
return m
}
// nodeStack is a stack of nodes.
type nodeStack []*Node
// pop pops the stack. It will panic if s is empty.
func (s *nodeStack) pop() *Node {
i := len(*s)
n := (*s)[i-1]
*s = (*s)[:i-1]
return n
}
// top returns the most recently pushed node, or nil if s is empty.
func (s *nodeStack) top() *Node {
if i := len(*s); i > 0 {
return (*s)[i-1]
}
return nil
}
// index returns the index of the top-most occurrence of n in the stack, or -1
// if n is not present.
func (s *nodeStack) index(n *Node) int {
for i := len(*s) - 1; i >= 0; i-- {
if (*s)[i] == n {
return i
}
}
return -1
}
// contains returns whether a is within s.
func (s *nodeStack) contains(a atom.Atom) bool {
for _, n := range *s {
if n.DataAtom == a && n.Namespace == "" {
return true
}
}
return false
}
// insert inserts a node at the given index.
func (s *nodeStack) insert(i int, n *Node) {
(*s) = append(*s, nil)
copy((*s)[i+1:], (*s)[i:])
(*s)[i] = n
}
// remove removes a node from the stack. It is a no-op if n is not present.
func (s *nodeStack) remove(n *Node) {
i := s.index(n)
if i == -1 {
return
}
copy((*s)[i:], (*s)[i+1:])
j := len(*s) - 1
(*s)[j] = nil
*s = (*s)[:j]
}
type insertionModeStack []insertionMode
func (s *insertionModeStack) pop() (im insertionMode) {
i := len(*s)
im = (*s)[i-1]
*s = (*s)[:i-1]
return im
}
func (s *insertionModeStack) top() insertionMode {
if i := len(*s); i > 0 {
return (*s)[i-1]
}
return nil
}

2464
vendor/golang.org/x/net/html/parse.go generated vendored Normal file
View file

File diff suppressed because it is too large Load diff

293
vendor/golang.org/x/net/html/render.go generated vendored Normal file
View file

@ -0,0 +1,293 @@
// Copyright 2011 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package html
import (
"bufio"
"errors"
"fmt"
"io"
"strings"
)
type writer interface {
io.Writer
io.ByteWriter
WriteString(string) (int, error)
}
// Render renders the parse tree n to the given writer.
//
// Rendering is done on a 'best effort' basis: calling Parse on the output of
// Render will always result in something similar to the original tree, but it
// is not necessarily an exact clone unless the original tree was 'well-formed'.
// 'Well-formed' is not easily specified; the HTML5 specification is
// complicated.
//
// Calling Parse on arbitrary input typically results in a 'well-formed' parse
// tree. However, it is possible for Parse to yield a 'badly-formed' parse tree.
// For example, in a 'well-formed' parse tree, no <a> element is a child of
// another <a> element: parsing "<a><a>" results in two sibling elements.
// Similarly, in a 'well-formed' parse tree, no <a> element is a child of a
// <table> element: parsing "<p><table><a>" results in a <p> with two sibling
// children; the <a> is reparented to the <table>'s parent. However, calling
// Parse on "<a><table><a>" does not return an error, but the result has an <a>
// element with an <a> child, and is therefore not 'well-formed'.
//
// Programmatically constructed trees are typically also 'well-formed', but it
// is possible to construct a tree that looks innocuous but, when rendered and
// re-parsed, results in a different tree. A simple example is that a solitary
// text node would become a tree containing <html>, <head> and <body> elements.
// Another example is that the programmatic equivalent of "a<head>b</head>c"
// becomes "<html><head><head/><body>abc</body></html>".
func Render(w io.Writer, n *Node) error {
if x, ok := w.(writer); ok {
return render(x, n)
}
buf := bufio.NewWriter(w)
if err := render(buf, n); err != nil {
return err
}
return buf.Flush()
}
// plaintextAbort is returned from render1 when a <plaintext> element
// has been rendered. No more end tags should be rendered after that.
var plaintextAbort = errors.New("html: internal error (plaintext abort)")
func render(w writer, n *Node) error {
err := render1(w, n)
if err == plaintextAbort {
err = nil
}
return err
}
func render1(w writer, n *Node) error {
// Render non-element nodes; these are the easy cases.
switch n.Type {
case ErrorNode:
return errors.New("html: cannot render an ErrorNode node")
case TextNode:
return escape(w, n.Data)
case DocumentNode:
for c := n.FirstChild; c != nil; c = c.NextSibling {
if err := render1(w, c); err != nil {
return err
}
}
return nil
case ElementNode:
// No-op.
case CommentNode:
if _, err := w.WriteString("<!--"); err != nil {
return err
}
if err := escapeComment(w, n.Data); err != nil {
return err
}
if _, err := w.WriteString("-->"); err != nil {
return err
}
return nil
case DoctypeNode:
if _, err := w.WriteString("<!DOCTYPE "); err != nil {
return err
}
if err := escape(w, n.Data); err != nil {
return err
}
if n.Attr != nil {
var p, s string
for _, a := range n.Attr {
switch a.Key {
case "public":
p = a.Val
case "system":
s = a.Val
}
}
if p != "" {
if _, err := w.WriteString(" PUBLIC "); err != nil {
return err
}
if err := writeQuoted(w, p); err != nil {
return err
}
if s != "" {
if err := w.WriteByte(' '); err != nil {
return err
}
if err := writeQuoted(w, s); err != nil {
return err
}
}
} else if s != "" {
if _, err := w.WriteString(" SYSTEM "); err != nil {
return err
}
if err := writeQuoted(w, s); err != nil {
return err
}
}
}
return w.WriteByte('>')
case RawNode:
_, err := w.WriteString(n.Data)
return err
default:
return errors.New("html: unknown node type")
}
// Render the <xxx> opening tag.
if err := w.WriteByte('<'); err != nil {
return err
}
if _, err := w.WriteString(n.Data); err != nil {
return err
}
for _, a := range n.Attr {
if err := w.WriteByte(' '); err != nil {
return err
}
if a.Namespace != "" {
if _, err := w.WriteString(a.Namespace); err != nil {
return err
}
if err := w.WriteByte(':'); err != nil {
return err
}
}
if _, err := w.WriteString(a.Key); err != nil {
return err
}
if _, err := w.WriteString(`="`); err != nil {
return err
}
if err := escape(w, a.Val); err != nil {
return err
}
if err := w.WriteByte('"'); err != nil {
return err
}
}
if voidElements[n.Data] {
if n.FirstChild != nil {
return fmt.Errorf("html: void element <%s> has child nodes", n.Data)
}
_, err := w.WriteString("/>")
return err
}
if err := w.WriteByte('>'); err != nil {
return err
}
// Add initial newline where there is danger of a newline beging ignored.
if c := n.FirstChild; c != nil && c.Type == TextNode && strings.HasPrefix(c.Data, "\n") {
switch n.Data {
case "pre", "listing", "textarea":
if err := w.WriteByte('\n'); err != nil {
return err
}
}
}
// Render any child nodes
if childTextNodesAreLiteral(n) {
for c := n.FirstChild; c != nil; c = c.NextSibling {
if c.Type == TextNode {
if _, err := w.WriteString(c.Data); err != nil {
return err
}
} else {
if err := render1(w, c); err != nil {
return err
}
}
}
if n.Data == "plaintext" {
// Don't render anything else. <plaintext> must be the
// last element in the file, with no closing tag.
return plaintextAbort
}
} else {
for c := n.FirstChild; c != nil; c = c.NextSibling {
if err := render1(w, c); err != nil {
return err
}
}
}
// Render the </xxx> closing tag.
if _, err := w.WriteString("</"); err != nil {
return err
}
if _, err := w.WriteString(n.Data); err != nil {
return err
}
return w.WriteByte('>')
}
func childTextNodesAreLiteral(n *Node) bool {
// Per WHATWG HTML 13.3, if the parent of the current node is a style,
// script, xmp, iframe, noembed, noframes, or plaintext element, and the
// current node is a text node, append the value of the node's data
// literally. The specification is not explicit about it, but we only
// enforce this if we are in the HTML namespace (i.e. when the namespace is
// "").
// NOTE: we also always include noscript elements, although the
// specification states that they should only be rendered as such if
// scripting is enabled for the node (which is not something we track).
if n.Namespace != "" {
return false
}
switch n.Data {
case "iframe", "noembed", "noframes", "noscript", "plaintext", "script", "style", "xmp":
return true
default:
return false
}
}
// writeQuoted writes s to w surrounded by quotes. Normally it will use double
// quotes, but if s contains a double quote, it will use single quotes.
// It is used for writing the identifiers in a doctype declaration.
// In valid HTML, they can't contain both types of quotes.
func writeQuoted(w writer, s string) error {
var q byte = '"'
if strings.Contains(s, `"`) {
q = '\''
}
if err := w.WriteByte(q); err != nil {
return err
}
if _, err := w.WriteString(s); err != nil {
return err
}
if err := w.WriteByte(q); err != nil {
return err
}
return nil
}
// Section 12.1.2, "Elements", gives this list of void elements. Void elements
// are those that can't have any contents.
var voidElements = map[string]bool{
"area": true,
"base": true,
"br": true,
"col": true,
"embed": true,
"hr": true,
"img": true,
"input": true,
"keygen": true, // "keygen" has been removed from the spec, but are kept here for backwards compatibility.
"link": true,
"meta": true,
"param": true,
"source": true,
"track": true,
"wbr": true,
}

1286
vendor/golang.org/x/net/html/token.go generated vendored Normal file
View file

File diff suppressed because it is too large Load diff