allow html in comment, sanitize with bluemonday
This commit is contained in:
Umputun
@@ -22,12 +22,12 @@ func TestDisqus_Convert(t *testing.T) {
|
||||
assert.Equal(t, 3, len(res), "3 comments total, 1 spam excluded")
|
||||
|
||||
exp0 := store.Comment{
|
||||
ID: "3565798471341011339",
|
||||
ID: "299619020",
|
||||
Locator: store.Locator{
|
||||
SiteID: "test",
|
||||
URL: "https://radio-t.com/p/2011/03/05/podcast-229/",
|
||||
},
|
||||
Text: "<p>The quick brown fox jumps over the lazy dog.</p>",
|
||||
Text: `<p>The quick brown fox jumps over the lazy dog.</p><p><a href="https://https://radio-t.com" rel="nofollow noopener" title="radio-t">some link</a></p>`,
|
||||
User: store.User{
|
||||
Name: "Alexander Blah",
|
||||
ID: "facebook-1787732238",
|
||||
@@ -87,7 +87,7 @@ var xmlTest = `<?xml version="1.0" encoding="utf-8"?>
|
||||
<post dsq:id="299619020">
|
||||
<id>3565798471341011339</id>
|
||||
<message>
|
||||
<![CDATA[<p>The quick brown fox jumps over the lazy dog.</p>]]>
|
||||
<![CDATA[<p>The quick brown fox jumps over the lazy dog.</p><p><a href="https://https://radio-t.com" rel="nofollow noopener" title="radio-t">some link</a></p>]]>
|
||||
</message>
|
||||
<createdAt>2011-08-31T15:16:29Z</createdAt>
|
||||
<isDeleted>false</isDeleted>
|
||||
|
||||
+23
-11
@@ -2,7 +2,6 @@ package rest
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"html/template"
|
||||
"log"
|
||||
"net/http"
|
||||
"path/filepath"
|
||||
@@ -15,6 +14,9 @@ import (
|
||||
"github.com/go-chi/render"
|
||||
"github.com/gorilla/sessions"
|
||||
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
|
||||
"github.com/umputun/remark/app/rest/auth"
|
||||
"github.com/umputun/remark/app/store"
|
||||
)
|
||||
@@ -107,14 +109,8 @@ func (s *Server) createCommentCtrl(w http.ResponseWriter, r *http.Request) {
|
||||
|
||||
comment.ID = "" // don't allow user to define ID, force auto-gen
|
||||
comment.Timestamp = time.Time{} // reset time, force auto-gen
|
||||
comment.Text = template.HTMLEscapeString(comment.Text)
|
||||
|
||||
comment.User = user
|
||||
comment.User.IP = strings.Split(r.RemoteAddr, ":")[0]
|
||||
comment.User.ID = template.HTMLEscapeString(user.ID)
|
||||
comment.User.Name = template.HTMLEscapeString(user.Name)
|
||||
comment.User.Picture = template.HTMLEscapeString(user.Picture)
|
||||
comment.User.Profile = template.HTMLEscapeString(user.Profile)
|
||||
comment.User.Admin = user.Admin
|
||||
|
||||
log.Printf("[INFO] create comment %+v", comment)
|
||||
|
||||
@@ -166,7 +162,7 @@ func (s *Server) findCommentsCtrl(w http.ResponseWriter, r *http.Request) {
|
||||
return
|
||||
}
|
||||
render.Status(r, http.StatusOK)
|
||||
render.JSON(w, r, comments)
|
||||
renderJSONWithHTML(w, r, comments)
|
||||
}
|
||||
|
||||
// GET /last/{max}?url=abc
|
||||
@@ -185,7 +181,7 @@ func (s *Server) lastCommentsCtrl(w http.ResponseWriter, r *http.Request) {
|
||||
}
|
||||
|
||||
render.Status(r, http.StatusOK)
|
||||
render.JSON(w, r, comments)
|
||||
renderJSONWithHTML(w, r, comments)
|
||||
}
|
||||
|
||||
// GET /id/{id}?url=post-url
|
||||
@@ -204,7 +200,7 @@ func (s *Server) commentByIDCtrl(w http.ResponseWriter, r *http.Request) {
|
||||
}
|
||||
|
||||
render.Status(r, http.StatusOK)
|
||||
render.JSON(w, r, comment)
|
||||
renderJSONWithHTML(w, r, comment)
|
||||
}
|
||||
|
||||
// GET /user
|
||||
@@ -257,3 +253,19 @@ func httpError(w http.ResponseWriter, r *http.Request, code int, err error, deta
|
||||
render.Status(r, code)
|
||||
render.JSON(w, r, JSON{"error": err.Error(), "details": details})
|
||||
}
|
||||
|
||||
// renderJSONWithHTML
|
||||
//allows html tags
|
||||
func renderJSONWithHTML(w http.ResponseWriter, r *http.Request, v interface{}) {
|
||||
buf := &bytes.Buffer{}
|
||||
enc := json.NewEncoder(buf)
|
||||
if err := enc.Encode(v); err != nil {
|
||||
http.Error(w, err.Error(), http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
if status, ok := r.Context().Value(render.StatusCtxKey).(int); ok {
|
||||
w.WriteHeader(status)
|
||||
}
|
||||
_, _ = w.Write(buf.Bytes())
|
||||
}
|
||||
|
||||
@@ -49,6 +49,7 @@ func (b *BoltDB) Create(comment Comment) (string, error) {
|
||||
}
|
||||
|
||||
comment.Votes = make(map[string]bool)
|
||||
comment = sanitizeComment(comment)
|
||||
|
||||
err := b.Update(func(tx *bolt.Tx) error {
|
||||
bucket, e := tx.CreateBucketIfNotExists([]byte(comment.Locator.URL))
|
||||
|
||||
@@ -18,7 +18,7 @@ func TestBoltDB_CreateAndFind(t *testing.T) {
|
||||
res, err := b.Find(Request{Locator: Locator{URL: "https://radio-t.com"}})
|
||||
assert.Nil(t, err)
|
||||
assert.Equal(t, 2, len(res))
|
||||
assert.Equal(t, "some text", res[0].Text)
|
||||
assert.Equal(t, "some text, <a href=\"http://radio-t.com\" rel=\"nofollow\">link</a>", res[0].Text)
|
||||
assert.Equal(t, "user1", res[0].User.ID)
|
||||
t.Log(res[0].ID)
|
||||
}
|
||||
@@ -133,7 +133,7 @@ func prep(t *testing.T) *BoltDB {
|
||||
b, err := NewBoltDB(testDb)
|
||||
assert.Nil(t, err)
|
||||
|
||||
comment := Comment{Text: "some text", Timestamp: time.Date(2017, 12, 20, 15, 18, 22, 0, time.Local),
|
||||
comment := Comment{Text: `some text, <a href="http://radio-t.com">link</a>`, Timestamp: time.Date(2017, 12, 20, 15, 18, 22, 0, time.Local),
|
||||
Locator: Locator{URL: "https://radio-t.com", SiteID: "radio-t"}, User: User{ID: "user1", Name: "user name"}}
|
||||
_, err = b.Create(comment)
|
||||
assert.Nil(t, err)
|
||||
|
||||
@@ -8,6 +8,10 @@ import (
|
||||
"fmt"
|
||||
"log"
|
||||
"time"
|
||||
|
||||
"html/template"
|
||||
|
||||
"github.com/microcosm-cc/bluemonday"
|
||||
)
|
||||
|
||||
// Comment represents a single comment with optional reference to its parent
|
||||
@@ -71,3 +75,13 @@ func makeCommentID() string {
|
||||
}
|
||||
return fmt.Sprintf("%x", s.Sum(nil))
|
||||
}
|
||||
|
||||
func sanitizeComment(comment Comment) Comment {
|
||||
p := bluemonday.UGCPolicy()
|
||||
comment.Text = p.Sanitize(comment.Text)
|
||||
comment.User.ID = template.HTMLEscapeString(comment.User.ID)
|
||||
comment.User.Name = template.HTMLEscapeString(comment.User.Name)
|
||||
comment.User.Picture = p.Sanitize(comment.User.Picture)
|
||||
comment.User.Profile = template.HTMLEscapeString(comment.User.Profile)
|
||||
return comment
|
||||
}
|
||||
|
||||
+51
@@ -0,0 +1,51 @@
|
||||
# Contributing to bluemonday
|
||||
|
||||
Third-party patches are essential for keeping bluemonday secure and offering the features developers want. However there are a few guidelines that we need contributors to follow so that we can maintain the quality of work that developers who use bluemonday expect.
|
||||
|
||||
## Getting Started
|
||||
|
||||
* Make sure you have a [Github account](https://github.com/signup/free)
|
||||
|
||||
## Guidelines
|
||||
|
||||
1. Do not vendor dependencies. As a security package, were we to vendor dependencies the projects that then vendor bluemonday may not receive the latest security updates to the dependencies. By not vendoring dependencies the project that implements bluemonday will vendor the latest version of any dependent packages. Vendoring is a project problem, not a package problem. bluemonday will be tested against the latest version of dependencies periodically and during any PR/merge.
|
||||
|
||||
## Submitting an Issue
|
||||
|
||||
* Submit a ticket for your issue, assuming one does not already exist
|
||||
* Clearly describe the issue including the steps to reproduce (with sample input and output) if it is a bug
|
||||
|
||||
If you are reporting a security flaw, you may expect that we will provide the code to fix it for you. Otherwise you may want to submit a pull request to ensure the resolution is applied sooner rather than later:
|
||||
|
||||
* Fork the repository on Github
|
||||
* Issue a pull request containing code to resolve the issue
|
||||
|
||||
## Submitting a Pull Request
|
||||
|
||||
* Submit a ticket for your issue, assuming one does not already exist
|
||||
* Describe the reason for the pull request and if applicable show some example inputs and outputs to demonstrate what the patch does
|
||||
* Fork the repository on Github
|
||||
* Before submitting the pull request you should
|
||||
1. Include tests for your patch, 1 test should encapsulate the entire patch and should refer to the Github issue
|
||||
1. If you have added new exposed/public functionality, you should ensure it is documented appropriately
|
||||
1. If you have added new exposed/public functionality, you should consider demonstrating how to use it within one of the helpers or shipped policies if appropriate or within a test if modifying a helper or policy is not appropriate
|
||||
1. Run all of the tests `go test -v ./...` or `make test` and ensure all tests pass
|
||||
1. Run gofmt `gofmt -w ./$*` or `make fmt`
|
||||
1. Run vet `go tool vet *.go` or `make vet` and resolve any issues
|
||||
1. Install golint using `go get -u github.com/golang/lint/golint` and run vet `golint *.go` or `make lint` and resolve every warning
|
||||
* When submitting the pull request you should
|
||||
1. Note the issue(s) it resolves, i.e. `Closes #6` in the pull request comment to close issue #6 when the pull request is accepted
|
||||
|
||||
Once you have submitted a pull request, we *may* merge it without changes. If we have any comments or feedback, or need you to make changes to your pull request we will update the Github pull request or the associated issue. We expect responses from you within two weeks, and we may close the pull request is there is no activity.
|
||||
|
||||
### Contributor Licence Agreement
|
||||
|
||||
We haven't gone for the formal "Sign a Contributor Licence Agreement" thing that projects like [puppet](https://cla.puppetlabs.com/), [Mojito](https://developer.yahoo.com/cocktails/mojito/cla/) and companies like [Google](http://code.google.com/legal/individual-cla-v1.0.html) are using.
|
||||
|
||||
But we do need to know that we can accept and merge your contributions, so for now the act of contributing a pull request should be considered equivalent to agreeing to a contributor licence agreement, specifically:
|
||||
|
||||
You accept that the act of submitting code to the bluemonday project is to grant a copyright licence to the project that is perpetual, worldwide, non-exclusive, no-charge, royalty free and irrevocable.
|
||||
|
||||
You accept that all who comply with the licence of the project (BSD 3-clause) are permitted to use your contributions to the project.
|
||||
|
||||
You accept, and by submitting code do declare, that you have the legal right to grant such a licence to the project and that each of the contributions is your own original creation.
|
||||
+6
@@ -0,0 +1,6 @@
|
||||
1. Andrew Krasichkov @buglloc https://github.com/buglloc
|
||||
1. John Graham-Cumming http://jgc.org/
|
||||
1. Mike Samuel mikesamuel@gmail.com
|
||||
1. Dmitri Shuralyov shurcooL@gmail.com
|
||||
1. https://github.com/opennota
|
||||
1. https://github.com/Gufran
|
||||
+28
@@ -0,0 +1,28 @@
|
||||
Copyright (c) 2014, David Kitchen <david@buro9.com>
|
||||
|
||||
All rights reserved.
|
||||
|
||||
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 the organisation (Microcosm) 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 HOLDER 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.
|
||||
+42
@@ -0,0 +1,42 @@
|
||||
# Targets:
|
||||
#
|
||||
# all: Builds the code locally after testing
|
||||
#
|
||||
# fmt: Formats the source files
|
||||
# build: Builds the code locally
|
||||
# vet: Vets the code
|
||||
# lint: Runs lint over the code (you do not need to fix everything)
|
||||
# test: Runs the tests
|
||||
# cover: Gives you the URL to a nice test coverage report
|
||||
#
|
||||
# install: Builds, tests and installs the code locally
|
||||
|
||||
.PHONY: all fmt build vet lint test cover install
|
||||
|
||||
# The first target is always the default action if `make` is called without
|
||||
# args we build and install into $GOPATH so that it can just be run
|
||||
|
||||
all: fmt vet test install
|
||||
|
||||
fmt:
|
||||
@gofmt -s -w ./$*
|
||||
|
||||
build:
|
||||
@go build
|
||||
|
||||
vet:
|
||||
@go vet *.go
|
||||
|
||||
lint:
|
||||
@golint *.go
|
||||
|
||||
test:
|
||||
@go test -v ./...
|
||||
|
||||
cover: COVERAGE_FILE := coverage.out
|
||||
cover:
|
||||
@go test -coverprofile=$(COVERAGE_FILE) && \
|
||||
cover -html=$(COVERAGE_FILE) && rm $(COVERAGE_FILE)
|
||||
|
||||
install:
|
||||
@go install ./...
|
||||
+346
@@ -0,0 +1,346 @@
|
||||
# bluemonday [](https://travis-ci.org/microcosm-cc/bluemonday) [](https://godoc.org/github.com/microcosm-cc/bluemonday) [](https://sourcegraph.com/github.com/microcosm-cc/bluemonday?badge)
|
||||
|
||||
bluemonday is a HTML sanitizer implemented in Go. It is fast and highly configurable.
|
||||
|
||||
bluemonday takes untrusted user generated content as an input, and will return HTML that has been sanitised against a whitelist of approved HTML elements and attributes so that you can safely include the content in your web page.
|
||||
|
||||
If you accept user generated content, and your server uses Go, you **need** bluemonday.
|
||||
|
||||
The default policy for user generated content (`bluemonday.UGCPolicy().Sanitize()`) turns this:
|
||||
```html
|
||||
Hello <STYLE>.XSS{background-image:url("javascript:alert('XSS')");}</STYLE><A CLASS=XSS></A>World
|
||||
```
|
||||
|
||||
Into a harmless:
|
||||
```html
|
||||
Hello World
|
||||
```
|
||||
|
||||
And it turns this:
|
||||
```html
|
||||
<a href="javascript:alert('XSS1')" onmouseover="alert('XSS2')">XSS<a>
|
||||
```
|
||||
|
||||
Into this:
|
||||
```html
|
||||
XSS
|
||||
```
|
||||
|
||||
Whilst still allowing this:
|
||||
```html
|
||||
<a href="http://www.google.com/">
|
||||
<img src="https://ssl.gstatic.com/accounts/ui/logo_2x.png"/>
|
||||
</a>
|
||||
```
|
||||
|
||||
To pass through mostly unaltered (it gained a rel="nofollow" which is a good thing for user generated content):
|
||||
```html
|
||||
<a href="http://www.google.com/" rel="nofollow">
|
||||
<img src="https://ssl.gstatic.com/accounts/ui/logo_2x.png"/>
|
||||
</a>
|
||||
```
|
||||
|
||||
It protects sites from [XSS](http://en.wikipedia.org/wiki/Cross-site_scripting) attacks. There are many [vectors for an XSS attack](https://www.owasp.org/index.php/XSS_Filter_Evasion_Cheat_Sheet) and the best way to mitigate the risk is to sanitize user input against a known safe list of HTML elements and attributes.
|
||||
|
||||
You should **always** run bluemonday **after** any other processing.
|
||||
|
||||
If you use [blackfriday](https://github.com/russross/blackfriday) or [Pandoc](http://johnmacfarlane.net/pandoc/) then bluemonday should be run after these steps. This ensures that no insecure HTML is introduced later in your process.
|
||||
|
||||
bluemonday is heavily inspired by both the [OWASP Java HTML Sanitizer](https://code.google.com/p/owasp-java-html-sanitizer/) and the [HTML Purifier](http://htmlpurifier.org/).
|
||||
|
||||
## Technical Summary
|
||||
|
||||
Whitelist based, you need to either build a policy describing the HTML elements and attributes to permit (and the `regexp` patterns of attributes), or use one of the supplied policies representing good defaults.
|
||||
|
||||
The policy containing the whitelist is applied using a fast non-validating, forward only, token-based parser implemented in the [Go net/html library](https://godoc.org/golang.org/x/net/html) by the core Go team.
|
||||
|
||||
We expect to be supplied with well-formatted HTML (closing elements for every applicable open element, nested correctly) and so we do not focus on repairing badly nested or incomplete HTML. We focus on simply ensuring that whatever elements do exist are described in the policy whitelist and that attributes and links are safe for use on your web page. [GIGO](http://en.wikipedia.org/wiki/Garbage_in,_garbage_out) does apply and if you feed it bad HTML bluemonday is not tasked with figuring out how to make it good again.
|
||||
|
||||
### Supported Go Versions
|
||||
|
||||
bluemonday is tested against Go 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, and tip.
|
||||
|
||||
We do not support Go 1.0 as we depend on `golang.org/x/net/html` which includes a reference to `io.ErrNoProgress` which did not exist in Go 1.0.
|
||||
|
||||
## Is it production ready?
|
||||
|
||||
*Yes*
|
||||
|
||||
We are using bluemonday in production having migrated from the widely used and heavily field tested OWASP Java HTML Sanitizer.
|
||||
|
||||
We are passing our extensive test suite (including AntiSamy tests as well as tests for any issues raised). Check for any [unresolved issues](https://github.com/microcosm-cc/bluemonday/issues?page=1&state=open) to see whether anything may be a blocker for you.
|
||||
|
||||
We invite pull requests and issues to help us ensure we are offering comprehensive protection against various attacks via user generated content.
|
||||
|
||||
## Usage
|
||||
|
||||
Install in your `${GOPATH}` using `go get -u github.com/microcosm-cc/bluemonday`
|
||||
|
||||
Then call it:
|
||||
```go
|
||||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
"github.com/microcosm-cc/bluemonday"
|
||||
)
|
||||
|
||||
func main() {
|
||||
p := bluemonday.UGCPolicy()
|
||||
html := p.Sanitize(
|
||||
`<a onblur="alert(secret)" href="http://www.google.com">Google</a>`,
|
||||
)
|
||||
|
||||
// Output:
|
||||
// <a href="http://www.google.com" rel="nofollow">Google</a>
|
||||
fmt.Println(html)
|
||||
}
|
||||
```
|
||||
|
||||
We offer three ways to call Sanitize:
|
||||
```go
|
||||
p.Sanitize(string) string
|
||||
p.SanitizeBytes([]byte) []byte
|
||||
p.SanitizeReader(io.Reader) bytes.Buffer
|
||||
```
|
||||
|
||||
If you are obsessed about performance, `p.SanitizeReader(r).Bytes()` will return a `[]byte` without performing any unnecessary casting of the inputs or outputs. Though the difference is so negligible you should never need to care.
|
||||
|
||||
You can build your own policies:
|
||||
```go
|
||||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
"github.com/microcosm-cc/bluemonday"
|
||||
)
|
||||
|
||||
func main() {
|
||||
p := bluemonday.NewPolicy()
|
||||
|
||||
// Require URLs to be parseable by net/url.Parse and either:
|
||||
// mailto: http:// or https://
|
||||
p.AllowStandardURLs()
|
||||
|
||||
// We only allow <p> and <a href="">
|
||||
p.AllowAttrs("href").OnElements("a")
|
||||
p.AllowElements("p")
|
||||
|
||||
html := p.Sanitize(
|
||||
`<a onblur="alert(secret)" href="http://www.google.com">Google</a>`,
|
||||
)
|
||||
|
||||
// Output:
|
||||
// <a href="http://www.google.com">Google</a>
|
||||
fmt.Println(html)
|
||||
}
|
||||
```
|
||||
|
||||
We ship two default policies:
|
||||
|
||||
1. `bluemonday.StrictPolicy()` which can be thought of as equivalent to stripping all HTML elements and their attributes as it has nothing on it's whitelist. An example usage scenario would be blog post titles where HTML tags are not expected at all and if they are then the elements *and* the content of the elements should be stripped. This is a *very* strict policy.
|
||||
2. `bluemonday.UGCPolicy()` which allows a broad selection of HTML elements and attributes that are safe for user generated content. Note that this policy does *not* whitelist iframes, object, embed, styles, script, etc. An example usage scenario would be blog post bodies where a variety of formatting is expected along with the potential for TABLEs and IMGs.
|
||||
|
||||
## Policy Building
|
||||
|
||||
The essence of building a policy is to determine which HTML elements and attributes are considered safe for your scenario. OWASP provide an [XSS prevention cheat sheet](https://www.owasp.org/index.php/XSS_(Cross_Site_Scripting)_Prevention_Cheat_Sheet) to help explain the risks, but essentially:
|
||||
|
||||
1. Avoid anything other than the standard HTML elements
|
||||
1. Avoid `script`, `style`, `iframe`, `object`, `embed`, `base` elements that allow code to be executed by the client or third party content to be included that can execute code
|
||||
1. Avoid anything other than plain HTML attributes with values matched to a regexp
|
||||
|
||||
Basically, you should be able to describe what HTML is fine for your scenario. If you do not have confidence that you can describe your policy please consider using one of the shipped policies such as `bluemonday.UGCPolicy()`.
|
||||
|
||||
To create a new policy:
|
||||
```go
|
||||
p := bluemonday.NewPolicy()
|
||||
```
|
||||
|
||||
To add elements to a policy either add just the elements:
|
||||
```go
|
||||
p.AllowElements("b", "strong")
|
||||
```
|
||||
|
||||
Or add elements as a virtue of adding an attribute:
|
||||
```go
|
||||
// Not the recommended pattern, see the recommendation on using .Matching() below
|
||||
p.AllowAttrs("nowrap").OnElements("td", "th")
|
||||
```
|
||||
|
||||
Attributes can either be added to all elements:
|
||||
```go
|
||||
p.AllowAttrs("dir").Matching(regexp.MustCompile("(?i)rtl|ltr")).Globally()
|
||||
```
|
||||
|
||||
Or attributes can be added to specific elements:
|
||||
```go
|
||||
// Not the recommended pattern, see the recommendation on using .Matching() below
|
||||
p.AllowAttrs("value").OnElements("li")
|
||||
```
|
||||
|
||||
It is **always** recommended that an attribute be made to match a pattern. XSS in HTML attributes is very easy otherwise:
|
||||
```go
|
||||
// \p{L} matches unicode letters, \p{N} matches unicode numbers
|
||||
p.AllowAttrs("title").Matching(regexp.MustCompile(`[\p{L}\p{N}\s\-_',:\[\]!\./\\\(\)&]*`)).Globally()
|
||||
```
|
||||
|
||||
You can stop at any time and call .Sanitize():
|
||||
```go
|
||||
// string htmlIn passed in from a HTTP POST
|
||||
htmlOut := p.Sanitize(htmlIn)
|
||||
```
|
||||
|
||||
And you can take any existing policy and extend it:
|
||||
```go
|
||||
p := bluemonday.UGCPolicy()
|
||||
p.AllowElements("fieldset", "select", "option")
|
||||
```
|
||||
|
||||
### Links
|
||||
|
||||
Links are difficult beasts to sanitise safely and also one of the biggest attack vectors for malicious content.
|
||||
|
||||
It is possible to do this:
|
||||
```go
|
||||
p.AllowAttrs("href").Matching(regexp.MustCompile(`(?i)mailto|https?`)).OnElements("a")
|
||||
```
|
||||
|
||||
But that will not protect you as the regular expression is insufficient in this case to have prevented a malformed value doing something unexpected.
|
||||
|
||||
We provide some additional global options for safely working with links.
|
||||
|
||||
`RequireParseableURLs` will ensure that URLs are parseable by Go's `net/url` package:
|
||||
```go
|
||||
p.RequireParseableURLs(true)
|
||||
```
|
||||
|
||||
If you have enabled parseable URLs then the following option will `AllowRelativeURLs`. By default this is disabled (bluemonday is a whitelist tool... you need to explicitly tell us to permit things) and when disabled it will prevent all local and scheme relative URLs (i.e. `href="localpage.html"`, `href="../home.html"` and even `href="//www.google.com"` are relative):
|
||||
```go
|
||||
p.AllowRelativeURLs(true)
|
||||
```
|
||||
|
||||
If you have enabled parseable URLs then you can whitelist the schemes (commonly called protocol when thinking of `http` and `https`) that are permitted. Bear in mind that allowing relative URLs in the above option will allow for a blank scheme:
|
||||
```go
|
||||
p.AllowURLSchemes("mailto", "http", "https")
|
||||
```
|
||||
|
||||
Regardless of whether you have enabled parseable URLs, you can force all URLs to have a rel="nofollow" attribute. This will be added if it does not exist, but only when the `href` is valid:
|
||||
```go
|
||||
// This applies to "a" "area" "link" elements that have a "href" attribute
|
||||
p.RequireNoFollowOnLinks(true)
|
||||
```
|
||||
|
||||
We provide a convenience method that applies all of the above, but you will still need to whitelist the linkable elements for the URL rules to be applied to:
|
||||
```go
|
||||
p.AllowStandardURLs()
|
||||
p.AllowAttrs("cite").OnElements("blockquote", "q")
|
||||
p.AllowAttrs("href").OnElements("a", "area")
|
||||
p.AllowAttrs("src").OnElements("img")
|
||||
```
|
||||
|
||||
An additional complexity regarding links is the data URI as defined in [RFC2397](http://tools.ietf.org/html/rfc2397). The data URI allows for images to be served inline using this format:
|
||||
|
||||
```html
|
||||
<img src="data:image/webp;base64,UklGRh4AAABXRUJQVlA4TBEAAAAvAAAAAAfQ//73v/+BiOh/AAA=">
|
||||
```
|
||||
|
||||
We have provided a helper to verify the mimetype followed by base64 content of data URIs links:
|
||||
|
||||
```go
|
||||
p.AllowDataURIImages()
|
||||
```
|
||||
|
||||
That helper will enable GIF, JPEG, PNG and WEBP images.
|
||||
|
||||
It should be noted that there is a potential [security](http://palizine.plynt.com/issues/2010Oct/bypass-xss-filters/) [risk](https://capec.mitre.org/data/definitions/244.html) with the use of data URI links. You should only enable data URI links if you already trust the content.
|
||||
|
||||
We also have some features to help deal with user generated content:
|
||||
```go
|
||||
p.AddTargetBlankToFullyQualifiedLinks(true)
|
||||
```
|
||||
|
||||
This will ensure that anchor `<a href="" />` links that are fully qualified (the href destination includes a host name) will get `target="_blank"` added to them.
|
||||
|
||||
Additionally any link that has `target="_blank"` after the policy has been applied will also have the `rel` attribute adjusted to add `noopener`. This means a link may start like `<a href="//host/path"/>` and will end up as `<a href="//host/path" rel="noopener" target="_blank">`. It is important to note that the addition of `noopener` is a security feature and not an issue. There is an unfortunate feature to browsers that a browser window opened as a result of `target="_blank"` can still control the opener (your web page) and this protects against that. The background to this can be found here: [https://dev.to/ben/the-targetblank-vulnerability-by-example](https://dev.to/ben/the-targetblank-vulnerability-by-example)
|
||||
|
||||
### Policy Building Helpers
|
||||
|
||||
We also bundle some helpers to simplify policy building:
|
||||
```go
|
||||
|
||||
// Permits the "dir", "id", "lang", "title" attributes globally
|
||||
p.AllowStandardAttributes()
|
||||
|
||||
// Permits the "img" element and it's standard attributes
|
||||
p.AllowImages()
|
||||
|
||||
// Permits ordered and unordered lists, and also definition lists
|
||||
p.AllowLists()
|
||||
|
||||
// Permits HTML tables and all applicable elements and non-styling attributes
|
||||
p.AllowTables()
|
||||
```
|
||||
|
||||
### Invalid Instructions
|
||||
|
||||
The following are invalid:
|
||||
```go
|
||||
// This does not say where the attributes are allowed, you need to add
|
||||
// .Globally() or .OnElements(...)
|
||||
// This will be ignored without error.
|
||||
p.AllowAttrs("value")
|
||||
|
||||
// This does not say where the attributes are allowed, you need to add
|
||||
// .Globally() or .OnElements(...)
|
||||
// This will be ignored without error.
|
||||
p.AllowAttrs(
|
||||
"type",
|
||||
).Matching(
|
||||
regexp.MustCompile("(?i)^(circle|disc|square|a|A|i|I|1)$"),
|
||||
)
|
||||
```
|
||||
|
||||
Both examples exhibit the same issue, they declare attributes but do not then specify whether they are whitelisted globally or only on specific elements (and which elements). Attributes belong to one or more elements, and the policy needs to declare this.
|
||||
|
||||
## Limitations
|
||||
|
||||
We are not yet including any tools to help whitelist and sanitize CSS. Which means that unless you wish to do the heavy lifting in a single regular expression (inadvisable), **you should not allow the "style" attribute anywhere**.
|
||||
|
||||
It is not the job of bluemonday to fix your bad HTML, it is merely the job of bluemonday to prevent malicious HTML getting through. If you have mismatched HTML elements, or non-conforming nesting of elements, those will remain. But if you have well-structured HTML bluemonday will not break it.
|
||||
|
||||
## TODO
|
||||
|
||||
* Add support for CSS sanitisation to allow some CSS properties based on a whitelist, possibly using the [Gorilla CSS3 scanner](http://www.gorillatoolkit.org/pkg/css/scanner) - PRs welcome so long as testing covers XSS and demonstrates safety first
|
||||
* Investigate whether devs want to blacklist elements and attributes. This would allow devs to take an existing policy (such as the `bluemonday.UGCPolicy()` ) that encapsulates 90% of what they're looking for but does more than they need, and to remove the extra things they do not want to make it 100% what they want
|
||||
* Investigate whether devs want a validating HTML mode, in which the HTML elements are not just transformed into a balanced tree (every start tag has a closing tag at the correct depth) but also that elements and character data appear only in their allowed context (i.e. that a `table` element isn't a descendent of a `caption`, that `colgroup`, `thead`, `tbody`, `tfoot` and `tr` are permitted, and that character data is not permitted)
|
||||
|
||||
## Development
|
||||
|
||||
If you have cloned this repo you will probably need the dependency:
|
||||
|
||||
`go get golang.org/x/net/html`
|
||||
|
||||
Gophers can use their familiar tools:
|
||||
|
||||
`go build`
|
||||
|
||||
`go test`
|
||||
|
||||
I personally use a Makefile as it spares typing the same args over and over whilst providing consistency for those of us who jump from language to language and enjoy just typing `make` in a project directory and watch magic happen.
|
||||
|
||||
`make` will build, vet, test and install the library.
|
||||
|
||||
`make clean` will remove the library from a *single* `${GOPATH}/pkg` directory tree
|
||||
|
||||
`make test` will run the tests
|
||||
|
||||
`make cover` will run the tests and *open a browser window* with the coverage report
|
||||
|
||||
`make lint` will run golint (install via `go get github.com/golang/lint/golint`)
|
||||
|
||||
## Long term goals
|
||||
|
||||
1. Open the code to adversarial peer review similar to the [Attack Review Ground Rules](https://code.google.com/p/owasp-java-html-sanitizer/wiki/AttackReviewGroundRules)
|
||||
1. Raise funds and pay for an external security review
|
||||
+104
@@ -0,0 +1,104 @@
|
||||
// Copyright (c) 2014, David Kitchen <david@buro9.com>
|
||||
//
|
||||
// All rights reserved.
|
||||
//
|
||||
// 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 the organisation (Microcosm) 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 HOLDER 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.
|
||||
|
||||
/*
|
||||
Package bluemonday provides a way of describing a whitelist of HTML elements
|
||||
and attributes as a policy, and for that policy to be applied to untrusted
|
||||
strings from users that may contain markup. All elements and attributes not on
|
||||
the whitelist will be stripped.
|
||||
|
||||
The default bluemonday.UGCPolicy().Sanitize() turns this:
|
||||
|
||||
Hello <STYLE>.XSS{background-image:url("javascript:alert('XSS')");}</STYLE><A CLASS=XSS></A>World
|
||||
|
||||
Into the more harmless:
|
||||
|
||||
Hello World
|
||||
|
||||
And it turns this:
|
||||
|
||||
<a href="javascript:alert('XSS1')" onmouseover="alert('XSS2')">XSS<a>
|
||||
|
||||
Into this:
|
||||
|
||||
XSS
|
||||
|
||||
Whilst still allowing this:
|
||||
|
||||
<a href="http://www.google.com/">
|
||||
<img src="https://ssl.gstatic.com/accounts/ui/logo_2x.png"/>
|
||||
</a>
|
||||
|
||||
To pass through mostly unaltered (it gained a rel="nofollow"):
|
||||
|
||||
<a href="http://www.google.com/" rel="nofollow">
|
||||
<img src="https://ssl.gstatic.com/accounts/ui/logo_2x.png"/>
|
||||
</a>
|
||||
|
||||
The primary purpose of bluemonday is to take potentially unsafe user generated
|
||||
content (from things like Markdown, HTML WYSIWYG tools, etc) and make it safe
|
||||
for you to put on your website.
|
||||
|
||||
It protects sites against XSS (http://en.wikipedia.org/wiki/Cross-site_scripting)
|
||||
and other malicious content that a user interface may deliver. There are many
|
||||
vectors for an XSS attack (https://www.owasp.org/index.php/XSS_Filter_Evasion_Cheat_Sheet)
|
||||
and the safest thing to do is to sanitize user input against a known safe list
|
||||
of HTML elements and attributes.
|
||||
|
||||
Note: You should always run bluemonday after any other processing.
|
||||
|
||||
If you use blackfriday (https://github.com/russross/blackfriday) or
|
||||
Pandoc (http://johnmacfarlane.net/pandoc/) then bluemonday should be run after
|
||||
these steps. This ensures that no insecure HTML is introduced later in your
|
||||
process.
|
||||
|
||||
bluemonday is heavily inspired by both the OWASP Java HTML Sanitizer
|
||||
(https://code.google.com/p/owasp-java-html-sanitizer/) and the HTML Purifier
|
||||
(http://htmlpurifier.org/).
|
||||
|
||||
We ship two default policies, one is bluemonday.StrictPolicy() and can be
|
||||
thought of as equivalent to stripping all HTML elements and their attributes as
|
||||
it has nothing on it's whitelist.
|
||||
|
||||
The other is bluemonday.UGCPolicy() and allows a broad selection of HTML
|
||||
elements and attributes that are safe for user generated content. Note that
|
||||
this policy does not whitelist iframes, object, embed, styles, script, etc.
|
||||
|
||||
The essence of building a policy is to determine which HTML elements and
|
||||
attributes are considered safe for your scenario. OWASP provide an XSS
|
||||
prevention cheat sheet ( https://www.google.com/search?q=xss+prevention+cheat+sheet )
|
||||
to help explain the risks, but essentially:
|
||||
|
||||
1. Avoid whitelisting anything other than plain HTML elements
|
||||
2. Avoid whitelisting `script`, `style`, `iframe`, `object`, `embed`, `base`
|
||||
elements
|
||||
3. Avoid whitelisting anything other than plain HTML elements with simple
|
||||
values that you can match to a regexp
|
||||
*/
|
||||
package bluemonday
|
||||
+297
@@ -0,0 +1,297 @@
|
||||
// Copyright (c) 2014, David Kitchen <david@buro9.com>
|
||||
//
|
||||
// All rights reserved.
|
||||
//
|
||||
// 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 the organisation (Microcosm) 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 HOLDER 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.
|
||||
|
||||
package bluemonday
|
||||
|
||||
import (
|
||||
"encoding/base64"
|
||||
"net/url"
|
||||
"regexp"
|
||||
)
|
||||
|
||||
// A selection of regular expressions that can be used as .Matching() rules on
|
||||
// HTML attributes.
|
||||
var (
|
||||
// CellAlign handles the `align` attribute
|
||||
// https://developer.mozilla.org/en-US/docs/Web/HTML/Element/td#attr-align
|
||||
CellAlign = regexp.MustCompile(`(?i)^(center|justify|left|right|char)$`)
|
||||
|
||||
// CellVerticalAlign handles the `valign` attribute
|
||||
// https://developer.mozilla.org/en-US/docs/Web/HTML/Element/td#attr-valign
|
||||
CellVerticalAlign = regexp.MustCompile(`(?i)^(baseline|bottom|middle|top)$`)
|
||||
|
||||
// Direction handles the `dir` attribute
|
||||
// https://developer.mozilla.org/en-US/docs/Web/HTML/Element/bdo#attr-dir
|
||||
Direction = regexp.MustCompile(`(?i)^(rtl|ltr)$`)
|
||||
|
||||
// ImageAlign handles the `align` attribute on the `image` tag
|
||||
// http://www.w3.org/MarkUp/Test/Img/imgtest.html
|
||||
ImageAlign = regexp.MustCompile(
|
||||
`(?i)^(left|right|top|texttop|middle|absmiddle|baseline|bottom|absbottom)$`,
|
||||
)
|
||||
|
||||
// Integer describes whole positive integers (including 0) used in places
|
||||
// like td.colspan
|
||||
// https://developer.mozilla.org/en-US/docs/Web/HTML/Element/td#attr-colspan
|
||||
Integer = regexp.MustCompile(`^[0-9]+$`)
|
||||
|
||||
// ISO8601 according to the W3 group is only a subset of the ISO8601
|
||||
// standard: http://www.w3.org/TR/NOTE-datetime
|
||||
//
|
||||
// Used in places like time.datetime
|
||||
// https://developer.mozilla.org/en-US/docs/Web/HTML/Element/time#attr-datetime
|
||||
//
|
||||
// Matches patterns:
|
||||
// Year:
|
||||
// YYYY (eg 1997)
|
||||
// Year and month:
|
||||
// YYYY-MM (eg 1997-07)
|
||||
// Complete date:
|
||||
// YYYY-MM-DD (eg 1997-07-16)
|
||||
// Complete date plus hours and minutes:
|
||||
// YYYY-MM-DDThh:mmTZD (eg 1997-07-16T19:20+01:00)
|
||||
// Complete date plus hours, minutes and seconds:
|
||||
// YYYY-MM-DDThh:mm:ssTZD (eg 1997-07-16T19:20:30+01:00)
|
||||
// Complete date plus hours, minutes, seconds and a decimal fraction of a
|
||||
// second
|
||||
// YYYY-MM-DDThh:mm:ss.sTZD (eg 1997-07-16T19:20:30.45+01:00)
|
||||
ISO8601 = regexp.MustCompile(
|
||||
`^[0-9]{4}(-[0-9]{2}(-[0-9]{2}([ T][0-9]{2}(:[0-9]{2}){1,2}(.[0-9]{1,6})` +
|
||||
`?Z?([\+-][0-9]{2}:[0-9]{2})?)?)?)?$`,
|
||||
)
|
||||
|
||||
// ListType encapsulates the common value as well as the latest spec
|
||||
// values for lists
|
||||
// https://developer.mozilla.org/en-US/docs/Web/HTML/Element/ol#attr-type
|
||||
ListType = regexp.MustCompile(`(?i)^(circle|disc|square|a|A|i|I|1)$`)
|
||||
|
||||
// SpaceSeparatedTokens is used in places like `a.rel` and the common attribute
|
||||
// `class` which both contain space delimited lists of data tokens
|
||||
// http://www.w3.org/TR/html-markup/datatypes.html#common.data.tokens-def
|
||||
// Regexp: \p{L} matches unicode letters, \p{N} matches unicode numbers
|
||||
SpaceSeparatedTokens = regexp.MustCompile(`^([\s\p{L}\p{N}_-]+)$`)
|
||||
|
||||
// Number is a double value used on HTML5 meter and progress elements
|
||||
// http://www.whatwg.org/specs/web-apps/current-work/multipage/the-button-element.html#the-meter-element
|
||||
Number = regexp.MustCompile(`^[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?$`)
|
||||
|
||||
// NumberOrPercent is used predominantly as units of measurement in width
|
||||
// and height attributes
|
||||
// https://developer.mozilla.org/en-US/docs/Web/HTML/Element/img#attr-height
|
||||
NumberOrPercent = regexp.MustCompile(`^[0-9]+[%]?$`)
|
||||
|
||||
// Paragraph of text in an attribute such as *.'title', img.alt, etc
|
||||
// https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes#attr-title
|
||||
// Note that we are not allowing chars that could close tags like '>'
|
||||
Paragraph = regexp.MustCompile(`^[\p{L}\p{N}\s\-_',\[\]!\./\\\(\)]*$`)
|
||||
|
||||
// dataURIImagePrefix is used by AllowDataURIImages to define the acceptable
|
||||
// prefix of data URIs that contain common web image formats.
|
||||
//
|
||||
// This is not exported as it's not useful by itself, and only has value
|
||||
// within the AllowDataURIImages func
|
||||
dataURIImagePrefix = regexp.MustCompile(
|
||||
`^image/(gif|jpeg|png|webp);base64,`,
|
||||
)
|
||||
)
|
||||
|
||||
// AllowStandardURLs is a convenience function that will enable rel="nofollow"
|
||||
// on "a", "area" and "link" (if you have allowed those elements) and will
|
||||
// ensure that the URL values are parseable and either relative or belong to the
|
||||
// "mailto", "http", or "https" schemes
|
||||
func (p *Policy) AllowStandardURLs() {
|
||||
// URLs must be parseable by net/url.Parse()
|
||||
p.RequireParseableURLs(true)
|
||||
|
||||
// !url.IsAbs() is permitted
|
||||
p.AllowRelativeURLs(true)
|
||||
|
||||
// Most common URL schemes only
|
||||
p.AllowURLSchemes("mailto", "http", "https")
|
||||
|
||||
// For all anchors we will add rel="nofollow" if it does not already exist
|
||||
// This applies to "a" "area" "link"
|
||||
p.RequireNoFollowOnLinks(true)
|
||||
}
|
||||
|
||||
// AllowStandardAttributes will enable "id", "title" and the language specific
|
||||
// attributes "dir" and "lang" on all elements that are whitelisted
|
||||
func (p *Policy) AllowStandardAttributes() {
|
||||
// "dir" "lang" are permitted as both language attributes affect charsets
|
||||
// and direction of text.
|
||||
p.AllowAttrs("dir").Matching(Direction).Globally()
|
||||
p.AllowAttrs(
|
||||
"lang",
|
||||
).Matching(regexp.MustCompile(`[a-zA-Z]{2,20}`)).Globally()
|
||||
|
||||
// "id" is permitted. This is pretty much as some HTML elements require this
|
||||
// to work well ("dfn" is an example of a "id" being value)
|
||||
// This does create a risk that JavaScript and CSS within your web page
|
||||
// might identify the wrong elements. Ensure that you select things
|
||||
// accurately
|
||||
p.AllowAttrs("id").Matching(
|
||||
regexp.MustCompile(`[a-zA-Z0-9\:\-_\.]+`),
|
||||
).Globally()
|
||||
|
||||
// "title" is permitted as it improves accessibility.
|
||||
p.AllowAttrs("title").Matching(Paragraph).Globally()
|
||||
}
|
||||
|
||||
// AllowStyling presently enables the class attribute globally.
|
||||
//
|
||||
// Note: When bluemonday ships a CSS parser and we can safely sanitise that,
|
||||
// this will also allow sanitized styling of elements via the style attribute.
|
||||
func (p *Policy) AllowStyling() {
|
||||
|
||||
// "class" is permitted globally
|
||||
p.AllowAttrs("class").Matching(SpaceSeparatedTokens).Globally()
|
||||
}
|
||||
|
||||
// AllowImages enables the img element and some popular attributes. It will also
|
||||
// ensure that URL values are parseable. This helper does not enable data URI
|
||||
// images, for that you should also use the AllowDataURIImages() helper.
|
||||
func (p *Policy) AllowImages() {
|
||||
|
||||
// "img" is permitted
|
||||
p.AllowAttrs("align").Matching(ImageAlign).OnElements("img")
|
||||
p.AllowAttrs("alt").Matching(Paragraph).OnElements("img")
|
||||
p.AllowAttrs("height", "width").Matching(NumberOrPercent).OnElements("img")
|
||||
|
||||
// Standard URLs enabled
|
||||
p.AllowStandardURLs()
|
||||
p.AllowAttrs("src").OnElements("img")
|
||||
}
|
||||
|
||||
// AllowDataURIImages permits the use of inline images defined in RFC2397
|
||||
// http://tools.ietf.org/html/rfc2397
|
||||
// http://en.wikipedia.org/wiki/Data_URI_scheme
|
||||
//
|
||||
// Images must have a mimetype matching:
|
||||
// image/gif
|
||||
// image/jpeg
|
||||
// image/png
|
||||
// image/webp
|
||||
//
|
||||
// NOTE: There is a potential security risk to allowing data URIs and you should
|
||||
// only permit them on content you already trust.
|
||||
// http://palizine.plynt.com/issues/2010Oct/bypass-xss-filters/
|
||||
// https://capec.mitre.org/data/definitions/244.html
|
||||
func (p *Policy) AllowDataURIImages() {
|
||||
|
||||
// URLs must be parseable by net/url.Parse()
|
||||
p.RequireParseableURLs(true)
|
||||
|
||||
// Supply a function to validate images contained within data URI
|
||||
p.AllowURLSchemeWithCustomPolicy(
|
||||
"data",
|
||||
func(url *url.URL) (allowUrl bool) {
|
||||
if url.RawQuery != "" || url.Fragment != "" {
|
||||
return false
|
||||
}
|
||||
|
||||
matched := dataURIImagePrefix.FindString(url.Opaque)
|
||||
if matched == "" {
|
||||
return false
|
||||
}
|
||||
|
||||
_, err := base64.StdEncoding.DecodeString(url.Opaque[len(matched):])
|
||||
if err != nil {
|
||||
return false
|
||||
}
|
||||
|
||||
return true
|
||||
},
|
||||
)
|
||||
}
|
||||
|
||||
// AllowLists will enabled ordered and unordered lists, as well as definition
|
||||
// lists
|
||||
func (p *Policy) AllowLists() {
|
||||
// "ol" "ul" are permitted
|
||||
p.AllowAttrs("type").Matching(ListType).OnElements("ol", "ul")
|
||||
|
||||
// "li" is permitted
|
||||
p.AllowAttrs("type").Matching(ListType).OnElements("li")
|
||||
p.AllowAttrs("value").Matching(Integer).OnElements("li")
|
||||
|
||||
// "dl" "dt" "dd" are permitted
|
||||
p.AllowElements("dl", "dt", "dd")
|
||||
}
|
||||
|
||||
// AllowTables will enable a rich set of elements and attributes to describe
|
||||
// HTML tables
|
||||
func (p *Policy) AllowTables() {
|
||||
|
||||
// "table" is permitted
|
||||
p.AllowAttrs("height", "width").Matching(NumberOrPercent).OnElements("table")
|
||||
p.AllowAttrs("summary").Matching(Paragraph).OnElements("table")
|
||||
|
||||
// "caption" is permitted
|
||||
p.AllowElements("caption")
|
||||
|
||||
// "col" "colgroup" are permitted
|
||||
p.AllowAttrs("align").Matching(CellAlign).OnElements("col", "colgroup")
|
||||
p.AllowAttrs("height", "width").Matching(
|
||||
NumberOrPercent,
|
||||
).OnElements("col", "colgroup")
|
||||
p.AllowAttrs("span").Matching(Integer).OnElements("colgroup", "col")
|
||||
p.AllowAttrs("valign").Matching(
|
||||
CellVerticalAlign,
|
||||
).OnElements("col", "colgroup")
|
||||
|
||||
// "thead" "tr" are permitted
|
||||
p.AllowAttrs("align").Matching(CellAlign).OnElements("thead", "tr")
|
||||
p.AllowAttrs("valign").Matching(CellVerticalAlign).OnElements("thead", "tr")
|
||||
|
||||
// "td" "th" are permitted
|
||||
p.AllowAttrs("abbr").Matching(Paragraph).OnElements("td", "th")
|
||||
p.AllowAttrs("align").Matching(CellAlign).OnElements("td", "th")
|
||||
p.AllowAttrs("colspan", "rowspan").Matching(Integer).OnElements("td", "th")
|
||||
p.AllowAttrs("headers").Matching(
|
||||
SpaceSeparatedTokens,
|
||||
).OnElements("td", "th")
|
||||
p.AllowAttrs("height", "width").Matching(
|
||||
NumberOrPercent,
|
||||
).OnElements("td", "th")
|
||||
p.AllowAttrs(
|
||||
"scope",
|
||||
).Matching(
|
||||
regexp.MustCompile(`(?i)(?:row|col)(?:group)?`),
|
||||
).OnElements("td", "th")
|
||||
p.AllowAttrs("valign").Matching(CellVerticalAlign).OnElements("td", "th")
|
||||
p.AllowAttrs("nowrap").Matching(
|
||||
regexp.MustCompile(`(?i)|nowrap`),
|
||||
).OnElements("td", "th")
|
||||
|
||||
// "tbody" "tfoot"
|
||||
p.AllowAttrs("align").Matching(CellAlign).OnElements("tbody", "tfoot")
|
||||
p.AllowAttrs("valign").Matching(
|
||||
CellVerticalAlign,
|
||||
).OnElements("tbody", "tfoot")
|
||||
}
|
||||
+253
@@ -0,0 +1,253 @@
|
||||
// Copyright (c) 2014, David Kitchen <david@buro9.com>
|
||||
//
|
||||
// All rights reserved.
|
||||
//
|
||||
// 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 the organisation (Microcosm) 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 HOLDER 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.
|
||||
|
||||
package bluemonday
|
||||
|
||||
import (
|
||||
"regexp"
|
||||
)
|
||||
|
||||
// StrictPolicy returns an empty policy, which will effectively strip all HTML
|
||||
// elements and their attributes from a document.
|
||||
func StrictPolicy() *Policy {
|
||||
return NewPolicy()
|
||||
}
|
||||
|
||||
// StripTagsPolicy is DEPRECATED. Use StrictPolicy instead.
|
||||
func StripTagsPolicy() *Policy {
|
||||
return StrictPolicy()
|
||||
}
|
||||
|
||||
// UGCPolicy returns a policy aimed at user generated content that is a result
|
||||
// of HTML WYSIWYG tools and Markdown conversions.
|
||||
//
|
||||
// This is expected to be a fairly rich document where as much markup as
|
||||
// possible should be retained. Markdown permits raw HTML so we are basically
|
||||
// providing a policy to sanitise HTML5 documents safely but with the
|
||||
// least intrusion on the formatting expectations of the user.
|
||||
func UGCPolicy() *Policy {
|
||||
|
||||
p := NewPolicy()
|
||||
|
||||
///////////////////////
|
||||
// Global attributes //
|
||||
///////////////////////
|
||||
|
||||
// "class" is not permitted as we are not allowing users to style their own
|
||||
// content
|
||||
|
||||
p.AllowStandardAttributes()
|
||||
|
||||
//////////////////////////////
|
||||
// Global URL format policy //
|
||||
//////////////////////////////
|
||||
|
||||
p.AllowStandardURLs()
|
||||
|
||||
////////////////////////////////
|
||||
// Declarations and structure //
|
||||
////////////////////////////////
|
||||
|
||||
// "xml" "xslt" "DOCTYPE" "html" "head" are not permitted as we are
|
||||
// expecting user generated content to be a fragment of HTML and not a full
|
||||
// document.
|
||||
|
||||
//////////////////////////
|
||||
// Sectioning root tags //
|
||||
//////////////////////////
|
||||
|
||||
// "article" and "aside" are permitted and takes no attributes
|
||||
p.AllowElements("article", "aside")
|
||||
|
||||
// "body" is not permitted as we are expecting user generated content to be a fragment
|
||||
// of HTML and not a full document.
|
||||
|
||||
// "details" is permitted, including the "open" attribute which can either
|
||||
// be blank or the value "open".
|
||||
p.AllowAttrs(
|
||||
"open",
|
||||
).Matching(regexp.MustCompile(`(?i)^(|open)$`)).OnElements("details")
|
||||
|
||||
// "fieldset" is not permitted as we are not allowing forms to be created.
|
||||
|
||||
// "figure" is permitted and takes no attributes
|
||||
p.AllowElements("figure")
|
||||
|
||||
// "nav" is not permitted as it is assumed that the site (and not the user)
|
||||
// has defined navigation elements
|
||||
|
||||
// "section" is permitted and takes no attributes
|
||||
p.AllowElements("section")
|
||||
|
||||
// "summary" is permitted and takes no attributes
|
||||
p.AllowElements("summary")
|
||||
|
||||
//////////////////////////
|
||||
// Headings and footers //
|
||||
//////////////////////////
|
||||
|
||||
// "footer" is not permitted as we expect user content to be a fragment and
|
||||
// not structural to this extent
|
||||
|
||||
// "h1" through "h6" are permitted and take no attributes
|
||||
p.AllowElements("h1", "h2", "h3", "h4", "h5", "h6")
|
||||
|
||||
// "header" is not permitted as we expect user content to be a fragment and
|
||||
// not structural to this extent
|
||||
|
||||
// "hgroup" is permitted and takes no attributes
|
||||
p.AllowElements("hgroup")
|
||||
|
||||
/////////////////////////////////////
|
||||
// Content grouping and separating //
|
||||
/////////////////////////////////////
|
||||
|
||||
// "blockquote" is permitted, including the "cite" attribute which must be
|
||||
// a standard URL.
|
||||
p.AllowAttrs("cite").OnElements("blockquote")
|
||||
|
||||
// "br" "div" "hr" "p" "span" "wbr" are permitted and take no attributes
|
||||
p.AllowElements("br", "div", "hr", "p", "span", "wbr")
|
||||
|
||||
///////////
|
||||
// Links //
|
||||
///////////
|
||||
|
||||
// "a" is permitted
|
||||
p.AllowAttrs("href").OnElements("a")
|
||||
|
||||
// "area" is permitted along with the attributes that map image maps work
|
||||
p.AllowAttrs("name").Matching(
|
||||
regexp.MustCompile(`^([\p{L}\p{N}_-]+)$`),
|
||||
).OnElements("map")
|
||||
p.AllowAttrs("alt").Matching(Paragraph).OnElements("area")
|
||||
p.AllowAttrs("coords").Matching(
|
||||
regexp.MustCompile(`^([0-9]+,)+[0-9]+$`),
|
||||
).OnElements("area")
|
||||
p.AllowAttrs("href").OnElements("area")
|
||||
p.AllowAttrs("rel").Matching(SpaceSeparatedTokens).OnElements("area")
|
||||
p.AllowAttrs("shape").Matching(
|
||||
regexp.MustCompile(`(?i)^(default|circle|rect|poly)$`),
|
||||
).OnElements("area")
|
||||
p.AllowAttrs("usemap").Matching(
|
||||
regexp.MustCompile(`(?i)^#[\p{L}\p{N}_-]+$`),
|
||||
).OnElements("img")
|
||||
|
||||
// "link" is not permitted
|
||||
|
||||
/////////////////////
|
||||
// Phrase elements //
|
||||
/////////////////////
|
||||
|
||||
// The following are all inline phrasing elements
|
||||
p.AllowElements("abbr", "acronym", "cite", "code", "dfn", "em",
|
||||
"figcaption", "mark", "s", "samp", "strong", "sub", "sup", "var")
|
||||
|
||||
// "q" is permitted and "cite" is a URL and handled by URL policies
|
||||
p.AllowAttrs("cite").OnElements("q")
|
||||
|
||||
// "time" is permitted
|
||||
p.AllowAttrs("datetime").Matching(ISO8601).OnElements("time")
|
||||
|
||||
////////////////////
|
||||
// Style elements //
|
||||
////////////////////
|
||||
|
||||
// block and inline elements that impart no semantic meaning but style the
|
||||
// document
|
||||
p.AllowElements("b", "i", "pre", "small", "strike", "tt", "u")
|
||||
|
||||
// "style" is not permitted as we are not yet sanitising CSS and it is an
|
||||
// XSS attack vector
|
||||
|
||||
//////////////////////
|
||||
// HTML5 Formatting //
|
||||
//////////////////////
|
||||
|
||||
// "bdi" "bdo" are permitted
|
||||
p.AllowAttrs("dir").Matching(Direction).OnElements("bdi", "bdo")
|
||||
|
||||
// "rp" "rt" "ruby" are permitted
|
||||
p.AllowElements("rp", "rt", "ruby")
|
||||
|
||||
///////////////////////////
|
||||
// HTML5 Change tracking //
|
||||
///////////////////////////
|
||||
|
||||
// "del" "ins" are permitted
|
||||
p.AllowAttrs("cite").Matching(Paragraph).OnElements("del", "ins")
|
||||
p.AllowAttrs("datetime").Matching(ISO8601).OnElements("del", "ins")
|
||||
|
||||
///////////
|
||||
// Lists //
|
||||
///////////
|
||||
|
||||
p.AllowLists()
|
||||
|
||||
////////////
|
||||
// Tables //
|
||||
////////////
|
||||
|
||||
p.AllowTables()
|
||||
|
||||
///////////
|
||||
// Forms //
|
||||
///////////
|
||||
|
||||
// By and large, forms are not permitted. However there are some form
|
||||
// elements that can be used to present data, and we do permit those
|
||||
//
|
||||
// "button" "fieldset" "input" "keygen" "label" "output" "select" "datalist"
|
||||
// "textarea" "optgroup" "option" are all not permitted
|
||||
|
||||
// "meter" is permitted
|
||||
p.AllowAttrs(
|
||||
"value",
|
||||
"min",
|
||||
"max",
|
||||
"low",
|
||||
"high",
|
||||
"optimum",
|
||||
).Matching(Number).OnElements("meter")
|
||||
|
||||
// "progress" is permitted
|
||||
p.AllowAttrs("value", "max").Matching(Number).OnElements("progress")
|
||||
|
||||
//////////////////////
|
||||
// Embedded content //
|
||||
//////////////////////
|
||||
|
||||
// Vast majority not permitted
|
||||
// "audio" "canvas" "embed" "iframe" "object" "param" "source" "svg" "track"
|
||||
// "video" are all not permitted
|
||||
|
||||
p.AllowImages()
|
||||
|
||||
return p
|
||||
}
|
||||
+533
@@ -0,0 +1,533 @@
|
||||
// Copyright (c) 2014, David Kitchen <david@buro9.com>
|
||||
//
|
||||
// All rights reserved.
|
||||
//
|
||||
// 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 the organisation (Microcosm) 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 HOLDER 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.
|
||||
|
||||
package bluemonday
|
||||
|
||||
import (
|
||||
"net/url"
|
||||
"regexp"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// Policy encapsulates the whitelist of HTML elements and attributes that will
|
||||
// be applied to the sanitised HTML.
|
||||
//
|
||||
// You should use bluemonday.NewPolicy() to create a blank policy as the
|
||||
// unexported fields contain maps that need to be initialized.
|
||||
type Policy struct {
|
||||
|
||||
// Declares whether the maps have been initialized, used as a cheap check to
|
||||
// ensure that those using Policy{} directly won't cause nil pointer
|
||||
// exceptions
|
||||
initialized bool
|
||||
|
||||
// If true then we add spaces when stripping tags, specifically the closing
|
||||
// tag is replaced by a space character.
|
||||
addSpaces bool
|
||||
|
||||
// When true, add rel="nofollow" to HTML anchors
|
||||
requireNoFollow bool
|
||||
|
||||
// When true, add rel="nofollow" to HTML anchors
|
||||
// Will add for href="http://foo"
|
||||
// Will skip for href="/foo" or href="foo"
|
||||
requireNoFollowFullyQualifiedLinks bool
|
||||
|
||||
// When true add target="_blank" to fully qualified links
|
||||
// Will add for href="http://foo"
|
||||
// Will skip for href="/foo" or href="foo"
|
||||
addTargetBlankToFullyQualifiedLinks bool
|
||||
|
||||
// When true, URLs must be parseable by "net/url" url.Parse()
|
||||
requireParseableURLs bool
|
||||
|
||||
// When true, u, _ := url.Parse("url"); !u.IsAbs() is permitted
|
||||
allowRelativeURLs bool
|
||||
|
||||
// map[htmlElementName]map[htmlAttributeName]attrPolicy
|
||||
elsAndAttrs map[string]map[string]attrPolicy
|
||||
|
||||
// map[htmlAttributeName]attrPolicy
|
||||
globalAttrs map[string]attrPolicy
|
||||
|
||||
// If urlPolicy is nil, all URLs with matching schema are allowed.
|
||||
// Otherwise, only the URLs with matching schema and urlPolicy(url)
|
||||
// returning true are allowed.
|
||||
allowURLSchemes map[string]urlPolicy
|
||||
|
||||
// If an element has had all attributes removed as a result of a policy
|
||||
// being applied, then the element would be removed from the output.
|
||||
//
|
||||
// However some elements are valid and have strong layout meaning without
|
||||
// any attributes, i.e. <table>. To prevent those being removed we maintain
|
||||
// a list of elements that are allowed to have no attributes and that will
|
||||
// be maintained in the output HTML.
|
||||
setOfElementsAllowedWithoutAttrs map[string]struct{}
|
||||
|
||||
setOfElementsToSkipContent map[string]struct{}
|
||||
}
|
||||
|
||||
type attrPolicy struct {
|
||||
|
||||
// optional pattern to match, when not nil the regexp needs to match
|
||||
// otherwise the attribute is removed
|
||||
regexp *regexp.Regexp
|
||||
}
|
||||
|
||||
type attrPolicyBuilder struct {
|
||||
p *Policy
|
||||
|
||||
attrNames []string
|
||||
regexp *regexp.Regexp
|
||||
allowEmpty bool
|
||||
}
|
||||
|
||||
type urlPolicy func(url *url.URL) (allowUrl bool)
|
||||
|
||||
// init initializes the maps if this has not been done already
|
||||
func (p *Policy) init() {
|
||||
if !p.initialized {
|
||||
p.elsAndAttrs = make(map[string]map[string]attrPolicy)
|
||||
p.globalAttrs = make(map[string]attrPolicy)
|
||||
p.allowURLSchemes = make(map[string]urlPolicy)
|
||||
p.setOfElementsAllowedWithoutAttrs = make(map[string]struct{})
|
||||
p.setOfElementsToSkipContent = make(map[string]struct{})
|
||||
p.initialized = true
|
||||
}
|
||||
}
|
||||
|
||||
// NewPolicy returns a blank policy with nothing whitelisted or permitted. This
|
||||
// is the recommended way to start building a policy and you should now use
|
||||
// AllowAttrs() and/or AllowElements() to construct the whitelist of HTML
|
||||
// elements and attributes.
|
||||
func NewPolicy() *Policy {
|
||||
|
||||
p := Policy{}
|
||||
|
||||
p.addDefaultElementsWithoutAttrs()
|
||||
p.addDefaultSkipElementContent()
|
||||
|
||||
return &p
|
||||
}
|
||||
|
||||
// AllowAttrs takes a range of HTML attribute names and returns an
|
||||
// attribute policy builder that allows you to specify the pattern and scope of
|
||||
// the whitelisted attribute.
|
||||
//
|
||||
// The attribute policy is only added to the core policy when either Globally()
|
||||
// or OnElements(...) are called.
|
||||
func (p *Policy) AllowAttrs(attrNames ...string) *attrPolicyBuilder {
|
||||
|
||||
p.init()
|
||||
|
||||
abp := attrPolicyBuilder{
|
||||
p: p,
|
||||
allowEmpty: false,
|
||||
}
|
||||
|
||||
for _, attrName := range attrNames {
|
||||
abp.attrNames = append(abp.attrNames, strings.ToLower(attrName))
|
||||
}
|
||||
|
||||
return &abp
|
||||
}
|
||||
|
||||
// AllowNoAttrs says that attributes on element are optional.
|
||||
//
|
||||
// The attribute policy is only added to the core policy when OnElements(...)
|
||||
// are called.
|
||||
func (p *Policy) AllowNoAttrs() *attrPolicyBuilder {
|
||||
|
||||
p.init()
|
||||
|
||||
abp := attrPolicyBuilder{
|
||||
p: p,
|
||||
allowEmpty: true,
|
||||
}
|
||||
return &abp
|
||||
}
|
||||
|
||||
// AllowNoAttrs says that attributes on element are optional.
|
||||
//
|
||||
// The attribute policy is only added to the core policy when OnElements(...)
|
||||
// are called.
|
||||
func (abp *attrPolicyBuilder) AllowNoAttrs() *attrPolicyBuilder {
|
||||
|
||||
abp.allowEmpty = true
|
||||
|
||||
return abp
|
||||
}
|
||||
|
||||
// Matching allows a regular expression to be applied to a nascent attribute
|
||||
// policy, and returns the attribute policy. Calling this more than once will
|
||||
// replace the existing regexp.
|
||||
func (abp *attrPolicyBuilder) Matching(regex *regexp.Regexp) *attrPolicyBuilder {
|
||||
|
||||
abp.regexp = regex
|
||||
|
||||
return abp
|
||||
}
|
||||
|
||||
// OnElements will bind an attribute policy to a given range of HTML elements
|
||||
// and return the updated policy
|
||||
func (abp *attrPolicyBuilder) OnElements(elements ...string) *Policy {
|
||||
|
||||
for _, element := range elements {
|
||||
element = strings.ToLower(element)
|
||||
|
||||
for _, attr := range abp.attrNames {
|
||||
|
||||
if _, ok := abp.p.elsAndAttrs[element]; !ok {
|
||||
abp.p.elsAndAttrs[element] = make(map[string]attrPolicy)
|
||||
}
|
||||
|
||||
ap := attrPolicy{}
|
||||
if abp.regexp != nil {
|
||||
ap.regexp = abp.regexp
|
||||
}
|
||||
|
||||
abp.p.elsAndAttrs[element][attr] = ap
|
||||
}
|
||||
|
||||
if abp.allowEmpty {
|
||||
abp.p.setOfElementsAllowedWithoutAttrs[element] = struct{}{}
|
||||
|
||||
if _, ok := abp.p.elsAndAttrs[element]; !ok {
|
||||
abp.p.elsAndAttrs[element] = make(map[string]attrPolicy)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return abp.p
|
||||
}
|
||||
|
||||
// Globally will bind an attribute policy to all HTML elements and return the
|
||||
// updated policy
|
||||
func (abp *attrPolicyBuilder) Globally() *Policy {
|
||||
|
||||
for _, attr := range abp.attrNames {
|
||||
if _, ok := abp.p.globalAttrs[attr]; !ok {
|
||||
abp.p.globalAttrs[attr] = attrPolicy{}
|
||||
}
|
||||
|
||||
ap := attrPolicy{}
|
||||
if abp.regexp != nil {
|
||||
ap.regexp = abp.regexp
|
||||
}
|
||||
|
||||
abp.p.globalAttrs[attr] = ap
|
||||
}
|
||||
|
||||
return abp.p
|
||||
}
|
||||
|
||||
// AllowElements will append HTML elements to the whitelist without applying an
|
||||
// attribute policy to those elements (the elements are permitted
|
||||
// sans-attributes)
|
||||
func (p *Policy) AllowElements(names ...string) *Policy {
|
||||
p.init()
|
||||
|
||||
for _, element := range names {
|
||||
element = strings.ToLower(element)
|
||||
|
||||
if _, ok := p.elsAndAttrs[element]; !ok {
|
||||
p.elsAndAttrs[element] = make(map[string]attrPolicy)
|
||||
}
|
||||
}
|
||||
|
||||
return p
|
||||
}
|
||||
|
||||
// RequireNoFollowOnLinks will result in all <a> tags having a rel="nofollow"
|
||||
// added to them if one does not already exist
|
||||
//
|
||||
// Note: This requires p.RequireParseableURLs(true) and will enable it.
|
||||
func (p *Policy) RequireNoFollowOnLinks(require bool) *Policy {
|
||||
|
||||
p.requireNoFollow = require
|
||||
p.requireParseableURLs = true
|
||||
|
||||
return p
|
||||
}
|
||||
|
||||
// RequireNoFollowOnFullyQualifiedLinks will result in all <a> tags that point
|
||||
// to a non-local destination (i.e. starts with a protocol and has a host)
|
||||
// having a rel="nofollow" added to them if one does not already exist
|
||||
//
|
||||
// Note: This requires p.RequireParseableURLs(true) and will enable it.
|
||||
func (p *Policy) RequireNoFollowOnFullyQualifiedLinks(require bool) *Policy {
|
||||
|
||||
p.requireNoFollowFullyQualifiedLinks = require
|
||||
p.requireParseableURLs = true
|
||||
|
||||
return p
|
||||
}
|
||||
|
||||
// AddTargetBlankToFullyQualifiedLinks will result in all <a> tags that point
|
||||
// to a non-local destination (i.e. starts with a protocol and has a host)
|
||||
// having a target="_blank" added to them if one does not already exist
|
||||
//
|
||||
// Note: This requires p.RequireParseableURLs(true) and will enable it.
|
||||
func (p *Policy) AddTargetBlankToFullyQualifiedLinks(require bool) *Policy {
|
||||
|
||||
p.addTargetBlankToFullyQualifiedLinks = require
|
||||
p.requireParseableURLs = true
|
||||
|
||||
return p
|
||||
}
|
||||
|
||||
// RequireParseableURLs will result in all URLs requiring that they be parseable
|
||||
// by "net/url" url.Parse()
|
||||
// This applies to:
|
||||
// - a.href
|
||||
// - area.href
|
||||
// - blockquote.cite
|
||||
// - img.src
|
||||
// - link.href
|
||||
// - script.src
|
||||
func (p *Policy) RequireParseableURLs(require bool) *Policy {
|
||||
|
||||
p.requireParseableURLs = require
|
||||
|
||||
return p
|
||||
}
|
||||
|
||||
// AllowRelativeURLs enables RequireParseableURLs and then permits URLs that
|
||||
// are parseable, have no schema information and url.IsAbs() returns false
|
||||
// This permits local URLs
|
||||
func (p *Policy) AllowRelativeURLs(require bool) *Policy {
|
||||
|
||||
p.RequireParseableURLs(true)
|
||||
p.allowRelativeURLs = require
|
||||
|
||||
return p
|
||||
}
|
||||
|
||||
// AllowURLSchemes will append URL schemes to the whitelist
|
||||
// Example: p.AllowURLSchemes("mailto", "http", "https")
|
||||
func (p *Policy) AllowURLSchemes(schemes ...string) *Policy {
|
||||
p.init()
|
||||
|
||||
p.RequireParseableURLs(true)
|
||||
|
||||
for _, scheme := range schemes {
|
||||
scheme = strings.ToLower(scheme)
|
||||
|
||||
// Allow all URLs with matching scheme.
|
||||
p.allowURLSchemes[scheme] = nil
|
||||
}
|
||||
|
||||
return p
|
||||
}
|
||||
|
||||
// AllowURLSchemeWithCustomPolicy will append URL schemes with
|
||||
// a custom URL policy to the whitelist.
|
||||
// Only the URLs with matching schema and urlPolicy(url)
|
||||
// returning true will be allowed.
|
||||
func (p *Policy) AllowURLSchemeWithCustomPolicy(
|
||||
scheme string,
|
||||
urlPolicy func(url *url.URL) (allowUrl bool),
|
||||
) *Policy {
|
||||
|
||||
p.init()
|
||||
|
||||
p.RequireParseableURLs(true)
|
||||
|
||||
scheme = strings.ToLower(scheme)
|
||||
|
||||
p.allowURLSchemes[scheme] = urlPolicy
|
||||
|
||||
return p
|
||||
}
|
||||
|
||||
// AddSpaceWhenStrippingTag states whether to add a single space " " when
|
||||
// removing tags that are not whitelisted by the policy.
|
||||
//
|
||||
// This is useful if you expect to strip tags in dense markup and may lose the
|
||||
// value of whitespace.
|
||||
//
|
||||
// For example: "<p>Hello</p><p>World</p>"" would be sanitized to "HelloWorld"
|
||||
// with the default value of false, but you may wish to sanitize this to
|
||||
// " Hello World " by setting AddSpaceWhenStrippingTag to true as this would
|
||||
// retain the intent of the text.
|
||||
func (p *Policy) AddSpaceWhenStrippingTag(allow bool) *Policy {
|
||||
|
||||
p.addSpaces = allow
|
||||
|
||||
return p
|
||||
}
|
||||
|
||||
// SkipElementsContent adds the HTML elements whose tags is needed to be removed
|
||||
// with it's content.
|
||||
func (p *Policy) SkipElementsContent(names ...string) *Policy {
|
||||
|
||||
p.init()
|
||||
|
||||
for _, element := range names {
|
||||
element = strings.ToLower(element)
|
||||
|
||||
if _, ok := p.setOfElementsToSkipContent[element]; !ok {
|
||||
p.setOfElementsToSkipContent[element] = struct{}{}
|
||||
}
|
||||
}
|
||||
|
||||
return p
|
||||
}
|
||||
|
||||
// AllowElementsContent marks the HTML elements whose content should be
|
||||
// retained after removing the tag.
|
||||
func (p *Policy) AllowElementsContent(names ...string) *Policy {
|
||||
|
||||
p.init()
|
||||
|
||||
for _, element := range names {
|
||||
delete(p.setOfElementsToSkipContent, strings.ToLower(element))
|
||||
}
|
||||
|
||||
return p
|
||||
}
|
||||
|
||||
// addDefaultElementsWithoutAttrs adds the HTML elements that we know are valid
|
||||
// without any attributes to an internal map.
|
||||
// i.e. we know that <table> is valid, but <bdo> isn't valid as the "dir" attr
|
||||
// is mandatory
|
||||
func (p *Policy) addDefaultElementsWithoutAttrs() {
|
||||
p.init()
|
||||
|
||||
p.setOfElementsAllowedWithoutAttrs["abbr"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["acronym"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["article"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["aside"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["audio"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["b"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["bdi"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["blockquote"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["body"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["br"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["button"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["canvas"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["caption"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["center"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["cite"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["code"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["col"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["colgroup"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["datalist"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["dd"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["del"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["details"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["dfn"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["div"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["dl"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["dt"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["em"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["fieldset"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["figcaption"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["figure"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["footer"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["h1"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["h2"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["h3"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["h4"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["h5"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["h6"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["head"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["header"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["hgroup"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["hr"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["html"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["i"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["ins"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["kbd"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["li"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["mark"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["marquee"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["nav"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["ol"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["optgroup"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["option"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["p"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["pre"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["q"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["rp"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["rt"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["ruby"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["s"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["samp"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["script"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["section"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["select"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["small"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["span"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["strike"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["strong"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["style"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["sub"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["summary"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["sup"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["svg"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["table"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["tbody"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["td"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["textarea"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["tfoot"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["th"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["thead"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["title"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["time"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["tr"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["tt"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["u"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["ul"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["var"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["video"] = struct{}{}
|
||||
p.setOfElementsAllowedWithoutAttrs["wbr"] = struct{}{}
|
||||
|
||||
}
|
||||
|
||||
// addDefaultSkipElementContent adds the HTML elements that we should skip
|
||||
// rendering the character content of, if the element itself is not allowed.
|
||||
// This is all character data that the end user would not normally see.
|
||||
// i.e. if we exclude a <script> tag then we shouldn't render the JavaScript or
|
||||
// anything else until we encounter the closing </script> tag.
|
||||
func (p *Policy) addDefaultSkipElementContent() {
|
||||
p.init()
|
||||
|
||||
p.setOfElementsToSkipContent["frame"] = struct{}{}
|
||||
p.setOfElementsToSkipContent["frameset"] = struct{}{}
|
||||
p.setOfElementsToSkipContent["iframe"] = struct{}{}
|
||||
p.setOfElementsToSkipContent["noembed"] = struct{}{}
|
||||
p.setOfElementsToSkipContent["noframes"] = struct{}{}
|
||||
p.setOfElementsToSkipContent["noscript"] = struct{}{}
|
||||
p.setOfElementsToSkipContent["nostyle"] = struct{}{}
|
||||
p.setOfElementsToSkipContent["object"] = struct{}{}
|
||||
p.setOfElementsToSkipContent["script"] = struct{}{}
|
||||
p.setOfElementsToSkipContent["style"] = struct{}{}
|
||||
p.setOfElementsToSkipContent["title"] = struct{}{}
|
||||
}
|
||||
+547
@@ -0,0 +1,547 @@
|
||||
// Copyright (c) 2014, David Kitchen <david@buro9.com>
|
||||
//
|
||||
// All rights reserved.
|
||||
//
|
||||
// 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 the organisation (Microcosm) 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 HOLDER 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.
|
||||
|
||||
package bluemonday
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"io"
|
||||
"net/url"
|
||||
"strings"
|
||||
|
||||
"golang.org/x/net/html"
|
||||
)
|
||||
|
||||
// Sanitize takes a string that contains a HTML fragment or document and applies
|
||||
// the given policy whitelist.
|
||||
//
|
||||
// It returns a HTML string that has been sanitized by the policy or an empty
|
||||
// string if an error has occurred (most likely as a consequence of extremely
|
||||
// malformed input)
|
||||
func (p *Policy) Sanitize(s string) string {
|
||||
if strings.TrimSpace(s) == "" {
|
||||
return s
|
||||
}
|
||||
|
||||
return p.sanitize(strings.NewReader(s)).String()
|
||||
}
|
||||
|
||||
// SanitizeBytes takes a []byte that contains a HTML fragment or document and applies
|
||||
// the given policy whitelist.
|
||||
//
|
||||
// It returns a []byte containing the HTML that has been sanitized by the policy
|
||||
// or an empty []byte if an error has occurred (most likely as a consequence of
|
||||
// extremely malformed input)
|
||||
func (p *Policy) SanitizeBytes(b []byte) []byte {
|
||||
if len(bytes.TrimSpace(b)) == 0 {
|
||||
return b
|
||||
}
|
||||
|
||||
return p.sanitize(bytes.NewReader(b)).Bytes()
|
||||
}
|
||||
|
||||
// SanitizeReader takes an io.Reader that contains a HTML fragment or document
|
||||
// and applies the given policy whitelist.
|
||||
//
|
||||
// It returns a bytes.Buffer containing the HTML that has been sanitized by the
|
||||
// policy. Errors during sanitization will merely return an empty result.
|
||||
func (p *Policy) SanitizeReader(r io.Reader) *bytes.Buffer {
|
||||
return p.sanitize(r)
|
||||
}
|
||||
|
||||
// Performs the actual sanitization process.
|
||||
func (p *Policy) sanitize(r io.Reader) *bytes.Buffer {
|
||||
|
||||
// It is possible that the developer has created the policy via:
|
||||
// p := bluemonday.Policy{}
|
||||
// rather than:
|
||||
// p := bluemonday.NewPolicy()
|
||||
// If this is the case, and if they haven't yet triggered an action that
|
||||
// would initiliaze the maps, then we need to do that.
|
||||
p.init()
|
||||
|
||||
var (
|
||||
buff bytes.Buffer
|
||||
skipElementContent bool
|
||||
skippingElementsCount int64
|
||||
skipClosingTag bool
|
||||
closingTagToSkipStack []string
|
||||
mostRecentlyStartedToken string
|
||||
)
|
||||
|
||||
tokenizer := html.NewTokenizer(r)
|
||||
for {
|
||||
if tokenizer.Next() == html.ErrorToken {
|
||||
err := tokenizer.Err()
|
||||
if err == io.EOF {
|
||||
// End of input means end of processing
|
||||
return &buff
|
||||
}
|
||||
|
||||
// Raw tokenizer error
|
||||
return &bytes.Buffer{}
|
||||
}
|
||||
|
||||
token := tokenizer.Token()
|
||||
switch token.Type {
|
||||
case html.DoctypeToken:
|
||||
|
||||
// DocType is not handled as there is no safe parsing mechanism
|
||||
// provided by golang.org/x/net/html for the content, and this can
|
||||
// be misused to insert HTML tags that are not then sanitized
|
||||
//
|
||||
// One might wish to recursively sanitize here using the same policy
|
||||
// but I will need to do some further testing before considering
|
||||
// this.
|
||||
|
||||
case html.CommentToken:
|
||||
|
||||
// Comments are ignored by default
|
||||
|
||||
case html.StartTagToken:
|
||||
|
||||
mostRecentlyStartedToken = token.Data
|
||||
|
||||
aps, ok := p.elsAndAttrs[token.Data]
|
||||
if !ok {
|
||||
if _, ok := p.setOfElementsToSkipContent[token.Data]; ok {
|
||||
skipElementContent = true
|
||||
skippingElementsCount++
|
||||
}
|
||||
if p.addSpaces {
|
||||
buff.WriteString(" ")
|
||||
}
|
||||
break
|
||||
}
|
||||
|
||||
if len(token.Attr) != 0 {
|
||||
token.Attr = p.sanitizeAttrs(token.Data, token.Attr, aps)
|
||||
}
|
||||
|
||||
if len(token.Attr) == 0 {
|
||||
if !p.allowNoAttrs(token.Data) {
|
||||
skipClosingTag = true
|
||||
closingTagToSkipStack = append(closingTagToSkipStack, token.Data)
|
||||
if p.addSpaces {
|
||||
buff.WriteString(" ")
|
||||
}
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
if !skipElementContent {
|
||||
buff.WriteString(token.String())
|
||||
}
|
||||
|
||||
case html.EndTagToken:
|
||||
|
||||
if mostRecentlyStartedToken == token.Data {
|
||||
mostRecentlyStartedToken = ""
|
||||
}
|
||||
|
||||
if skipClosingTag && closingTagToSkipStack[len(closingTagToSkipStack)-1] == token.Data {
|
||||
closingTagToSkipStack = closingTagToSkipStack[:len(closingTagToSkipStack)-1]
|
||||
if len(closingTagToSkipStack) == 0 {
|
||||
skipClosingTag = false
|
||||
}
|
||||
if p.addSpaces {
|
||||
buff.WriteString(" ")
|
||||
}
|
||||
break
|
||||
}
|
||||
|
||||
if _, ok := p.elsAndAttrs[token.Data]; !ok {
|
||||
if _, ok := p.setOfElementsToSkipContent[token.Data]; ok {
|
||||
skippingElementsCount--
|
||||
if skippingElementsCount == 0 {
|
||||
skipElementContent = false
|
||||
}
|
||||
}
|
||||
if p.addSpaces {
|
||||
buff.WriteString(" ")
|
||||
}
|
||||
break
|
||||
}
|
||||
|
||||
if !skipElementContent {
|
||||
buff.WriteString(token.String())
|
||||
}
|
||||
|
||||
case html.SelfClosingTagToken:
|
||||
|
||||
aps, ok := p.elsAndAttrs[token.Data]
|
||||
if !ok {
|
||||
if p.addSpaces {
|
||||
buff.WriteString(" ")
|
||||
}
|
||||
break
|
||||
}
|
||||
|
||||
if len(token.Attr) != 0 {
|
||||
token.Attr = p.sanitizeAttrs(token.Data, token.Attr, aps)
|
||||
}
|
||||
|
||||
if len(token.Attr) == 0 && !p.allowNoAttrs(token.Data) {
|
||||
if p.addSpaces {
|
||||
buff.WriteString(" ")
|
||||
}
|
||||
break
|
||||
}
|
||||
|
||||
if !skipElementContent {
|
||||
buff.WriteString(token.String())
|
||||
}
|
||||
|
||||
case html.TextToken:
|
||||
|
||||
if !skipElementContent {
|
||||
switch mostRecentlyStartedToken {
|
||||
case "script":
|
||||
// not encouraged, but if a policy allows JavaScript we
|
||||
// should not HTML escape it as that would break the output
|
||||
buff.WriteString(token.Data)
|
||||
case "style":
|
||||
// not encouraged, but if a policy allows CSS styles we
|
||||
// should not HTML escape it as that would break the output
|
||||
buff.WriteString(token.Data)
|
||||
default:
|
||||
// HTML escape the text
|
||||
buff.WriteString(token.String())
|
||||
}
|
||||
}
|
||||
default:
|
||||
// A token that didn't exist in the html package when we wrote this
|
||||
return &bytes.Buffer{}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// sanitizeAttrs takes a set of element attribute policies and the global
|
||||
// attribute policies and applies them to the []html.Attribute returning a set
|
||||
// of html.Attributes that match the policies
|
||||
func (p *Policy) sanitizeAttrs(
|
||||
elementName string,
|
||||
attrs []html.Attribute,
|
||||
aps map[string]attrPolicy,
|
||||
) []html.Attribute {
|
||||
|
||||
if len(attrs) == 0 {
|
||||
return attrs
|
||||
}
|
||||
|
||||
// Builds a new attribute slice based on the whether the attribute has been
|
||||
// whitelisted explicitly or globally.
|
||||
cleanAttrs := []html.Attribute{}
|
||||
for _, htmlAttr := range attrs {
|
||||
// Is there an element specific attribute policy that applies?
|
||||
if ap, ok := aps[htmlAttr.Key]; ok {
|
||||
if ap.regexp != nil {
|
||||
if ap.regexp.MatchString(htmlAttr.Val) {
|
||||
cleanAttrs = append(cleanAttrs, htmlAttr)
|
||||
continue
|
||||
}
|
||||
} else {
|
||||
cleanAttrs = append(cleanAttrs, htmlAttr)
|
||||
continue
|
||||
}
|
||||
}
|
||||
|
||||
// Is there a global attribute policy that applies?
|
||||
if ap, ok := p.globalAttrs[htmlAttr.Key]; ok {
|
||||
if ap.regexp != nil {
|
||||
if ap.regexp.MatchString(htmlAttr.Val) {
|
||||
cleanAttrs = append(cleanAttrs, htmlAttr)
|
||||
}
|
||||
} else {
|
||||
cleanAttrs = append(cleanAttrs, htmlAttr)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if len(cleanAttrs) == 0 {
|
||||
// If nothing was allowed, let's get out of here
|
||||
return cleanAttrs
|
||||
}
|
||||
// cleanAttrs now contains the attributes that are permitted
|
||||
|
||||
if linkable(elementName) {
|
||||
if p.requireParseableURLs {
|
||||
// Ensure URLs are parseable:
|
||||
// - a.href
|
||||
// - area.href
|
||||
// - link.href
|
||||
// - blockquote.cite
|
||||
// - q.cite
|
||||
// - img.src
|
||||
// - script.src
|
||||
tmpAttrs := []html.Attribute{}
|
||||
for _, htmlAttr := range cleanAttrs {
|
||||
switch elementName {
|
||||
case "a", "area", "link":
|
||||
if htmlAttr.Key == "href" {
|
||||
if u, ok := p.validURL(htmlAttr.Val); ok {
|
||||
htmlAttr.Val = u
|
||||
tmpAttrs = append(tmpAttrs, htmlAttr)
|
||||
}
|
||||
break
|
||||
}
|
||||
tmpAttrs = append(tmpAttrs, htmlAttr)
|
||||
case "blockquote", "q":
|
||||
if htmlAttr.Key == "cite" {
|
||||
if u, ok := p.validURL(htmlAttr.Val); ok {
|
||||
htmlAttr.Val = u
|
||||
tmpAttrs = append(tmpAttrs, htmlAttr)
|
||||
}
|
||||
break
|
||||
}
|
||||
tmpAttrs = append(tmpAttrs, htmlAttr)
|
||||
case "img", "script":
|
||||
if htmlAttr.Key == "src" {
|
||||
if u, ok := p.validURL(htmlAttr.Val); ok {
|
||||
htmlAttr.Val = u
|
||||
tmpAttrs = append(tmpAttrs, htmlAttr)
|
||||
}
|
||||
break
|
||||
}
|
||||
tmpAttrs = append(tmpAttrs, htmlAttr)
|
||||
default:
|
||||
tmpAttrs = append(tmpAttrs, htmlAttr)
|
||||
}
|
||||
}
|
||||
cleanAttrs = tmpAttrs
|
||||
}
|
||||
|
||||
if (p.requireNoFollow ||
|
||||
p.requireNoFollowFullyQualifiedLinks ||
|
||||
p.addTargetBlankToFullyQualifiedLinks) &&
|
||||
len(cleanAttrs) > 0 {
|
||||
|
||||
// Add rel="nofollow" if a "href" exists
|
||||
switch elementName {
|
||||
case "a", "area", "link":
|
||||
var hrefFound bool
|
||||
var externalLink bool
|
||||
for _, htmlAttr := range cleanAttrs {
|
||||
if htmlAttr.Key == "href" {
|
||||
hrefFound = true
|
||||
|
||||
u, err := url.Parse(htmlAttr.Val)
|
||||
if err != nil {
|
||||
continue
|
||||
}
|
||||
if u.Host != "" {
|
||||
externalLink = true
|
||||
}
|
||||
|
||||
continue
|
||||
}
|
||||
}
|
||||
|
||||
if hrefFound {
|
||||
var (
|
||||
noFollowFound bool
|
||||
targetBlankFound bool
|
||||
)
|
||||
|
||||
addNoFollow := (p.requireNoFollow ||
|
||||
externalLink && p.requireNoFollowFullyQualifiedLinks)
|
||||
|
||||
addTargetBlank := (externalLink &&
|
||||
p.addTargetBlankToFullyQualifiedLinks)
|
||||
|
||||
tmpAttrs := []html.Attribute{}
|
||||
for _, htmlAttr := range cleanAttrs {
|
||||
|
||||
var appended bool
|
||||
if htmlAttr.Key == "rel" && addNoFollow {
|
||||
|
||||
if strings.Contains(htmlAttr.Val, "nofollow") {
|
||||
noFollowFound = true
|
||||
tmpAttrs = append(tmpAttrs, htmlAttr)
|
||||
appended = true
|
||||
} else {
|
||||
htmlAttr.Val += " nofollow"
|
||||
noFollowFound = true
|
||||
tmpAttrs = append(tmpAttrs, htmlAttr)
|
||||
appended = true
|
||||
}
|
||||
}
|
||||
|
||||
if elementName == "a" && htmlAttr.Key == "target" {
|
||||
if htmlAttr.Val == "_blank" {
|
||||
targetBlankFound = true
|
||||
}
|
||||
if addTargetBlank && !targetBlankFound {
|
||||
htmlAttr.Val = "_blank"
|
||||
targetBlankFound = true
|
||||
tmpAttrs = append(tmpAttrs, htmlAttr)
|
||||
appended = true
|
||||
}
|
||||
}
|
||||
|
||||
if !appended {
|
||||
tmpAttrs = append(tmpAttrs, htmlAttr)
|
||||
}
|
||||
}
|
||||
if noFollowFound || targetBlankFound {
|
||||
cleanAttrs = tmpAttrs
|
||||
}
|
||||
|
||||
if addNoFollow && !noFollowFound {
|
||||
rel := html.Attribute{}
|
||||
rel.Key = "rel"
|
||||
rel.Val = "nofollow"
|
||||
cleanAttrs = append(cleanAttrs, rel)
|
||||
}
|
||||
|
||||
if elementName == "a" && addTargetBlank && !targetBlankFound {
|
||||
rel := html.Attribute{}
|
||||
rel.Key = "target"
|
||||
rel.Val = "_blank"
|
||||
targetBlankFound = true
|
||||
cleanAttrs = append(cleanAttrs, rel)
|
||||
}
|
||||
|
||||
if targetBlankFound {
|
||||
// target="_blank" has a security risk that allows the
|
||||
// opened window/tab to issue JavaScript calls against
|
||||
// window.opener, which in effect allow the destination
|
||||
// of the link to control the source:
|
||||
// https://dev.to/ben/the-targetblank-vulnerability-by-example
|
||||
//
|
||||
// To mitigate this risk, we need to add a specific rel
|
||||
// attribute if it is not already present.
|
||||
// rel="noopener"
|
||||
//
|
||||
// Unfortunately this is processing the rel twice (we
|
||||
// already looked at it earlier ^^) as we cannot be sure
|
||||
// of the ordering of the href and rel, and whether we
|
||||
// have fully satisfied that we need to do this. This
|
||||
// double processing only happens *if* target="_blank"
|
||||
// is true.
|
||||
var noOpenerAdded bool
|
||||
tmpAttrs := []html.Attribute{}
|
||||
for _, htmlAttr := range cleanAttrs {
|
||||
var appended bool
|
||||
if htmlAttr.Key == "rel" {
|
||||
if strings.Contains(htmlAttr.Val, "noopener") {
|
||||
noOpenerAdded = true
|
||||
tmpAttrs = append(tmpAttrs, htmlAttr)
|
||||
} else {
|
||||
htmlAttr.Val += " noopener"
|
||||
noOpenerAdded = true
|
||||
tmpAttrs = append(tmpAttrs, htmlAttr)
|
||||
}
|
||||
|
||||
appended = true
|
||||
}
|
||||
if !appended {
|
||||
tmpAttrs = append(tmpAttrs, htmlAttr)
|
||||
}
|
||||
}
|
||||
if noOpenerAdded {
|
||||
cleanAttrs = tmpAttrs
|
||||
} else {
|
||||
// rel attr was not found, or else noopener would
|
||||
// have been added already
|
||||
rel := html.Attribute{}
|
||||
rel.Key = "rel"
|
||||
rel.Val = "noopener"
|
||||
cleanAttrs = append(cleanAttrs, rel)
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
default:
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return cleanAttrs
|
||||
}
|
||||
|
||||
func (p *Policy) allowNoAttrs(elementName string) bool {
|
||||
_, ok := p.setOfElementsAllowedWithoutAttrs[elementName]
|
||||
return ok
|
||||
}
|
||||
|
||||
func (p *Policy) validURL(rawurl string) (string, bool) {
|
||||
if p.requireParseableURLs {
|
||||
// URLs are valid if when space is trimmed the URL is valid
|
||||
rawurl = strings.TrimSpace(rawurl)
|
||||
|
||||
// URLs cannot contain whitespace, unless it is a data-uri
|
||||
if (strings.Contains(rawurl, " ") ||
|
||||
strings.Contains(rawurl, "\t") ||
|
||||
strings.Contains(rawurl, "\n")) &&
|
||||
!strings.HasPrefix(rawurl, `data:`) {
|
||||
return "", false
|
||||
}
|
||||
|
||||
// URLs are valid if they parse
|
||||
u, err := url.Parse(rawurl)
|
||||
if err != nil {
|
||||
return "", false
|
||||
}
|
||||
|
||||
if u.Scheme != "" {
|
||||
|
||||
urlPolicy, ok := p.allowURLSchemes[u.Scheme]
|
||||
if !ok {
|
||||
return "", false
|
||||
|
||||
}
|
||||
|
||||
if urlPolicy == nil || urlPolicy(u) == true {
|
||||
return u.String(), true
|
||||
}
|
||||
|
||||
return "", false
|
||||
}
|
||||
|
||||
if p.allowRelativeURLs {
|
||||
if u.String() != "" {
|
||||
return u.String(), true
|
||||
}
|
||||
}
|
||||
|
||||
return "", false
|
||||
}
|
||||
|
||||
return rawurl, true
|
||||
}
|
||||
|
||||
func linkable(elementName string) bool {
|
||||
switch elementName {
|
||||
case "a", "area", "blockquote", "img", "link", "script":
|
||||
return true
|
||||
default:
|
||||
return false
|
||||
}
|
||||
}
|
||||
+78
@@ -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)
|
||||
}
|
||||
+709
@@ -0,0 +1,709 @@
|
||||
// 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.
|
||||
|
||||
// +build ignore
|
||||
|
||||
//go:generate go run gen.go
|
||||
//go:generate go run gen.go -test
|
||||
|
||||
package main
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"flag"
|
||||
"fmt"
|
||||
"go/format"
|
||||
"io/ioutil"
|
||||
"math/rand"
|
||||
"os"
|
||||
"sort"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// identifier converts s to a Go exported identifier.
|
||||
// It converts "div" to "Div" and "accept-charset" to "AcceptCharset".
|
||||
func identifier(s string) string {
|
||||
b := make([]byte, 0, len(s))
|
||||
cap := true
|
||||
for _, c := range s {
|
||||
if c == '-' {
|
||||
cap = true
|
||||
continue
|
||||
}
|
||||
if cap && 'a' <= c && c <= 'z' {
|
||||
c -= 'a' - 'A'
|
||||
}
|
||||
cap = false
|
||||
b = append(b, byte(c))
|
||||
}
|
||||
return string(b)
|
||||
}
|
||||
|
||||
var test = flag.Bool("test", false, "generate table_test.go")
|
||||
|
||||
func genFile(name string, buf *bytes.Buffer) {
|
||||
b, err := format.Source(buf.Bytes())
|
||||
if err != nil {
|
||||
fmt.Fprintln(os.Stderr, err)
|
||||
os.Exit(1)
|
||||
}
|
||||
if err := ioutil.WriteFile(name, b, 0644); err != nil {
|
||||
fmt.Fprintln(os.Stderr, err)
|
||||
os.Exit(1)
|
||||
}
|
||||
}
|
||||
|
||||
func main() {
|
||||
flag.Parse()
|
||||
|
||||
var all []string
|
||||
all = append(all, elements...)
|
||||
all = append(all, attributes...)
|
||||
all = append(all, eventHandlers...)
|
||||
all = append(all, extra...)
|
||||
sort.Strings(all)
|
||||
|
||||
// uniq - lists have dups
|
||||
w := 0
|
||||
for _, s := range all {
|
||||
if w == 0 || all[w-1] != s {
|
||||
all[w] = s
|
||||
w++
|
||||
}
|
||||
}
|
||||
all = all[:w]
|
||||
|
||||
if *test {
|
||||
var buf bytes.Buffer
|
||||
fmt.Fprintln(&buf, "// Code generated by go generate gen.go; DO NOT EDIT.\n")
|
||||
fmt.Fprintln(&buf, "//go:generate go run gen.go -test\n")
|
||||
fmt.Fprintln(&buf, "package atom\n")
|
||||
fmt.Fprintln(&buf, "var testAtomList = []string{")
|
||||
for _, s := range all {
|
||||
fmt.Fprintf(&buf, "\t%q,\n", s)
|
||||
}
|
||||
fmt.Fprintln(&buf, "}")
|
||||
|
||||
genFile("table_test.go", &buf)
|
||||
return
|
||||
}
|
||||
|
||||
// Find hash that minimizes table size.
|
||||
var best *table
|
||||
for i := 0; i < 1000000; i++ {
|
||||
if best != nil && 1<<(best.k-1) < len(all) {
|
||||
break
|
||||
}
|
||||
h := rand.Uint32()
|
||||
for k := uint(0); k <= 16; k++ {
|
||||
if best != nil && k >= best.k {
|
||||
break
|
||||
}
|
||||
var t table
|
||||
if t.init(h, k, all) {
|
||||
best = &t
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
if best == nil {
|
||||
fmt.Fprintf(os.Stderr, "failed to construct string table\n")
|
||||
os.Exit(1)
|
||||
}
|
||||
|
||||
// Lay out strings, using overlaps when possible.
|
||||
layout := append([]string{}, all...)
|
||||
|
||||
// Remove strings that are substrings of other strings
|
||||
for changed := true; changed; {
|
||||
changed = false
|
||||
for i, s := range layout {
|
||||
if s == "" {
|
||||
continue
|
||||
}
|
||||
for j, t := range layout {
|
||||
if i != j && t != "" && strings.Contains(s, t) {
|
||||
changed = true
|
||||
layout[j] = ""
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Join strings where one suffix matches another prefix.
|
||||
for {
|
||||
// Find best i, j, k such that layout[i][len-k:] == layout[j][:k],
|
||||
// maximizing overlap length k.
|
||||
besti := -1
|
||||
bestj := -1
|
||||
bestk := 0
|
||||
for i, s := range layout {
|
||||
if s == "" {
|
||||
continue
|
||||
}
|
||||
for j, t := range layout {
|
||||
if i == j {
|
||||
continue
|
||||
}
|
||||
for k := bestk + 1; k <= len(s) && k <= len(t); k++ {
|
||||
if s[len(s)-k:] == t[:k] {
|
||||
besti = i
|
||||
bestj = j
|
||||
bestk = k
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if bestk > 0 {
|
||||
layout[besti] += layout[bestj][bestk:]
|
||||
layout[bestj] = ""
|
||||
continue
|
||||
}
|
||||
break
|
||||
}
|
||||
|
||||
text := strings.Join(layout, "")
|
||||
|
||||
atom := map[string]uint32{}
|
||||
for _, s := range all {
|
||||
off := strings.Index(text, s)
|
||||
if off < 0 {
|
||||
panic("lost string " + s)
|
||||
}
|
||||
atom[s] = uint32(off<<8 | len(s))
|
||||
}
|
||||
|
||||
var buf bytes.Buffer
|
||||
// Generate the Go code.
|
||||
fmt.Fprintln(&buf, "// Code generated by go generate gen.go; DO NOT EDIT.\n")
|
||||
fmt.Fprintln(&buf, "//go:generate go run gen.go\n")
|
||||
fmt.Fprintln(&buf, "package atom\n\nconst (")
|
||||
|
||||
// compute max len
|
||||
maxLen := 0
|
||||
for _, s := range all {
|
||||
if maxLen < len(s) {
|
||||
maxLen = len(s)
|
||||
}
|
||||
fmt.Fprintf(&buf, "\t%s Atom = %#x\n", identifier(s), atom[s])
|
||||
}
|
||||
fmt.Fprintln(&buf, ")\n")
|
||||
|
||||
fmt.Fprintf(&buf, "const hash0 = %#x\n\n", best.h0)
|
||||
fmt.Fprintf(&buf, "const maxAtomLen = %d\n\n", maxLen)
|
||||
|
||||
fmt.Fprintf(&buf, "var table = [1<<%d]Atom{\n", best.k)
|
||||
for i, s := range best.tab {
|
||||
if s == "" {
|
||||
continue
|
||||
}
|
||||
fmt.Fprintf(&buf, "\t%#x: %#x, // %s\n", i, atom[s], s)
|
||||
}
|
||||
fmt.Fprintf(&buf, "}\n")
|
||||
datasize := (1 << best.k) * 4
|
||||
|
||||
fmt.Fprintln(&buf, "const atomText =")
|
||||
textsize := len(text)
|
||||
for len(text) > 60 {
|
||||
fmt.Fprintf(&buf, "\t%q +\n", text[:60])
|
||||
text = text[60:]
|
||||
}
|
||||
fmt.Fprintf(&buf, "\t%q\n\n", text)
|
||||
|
||||
genFile("table.go", &buf)
|
||||
|
||||
fmt.Fprintf(os.Stdout, "%d atoms; %d string bytes + %d tables = %d total data\n", len(all), textsize, datasize, textsize+datasize)
|
||||
}
|
||||
|
||||
type byLen []string
|
||||
|
||||
func (x byLen) Less(i, j int) bool { return len(x[i]) > len(x[j]) }
|
||||
func (x byLen) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
|
||||
func (x byLen) Len() int { return len(x) }
|
||||
|
||||
// fnv computes the FNV hash with an arbitrary starting value h.
|
||||
func fnv(h uint32, s string) uint32 {
|
||||
for i := 0; i < len(s); i++ {
|
||||
h ^= uint32(s[i])
|
||||
h *= 16777619
|
||||
}
|
||||
return h
|
||||
}
|
||||
|
||||
// A table represents an attempt at constructing the lookup table.
|
||||
// The lookup table uses cuckoo hashing, meaning that each string
|
||||
// can be found in one of two positions.
|
||||
type table struct {
|
||||
h0 uint32
|
||||
k uint
|
||||
mask uint32
|
||||
tab []string
|
||||
}
|
||||
|
||||
// hash returns the two hashes for s.
|
||||
func (t *table) hash(s string) (h1, h2 uint32) {
|
||||
h := fnv(t.h0, s)
|
||||
h1 = h & t.mask
|
||||
h2 = (h >> 16) & t.mask
|
||||
return
|
||||
}
|
||||
|
||||
// init initializes the table with the given parameters.
|
||||
// h0 is the initial hash value,
|
||||
// k is the number of bits of hash value to use, and
|
||||
// x is the list of strings to store in the table.
|
||||
// init returns false if the table cannot be constructed.
|
||||
func (t *table) init(h0 uint32, k uint, x []string) bool {
|
||||
t.h0 = h0
|
||||
t.k = k
|
||||
t.tab = make([]string, 1<<k)
|
||||
t.mask = 1<<k - 1
|
||||
for _, s := range x {
|
||||
if !t.insert(s) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// insert inserts s in the table.
|
||||
func (t *table) insert(s string) bool {
|
||||
h1, h2 := t.hash(s)
|
||||
if t.tab[h1] == "" {
|
||||
t.tab[h1] = s
|
||||
return true
|
||||
}
|
||||
if t.tab[h2] == "" {
|
||||
t.tab[h2] = s
|
||||
return true
|
||||
}
|
||||
if t.push(h1, 0) {
|
||||
t.tab[h1] = s
|
||||
return true
|
||||
}
|
||||
if t.push(h2, 0) {
|
||||
t.tab[h2] = s
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// push attempts to push aside the entry in slot i.
|
||||
func (t *table) push(i uint32, depth int) bool {
|
||||
if depth > len(t.tab) {
|
||||
return false
|
||||
}
|
||||
s := t.tab[i]
|
||||
h1, h2 := t.hash(s)
|
||||
j := h1 + h2 - i
|
||||
if t.tab[j] != "" && !t.push(j, depth+1) {
|
||||
return false
|
||||
}
|
||||
t.tab[j] = s
|
||||
return true
|
||||
}
|
||||
|
||||
// The lists of element names and attribute keys were taken from
|
||||
// https://html.spec.whatwg.org/multipage/indices.html#index
|
||||
// as of the "HTML Living Standard - Last Updated 18 September 2017" version.
|
||||
|
||||
// "command", "keygen" and "menuitem" have been removed from the spec,
|
||||
// but are kept here for backwards compatibility.
|
||||
var elements = []string{
|
||||
"a",
|
||||
"abbr",
|
||||
"address",
|
||||
"area",
|
||||
"article",
|
||||
"aside",
|
||||
"audio",
|
||||
"b",
|
||||
"base",
|
||||
"bdi",
|
||||
"bdo",
|
||||
"blockquote",
|
||||
"body",
|
||||
"br",
|
||||
"button",
|
||||
"canvas",
|
||||
"caption",
|
||||
"cite",
|
||||
"code",
|
||||
"col",
|
||||
"colgroup",
|
||||
"command",
|
||||
"data",
|
||||
"datalist",
|
||||
"dd",
|
||||
"del",
|
||||
"details",
|
||||
"dfn",
|
||||
"dialog",
|
||||
"div",
|
||||
"dl",
|
||||
"dt",
|
||||
"em",
|
||||
"embed",
|
||||
"fieldset",
|
||||
"figcaption",
|
||||
"figure",
|
||||
"footer",
|
||||
"form",
|
||||
"h1",
|
||||
"h2",
|
||||
"h3",
|
||||
"h4",
|
||||
"h5",
|
||||
"h6",
|
||||
"head",
|
||||
"header",
|
||||
"hgroup",
|
||||
"hr",
|
||||
"html",
|
||||
"i",
|
||||
"iframe",
|
||||
"img",
|
||||
"input",
|
||||
"ins",
|
||||
"kbd",
|
||||
"keygen",
|
||||
"label",
|
||||
"legend",
|
||||
"li",
|
||||
"link",
|
||||
"main",
|
||||
"map",
|
||||
"mark",
|
||||
"menu",
|
||||
"menuitem",
|
||||
"meta",
|
||||
"meter",
|
||||
"nav",
|
||||
"noscript",
|
||||
"object",
|
||||
"ol",
|
||||
"optgroup",
|
||||
"option",
|
||||
"output",
|
||||
"p",
|
||||
"param",
|
||||
"picture",
|
||||
"pre",
|
||||
"progress",
|
||||
"q",
|
||||
"rp",
|
||||
"rt",
|
||||
"ruby",
|
||||
"s",
|
||||
"samp",
|
||||
"script",
|
||||
"section",
|
||||
"select",
|
||||
"slot",
|
||||
"small",
|
||||
"source",
|
||||
"span",
|
||||
"strong",
|
||||
"style",
|
||||
"sub",
|
||||
"summary",
|
||||
"sup",
|
||||
"table",
|
||||
"tbody",
|
||||
"td",
|
||||
"template",
|
||||
"textarea",
|
||||
"tfoot",
|
||||
"th",
|
||||
"thead",
|
||||
"time",
|
||||
"title",
|
||||
"tr",
|
||||
"track",
|
||||
"u",
|
||||
"ul",
|
||||
"var",
|
||||
"video",
|
||||
"wbr",
|
||||
}
|
||||
|
||||
// https://html.spec.whatwg.org/multipage/indices.html#attributes-3
|
||||
//
|
||||
// "challenge", "command", "contextmenu", "dropzone", "icon", "keytype", "mediagroup",
|
||||
// "radiogroup", "spellcheck", "scoped", "seamless", "sortable" and "sorted" have been removed from the spec,
|
||||
// but are kept here for backwards compatibility.
|
||||
var attributes = []string{
|
||||
"abbr",
|
||||
"accept",
|
||||
"accept-charset",
|
||||
"accesskey",
|
||||
"action",
|
||||
"allowfullscreen",
|
||||
"allowpaymentrequest",
|
||||
"allowusermedia",
|
||||
"alt",
|
||||
"as",
|
||||
"async",
|
||||
"autocomplete",
|
||||
"autofocus",
|
||||
"autoplay",
|
||||
"challenge",
|
||||
"charset",
|
||||
"checked",
|
||||
"cite",
|
||||
"class",
|
||||
"color",
|
||||
"cols",
|
||||
"colspan",
|
||||
"command",
|
||||
"content",
|
||||
"contenteditable",
|
||||
"contextmenu",
|
||||
"controls",
|
||||
"coords",
|
||||
"crossorigin",
|
||||
"data",
|
||||
"datetime",
|
||||
"default",
|
||||
"defer",
|
||||
"dir",
|
||||
"dirname",
|
||||
"disabled",
|
||||
"download",
|
||||
"draggable",
|
||||
"dropzone",
|
||||
"enctype",
|
||||
"for",
|
||||
"form",
|
||||
"formaction",
|
||||
"formenctype",
|
||||
"formmethod",
|
||||
"formnovalidate",
|
||||
"formtarget",
|
||||
"headers",
|
||||
"height",
|
||||
"hidden",
|
||||
"high",
|
||||
"href",
|
||||
"hreflang",
|
||||
"http-equiv",
|
||||
"icon",
|
||||
"id",
|
||||
"inputmode",
|
||||
"integrity",
|
||||
"is",
|
||||
"ismap",
|
||||
"itemid",
|
||||
"itemprop",
|
||||
"itemref",
|
||||
"itemscope",
|
||||
"itemtype",
|
||||
"keytype",
|
||||
"kind",
|
||||
"label",
|
||||
"lang",
|
||||
"list",
|
||||
"loop",
|
||||
"low",
|
||||
"manifest",
|
||||
"max",
|
||||
"maxlength",
|
||||
"media",
|
||||
"mediagroup",
|
||||
"method",
|
||||
"min",
|
||||
"minlength",
|
||||
"multiple",
|
||||
"muted",
|
||||
"name",
|
||||
"nomodule",
|
||||
"nonce",
|
||||
"novalidate",
|
||||
"open",
|
||||
"optimum",
|
||||
"pattern",
|
||||
"ping",
|
||||
"placeholder",
|
||||
"playsinline",
|
||||
"poster",
|
||||
"preload",
|
||||
"radiogroup",
|
||||
"readonly",
|
||||
"referrerpolicy",
|
||||
"rel",
|
||||
"required",
|
||||
"reversed",
|
||||
"rows",
|
||||
"rowspan",
|
||||
"sandbox",
|
||||
"spellcheck",
|
||||
"scope",
|
||||
"scoped",
|
||||
"seamless",
|
||||
"selected",
|
||||
"shape",
|
||||
"size",
|
||||
"sizes",
|
||||
"sortable",
|
||||
"sorted",
|
||||
"slot",
|
||||
"span",
|
||||
"spellcheck",
|
||||
"src",
|
||||
"srcdoc",
|
||||
"srclang",
|
||||
"srcset",
|
||||
"start",
|
||||
"step",
|
||||
"style",
|
||||
"tabindex",
|
||||
"target",
|
||||
"title",
|
||||
"translate",
|
||||
"type",
|
||||
"typemustmatch",
|
||||
"updateviacache",
|
||||
"usemap",
|
||||
"value",
|
||||
"width",
|
||||
"workertype",
|
||||
"wrap",
|
||||
}
|
||||
|
||||
// "onautocomplete", "onautocompleteerror", "onmousewheel",
|
||||
// "onshow" and "onsort" have been removed from the spec,
|
||||
// but are kept here for backwards compatibility.
|
||||
var eventHandlers = []string{
|
||||
"onabort",
|
||||
"onautocomplete",
|
||||
"onautocompleteerror",
|
||||
"onauxclick",
|
||||
"onafterprint",
|
||||
"onbeforeprint",
|
||||
"onbeforeunload",
|
||||
"onblur",
|
||||
"oncancel",
|
||||
"oncanplay",
|
||||
"oncanplaythrough",
|
||||
"onchange",
|
||||
"onclick",
|
||||
"onclose",
|
||||
"oncontextmenu",
|
||||
"oncopy",
|
||||
"oncuechange",
|
||||
"oncut",
|
||||
"ondblclick",
|
||||
"ondrag",
|
||||
"ondragend",
|
||||
"ondragenter",
|
||||
"ondragexit",
|
||||
"ondragleave",
|
||||
"ondragover",
|
||||
"ondragstart",
|
||||
"ondrop",
|
||||
"ondurationchange",
|
||||
"onemptied",
|
||||
"onended",
|
||||
"onerror",
|
||||
"onfocus",
|
||||
"onhashchange",
|
||||
"oninput",
|
||||
"oninvalid",
|
||||
"onkeydown",
|
||||
"onkeypress",
|
||||
"onkeyup",
|
||||
"onlanguagechange",
|
||||
"onload",
|
||||
"onloadeddata",
|
||||
"onloadedmetadata",
|
||||
"onloadend",
|
||||
"onloadstart",
|
||||
"onmessage",
|
||||
"onmessageerror",
|
||||
"onmousedown",
|
||||
"onmouseenter",
|
||||
"onmouseleave",
|
||||
"onmousemove",
|
||||
"onmouseout",
|
||||
"onmouseover",
|
||||
"onmouseup",
|
||||
"onmousewheel",
|
||||
"onwheel",
|
||||
"onoffline",
|
||||
"ononline",
|
||||
"onpagehide",
|
||||
"onpageshow",
|
||||
"onpaste",
|
||||
"onpause",
|
||||
"onplay",
|
||||
"onplaying",
|
||||
"onpopstate",
|
||||
"onprogress",
|
||||
"onratechange",
|
||||
"onreset",
|
||||
"onresize",
|
||||
"onrejectionhandled",
|
||||
"onscroll",
|
||||
"onsecuritypolicyviolation",
|
||||
"onseeked",
|
||||
"onseeking",
|
||||
"onselect",
|
||||
"onshow",
|
||||
"onsort",
|
||||
"onstalled",
|
||||
"onstorage",
|
||||
"onsubmit",
|
||||
"onsuspend",
|
||||
"ontimeupdate",
|
||||
"ontoggle",
|
||||
"onunhandledrejection",
|
||||
"onunload",
|
||||
"onvolumechange",
|
||||
"onwaiting",
|
||||
}
|
||||
|
||||
// extra are ad-hoc values not covered by any of the lists above.
|
||||
var extra = []string{
|
||||
"align",
|
||||
"annotation",
|
||||
"annotation-xml",
|
||||
"applet",
|
||||
"basefont",
|
||||
"bgsound",
|
||||
"big",
|
||||
"blink",
|
||||
"center",
|
||||
"color",
|
||||
"desc",
|
||||
"face",
|
||||
"font",
|
||||
"foreignObject", // HTML is case-insensitive, but SVG-embedded-in-HTML is case-sensitive.
|
||||
"foreignobject",
|
||||
"frame",
|
||||
"frameset",
|
||||
"image",
|
||||
"isindex",
|
||||
"listing",
|
||||
"malignmark",
|
||||
"marquee",
|
||||
"math",
|
||||
"mglyph",
|
||||
"mi",
|
||||
"mn",
|
||||
"mo",
|
||||
"ms",
|
||||
"mtext",
|
||||
"nobr",
|
||||
"noembed",
|
||||
"noframes",
|
||||
"plaintext",
|
||||
"prompt",
|
||||
"public",
|
||||
"spacer",
|
||||
"strike",
|
||||
"svg",
|
||||
"system",
|
||||
"tt",
|
||||
"xmp",
|
||||
}
|
||||
+777
@@ -0,0 +1,777 @@
|
||||
// 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
|
||||
Action Atom = 0x25a06
|
||||
Address Atom = 0x6ed07
|
||||
Align Atom = 0x6d405
|
||||
Allowfullscreen Atom = 0x1f00f
|
||||
Allowpaymentrequest Atom = 0x6913
|
||||
Allowusermedia Atom = 0x850e
|
||||
Alt Atom = 0xb003
|
||||
Annotation Atom = 0x1b90a
|
||||
AnnotationXml Atom = 0x1b90e
|
||||
Applet Atom = 0x30106
|
||||
Area Atom = 0x34a04
|
||||
Article Atom = 0x3f007
|
||||
As Atom = 0xb902
|
||||
Aside Atom = 0xc105
|
||||
Async Atom = 0xb905
|
||||
Audio Atom = 0xcf05
|
||||
Autocomplete Atom = 0x2600c
|
||||
Autofocus Atom = 0xeb09
|
||||
Autoplay Atom = 0x10608
|
||||
B Atom = 0x101
|
||||
Base Atom = 0x11504
|
||||
Basefont Atom = 0x11508
|
||||
Bdi Atom = 0x16103
|
||||
Bdo Atom = 0x13403
|
||||
Bgsound Atom = 0x14707
|
||||
Big Atom = 0x15903
|
||||
Blink Atom = 0x15c05
|
||||
Blockquote Atom = 0x1680a
|
||||
Body Atom = 0x2804
|
||||
Br Atom = 0x202
|
||||
Button Atom = 0x17206
|
||||
Canvas Atom = 0xbd06
|
||||
Caption Atom = 0x21907
|
||||
Center Atom = 0x20806
|
||||
Challenge Atom = 0x28309
|
||||
Charset Atom = 0x2107
|
||||
Checked Atom = 0x46d07
|
||||
Cite Atom = 0x55804
|
||||
Class Atom = 0x5b905
|
||||
Code Atom = 0x19004
|
||||
Col Atom = 0x19703
|
||||
Colgroup Atom = 0x19708
|
||||
Color Atom = 0x1af05
|
||||
Cols Atom = 0x1b404
|
||||
Colspan Atom = 0x1b407
|
||||
Command Atom = 0x1c707
|
||||
Content Atom = 0x57f07
|
||||
Contenteditable Atom = 0x57f0f
|
||||
Contextmenu Atom = 0x3740b
|
||||
Controls Atom = 0x1ce08
|
||||
Coords Atom = 0x1da06
|
||||
Crossorigin Atom = 0x1e30b
|
||||
Data Atom = 0x49904
|
||||
Datalist Atom = 0x49908
|
||||
Datetime Atom = 0x2a008
|
||||
Dd Atom = 0x2bf02
|
||||
Default Atom = 0xc407
|
||||
Defer Atom = 0x19205
|
||||
Del Atom = 0x44603
|
||||
Desc Atom = 0x55504
|
||||
Details Atom = 0x4607
|
||||
Dfn Atom = 0x5f03
|
||||
Dialog Atom = 0x16206
|
||||
Dir Atom = 0xa303
|
||||
Dirname Atom = 0xa307
|
||||
Disabled Atom = 0x14d08
|
||||
Div Atom = 0x15403
|
||||
Dl Atom = 0x5e202
|
||||
Download Atom = 0x45708
|
||||
Draggable Atom = 0x18309
|
||||
Dropzone Atom = 0x3f908
|
||||
Dt Atom = 0x64702
|
||||
Em Atom = 0x4202
|
||||
Embed Atom = 0x4205
|
||||
Enctype Atom = 0x27507
|
||||
Face Atom = 0x20604
|
||||
Fieldset Atom = 0x20e08
|
||||
Figcaption Atom = 0x2160a
|
||||
Figure Atom = 0x23006
|
||||
Font Atom = 0x11904
|
||||
Footer Atom = 0xb306
|
||||
For Atom = 0x23c03
|
||||
ForeignObject Atom = 0x23c0d
|
||||
Foreignobject Atom = 0x2490d
|
||||
Form Atom = 0x25604
|
||||
Formaction Atom = 0x2560a
|
||||
Formenctype Atom = 0x2710b
|
||||
Formmethod Atom = 0x28c0a
|
||||
Formnovalidate Atom = 0x2960e
|
||||
Formtarget Atom = 0x2a80a
|
||||
Frame Atom = 0x5705
|
||||
Frameset Atom = 0x5708
|
||||
H1 Atom = 0x14502
|
||||
H2 Atom = 0x2c602
|
||||
H3 Atom = 0x2f502
|
||||
H4 Atom = 0x33902
|
||||
H5 Atom = 0x34302
|
||||
H6 Atom = 0x64902
|
||||
Head Atom = 0x32504
|
||||
Header Atom = 0x32506
|
||||
Headers Atom = 0x32507
|
||||
Height Atom = 0x12c06
|
||||
Hgroup Atom = 0x2b206
|
||||
Hidden Atom = 0x2bd06
|
||||
High Atom = 0x2c304
|
||||
Hr Atom = 0x14002
|
||||
Href Atom = 0x2c804
|
||||
Hreflang Atom = 0x2c808
|
||||
Html Atom = 0x13004
|
||||
HttpEquiv Atom = 0x2d00a
|
||||
I Atom = 0x601
|
||||
Icon Atom = 0x57e04
|
||||
Id Atom = 0xc302
|
||||
Iframe Atom = 0x2e406
|
||||
Image Atom = 0x2ea05
|
||||
Img Atom = 0x2ef03
|
||||
Input Atom = 0x43f05
|
||||
Inputmode Atom = 0x43f09
|
||||
Ins Atom = 0x1ec03
|
||||
Integrity Atom = 0x22709
|
||||
Is Atom = 0x14e02
|
||||
Isindex Atom = 0x2f707
|
||||
Ismap Atom = 0x2fe05
|
||||
Itemid Atom = 0x37f06
|
||||
Itemprop Atom = 0x55908
|
||||
Itemref Atom = 0x3c107
|
||||
Itemscope Atom = 0x66d09
|
||||
Itemtype Atom = 0x30708
|
||||
Kbd Atom = 0x16003
|
||||
Keygen Atom = 0x3206
|
||||
Keytype Atom = 0x7e07
|
||||
Kind Atom = 0x18004
|
||||
Label Atom = 0xda05
|
||||
Lang Atom = 0x2cc04
|
||||
Legend Atom = 0x18a06
|
||||
Li Atom = 0x11102
|
||||
Link Atom = 0x15d04
|
||||
List Atom = 0x49d04
|
||||
Listing Atom = 0x49d07
|
||||
Loop Atom = 0xde04
|
||||
Low Atom = 0x6b03
|
||||
Main Atom = 0x1004
|
||||
Malignmark Atom = 0x6d30a
|
||||
Manifest Atom = 0x30f08
|
||||
Map Atom = 0x30003
|
||||
Mark Atom = 0x6d904
|
||||
Marquee Atom = 0x31b07
|
||||
Math Atom = 0x32204
|
||||
Max Atom = 0x33103
|
||||
Maxlength Atom = 0x33109
|
||||
Media Atom = 0x8e05
|
||||
Mediagroup Atom = 0x8e0a
|
||||
Menu Atom = 0x37b04
|
||||
Menuitem Atom = 0x37b08
|
||||
Meta Atom = 0x4ac04
|
||||
Meter Atom = 0xa805
|
||||
Method Atom = 0x29006
|
||||
Mglyph Atom = 0x2f006
|
||||
Mi Atom = 0x33b02
|
||||
Min Atom = 0x33b03
|
||||
Minlength Atom = 0x33b09
|
||||
Mn Atom = 0x29902
|
||||
Mo Atom = 0x6302
|
||||
Ms Atom = 0x67002
|
||||
Mtext Atom = 0x34505
|
||||
Multiple Atom = 0x35308
|
||||
Muted Atom = 0x35b05
|
||||
Name Atom = 0xa604
|
||||
Nav Atom = 0x1303
|
||||
Nobr Atom = 0x3704
|
||||
Noembed Atom = 0x4007
|
||||
Noframes Atom = 0x5508
|
||||
Nomodule Atom = 0x6108
|
||||
Nonce Atom = 0x56205
|
||||
Noscript Atom = 0x1fe08
|
||||
Novalidate Atom = 0x29a0a
|
||||
Object Atom = 0x25006
|
||||
Ol Atom = 0x10102
|
||||
Onabort Atom = 0x17607
|
||||
Onafterprint Atom = 0x21e0c
|
||||
Onautocomplete Atom = 0x25e0e
|
||||
Onautocompleteerror Atom = 0x25e13
|
||||
Onauxclick Atom = 0x61b0a
|
||||
Onbeforeprint Atom = 0x69a0d
|
||||
Onbeforeunload Atom = 0x6e10e
|
||||
Onblur Atom = 0x5c206
|
||||
Oncancel Atom = 0xd308
|
||||
Oncanplay Atom = 0x13609
|
||||
Oncanplaythrough Atom = 0x13610
|
||||
Onchange Atom = 0x40f08
|
||||
Onclick Atom = 0x2dd07
|
||||
Onclose Atom = 0x36007
|
||||
Oncontextmenu Atom = 0x3720d
|
||||
Oncopy Atom = 0x38506
|
||||
Oncuechange Atom = 0x38b0b
|
||||
Oncut Atom = 0x39605
|
||||
Ondblclick Atom = 0x39b0a
|
||||
Ondrag Atom = 0x3a506
|
||||
Ondragend Atom = 0x3a509
|
||||
Ondragenter Atom = 0x3ae0b
|
||||
Ondragexit Atom = 0x3b90a
|
||||
Ondragleave Atom = 0x3d30b
|
||||
Ondragover Atom = 0x3de0a
|
||||
Ondragstart Atom = 0x3e80b
|
||||
Ondrop Atom = 0x3f706
|
||||
Ondurationchange Atom = 0x40710
|
||||
Onemptied Atom = 0x3fe09
|
||||
Onended Atom = 0x41707
|
||||
Onerror Atom = 0x41e07
|
||||
Onfocus Atom = 0x42507
|
||||
Onhashchange Atom = 0x4310c
|
||||
Oninput Atom = 0x43d07
|
||||
Oninvalid Atom = 0x44909
|
||||
Onkeydown Atom = 0x45209
|
||||
Onkeypress Atom = 0x45f0a
|
||||
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 = 0x5670a
|
||||
Onpaste Atom = 0x57307
|
||||
Onpause Atom = 0x58e07
|
||||
Onplay Atom = 0x59806
|
||||
Onplaying Atom = 0x59809
|
||||
Onpopstate Atom = 0x5a10a
|
||||
Onprogress Atom = 0x5ab0a
|
||||
Onratechange Atom = 0x5c80c
|
||||
Onrejectionhandled Atom = 0x5d412
|
||||
Onreset Atom = 0x5e607
|
||||
Onresize Atom = 0x5ed08
|
||||
Onscroll Atom = 0x5fc08
|
||||
Onsecuritypolicyviolation Atom = 0x60419
|
||||
Onseeked Atom = 0x62508
|
||||
Onseeking Atom = 0x62d09
|
||||
Onselect Atom = 0x63608
|
||||
Onshow Atom = 0x64006
|
||||
Onsort Atom = 0x64b06
|
||||
Onstalled Atom = 0x65509
|
||||
Onstorage Atom = 0x65e09
|
||||
Onsubmit Atom = 0x66708
|
||||
Onsuspend Atom = 0x67709
|
||||
Ontimeupdate Atom = 0x11a0c
|
||||
Ontoggle Atom = 0x68008
|
||||
Onunhandledrejection Atom = 0x68814
|
||||
Onunload Atom = 0x6a708
|
||||
Onvolumechange Atom = 0x6af0e
|
||||
Onwaiting Atom = 0x6bd09
|
||||
Onwheel Atom = 0x6c607
|
||||
Open Atom = 0x55f04
|
||||
Optgroup Atom = 0xe008
|
||||
Optimum Atom = 0x6cd07
|
||||
Option Atom = 0x6dd06
|
||||
Output Atom = 0x51106
|
||||
P Atom = 0xc01
|
||||
Param Atom = 0xc05
|
||||
Pattern Atom = 0x4f07
|
||||
Picture Atom = 0x9707
|
||||
Ping Atom = 0xe704
|
||||
Placeholder Atom = 0xfb0b
|
||||
Plaintext Atom = 0x19e09
|
||||
Playsinline Atom = 0x10a0b
|
||||
Poster Atom = 0x2b706
|
||||
Pre Atom = 0x46403
|
||||
Preload Atom = 0x47a07
|
||||
Progress Atom = 0x5ad08
|
||||
Prompt Atom = 0x52a06
|
||||
Public Atom = 0x57a06
|
||||
Q Atom = 0x7701
|
||||
Radiogroup Atom = 0x30a
|
||||
Readonly Atom = 0x34b08
|
||||
Referrerpolicy Atom = 0x3c50e
|
||||
Rel Atom = 0x47b03
|
||||
Required Atom = 0x23408
|
||||
Reversed Atom = 0x9c08
|
||||
Rows Atom = 0x3a04
|
||||
Rowspan Atom = 0x3a07
|
||||
Rp Atom = 0x22402
|
||||
Rt Atom = 0x17b02
|
||||
Ruby Atom = 0xac04
|
||||
S Atom = 0x2501
|
||||
Samp Atom = 0x4c04
|
||||
Sandbox Atom = 0xf307
|
||||
Scope Atom = 0x67105
|
||||
Scoped Atom = 0x67106
|
||||
Script Atom = 0x20006
|
||||
Seamless Atom = 0x36508
|
||||
Section Atom = 0x5bd07
|
||||
Select Atom = 0x63806
|
||||
Selected Atom = 0x63808
|
||||
Shape Atom = 0x1d505
|
||||
Size Atom = 0x5f104
|
||||
Sizes Atom = 0x5f105
|
||||
Slot Atom = 0x1df04
|
||||
Small Atom = 0x1ee05
|
||||
Sortable Atom = 0x64d08
|
||||
Sorted Atom = 0x32b06
|
||||
Source Atom = 0x36c06
|
||||
Spacer Atom = 0x42b06
|
||||
Span Atom = 0x3d04
|
||||
Spellcheck Atom = 0x4680a
|
||||
Src Atom = 0x5b403
|
||||
Srcdoc Atom = 0x5b406
|
||||
Srclang Atom = 0x5f507
|
||||
Srcset Atom = 0x6f306
|
||||
Start Atom = 0x3ee05
|
||||
Step Atom = 0x57704
|
||||
Strike Atom = 0x7a06
|
||||
Strong Atom = 0x31506
|
||||
Style Atom = 0x6f905
|
||||
Sub Atom = 0x66903
|
||||
Summary Atom = 0x6fe07
|
||||
Sup Atom = 0x70503
|
||||
Svg Atom = 0x70803
|
||||
System Atom = 0x70b06
|
||||
Tabindex Atom = 0x4b208
|
||||
Table Atom = 0x58905
|
||||
Target Atom = 0x2ac06
|
||||
Tbody Atom = 0x2705
|
||||
Td Atom = 0x5e02
|
||||
Template Atom = 0x70e08
|
||||
Textarea Atom = 0x34608
|
||||
Tfoot Atom = 0xb205
|
||||
Th Atom = 0x13f02
|
||||
Thead Atom = 0x32405
|
||||
Time Atom = 0x11c04
|
||||
Title Atom = 0xca05
|
||||
Tr Atom = 0x7402
|
||||
Track Atom = 0x17c05
|
||||
Translate Atom = 0x1a609
|
||||
Tt Atom = 0x5102
|
||||
Type Atom = 0x8104
|
||||
Typemustmatch Atom = 0x2780d
|
||||
U Atom = 0xb01
|
||||
Ul Atom = 0x6602
|
||||
Updateviacache Atom = 0x1200e
|
||||
Usemap Atom = 0x59206
|
||||
Value Atom = 0x1505
|
||||
Var Atom = 0x15603
|
||||
Video Atom = 0x2d905
|
||||
Wbr Atom = 0x57003
|
||||
Width Atom = 0x64505
|
||||
Workertype Atom = 0x7160a
|
||||
Wrap Atom = 0x72004
|
||||
Xmp Atom = 0xf903
|
||||
)
|
||||
|
||||
const hash0 = 0x81cdf10e
|
||||
|
||||
const maxAtomLen = 25
|
||||
|
||||
var table = [1 << 9]Atom{
|
||||
0x1: 0x8e0a, // mediagroup
|
||||
0x2: 0x2cc04, // lang
|
||||
0x4: 0x2c09, // accesskey
|
||||
0x5: 0x5708, // frameset
|
||||
0x7: 0x63608, // onselect
|
||||
0x8: 0x70b06, // system
|
||||
0xa: 0x64505, // width
|
||||
0xc: 0x2710b, // formenctype
|
||||
0xd: 0x10102, // ol
|
||||
0xe: 0x38b0b, // oncuechange
|
||||
0x10: 0x13403, // bdo
|
||||
0x11: 0xcf05, // audio
|
||||
0x12: 0x18309, // draggable
|
||||
0x14: 0x2d905, // video
|
||||
0x15: 0x29902, // mn
|
||||
0x16: 0x37b04, // menu
|
||||
0x17: 0x2b706, // poster
|
||||
0x19: 0xb306, // footer
|
||||
0x1a: 0x29006, // method
|
||||
0x1b: 0x2a008, // datetime
|
||||
0x1c: 0x17607, // onabort
|
||||
0x1d: 0x1200e, // updateviacache
|
||||
0x1e: 0xb905, // async
|
||||
0x1f: 0x49106, // onload
|
||||
0x21: 0xd308, // oncancel
|
||||
0x22: 0x62508, // onseeked
|
||||
0x23: 0x2ea05, // image
|
||||
0x24: 0x5d412, // onrejectionhandled
|
||||
0x26: 0x15d04, // link
|
||||
0x27: 0x51106, // output
|
||||
0x28: 0x32504, // head
|
||||
0x29: 0x4f30c, // onmouseleave
|
||||
0x2a: 0x57307, // onpaste
|
||||
0x2b: 0x59809, // onplaying
|
||||
0x2c: 0x1b407, // colspan
|
||||
0x2f: 0x1af05, // color
|
||||
0x30: 0x5f104, // size
|
||||
0x31: 0x2d00a, // http-equiv
|
||||
0x33: 0x601, // i
|
||||
0x34: 0x54d0a, // onpagehide
|
||||
0x35: 0x68814, // onunhandledrejection
|
||||
0x37: 0x41e07, // onerror
|
||||
0x3a: 0x11508, // basefont
|
||||
0x3f: 0x1303, // nav
|
||||
0x40: 0x18004, // kind
|
||||
0x41: 0x34b08, // readonly
|
||||
0x42: 0x2f006, // mglyph
|
||||
0x44: 0x11102, // li
|
||||
0x46: 0x2bd06, // hidden
|
||||
0x47: 0x70803, // svg
|
||||
0x48: 0x57704, // step
|
||||
0x49: 0x22709, // integrity
|
||||
0x4a: 0x57a06, // public
|
||||
0x4c: 0x19703, // col
|
||||
0x4d: 0x1680a, // blockquote
|
||||
0x4e: 0x34302, // h5
|
||||
0x50: 0x5ad08, // progress
|
||||
0x51: 0x5f105, // sizes
|
||||
0x52: 0x33902, // h4
|
||||
0x56: 0x32405, // thead
|
||||
0x57: 0x7e07, // keytype
|
||||
0x58: 0x5ab0a, // onprogress
|
||||
0x59: 0x43f09, // inputmode
|
||||
0x5a: 0x3a509, // ondragend
|
||||
0x5d: 0x39605, // oncut
|
||||
0x5e: 0x42b06, // spacer
|
||||
0x5f: 0x19708, // colgroup
|
||||
0x62: 0x14e02, // is
|
||||
0x65: 0xb902, // as
|
||||
0x66: 0x53c09, // onoffline
|
||||
0x67: 0x32b06, // sorted
|
||||
0x69: 0x48110, // onlanguagechange
|
||||
0x6c: 0x4310c, // onhashchange
|
||||
0x6d: 0xa604, // name
|
||||
0x6e: 0xb205, // tfoot
|
||||
0x6f: 0x55504, // desc
|
||||
0x70: 0x33103, // max
|
||||
0x72: 0x1da06, // coords
|
||||
0x73: 0x2f502, // h3
|
||||
0x74: 0x6e10e, // onbeforeunload
|
||||
0x75: 0x3a04, // rows
|
||||
0x76: 0x63806, // select
|
||||
0x77: 0xa805, // meter
|
||||
0x78: 0x37f06, // itemid
|
||||
0x79: 0x5300c, // onmousewheel
|
||||
0x7a: 0x5b406, // srcdoc
|
||||
0x7d: 0x17c05, // track
|
||||
0x7f: 0x30708, // itemtype
|
||||
0x82: 0x6302, // mo
|
||||
0x83: 0x40f08, // onchange
|
||||
0x84: 0x32507, // headers
|
||||
0x85: 0x5c80c, // onratechange
|
||||
0x86: 0x60419, // onsecuritypolicyviolation
|
||||
0x88: 0x49908, // datalist
|
||||
0x89: 0x4dc0b, // onmousedown
|
||||
0x8a: 0x1df04, // slot
|
||||
0x8b: 0x4a410, // onloadedmetadata
|
||||
0x8c: 0x1a06, // accept
|
||||
0x8d: 0x25006, // object
|
||||
0x91: 0x6af0e, // onvolumechange
|
||||
0x92: 0x2107, // charset
|
||||
0x93: 0x25e13, // onautocompleteerror
|
||||
0x94: 0x6913, // allowpaymentrequest
|
||||
0x95: 0x2804, // body
|
||||
0x96: 0xc407, // default
|
||||
0x97: 0x63808, // selected
|
||||
0x98: 0x20604, // face
|
||||
0x99: 0x1d505, // shape
|
||||
0x9b: 0x68008, // ontoggle
|
||||
0x9e: 0x64702, // dt
|
||||
0x9f: 0x6d904, // mark
|
||||
0xa1: 0xb01, // u
|
||||
0xa4: 0x6a708, // onunload
|
||||
0xa5: 0xde04, // loop
|
||||
0xa6: 0x14d08, // disabled
|
||||
0xaa: 0x41707, // onended
|
||||
0xab: 0x6d30a, // malignmark
|
||||
0xad: 0x67709, // onsuspend
|
||||
0xae: 0x34505, // mtext
|
||||
0xaf: 0x64b06, // onsort
|
||||
0xb0: 0x55908, // itemprop
|
||||
0xb3: 0x66d09, // itemscope
|
||||
0xb4: 0x15c05, // blink
|
||||
0xb6: 0x3a506, // ondrag
|
||||
0xb7: 0x6602, // ul
|
||||
0xb8: 0x25604, // form
|
||||
0xb9: 0xf307, // sandbox
|
||||
0xba: 0x5705, // frame
|
||||
0xbb: 0x1505, // value
|
||||
0xbc: 0x65e09, // onstorage
|
||||
0xc0: 0x17b02, // rt
|
||||
0xc2: 0x202, // br
|
||||
0xc3: 0x20e08, // fieldset
|
||||
0xc4: 0x2780d, // typemustmatch
|
||||
0xc5: 0x6108, // nomodule
|
||||
0xc6: 0x4007, // noembed
|
||||
0xc7: 0x69a0d, // onbeforeprint
|
||||
0xc8: 0x17206, // button
|
||||
0xc9: 0x2dd07, // onclick
|
||||
0xca: 0x6fe07, // summary
|
||||
0xcd: 0xac04, // ruby
|
||||
0xce: 0x5b905, // class
|
||||
0xcf: 0x3e80b, // ondragstart
|
||||
0xd0: 0x21907, // caption
|
||||
0xd4: 0x850e, // allowusermedia
|
||||
0xd5: 0x4c30b, // onloadstart
|
||||
0xd9: 0x15403, // div
|
||||
0xda: 0x49d04, // list
|
||||
0xdb: 0x32204, // math
|
||||
0xdc: 0x43f05, // input
|
||||
0xdf: 0x3de0a, // ondragover
|
||||
0xe0: 0x2c602, // h2
|
||||
0xe2: 0x19e09, // plaintext
|
||||
0xe4: 0x4e70c, // onmouseenter
|
||||
0xe7: 0x46d07, // checked
|
||||
0xe8: 0x46403, // pre
|
||||
0xea: 0x35308, // multiple
|
||||
0xeb: 0x16103, // bdi
|
||||
0xec: 0x33109, // maxlength
|
||||
0xed: 0x7701, // q
|
||||
0xee: 0x61b0a, // onauxclick
|
||||
0xf0: 0x57003, // wbr
|
||||
0xf2: 0x11504, // base
|
||||
0xf3: 0x6dd06, // option
|
||||
0xf5: 0x40710, // ondurationchange
|
||||
0xf7: 0x5508, // noframes
|
||||
0xf9: 0x3f908, // dropzone
|
||||
0xfb: 0x67105, // scope
|
||||
0xfc: 0x9c08, // reversed
|
||||
0xfd: 0x3ae0b, // ondragenter
|
||||
0xfe: 0x3ee05, // start
|
||||
0xff: 0xf903, // xmp
|
||||
0x100: 0x5f507, // srclang
|
||||
0x101: 0x2ef03, // img
|
||||
0x104: 0x101, // b
|
||||
0x105: 0x23c03, // for
|
||||
0x106: 0xc105, // aside
|
||||
0x107: 0x43d07, // oninput
|
||||
0x108: 0x34a04, // area
|
||||
0x109: 0x28c0a, // formmethod
|
||||
0x10a: 0x72004, // wrap
|
||||
0x10c: 0x22402, // rp
|
||||
0x10d: 0x45f0a, // onkeypress
|
||||
0x10e: 0x5102, // tt
|
||||
0x110: 0x33b02, // mi
|
||||
0x111: 0x35b05, // muted
|
||||
0x112: 0xb003, // alt
|
||||
0x113: 0x19004, // code
|
||||
0x114: 0x4202, // em
|
||||
0x115: 0x3b90a, // ondragexit
|
||||
0x117: 0x3d04, // span
|
||||
0x119: 0x30f08, // manifest
|
||||
0x11a: 0x37b08, // menuitem
|
||||
0x11b: 0x57f07, // content
|
||||
0x11d: 0x6bd09, // onwaiting
|
||||
0x11f: 0x4ba09, // onloadend
|
||||
0x121: 0x3720d, // oncontextmenu
|
||||
0x123: 0x5c206, // onblur
|
||||
0x124: 0x3f007, // article
|
||||
0x125: 0xa303, // dir
|
||||
0x126: 0xe704, // ping
|
||||
0x127: 0x23408, // required
|
||||
0x128: 0x44909, // oninvalid
|
||||
0x129: 0x6d405, // align
|
||||
0x12b: 0x57e04, // icon
|
||||
0x12c: 0x64902, // h6
|
||||
0x12d: 0x1b404, // cols
|
||||
0x12e: 0x2160a, // figcaption
|
||||
0x12f: 0x45209, // onkeydown
|
||||
0x130: 0x66708, // onsubmit
|
||||
0x131: 0x13609, // oncanplay
|
||||
0x132: 0x70503, // sup
|
||||
0x133: 0xc01, // p
|
||||
0x135: 0x3fe09, // onemptied
|
||||
0x136: 0x38506, // oncopy
|
||||
0x137: 0x55804, // cite
|
||||
0x138: 0x39b0a, // ondblclick
|
||||
0x13a: 0x4ff0b, // onmousemove
|
||||
0x13c: 0x66903, // sub
|
||||
0x13d: 0x47b03, // rel
|
||||
0x13e: 0xe008, // optgroup
|
||||
0x142: 0x3a07, // rowspan
|
||||
0x143: 0x36c06, // source
|
||||
0x144: 0x1fe08, // noscript
|
||||
0x145: 0x55f04, // open
|
||||
0x146: 0x1ec03, // ins
|
||||
0x147: 0x23c0d, // foreignObject
|
||||
0x148: 0x5a10a, // onpopstate
|
||||
0x14a: 0x27507, // enctype
|
||||
0x14b: 0x25e0e, // onautocomplete
|
||||
0x14c: 0x34608, // textarea
|
||||
0x14e: 0x2600c, // autocomplete
|
||||
0x14f: 0x14002, // hr
|
||||
0x150: 0x1ce08, // controls
|
||||
0x151: 0xc302, // id
|
||||
0x153: 0x21e0c, // onafterprint
|
||||
0x155: 0x2490d, // foreignobject
|
||||
0x156: 0x31b07, // marquee
|
||||
0x157: 0x58e07, // onpause
|
||||
0x158: 0x5e202, // dl
|
||||
0x159: 0x12c06, // height
|
||||
0x15a: 0x33b03, // min
|
||||
0x15b: 0xa307, // dirname
|
||||
0x15c: 0x1a609, // translate
|
||||
0x15d: 0x13004, // html
|
||||
0x15e: 0x33b09, // minlength
|
||||
0x15f: 0x47a07, // preload
|
||||
0x160: 0x70e08, // template
|
||||
0x161: 0x3d30b, // ondragleave
|
||||
0x164: 0x5b403, // src
|
||||
0x165: 0x31506, // strong
|
||||
0x167: 0x4c04, // samp
|
||||
0x168: 0x6ed07, // address
|
||||
0x169: 0x54508, // ononline
|
||||
0x16b: 0xfb0b, // placeholder
|
||||
0x16c: 0x2ac06, // target
|
||||
0x16d: 0x1ee05, // small
|
||||
0x16e: 0x6c607, // onwheel
|
||||
0x16f: 0x1b90a, // annotation
|
||||
0x170: 0x4680a, // spellcheck
|
||||
0x171: 0x4607, // details
|
||||
0x172: 0xbd06, // canvas
|
||||
0x173: 0xeb09, // autofocus
|
||||
0x174: 0xc05, // param
|
||||
0x176: 0x45708, // download
|
||||
0x177: 0x44603, // del
|
||||
0x178: 0x36007, // onclose
|
||||
0x179: 0x16003, // kbd
|
||||
0x17a: 0x30106, // applet
|
||||
0x17b: 0x2c804, // href
|
||||
0x17c: 0x5ed08, // onresize
|
||||
0x17e: 0x4910c, // onloadeddata
|
||||
0x180: 0x7402, // tr
|
||||
0x181: 0x2a80a, // formtarget
|
||||
0x182: 0xca05, // title
|
||||
0x183: 0x6f905, // style
|
||||
0x184: 0x7a06, // strike
|
||||
0x185: 0x59206, // usemap
|
||||
0x186: 0x2e406, // iframe
|
||||
0x187: 0x1004, // main
|
||||
0x189: 0x9707, // picture
|
||||
0x18c: 0x2fe05, // ismap
|
||||
0x18e: 0x49904, // data
|
||||
0x18f: 0xda05, // label
|
||||
0x191: 0x3c50e, // referrerpolicy
|
||||
0x192: 0x13f02, // th
|
||||
0x194: 0x52a06, // prompt
|
||||
0x195: 0x5bd07, // section
|
||||
0x197: 0x6cd07, // optimum
|
||||
0x198: 0x2c304, // high
|
||||
0x199: 0x14502, // h1
|
||||
0x19a: 0x65509, // onstalled
|
||||
0x19b: 0x15603, // var
|
||||
0x19c: 0x11c04, // time
|
||||
0x19e: 0x67002, // ms
|
||||
0x19f: 0x32506, // header
|
||||
0x1a0: 0x4ce09, // onmessage
|
||||
0x1a1: 0x56205, // nonce
|
||||
0x1a2: 0x2560a, // formaction
|
||||
0x1a3: 0x20806, // center
|
||||
0x1a4: 0x3704, // nobr
|
||||
0x1a5: 0x58905, // table
|
||||
0x1a6: 0x49d07, // listing
|
||||
0x1a7: 0x18a06, // legend
|
||||
0x1a9: 0x28309, // challenge
|
||||
0x1aa: 0x23006, // figure
|
||||
0x1ab: 0x8e05, // media
|
||||
0x1ae: 0x8104, // type
|
||||
0x1af: 0x11904, // font
|
||||
0x1b0: 0x4ce0e, // onmessageerror
|
||||
0x1b1: 0x36508, // seamless
|
||||
0x1b2: 0x5f03, // dfn
|
||||
0x1b3: 0x19205, // defer
|
||||
0x1b4: 0x6b03, // low
|
||||
0x1b5: 0x62d09, // onseeking
|
||||
0x1b6: 0x5170b, // onmouseover
|
||||
0x1b7: 0x29a0a, // novalidate
|
||||
0x1b8: 0x7160a, // workertype
|
||||
0x1ba: 0x3c107, // itemref
|
||||
0x1bd: 0x1, // a
|
||||
0x1be: 0x30003, // map
|
||||
0x1bf: 0x11a0c, // ontimeupdate
|
||||
0x1c0: 0x14707, // bgsound
|
||||
0x1c1: 0x3206, // keygen
|
||||
0x1c2: 0x2705, // tbody
|
||||
0x1c5: 0x64006, // onshow
|
||||
0x1c7: 0x2501, // s
|
||||
0x1c8: 0x4f07, // pattern
|
||||
0x1cc: 0x13610, // oncanplaythrough
|
||||
0x1ce: 0x2bf02, // dd
|
||||
0x1cf: 0x6f306, // srcset
|
||||
0x1d0: 0x15903, // big
|
||||
0x1d2: 0x64d08, // sortable
|
||||
0x1d3: 0x47407, // onkeyup
|
||||
0x1d5: 0x59806, // onplay
|
||||
0x1d7: 0x4ac04, // meta
|
||||
0x1d8: 0x3f706, // ondrop
|
||||
0x1da: 0x5fc08, // onscroll
|
||||
0x1db: 0x1e30b, // crossorigin
|
||||
0x1dc: 0x5670a, // onpageshow
|
||||
0x1dd: 0x4, // abbr
|
||||
0x1de: 0x5e02, // td
|
||||
0x1df: 0x57f0f, // contenteditable
|
||||
0x1e0: 0x25a06, // action
|
||||
0x1e1: 0x10a0b, // playsinline
|
||||
0x1e2: 0x42507, // onfocus
|
||||
0x1e3: 0x2c808, // hreflang
|
||||
0x1e5: 0x50a0a, // onmouseout
|
||||
0x1e6: 0x5e607, // onreset
|
||||
0x1e7: 0x10608, // autoplay
|
||||
0x1ea: 0x67106, // scoped
|
||||
0x1ec: 0x30a, // radiogroup
|
||||
0x1ee: 0x3740b, // contextmenu
|
||||
0x1ef: 0x52209, // onmouseup
|
||||
0x1f1: 0x2b206, // hgroup
|
||||
0x1f2: 0x1f00f, // allowfullscreen
|
||||
0x1f3: 0x4b208, // tabindex
|
||||
0x1f6: 0x2f707, // isindex
|
||||
0x1f7: 0x1a0e, // accept-charset
|
||||
0x1f8: 0x2960e, // formnovalidate
|
||||
0x1fb: 0x1b90e, // annotation-xml
|
||||
0x1fc: 0x4205, // embed
|
||||
0x1fd: 0x20006, // script
|
||||
0x1fe: 0x16206, // dialog
|
||||
0x1ff: 0x1c707, // command
|
||||
}
|
||||
|
||||
const atomText = "abbradiogrouparamainavalueaccept-charsetbodyaccesskeygenobro" +
|
||||
"wspanoembedetailsampatternoframesetdfnomoduleallowpaymentreq" +
|
||||
"uestrikeytypeallowusermediagroupictureversedirnameterubyaltf" +
|
||||
"ooterasyncanvasidefaultitleaudioncancelabelooptgroupingautof" +
|
||||
"ocusandboxmplaceholderautoplaysinlinebasefontimeupdateviacac" +
|
||||
"heightmlbdoncanplaythrough1bgsoundisabledivarbigblinkbdialog" +
|
||||
"blockquotebuttonabortrackindraggablegendcodefercolgrouplaint" +
|
||||
"extranslatecolorcolspannotation-xmlcommandcontrolshapecoords" +
|
||||
"lotcrossoriginsmallowfullscreenoscriptfacenterfieldsetfigcap" +
|
||||
"tionafterprintegrityfigurequiredforeignObjectforeignobjectfo" +
|
||||
"rmactionautocompleteerrorformenctypemustmatchallengeformmeth" +
|
||||
"odformnovalidatetimeformtargethgrouposterhiddenhigh2hreflang" +
|
||||
"http-equivideonclickiframeimageimglyph3isindexismappletitemt" +
|
||||
"ypemanifestrongmarqueematheadersortedmaxlength4minlength5mte" +
|
||||
"xtareadonlymultiplemutedoncloseamlessourceoncontextmenuitemi" +
|
||||
"doncopyoncuechangeoncutondblclickondragendondragenterondrage" +
|
||||
"xitemreferrerpolicyondragleaveondragoverondragstarticleondro" +
|
||||
"pzonemptiedondurationchangeonendedonerroronfocuspaceronhashc" +
|
||||
"hangeoninputmodeloninvalidonkeydownloadonkeypresspellchecked" +
|
||||
"onkeyupreloadonlanguagechangeonloadeddatalistingonloadedmeta" +
|
||||
"databindexonloadendonloadstartonmessageerroronmousedownonmou" +
|
||||
"seenteronmouseleaveonmousemoveonmouseoutputonmouseoveronmous" +
|
||||
"eupromptonmousewheelonofflineononlineonpagehidescitempropeno" +
|
||||
"nceonpageshowbronpastepublicontenteditableonpausemaponplayin" +
|
||||
"gonpopstateonprogressrcdoclassectionbluronratechangeonreject" +
|
||||
"ionhandledonresetonresizesrclangonscrollonsecuritypolicyviol" +
|
||||
"ationauxclickonseekedonseekingonselectedonshowidth6onsortabl" +
|
||||
"eonstalledonstorageonsubmitemscopedonsuspendontoggleonunhand" +
|
||||
"ledrejectionbeforeprintonunloadonvolumechangeonwaitingonwhee" +
|
||||
"loptimumalignmarkoptionbeforeunloaddressrcsetstylesummarysup" +
|
||||
"svgsystemplateworkertypewrap"
|
||||
+104
@@ -0,0 +1,104 @@
|
||||
// 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.3.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,
|
||||
"isindex": true, // The 'isindex' element has been removed, but keep it for backwards compatibility.
|
||||
"keygen": true,
|
||||
"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 "svg":
|
||||
return element.Data == "foreignObject"
|
||||
}
|
||||
return false
|
||||
}
|
||||
+106
@@ -0,0 +1,106 @@
|
||||
// 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 "<") 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 {
|
||||
// ...
|
||||
}
|
||||
var f func(*html.Node)
|
||||
f = func(n *html.Node) {
|
||||
if n.Type == html.ElementNode && n.Data == "a" {
|
||||
// Do something with n...
|
||||
}
|
||||
for c := n.FirstChild; c != nil; c = c.NextSibling {
|
||||
f(c)
|
||||
}
|
||||
}
|
||||
f(doc)
|
||||
|
||||
The relevant specifications include:
|
||||
https://html.spec.whatwg.org/multipage/syntax.html and
|
||||
https://html.spec.whatwg.org/multipage/syntax.html#tokenization
|
||||
*/
|
||||
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
@@ -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.ToLower(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
File diff suppressed because it is too large
Load Diff
+258
@@ -0,0 +1,258 @@
|
||||
// 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 "<" 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<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
|
||||
}
|
||||
|
||||
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 = "&"
|
||||
case '\'':
|
||||
// "'" is shorter than "'" and apos was not in HTML until HTML5.
|
||||
esc = "'"
|
||||
case '<':
|
||||
esc = "<"
|
||||
case '>':
|
||||
esc = ">"
|
||||
case '"':
|
||||
// """ is shorter than """.
|
||||
esc = """
|
||||
case '\r':
|
||||
esc = " "
|
||||
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 "<". 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 "<" to become "<". It unescapes a
|
||||
// larger range of entities than EscapeString escapes. For example, "á"
|
||||
// unescapes to "á", as does "á" 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
|
||||
}
|
||||
+226
@@ -0,0 +1,226 @@
|
||||
// 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" {
|
||||
val := strings.ToLower(a.Val)
|
||||
if val == "text/html" || 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.5.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.5.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.5.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",
|
||||
"contentscripttype": "contentScriptType",
|
||||
"contentstyletype": "contentStyleType",
|
||||
"diffuseconstant": "diffuseConstant",
|
||||
"edgemode": "edgeMode",
|
||||
"externalresourcesrequired": "externalResourcesRequired",
|
||||
"filterres": "filterRes",
|
||||
"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",
|
||||
}
|
||||
+193
@@ -0,0 +1,193 @@
|
||||
// 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
|
||||
scopeMarkerNode
|
||||
)
|
||||
|
||||
// Section 12.2.3.3 says "scope markers are inserted when entering applet
|
||||
// elements, buttons, object elements, marquees, table cells, and table
|
||||
// captions, and are used to prevent formatting from 'leaking'".
|
||||
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<b". For element nodes, DataAtom
|
||||
// is the atom for Data, or zero if Data is not a known tag name.
|
||||
//
|
||||
// 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
|
||||
}
|
||||
|
||||
// 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]
|
||||
}
|
||||
+2094
File diff suppressed because it is too large
Load Diff
+271
@@ -0,0 +1,271 @@
|
||||
// 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 := w.WriteString(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 := w.WriteString(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('>')
|
||||
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.
|
||||
switch n.Data {
|
||||
case "iframe", "noembed", "noframes", "noscript", "plaintext", "script", "style", "xmp":
|
||||
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
|
||||
}
|
||||
default:
|
||||
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('>')
|
||||
}
|
||||
|
||||
// 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,
|
||||
"command": true,
|
||||
"embed": true,
|
||||
"hr": true,
|
||||
"img": true,
|
||||
"input": true,
|
||||
"keygen": true,
|
||||
"link": true,
|
||||
"meta": true,
|
||||
"param": true,
|
||||
"source": true,
|
||||
"track": true,
|
||||
"wbr": true,
|
||||
}
|
||||
+1219
File diff suppressed because it is too large
Load Diff
Vendored
+18
@@ -105,6 +105,12 @@
|
||||
"revision": "77ed1c8a01217656d2080ad51981f6e99adaa177",
|
||||
"revisionTime": "2015-11-25T20:19:25Z"
|
||||
},
|
||||
{
|
||||
"checksumSHA1": "+C5xtTR8XG1rwSVunPPRANfYolY=",
|
||||
"path": "github.com/microcosm-cc/bluemonday",
|
||||
"revision": "542fd4642604d0d0c26112396ce5b1a9d01eee0b",
|
||||
"revisionTime": "2017-12-22T15:26:07Z"
|
||||
},
|
||||
{
|
||||
"checksumSHA1": "rJab1YdNhQooDiBWNnt7TLWPyBU=",
|
||||
"path": "github.com/pkg/errors",
|
||||
@@ -136,6 +142,18 @@
|
||||
"revision": "d1e1b351919c6738fdeb9893d5c998b161464f0c",
|
||||
"revisionTime": "2016-12-29T22:47:41Z"
|
||||
},
|
||||
{
|
||||
"checksumSHA1": "2t6c6F2y4b/PEV04TOHpQxh/xLc=",
|
||||
"path": "golang.org/x/net/html",
|
||||
"revision": "d866cfc389cec985d6fda2859936a575a55a3ab6",
|
||||
"revisionTime": "2017-12-11T20:45:21Z"
|
||||
},
|
||||
{
|
||||
"checksumSHA1": "iWvOOLdDxvI4AVX6px6/HYBPeaQ=",
|
||||
"path": "golang.org/x/net/html/atom",
|
||||
"revision": "d866cfc389cec985d6fda2859936a575a55a3ab6",
|
||||
"revisionTime": "2017-12-11T20:45:21Z"
|
||||
},
|
||||
{
|
||||
"checksumSHA1": "J+KmMiCOHG4E4vbd4C1BtRp813s=",
|
||||
"path": "golang.org/x/oauth2",
|
||||
|
||||
Reference in New Issue
Block a user