From d938e0f6a2a009fe44bf76907321c121aafcfc9e Mon Sep 17 00:00:00 2001
From: Sergey Gaynetdinov <sergey@gaynetdinov.ru>
Date: Sat, 16 Nov 2019 15:12:55 +0500
Subject: [PATCH 01/25] Add telegram client, for send notification

---
 app/proc/telegram.go | 78 ++++++++++++++++++++++++++++++++++++++++++++
 go.mod               |  2 ++
 go.sum               |  5 +++
 3 files changed, 85 insertions(+)
 create mode 100644 app/proc/telegram.go

diff --git a/app/proc/telegram.go b/app/proc/telegram.go
new file mode 100644
index 00000000..c14bf7d7
--- /dev/null
+++ b/app/proc/telegram.go
@@ -0,0 +1,78 @@
+package proc
+
+import (
+	"fmt"
+	"strings"
+
+	log "github.com/go-pkgz/lgr"
+	"github.com/microcosm-cc/bluemonday"
+	tb "gopkg.in/tucnak/telebot.v2"
+
+	"github.com/umputun/feed-master/app/feed"
+)
+
+// TelegramClient client
+type TelegramClient struct {
+	Bot *tb.Bot
+}
+
+// NewTelegramClient init telegram client
+func NewTelegramClient(token string) (*TelegramClient, error) {
+	bot, err := tb.NewBot(tb.Settings{
+		Token: token,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	result := TelegramClient{
+		Bot: bot,
+	}
+	return &result, err
+}
+
+// Send message, skip if telegram token empty
+func (client TelegramClient) Send(channelID string, item feed.Item) error {
+	if channelID == "" {
+		return nil
+	}
+
+	message, err := client.Bot.Send(
+		recipient{chatID: channelID},
+		client.getMessageHTML(item),
+		tb.ModeHTML,
+		tb.NoPreview,
+	)
+	if err != nil {
+		return err
+	}
+
+	log.Printf("[DEBUG] send telegram message: \n%s", message.Text)
+	return err
+}
+
+// https://core.telegram.org/bots/api#html-style
+func (client TelegramClient) tagLinkOnlySupport(html string) string {
+	p := bluemonday.NewPolicy()
+	p.AllowAttrs("href").OnElements("a")
+	return p.Sanitize(html)
+}
+
+func (client TelegramClient) getMessageHTML(item feed.Item) string {
+	title := strings.TrimSpace(item.Title)
+
+	description := client.tagLinkOnlySupport(string(item.Description))
+	description = strings.TrimSpace(description)
+
+	messageHTML := fmt.Sprintf("%s\n\n%s\n\n%s", title, description, item.Enclosure.URL)
+
+	return messageHTML
+}
+
+type recipient struct {
+	chatID string
+}
+
+func (r recipient) Recipient() string {
+	return r.chatID
+}
diff --git a/go.mod b/go.mod
index 3520a203..6ea6a946 100644
--- a/go.mod
+++ b/go.mod
@@ -13,12 +13,14 @@ require (
 	github.com/hashicorp/golang-lru v0.5.3 // indirect
 	github.com/jessevdk/go-flags v1.4.0
 	github.com/kr/pretty v0.1.0 // indirect
+	github.com/microcosm-cc/bluemonday v1.0.2
 	github.com/pkg/errors v0.8.1
 	github.com/stretchr/testify v1.3.0
 	golang.org/x/net v0.0.0-20190311183353-d8887717615a // indirect
 	golang.org/x/sys v0.0.0-20191010194322-b09406accb47 // indirect
 	golang.org/x/time v0.0.0-20190921001708-c4c64cad1fd0 // indirect
 	gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 // indirect
+	gopkg.in/tucnak/telebot.v2 v2.0.0-20191005061224-d0707a9d73c4
 	gopkg.in/yaml.v2 v2.2.4
 )
 
diff --git a/go.sum b/go.sum
index c3cb9c78..5dff4ee3 100644
--- a/go.sum
+++ b/go.sum
@@ -40,6 +40,8 @@ github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORN
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/microcosm-cc/bluemonday v1.0.2 h1:5lPfLTTAvAbtS0VqT+94yOtFnGfUWYyx0+iToC3Os3s=
+github.com/microcosm-cc/bluemonday v1.0.2/go.mod h1:iVP4YcDBq+n/5fb23BhYFvIMq/leAFZyRl6bYmGDlGc=
 github.com/patrickmn/go-cache v2.1.0+incompatible h1:HRMgzkcYKYpi3C8ajMPV8OFXaaRUnok+kx1WdO15EQc=
 github.com/patrickmn/go-cache v2.1.0+incompatible/go.mod h1:3Qf8kWWT7OJRJbdiICTKqZju1ZixQ/KpMGzzAfe6+WQ=
 github.com/pkg/errors v0.8.0 h1:WdK/asTD0HN+q6hsWO3/vpuAkAr+tw6aNJNDFFf0+qw=
@@ -53,6 +55,7 @@ github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+
 github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/net v0.0.0-20181220203305-927f97764cc3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190311183353-d8887717615a h1:oWX7TPOiFAMXLq8o0ikBYfCJVlRHBcsciT5bXOrH628=
 golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
@@ -69,6 +72,8 @@ golang.org/x/time v0.0.0-20190921001708-c4c64cad1fd0/go.mod h1:tRJNPiyCQ0inRvYxb
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/tucnak/telebot.v2 v2.0.0-20191005061224-d0707a9d73c4 h1:MSLXMclm1f+66ozQ1n4/+LRToMtonMsAySOo5TWK9aU=
+gopkg.in/tucnak/telebot.v2 v2.0.0-20191005061224-d0707a9d73c4/go.mod h1:+//wyPtHTeW2kfyEBwB05Hqnxev7AGrsLIyylSH++KU=
 gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.4 h1:/eiJrUcujPVeJ3xlSWaiNi3uSVmDGBK1pDHUHAnao1I=

From 908cda8fcdaada9d477acec0223fa96aca85d28b Mon Sep 17 00:00:00 2001
From: Sergey Gaynetdinov <sergey@gaynetdinov.ru>
Date: Sat, 16 Nov 2019 15:21:56 +0500
Subject: [PATCH 02/25] Send message telegram if get new item RSS

---
 app/main.go           |  7 ++++++-
 app/proc/processor.go | 35 +++++++++++++++++++++++------------
 app/proc/store.go     | 18 ++++++++++++++----
 3 files changed, 43 insertions(+), 17 deletions(-)

diff --git a/app/main.go b/app/main.go
index db526b17..33994f6a 100644
--- a/app/main.go
+++ b/app/main.go
@@ -17,6 +17,7 @@ var opts struct {
 	DB   string `short:"c" long:"db" env:"FM_DB" default:"var/feed-master.bdb" description:"bolt db file"`
 	Conf string `short:"f" long:"conf" env:"FM_CONF" default:"feed-master.yml" description:"config file (yml)"`
 	Dbg  bool   `long:"dbg" env:"DEBUG" description:"debug mode"`
+	TG   string `long:"telegram_token" env:"TELEGRAM_TOKEN" description:"Telegram token"`
 }
 
 var revision = "local"
@@ -36,8 +37,12 @@ func main() {
 	if err != nil {
 		log.Fatalf("[ERROR] can't open db %s, %v", opts.DB, err)
 	}
+	tg, err := proc.NewTelegramClient(opts.TG)
+	if err != nil {
+		log.Fatalf("[ERROR] failed initilization telegram client %s, %v", opts.TG, err)
+	}
 
-	p := &proc.Processor{Conf: conf, Store: db}
+	p := &proc.Processor{Conf: conf, Store: db, Telegram: tg}
 	go p.Do()
 
 	server := api.Server{
diff --git a/app/proc/processor.go b/app/proc/processor.go
index 76293f7e..12b74833 100644
--- a/app/proc/processor.go
+++ b/app/proc/processor.go
@@ -14,19 +14,21 @@ import (
 
 // Processor is a feed reader and store writer
 type Processor struct {
-	Conf  *Conf
-	Store *BoltDB
+	Conf     *Conf
+	Store    *BoltDB
+	Telegram *TelegramClient
 }
 
 // Conf for feeds config yml
 type Conf struct {
 	Feeds map[string]struct {
-		Title       string `yaml:"title"`
-		Description string `yaml:"description"`
-		Link        string `yaml:"link"`
-		Image       string `yaml:"image"`
-		Language    string `yaml:"language"`
-		Sources     []struct {
+		Title           string `yaml:"title"`
+		Description     string `yaml:"description"`
+		Link            string `yaml:"link"`
+		Image           string `yaml:"image"`
+		Language        string `yaml:"language"`
+		TelegramChannel string `yaml:"telegram_channel"`
+		Sources         []struct {
 			Name string `yaml:"name"`
 			URL  string `yaml:"url"`
 		} `yaml:"sources"`
@@ -51,9 +53,9 @@ func (p *Processor) Do() {
 		swg := syncs.NewSizedGroup(p.Conf.System.Concurrent, syncs.Preemptive)
 		for name, fm := range p.Conf.Feeds {
 			for _, src := range fm.Sources {
-				name, src := name, src
+				name, src, fm := name, src, fm
 				swg.Go(func(_ context.Context) {
-					p.feed(name, src.URL, p.Conf.System.MaxItems)
+					p.feed(name, src.URL, fm.TelegramChannel, p.Conf.System.MaxItems)
 				})
 			}
 			// keep up to MaxKeepInDB items in bucket
@@ -71,7 +73,7 @@ func (p *Processor) Do() {
 	}
 }
 
-func (p *Processor) feed(name, url string, max int) {
+func (p *Processor) feed(name, url, telegramChannel string, max int) {
 
 	rss, err := feed.Parse(url)
 	if err != nil {
@@ -91,9 +93,18 @@ func (p *Processor) feed(name, url string, max int) {
 			continue
 		}
 
-		if err := p.Store.Save(name, item); err != nil {
+		created, err := p.Store.Save(name, item)
+		if err != nil {
 			log.Printf("[WARN] failed to save %s (%s) to %s, %v", item.GUID, item.PubDate, name, err)
 		}
+
+		if !created {
+			return
+		}
+
+		if err := p.Telegram.Send(telegramChannel, item); err != nil {
+			log.Printf("[WARN] failed send telegram message %s (%s) to %s, %v", item.GUID, item.PubDate, name, err)
+		}
 	}
 }
 
diff --git a/app/proc/store.go b/app/proc/store.go
index 440a017f..6a82a96b 100644
--- a/app/proc/store.go
+++ b/app/proc/store.go
@@ -35,7 +35,8 @@ func NewBoltDB(dbFile string) (*BoltDB, error) {
 }
 
 // Save to bolt, skip if found
-func (b BoltDB) Save(fmFeed string, item feed.Item) error {
+func (b BoltDB) Save(fmFeed string, item feed.Item) (bool, error) {
+	var created bool
 
 	key, err := func() ([]byte, error) {
 		ts, err := time.Parse(time.RFC1123Z, item.PubDate)
@@ -50,10 +51,10 @@ func (b BoltDB) Save(fmFeed string, item feed.Item) error {
 	}()
 
 	if err != nil {
-		return err
+		return created, err
 	}
 
-	return b.DB.Update(func(tx *bolt.Tx) error {
+	err = b.DB.Update(func(tx *bolt.Tx) error {
 		bucket, e := tx.CreateBucketIfNotExists([]byte(fmFeed))
 		if e != nil {
 			return e
@@ -66,9 +67,18 @@ func (b BoltDB) Save(fmFeed string, item feed.Item) error {
 		if jerr != nil {
 			return jerr
 		}
+
 		log.Printf("[INFO] save %s - %s - %s - %s", string(key), fmFeed, item.Title, item.GUID)
-		return bucket.Put(key, jdata)
+		e = bucket.Put(key, jdata)
+		if e != nil {
+			return e
+		}
+
+		created = true
+		return e
 	})
+
+	return created, err
 }
 
 // Load from bold for given feed, up to max

From 3ae8267094a9253336375f6c7c8c8422bcb23eb9 Mon Sep 17 00:00:00 2001
From: Sergey Gaynetdinov <sergey@gaynetdinov.ru>
Date: Sat, 16 Nov 2019 19:45:45 +0500
Subject: [PATCH 03/25] Add new package in vendor

---
 .../microcosm-cc/bluemonday/.coveralls.yml    |    1 +
 .../microcosm-cc/bluemonday/.travis.yml       |   22 +
 .../microcosm-cc/bluemonday/CONTRIBUTING.md   |   51 +
 .../microcosm-cc/bluemonday/CREDITS.md        |    6 +
 .../microcosm-cc/bluemonday/LICENSE.md        |   28 +
 .../microcosm-cc/bluemonday/Makefile          |   42 +
 .../microcosm-cc/bluemonday/README.md         |  350 +++
 .../github.com/microcosm-cc/bluemonday/doc.go |  104 +
 .../github.com/microcosm-cc/bluemonday/go.mod |    5 +
 .../github.com/microcosm-cc/bluemonday/go.sum |    2 +
 .../microcosm-cc/bluemonday/helpers.go        |  297 +++
 .../microcosm-cc/bluemonday/policies.go       |  253 ++
 .../microcosm-cc/bluemonday/policy.go         |  552 ++++
 .../microcosm-cc/bluemonday/sanitize.go       |  581 +++++
 vendor/golang.org/x/net/AUTHORS               |    3 +
 vendor/golang.org/x/net/CONTRIBUTORS          |    3 +
 vendor/golang.org/x/net/LICENSE               |   27 +
 vendor/golang.org/x/net/PATENTS               |   22 +
 vendor/golang.org/x/net/html/atom/atom.go     |   78 +
 vendor/golang.org/x/net/html/atom/table.go    |  783 ++++++
 vendor/golang.org/x/net/html/const.go         |  112 +
 vendor/golang.org/x/net/html/doc.go           |  106 +
 vendor/golang.org/x/net/html/doctype.go       |  156 ++
 vendor/golang.org/x/net/html/entity.go        | 2253 ++++++++++++++++
 vendor/golang.org/x/net/html/escape.go        |  258 ++
 vendor/golang.org/x/net/html/foreign.go       |  226 ++
 vendor/golang.org/x/net/html/node.go          |  220 ++
 vendor/golang.org/x/net/html/parse.go         | 2324 +++++++++++++++++
 vendor/golang.org/x/net/html/render.go        |  271 ++
 vendor/golang.org/x/net/html/token.go         | 1219 +++++++++
 vendor/gopkg.in/tucnak/telebot.v2/.gitignore  |   27 +
 vendor/gopkg.in/tucnak/telebot.v2/.travis.yml |    4 +
 vendor/gopkg.in/tucnak/telebot.v2/LICENSE     |   22 +
 vendor/gopkg.in/tucnak/telebot.v2/README.md   |  444 ++++
 vendor/gopkg.in/tucnak/telebot.v2/admin.go    |  205 ++
 vendor/gopkg.in/tucnak/telebot.v2/api.go      |  210 ++
 vendor/gopkg.in/tucnak/telebot.v2/bot.go      | 1522 +++++++++++
 .../gopkg.in/tucnak/telebot.v2/callbacks.go   |   82 +
 vendor/gopkg.in/tucnak/telebot.v2/chat.go     |   57 +
 .../tucnak/telebot.v2/data_payments.go        |    3 +
 vendor/gopkg.in/tucnak/telebot.v2/editable.go |   30 +
 vendor/gopkg.in/tucnak/telebot.v2/file.go     |   87 +
 vendor/gopkg.in/tucnak/telebot.v2/filters.go  |   66 +
 vendor/gopkg.in/tucnak/telebot.v2/go.mod      |    5 +
 vendor/gopkg.in/tucnak/telebot.v2/go.sum      |    2 +
 vendor/gopkg.in/tucnak/telebot.v2/inline.go   |  122 +
 .../tucnak/telebot.v2/inline_types.go         |  319 +++
 .../gopkg.in/tucnak/telebot.v2/input_types.go |   78 +
 vendor/gopkg.in/tucnak/telebot.v2/media.go    |  189 ++
 vendor/gopkg.in/tucnak/telebot.v2/message.go  |  267 ++
 vendor/gopkg.in/tucnak/telebot.v2/options.go  |  146 ++
 vendor/gopkg.in/tucnak/telebot.v2/payments.go |   64 +
 vendor/gopkg.in/tucnak/telebot.v2/poller.go   |  106 +
 vendor/gopkg.in/tucnak/telebot.v2/sendable.go |  279 ++
 vendor/gopkg.in/tucnak/telebot.v2/stickers.go |   40 +
 vendor/gopkg.in/tucnak/telebot.v2/telebot.go  |  167 ++
 vendor/gopkg.in/tucnak/telebot.v2/util.go     |  221 ++
 vendor/gopkg.in/tucnak/telebot.v2/webhook.go  |  150 ++
 vendor/modules.txt                            |    7 +
 59 files changed, 15276 insertions(+)
 create mode 100644 vendor/github.com/microcosm-cc/bluemonday/.coveralls.yml
 create mode 100644 vendor/github.com/microcosm-cc/bluemonday/.travis.yml
 create mode 100644 vendor/github.com/microcosm-cc/bluemonday/CONTRIBUTING.md
 create mode 100644 vendor/github.com/microcosm-cc/bluemonday/CREDITS.md
 create mode 100644 vendor/github.com/microcosm-cc/bluemonday/LICENSE.md
 create mode 100644 vendor/github.com/microcosm-cc/bluemonday/Makefile
 create mode 100644 vendor/github.com/microcosm-cc/bluemonday/README.md
 create mode 100644 vendor/github.com/microcosm-cc/bluemonday/doc.go
 create mode 100644 vendor/github.com/microcosm-cc/bluemonday/go.mod
 create mode 100644 vendor/github.com/microcosm-cc/bluemonday/go.sum
 create mode 100644 vendor/github.com/microcosm-cc/bluemonday/helpers.go
 create mode 100644 vendor/github.com/microcosm-cc/bluemonday/policies.go
 create mode 100644 vendor/github.com/microcosm-cc/bluemonday/policy.go
 create mode 100644 vendor/github.com/microcosm-cc/bluemonday/sanitize.go
 create mode 100644 vendor/golang.org/x/net/AUTHORS
 create mode 100644 vendor/golang.org/x/net/CONTRIBUTORS
 create mode 100644 vendor/golang.org/x/net/LICENSE
 create mode 100644 vendor/golang.org/x/net/PATENTS
 create mode 100644 vendor/golang.org/x/net/html/atom/atom.go
 create mode 100644 vendor/golang.org/x/net/html/atom/table.go
 create mode 100644 vendor/golang.org/x/net/html/const.go
 create mode 100644 vendor/golang.org/x/net/html/doc.go
 create mode 100644 vendor/golang.org/x/net/html/doctype.go
 create mode 100644 vendor/golang.org/x/net/html/entity.go
 create mode 100644 vendor/golang.org/x/net/html/escape.go
 create mode 100644 vendor/golang.org/x/net/html/foreign.go
 create mode 100644 vendor/golang.org/x/net/html/node.go
 create mode 100644 vendor/golang.org/x/net/html/parse.go
 create mode 100644 vendor/golang.org/x/net/html/render.go
 create mode 100644 vendor/golang.org/x/net/html/token.go
 create mode 100644 vendor/gopkg.in/tucnak/telebot.v2/.gitignore
 create mode 100644 vendor/gopkg.in/tucnak/telebot.v2/.travis.yml
 create mode 100644 vendor/gopkg.in/tucnak/telebot.v2/LICENSE
 create mode 100644 vendor/gopkg.in/tucnak/telebot.v2/README.md
 create mode 100644 vendor/gopkg.in/tucnak/telebot.v2/admin.go
 create mode 100644 vendor/gopkg.in/tucnak/telebot.v2/api.go
 create mode 100644 vendor/gopkg.in/tucnak/telebot.v2/bot.go
 create mode 100644 vendor/gopkg.in/tucnak/telebot.v2/callbacks.go
 create mode 100644 vendor/gopkg.in/tucnak/telebot.v2/chat.go
 create mode 100644 vendor/gopkg.in/tucnak/telebot.v2/data_payments.go
 create mode 100644 vendor/gopkg.in/tucnak/telebot.v2/editable.go
 create mode 100644 vendor/gopkg.in/tucnak/telebot.v2/file.go
 create mode 100644 vendor/gopkg.in/tucnak/telebot.v2/filters.go
 create mode 100644 vendor/gopkg.in/tucnak/telebot.v2/go.mod
 create mode 100644 vendor/gopkg.in/tucnak/telebot.v2/go.sum
 create mode 100644 vendor/gopkg.in/tucnak/telebot.v2/inline.go
 create mode 100644 vendor/gopkg.in/tucnak/telebot.v2/inline_types.go
 create mode 100644 vendor/gopkg.in/tucnak/telebot.v2/input_types.go
 create mode 100644 vendor/gopkg.in/tucnak/telebot.v2/media.go
 create mode 100644 vendor/gopkg.in/tucnak/telebot.v2/message.go
 create mode 100644 vendor/gopkg.in/tucnak/telebot.v2/options.go
 create mode 100644 vendor/gopkg.in/tucnak/telebot.v2/payments.go
 create mode 100644 vendor/gopkg.in/tucnak/telebot.v2/poller.go
 create mode 100644 vendor/gopkg.in/tucnak/telebot.v2/sendable.go
 create mode 100644 vendor/gopkg.in/tucnak/telebot.v2/stickers.go
 create mode 100644 vendor/gopkg.in/tucnak/telebot.v2/telebot.go
 create mode 100644 vendor/gopkg.in/tucnak/telebot.v2/util.go
 create mode 100644 vendor/gopkg.in/tucnak/telebot.v2/webhook.go

diff --git a/vendor/github.com/microcosm-cc/bluemonday/.coveralls.yml b/vendor/github.com/microcosm-cc/bluemonday/.coveralls.yml
new file mode 100644
index 00000000..e0c87602
--- /dev/null
+++ b/vendor/github.com/microcosm-cc/bluemonday/.coveralls.yml
@@ -0,0 +1 @@
+repo_token: x2wlA1x0X8CK45ybWpZRCVRB4g7vtkhaw
diff --git a/vendor/github.com/microcosm-cc/bluemonday/.travis.yml b/vendor/github.com/microcosm-cc/bluemonday/.travis.yml
new file mode 100644
index 00000000..4f666461
--- /dev/null
+++ b/vendor/github.com/microcosm-cc/bluemonday/.travis.yml
@@ -0,0 +1,22 @@
+language: go
+go:
+  - 1.1.x
+  - 1.2.x
+  - 1.3.x
+  - 1.4.x
+  - 1.5.x
+  - 1.6.x
+  - 1.7.x
+  - 1.8.x
+  - 1.9.x
+  - 1.10.x
+  - 1.11.x
+  - tip
+matrix:
+  allow_failures:
+    - go: tip
+  fast_finish: true
+install:
+  - go get .
+script:
+  - go test -v ./...
diff --git a/vendor/github.com/microcosm-cc/bluemonday/CONTRIBUTING.md b/vendor/github.com/microcosm-cc/bluemonday/CONTRIBUTING.md
new file mode 100644
index 00000000..d2b12302
--- /dev/null
+++ b/vendor/github.com/microcosm-cc/bluemonday/CONTRIBUTING.md
@@ -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.
diff --git a/vendor/github.com/microcosm-cc/bluemonday/CREDITS.md b/vendor/github.com/microcosm-cc/bluemonday/CREDITS.md
new file mode 100644
index 00000000..b98873f3
--- /dev/null
+++ b/vendor/github.com/microcosm-cc/bluemonday/CREDITS.md
@@ -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
\ No newline at end of file
diff --git a/vendor/github.com/microcosm-cc/bluemonday/LICENSE.md b/vendor/github.com/microcosm-cc/bluemonday/LICENSE.md
new file mode 100644
index 00000000..f822458e
--- /dev/null
+++ b/vendor/github.com/microcosm-cc/bluemonday/LICENSE.md
@@ -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.
diff --git a/vendor/github.com/microcosm-cc/bluemonday/Makefile b/vendor/github.com/microcosm-cc/bluemonday/Makefile
new file mode 100644
index 00000000..b15dc74f
--- /dev/null
+++ b/vendor/github.com/microcosm-cc/bluemonday/Makefile
@@ -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 ./...
diff --git a/vendor/github.com/microcosm-cc/bluemonday/README.md b/vendor/github.com/microcosm-cc/bluemonday/README.md
new file mode 100644
index 00000000..ce679c10
--- /dev/null
+++ b/vendor/github.com/microcosm-cc/bluemonday/README.md
@@ -0,0 +1,350 @@
+# bluemonday [![Build Status](https://travis-ci.org/microcosm-cc/bluemonday.svg?branch=master)](https://travis-ci.org/microcosm-cc/bluemonday) [![GoDoc](https://godoc.org/github.com/microcosm-cc/bluemonday?status.png)](https://godoc.org/github.com/microcosm-cc/bluemonday) [![Sourcegraph](https://sourcegraph.com/github.com/microcosm-cc/bluemonday/-/badge.svg)](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() {
+	// Do this once for each unique policy, and use the policy for the life of the program
+	// Policy creation/editing is not safe to use in multiple goroutines
+	p := bluemonday.UGCPolicy()
+	
+	// The policy can then be used to sanitize lots of input and it is safe to use the policy in multiple goroutines
+	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 its 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 its 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
diff --git a/vendor/github.com/microcosm-cc/bluemonday/doc.go b/vendor/github.com/microcosm-cc/bluemonday/doc.go
new file mode 100644
index 00000000..71dab608
--- /dev/null
+++ b/vendor/github.com/microcosm-cc/bluemonday/doc.go
@@ -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 its 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
diff --git a/vendor/github.com/microcosm-cc/bluemonday/go.mod b/vendor/github.com/microcosm-cc/bluemonday/go.mod
new file mode 100644
index 00000000..fa8453c5
--- /dev/null
+++ b/vendor/github.com/microcosm-cc/bluemonday/go.mod
@@ -0,0 +1,5 @@
+module github.com/microcosm-cc/bluemonday
+
+go 1.9
+
+require golang.org/x/net v0.0.0-20181220203305-927f97764cc3
diff --git a/vendor/github.com/microcosm-cc/bluemonday/go.sum b/vendor/github.com/microcosm-cc/bluemonday/go.sum
new file mode 100644
index 00000000..bee241d1
--- /dev/null
+++ b/vendor/github.com/microcosm-cc/bluemonday/go.sum
@@ -0,0 +1,2 @@
+golang.org/x/net v0.0.0-20181220203305-927f97764cc3 h1:eH6Eip3UpmR+yM/qI9Ijluzb1bNv/cAU/n+6l8tRSis=
+golang.org/x/net v0.0.0-20181220203305-927f97764cc3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
diff --git a/vendor/github.com/microcosm-cc/bluemonday/helpers.go b/vendor/github.com/microcosm-cc/bluemonday/helpers.go
new file mode 100644
index 00000000..dfa5868d
--- /dev/null
+++ b/vendor/github.com/microcosm-cc/bluemonday/helpers.go
@@ -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")
+}
diff --git a/vendor/github.com/microcosm-cc/bluemonday/policies.go b/vendor/github.com/microcosm-cc/bluemonday/policies.go
new file mode 100644
index 00000000..570bba88
--- /dev/null
+++ b/vendor/github.com/microcosm-cc/bluemonday/policies.go
@@ -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
+}
diff --git a/vendor/github.com/microcosm-cc/bluemonday/policy.go b/vendor/github.com/microcosm-cc/bluemonday/policy.go
new file mode 100644
index 00000000..f61d98f5
--- /dev/null
+++ b/vendor/github.com/microcosm-cc/bluemonday/policy.go
@@ -0,0 +1,552 @@
+// 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
+
+	// When true, allow data attributes.
+	allowDataAttributes 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
+}
+
+// AllowDataAttributes whitelists all data attributes. We can't specify the name
+// of each attribute exactly as they are customized.
+//
+// NOTE: These values are not sanitized and applications that evaluate or process
+// them without checking and verification of the input may be at risk if this option
+// is enabled. This is a 'caveat emptor' option and the person enabling this option
+// needs to fully understand the potential impact with regards to whatever application
+// will be consuming the sanitized HTML afterwards, i.e. if you know you put a link in a
+// data attribute and use that to automatically load some new window then you're giving
+// the author of a HTML fragment the means to open a malicious destination automatically.
+// Use with care!
+func (p *Policy) AllowDataAttributes() {
+	p.allowDataAttributes = true
+}
+
+// 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 its 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["address"] = 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{}{}
+}
diff --git a/vendor/github.com/microcosm-cc/bluemonday/sanitize.go b/vendor/github.com/microcosm-cc/bluemonday/sanitize.go
new file mode 100644
index 00000000..65ed89b7
--- /dev/null
+++ b/vendor/github.com/microcosm-cc/bluemonday/sanitize.go
@@ -0,0 +1,581 @@
+// 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"
+	"regexp"
+	"strings"
+
+	"golang.org/x/net/html"
+)
+
+var (
+	dataAttribute             = regexp.MustCompile("^data-.+")
+	dataAttributeXMLPrefix    = regexp.MustCompile("^xml.+")
+	dataAttributeInvalidChars = regexp.MustCompile("[A-Z;]+")
+)
+
+// 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 {
+		if p.allowDataAttributes {
+			// If we see a data attribute, let it through.
+			if isDataAttribute(htmlAttr.Key) {
+				cleanAttrs = append(cleanAttrs, htmlAttr)
+				continue
+			}
+		}
+		// 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
+	}
+}
+
+func isDataAttribute(val string) bool {
+	if !dataAttribute.MatchString(val) {
+		return false
+	}
+	rest := strings.Split(val, "data-")
+	if len(rest) == 1 {
+		return false
+	}
+	// data-xml* is invalid.
+	if dataAttributeXMLPrefix.MatchString(rest[1]) {
+		return false
+	}
+	// no uppercase or semi-colons allowed.
+	if dataAttributeInvalidChars.MatchString(rest[1]) {
+		return false
+	}
+	return true
+}
diff --git a/vendor/golang.org/x/net/AUTHORS b/vendor/golang.org/x/net/AUTHORS
new file mode 100644
index 00000000..15167cd7
--- /dev/null
+++ b/vendor/golang.org/x/net/AUTHORS
@@ -0,0 +1,3 @@
+# This source code refers to The Go Authors for copyright purposes.
+# The master list of authors is in the main Go distribution,
+# visible at http://tip.golang.org/AUTHORS.
diff --git a/vendor/golang.org/x/net/CONTRIBUTORS b/vendor/golang.org/x/net/CONTRIBUTORS
new file mode 100644
index 00000000..1c4577e9
--- /dev/null
+++ b/vendor/golang.org/x/net/CONTRIBUTORS
@@ -0,0 +1,3 @@
+# This source code was written by the Go contributors.
+# The master list of contributors is in the main Go distribution,
+# visible at http://tip.golang.org/CONTRIBUTORS.
diff --git a/vendor/golang.org/x/net/LICENSE b/vendor/golang.org/x/net/LICENSE
new file mode 100644
index 00000000..6a66aea5
--- /dev/null
+++ b/vendor/golang.org/x/net/LICENSE
@@ -0,0 +1,27 @@
+Copyright (c) 2009 The Go Authors. 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 Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/golang.org/x/net/PATENTS b/vendor/golang.org/x/net/PATENTS
new file mode 100644
index 00000000..73309904
--- /dev/null
+++ b/vendor/golang.org/x/net/PATENTS
@@ -0,0 +1,22 @@
+Additional IP Rights Grant (Patents)
+
+"This implementation" means the copyrightable works distributed by
+Google as part of the Go project.
+
+Google hereby grants to You a perpetual, worldwide, non-exclusive,
+no-charge, royalty-free, irrevocable (except as stated in this section)
+patent license to make, have made, use, offer to sell, sell, import,
+transfer and otherwise run, modify and propagate the contents of this
+implementation of Go, where such license applies only to those patent
+claims, both currently owned or controlled by Google and acquired in
+the future, licensable by Google that are necessarily infringed by this
+implementation of Go.  This grant does not include claims that would be
+infringed only as a consequence of further modification of this
+implementation.  If you or your agent or exclusive licensee institute or
+order or agree to the institution of patent litigation against any
+entity (including a cross-claim or counterclaim in a lawsuit) alleging
+that this implementation of Go or any code incorporated within this
+implementation of Go constitutes direct or contributory patent
+infringement, or inducement of patent infringement, then any patent
+rights granted to you under this License for this implementation of Go
+shall terminate as of the date such litigation is filed.
diff --git a/vendor/golang.org/x/net/html/atom/atom.go b/vendor/golang.org/x/net/html/atom/atom.go
new file mode 100644
index 00000000..cd0a8ac1
--- /dev/null
+++ b/vendor/golang.org/x/net/html/atom/atom.go
@@ -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)
+}
diff --git a/vendor/golang.org/x/net/html/atom/table.go b/vendor/golang.org/x/net/html/atom/table.go
new file mode 100644
index 00000000..2a938864
--- /dev/null
+++ b/vendor/golang.org/x/net/html/atom/table.go
@@ -0,0 +1,783 @@
+// Code generated by go generate gen.go; DO NOT EDIT.
+
+//go:generate go run gen.go
+
+package atom
+
+const (
+	A                         Atom = 0x1
+	Abbr                      Atom = 0x4
+	Accept                    Atom = 0x1a06
+	AcceptCharset             Atom = 0x1a0e
+	Accesskey                 Atom = 0x2c09
+	Acronym                   Atom = 0xaa07
+	Action                    Atom = 0x27206
+	Address                   Atom = 0x6f307
+	Align                     Atom = 0xb105
+	Allowfullscreen           Atom = 0x2080f
+	Allowpaymentrequest       Atom = 0xc113
+	Allowusermedia            Atom = 0xdd0e
+	Alt                       Atom = 0xf303
+	Annotation                Atom = 0x1c90a
+	AnnotationXml             Atom = 0x1c90e
+	Applet                    Atom = 0x31906
+	Area                      Atom = 0x35604
+	Article                   Atom = 0x3fc07
+	As                        Atom = 0x3c02
+	Aside                     Atom = 0x10705
+	Async                     Atom = 0xff05
+	Audio                     Atom = 0x11505
+	Autocomplete              Atom = 0x2780c
+	Autofocus                 Atom = 0x12109
+	Autoplay                  Atom = 0x13c08
+	B                         Atom = 0x101
+	Base                      Atom = 0x3b04
+	Basefont                  Atom = 0x3b08
+	Bdi                       Atom = 0xba03
+	Bdo                       Atom = 0x14b03
+	Bgsound                   Atom = 0x15e07
+	Big                       Atom = 0x17003
+	Blink                     Atom = 0x17305
+	Blockquote                Atom = 0x1870a
+	Body                      Atom = 0x2804
+	Br                        Atom = 0x202
+	Button                    Atom = 0x19106
+	Canvas                    Atom = 0x10306
+	Caption                   Atom = 0x23107
+	Center                    Atom = 0x22006
+	Challenge                 Atom = 0x29b09
+	Charset                   Atom = 0x2107
+	Checked                   Atom = 0x47907
+	Cite                      Atom = 0x19c04
+	Class                     Atom = 0x56405
+	Code                      Atom = 0x5c504
+	Col                       Atom = 0x1ab03
+	Colgroup                  Atom = 0x1ab08
+	Color                     Atom = 0x1bf05
+	Cols                      Atom = 0x1c404
+	Colspan                   Atom = 0x1c407
+	Command                   Atom = 0x1d707
+	Content                   Atom = 0x58b07
+	Contenteditable           Atom = 0x58b0f
+	Contextmenu               Atom = 0x3800b
+	Controls                  Atom = 0x1de08
+	Coords                    Atom = 0x1ea06
+	Crossorigin               Atom = 0x1fb0b
+	Data                      Atom = 0x4a504
+	Datalist                  Atom = 0x4a508
+	Datetime                  Atom = 0x2b808
+	Dd                        Atom = 0x2d702
+	Default                   Atom = 0x10a07
+	Defer                     Atom = 0x5c705
+	Del                       Atom = 0x45203
+	Desc                      Atom = 0x56104
+	Details                   Atom = 0x7207
+	Dfn                       Atom = 0x8703
+	Dialog                    Atom = 0xbb06
+	Dir                       Atom = 0x9303
+	Dirname                   Atom = 0x9307
+	Disabled                  Atom = 0x16408
+	Div                       Atom = 0x16b03
+	Dl                        Atom = 0x5e602
+	Download                  Atom = 0x46308
+	Draggable                 Atom = 0x17a09
+	Dropzone                  Atom = 0x40508
+	Dt                        Atom = 0x64b02
+	Em                        Atom = 0x6e02
+	Embed                     Atom = 0x6e05
+	Enctype                   Atom = 0x28d07
+	Face                      Atom = 0x21e04
+	Fieldset                  Atom = 0x22608
+	Figcaption                Atom = 0x22e0a
+	Figure                    Atom = 0x24806
+	Font                      Atom = 0x3f04
+	Footer                    Atom = 0xf606
+	For                       Atom = 0x25403
+	ForeignObject             Atom = 0x2540d
+	Foreignobject             Atom = 0x2610d
+	Form                      Atom = 0x26e04
+	Formaction                Atom = 0x26e0a
+	Formenctype               Atom = 0x2890b
+	Formmethod                Atom = 0x2a40a
+	Formnovalidate            Atom = 0x2ae0e
+	Formtarget                Atom = 0x2c00a
+	Frame                     Atom = 0x8b05
+	Frameset                  Atom = 0x8b08
+	H1                        Atom = 0x15c02
+	H2                        Atom = 0x2de02
+	H3                        Atom = 0x30d02
+	H4                        Atom = 0x34502
+	H5                        Atom = 0x34f02
+	H6                        Atom = 0x64d02
+	Head                      Atom = 0x33104
+	Header                    Atom = 0x33106
+	Headers                   Atom = 0x33107
+	Height                    Atom = 0x5206
+	Hgroup                    Atom = 0x2ca06
+	Hidden                    Atom = 0x2d506
+	High                      Atom = 0x2db04
+	Hr                        Atom = 0x15702
+	Href                      Atom = 0x2e004
+	Hreflang                  Atom = 0x2e008
+	Html                      Atom = 0x5604
+	HttpEquiv                 Atom = 0x2e80a
+	I                         Atom = 0x601
+	Icon                      Atom = 0x58a04
+	Id                        Atom = 0x10902
+	Iframe                    Atom = 0x2fc06
+	Image                     Atom = 0x30205
+	Img                       Atom = 0x30703
+	Input                     Atom = 0x44b05
+	Inputmode                 Atom = 0x44b09
+	Ins                       Atom = 0x20403
+	Integrity                 Atom = 0x23f09
+	Is                        Atom = 0x16502
+	Isindex                   Atom = 0x30f07
+	Ismap                     Atom = 0x31605
+	Itemid                    Atom = 0x38b06
+	Itemprop                  Atom = 0x19d08
+	Itemref                   Atom = 0x3cd07
+	Itemscope                 Atom = 0x67109
+	Itemtype                  Atom = 0x31f08
+	Kbd                       Atom = 0xb903
+	Keygen                    Atom = 0x3206
+	Keytype                   Atom = 0xd607
+	Kind                      Atom = 0x17704
+	Label                     Atom = 0x5905
+	Lang                      Atom = 0x2e404
+	Legend                    Atom = 0x18106
+	Li                        Atom = 0xb202
+	Link                      Atom = 0x17404
+	List                      Atom = 0x4a904
+	Listing                   Atom = 0x4a907
+	Loop                      Atom = 0x5d04
+	Low                       Atom = 0xc303
+	Main                      Atom = 0x1004
+	Malignmark                Atom = 0xb00a
+	Manifest                  Atom = 0x6d708
+	Map                       Atom = 0x31803
+	Mark                      Atom = 0xb604
+	Marquee                   Atom = 0x32707
+	Math                      Atom = 0x32e04
+	Max                       Atom = 0x33d03
+	Maxlength                 Atom = 0x33d09
+	Media                     Atom = 0xe605
+	Mediagroup                Atom = 0xe60a
+	Menu                      Atom = 0x38704
+	Menuitem                  Atom = 0x38708
+	Meta                      Atom = 0x4b804
+	Meter                     Atom = 0x9805
+	Method                    Atom = 0x2a806
+	Mglyph                    Atom = 0x30806
+	Mi                        Atom = 0x34702
+	Min                       Atom = 0x34703
+	Minlength                 Atom = 0x34709
+	Mn                        Atom = 0x2b102
+	Mo                        Atom = 0xa402
+	Ms                        Atom = 0x67402
+	Mtext                     Atom = 0x35105
+	Multiple                  Atom = 0x35f08
+	Muted                     Atom = 0x36705
+	Name                      Atom = 0x9604
+	Nav                       Atom = 0x1303
+	Nobr                      Atom = 0x3704
+	Noembed                   Atom = 0x6c07
+	Noframes                  Atom = 0x8908
+	Nomodule                  Atom = 0xa208
+	Nonce                     Atom = 0x1a605
+	Noscript                  Atom = 0x21608
+	Novalidate                Atom = 0x2b20a
+	Object                    Atom = 0x26806
+	Ol                        Atom = 0x13702
+	Onabort                   Atom = 0x19507
+	Onafterprint              Atom = 0x2360c
+	Onautocomplete            Atom = 0x2760e
+	Onautocompleteerror       Atom = 0x27613
+	Onauxclick                Atom = 0x61f0a
+	Onbeforeprint             Atom = 0x69e0d
+	Onbeforeunload            Atom = 0x6e70e
+	Onblur                    Atom = 0x56d06
+	Oncancel                  Atom = 0x11908
+	Oncanplay                 Atom = 0x14d09
+	Oncanplaythrough          Atom = 0x14d10
+	Onchange                  Atom = 0x41b08
+	Onclick                   Atom = 0x2f507
+	Onclose                   Atom = 0x36c07
+	Oncontextmenu             Atom = 0x37e0d
+	Oncopy                    Atom = 0x39106
+	Oncuechange               Atom = 0x3970b
+	Oncut                     Atom = 0x3a205
+	Ondblclick                Atom = 0x3a70a
+	Ondrag                    Atom = 0x3b106
+	Ondragend                 Atom = 0x3b109
+	Ondragenter               Atom = 0x3ba0b
+	Ondragexit                Atom = 0x3c50a
+	Ondragleave               Atom = 0x3df0b
+	Ondragover                Atom = 0x3ea0a
+	Ondragstart               Atom = 0x3f40b
+	Ondrop                    Atom = 0x40306
+	Ondurationchange          Atom = 0x41310
+	Onemptied                 Atom = 0x40a09
+	Onended                   Atom = 0x42307
+	Onerror                   Atom = 0x42a07
+	Onfocus                   Atom = 0x43107
+	Onhashchange              Atom = 0x43d0c
+	Oninput                   Atom = 0x44907
+	Oninvalid                 Atom = 0x45509
+	Onkeydown                 Atom = 0x45e09
+	Onkeypress                Atom = 0x46b0a
+	Onkeyup                   Atom = 0x48007
+	Onlanguagechange          Atom = 0x48d10
+	Onload                    Atom = 0x49d06
+	Onloadeddata              Atom = 0x49d0c
+	Onloadedmetadata          Atom = 0x4b010
+	Onloadend                 Atom = 0x4c609
+	Onloadstart               Atom = 0x4cf0b
+	Onmessage                 Atom = 0x4da09
+	Onmessageerror            Atom = 0x4da0e
+	Onmousedown               Atom = 0x4e80b
+	Onmouseenter              Atom = 0x4f30c
+	Onmouseleave              Atom = 0x4ff0c
+	Onmousemove               Atom = 0x50b0b
+	Onmouseout                Atom = 0x5160a
+	Onmouseover               Atom = 0x5230b
+	Onmouseup                 Atom = 0x52e09
+	Onmousewheel              Atom = 0x53c0c
+	Onoffline                 Atom = 0x54809
+	Ononline                  Atom = 0x55108
+	Onpagehide                Atom = 0x5590a
+	Onpageshow                Atom = 0x5730a
+	Onpaste                   Atom = 0x57f07
+	Onpause                   Atom = 0x59a07
+	Onplay                    Atom = 0x5a406
+	Onplaying                 Atom = 0x5a409
+	Onpopstate                Atom = 0x5ad0a
+	Onprogress                Atom = 0x5b70a
+	Onratechange              Atom = 0x5cc0c
+	Onrejectionhandled        Atom = 0x5d812
+	Onreset                   Atom = 0x5ea07
+	Onresize                  Atom = 0x5f108
+	Onscroll                  Atom = 0x60008
+	Onsecuritypolicyviolation Atom = 0x60819
+	Onseeked                  Atom = 0x62908
+	Onseeking                 Atom = 0x63109
+	Onselect                  Atom = 0x63a08
+	Onshow                    Atom = 0x64406
+	Onsort                    Atom = 0x64f06
+	Onstalled                 Atom = 0x65909
+	Onstorage                 Atom = 0x66209
+	Onsubmit                  Atom = 0x66b08
+	Onsuspend                 Atom = 0x67b09
+	Ontimeupdate              Atom = 0x400c
+	Ontoggle                  Atom = 0x68408
+	Onunhandledrejection      Atom = 0x68c14
+	Onunload                  Atom = 0x6ab08
+	Onvolumechange            Atom = 0x6b30e
+	Onwaiting                 Atom = 0x6c109
+	Onwheel                   Atom = 0x6ca07
+	Open                      Atom = 0x1a304
+	Optgroup                  Atom = 0x5f08
+	Optimum                   Atom = 0x6d107
+	Option                    Atom = 0x6e306
+	Output                    Atom = 0x51d06
+	P                         Atom = 0xc01
+	Param                     Atom = 0xc05
+	Pattern                   Atom = 0x6607
+	Picture                   Atom = 0x7b07
+	Ping                      Atom = 0xef04
+	Placeholder               Atom = 0x1310b
+	Plaintext                 Atom = 0x1b209
+	Playsinline               Atom = 0x1400b
+	Poster                    Atom = 0x2cf06
+	Pre                       Atom = 0x47003
+	Preload                   Atom = 0x48607
+	Progress                  Atom = 0x5b908
+	Prompt                    Atom = 0x53606
+	Public                    Atom = 0x58606
+	Q                         Atom = 0xcf01
+	Radiogroup                Atom = 0x30a
+	Rb                        Atom = 0x3a02
+	Readonly                  Atom = 0x35708
+	Referrerpolicy            Atom = 0x3d10e
+	Rel                       Atom = 0x48703
+	Required                  Atom = 0x24c08
+	Reversed                  Atom = 0x8008
+	Rows                      Atom = 0x9c04
+	Rowspan                   Atom = 0x9c07
+	Rp                        Atom = 0x23c02
+	Rt                        Atom = 0x19a02
+	Rtc                       Atom = 0x19a03
+	Ruby                      Atom = 0xfb04
+	S                         Atom = 0x2501
+	Samp                      Atom = 0x7804
+	Sandbox                   Atom = 0x12907
+	Scope                     Atom = 0x67505
+	Scoped                    Atom = 0x67506
+	Script                    Atom = 0x21806
+	Seamless                  Atom = 0x37108
+	Section                   Atom = 0x56807
+	Select                    Atom = 0x63c06
+	Selected                  Atom = 0x63c08
+	Shape                     Atom = 0x1e505
+	Size                      Atom = 0x5f504
+	Sizes                     Atom = 0x5f505
+	Slot                      Atom = 0x1ef04
+	Small                     Atom = 0x20605
+	Sortable                  Atom = 0x65108
+	Sorted                    Atom = 0x33706
+	Source                    Atom = 0x37806
+	Spacer                    Atom = 0x43706
+	Span                      Atom = 0x9f04
+	Spellcheck                Atom = 0x4740a
+	Src                       Atom = 0x5c003
+	Srcdoc                    Atom = 0x5c006
+	Srclang                   Atom = 0x5f907
+	Srcset                    Atom = 0x6f906
+	Start                     Atom = 0x3fa05
+	Step                      Atom = 0x58304
+	Strike                    Atom = 0xd206
+	Strong                    Atom = 0x6dd06
+	Style                     Atom = 0x6ff05
+	Sub                       Atom = 0x66d03
+	Summary                   Atom = 0x70407
+	Sup                       Atom = 0x70b03
+	Svg                       Atom = 0x70e03
+	System                    Atom = 0x71106
+	Tabindex                  Atom = 0x4be08
+	Table                     Atom = 0x59505
+	Target                    Atom = 0x2c406
+	Tbody                     Atom = 0x2705
+	Td                        Atom = 0x9202
+	Template                  Atom = 0x71408
+	Textarea                  Atom = 0x35208
+	Tfoot                     Atom = 0xf505
+	Th                        Atom = 0x15602
+	Thead                     Atom = 0x33005
+	Time                      Atom = 0x4204
+	Title                     Atom = 0x11005
+	Tr                        Atom = 0xcc02
+	Track                     Atom = 0x1ba05
+	Translate                 Atom = 0x1f209
+	Tt                        Atom = 0x6802
+	Type                      Atom = 0xd904
+	Typemustmatch             Atom = 0x2900d
+	U                         Atom = 0xb01
+	Ul                        Atom = 0xa702
+	Updateviacache            Atom = 0x460e
+	Usemap                    Atom = 0x59e06
+	Value                     Atom = 0x1505
+	Var                       Atom = 0x16d03
+	Video                     Atom = 0x2f105
+	Wbr                       Atom = 0x57c03
+	Width                     Atom = 0x64905
+	Workertype                Atom = 0x71c0a
+	Wrap                      Atom = 0x72604
+	Xmp                       Atom = 0x12f03
+)
+
+const hash0 = 0x81cdf10e
+
+const maxAtomLen = 25
+
+var table = [1 << 9]Atom{
+	0x1:   0xe60a,  // mediagroup
+	0x2:   0x2e404, // lang
+	0x4:   0x2c09,  // accesskey
+	0x5:   0x8b08,  // frameset
+	0x7:   0x63a08, // onselect
+	0x8:   0x71106, // system
+	0xa:   0x64905, // width
+	0xc:   0x2890b, // formenctype
+	0xd:   0x13702, // ol
+	0xe:   0x3970b, // oncuechange
+	0x10:  0x14b03, // bdo
+	0x11:  0x11505, // audio
+	0x12:  0x17a09, // draggable
+	0x14:  0x2f105, // video
+	0x15:  0x2b102, // mn
+	0x16:  0x38704, // menu
+	0x17:  0x2cf06, // poster
+	0x19:  0xf606,  // footer
+	0x1a:  0x2a806, // method
+	0x1b:  0x2b808, // datetime
+	0x1c:  0x19507, // onabort
+	0x1d:  0x460e,  // updateviacache
+	0x1e:  0xff05,  // async
+	0x1f:  0x49d06, // onload
+	0x21:  0x11908, // oncancel
+	0x22:  0x62908, // onseeked
+	0x23:  0x30205, // image
+	0x24:  0x5d812, // onrejectionhandled
+	0x26:  0x17404, // link
+	0x27:  0x51d06, // output
+	0x28:  0x33104, // head
+	0x29:  0x4ff0c, // onmouseleave
+	0x2a:  0x57f07, // onpaste
+	0x2b:  0x5a409, // onplaying
+	0x2c:  0x1c407, // colspan
+	0x2f:  0x1bf05, // color
+	0x30:  0x5f504, // size
+	0x31:  0x2e80a, // http-equiv
+	0x33:  0x601,   // i
+	0x34:  0x5590a, // onpagehide
+	0x35:  0x68c14, // onunhandledrejection
+	0x37:  0x42a07, // onerror
+	0x3a:  0x3b08,  // basefont
+	0x3f:  0x1303,  // nav
+	0x40:  0x17704, // kind
+	0x41:  0x35708, // readonly
+	0x42:  0x30806, // mglyph
+	0x44:  0xb202,  // li
+	0x46:  0x2d506, // hidden
+	0x47:  0x70e03, // svg
+	0x48:  0x58304, // step
+	0x49:  0x23f09, // integrity
+	0x4a:  0x58606, // public
+	0x4c:  0x1ab03, // col
+	0x4d:  0x1870a, // blockquote
+	0x4e:  0x34f02, // h5
+	0x50:  0x5b908, // progress
+	0x51:  0x5f505, // sizes
+	0x52:  0x34502, // h4
+	0x56:  0x33005, // thead
+	0x57:  0xd607,  // keytype
+	0x58:  0x5b70a, // onprogress
+	0x59:  0x44b09, // inputmode
+	0x5a:  0x3b109, // ondragend
+	0x5d:  0x3a205, // oncut
+	0x5e:  0x43706, // spacer
+	0x5f:  0x1ab08, // colgroup
+	0x62:  0x16502, // is
+	0x65:  0x3c02,  // as
+	0x66:  0x54809, // onoffline
+	0x67:  0x33706, // sorted
+	0x69:  0x48d10, // onlanguagechange
+	0x6c:  0x43d0c, // onhashchange
+	0x6d:  0x9604,  // name
+	0x6e:  0xf505,  // tfoot
+	0x6f:  0x56104, // desc
+	0x70:  0x33d03, // max
+	0x72:  0x1ea06, // coords
+	0x73:  0x30d02, // h3
+	0x74:  0x6e70e, // onbeforeunload
+	0x75:  0x9c04,  // rows
+	0x76:  0x63c06, // select
+	0x77:  0x9805,  // meter
+	0x78:  0x38b06, // itemid
+	0x79:  0x53c0c, // onmousewheel
+	0x7a:  0x5c006, // srcdoc
+	0x7d:  0x1ba05, // track
+	0x7f:  0x31f08, // itemtype
+	0x82:  0xa402,  // mo
+	0x83:  0x41b08, // onchange
+	0x84:  0x33107, // headers
+	0x85:  0x5cc0c, // onratechange
+	0x86:  0x60819, // onsecuritypolicyviolation
+	0x88:  0x4a508, // datalist
+	0x89:  0x4e80b, // onmousedown
+	0x8a:  0x1ef04, // slot
+	0x8b:  0x4b010, // onloadedmetadata
+	0x8c:  0x1a06,  // accept
+	0x8d:  0x26806, // object
+	0x91:  0x6b30e, // onvolumechange
+	0x92:  0x2107,  // charset
+	0x93:  0x27613, // onautocompleteerror
+	0x94:  0xc113,  // allowpaymentrequest
+	0x95:  0x2804,  // body
+	0x96:  0x10a07, // default
+	0x97:  0x63c08, // selected
+	0x98:  0x21e04, // face
+	0x99:  0x1e505, // shape
+	0x9b:  0x68408, // ontoggle
+	0x9e:  0x64b02, // dt
+	0x9f:  0xb604,  // mark
+	0xa1:  0xb01,   // u
+	0xa4:  0x6ab08, // onunload
+	0xa5:  0x5d04,  // loop
+	0xa6:  0x16408, // disabled
+	0xaa:  0x42307, // onended
+	0xab:  0xb00a,  // malignmark
+	0xad:  0x67b09, // onsuspend
+	0xae:  0x35105, // mtext
+	0xaf:  0x64f06, // onsort
+	0xb0:  0x19d08, // itemprop
+	0xb3:  0x67109, // itemscope
+	0xb4:  0x17305, // blink
+	0xb6:  0x3b106, // ondrag
+	0xb7:  0xa702,  // ul
+	0xb8:  0x26e04, // form
+	0xb9:  0x12907, // sandbox
+	0xba:  0x8b05,  // frame
+	0xbb:  0x1505,  // value
+	0xbc:  0x66209, // onstorage
+	0xbf:  0xaa07,  // acronym
+	0xc0:  0x19a02, // rt
+	0xc2:  0x202,   // br
+	0xc3:  0x22608, // fieldset
+	0xc4:  0x2900d, // typemustmatch
+	0xc5:  0xa208,  // nomodule
+	0xc6:  0x6c07,  // noembed
+	0xc7:  0x69e0d, // onbeforeprint
+	0xc8:  0x19106, // button
+	0xc9:  0x2f507, // onclick
+	0xca:  0x70407, // summary
+	0xcd:  0xfb04,  // ruby
+	0xce:  0x56405, // class
+	0xcf:  0x3f40b, // ondragstart
+	0xd0:  0x23107, // caption
+	0xd4:  0xdd0e,  // allowusermedia
+	0xd5:  0x4cf0b, // onloadstart
+	0xd9:  0x16b03, // div
+	0xda:  0x4a904, // list
+	0xdb:  0x32e04, // math
+	0xdc:  0x44b05, // input
+	0xdf:  0x3ea0a, // ondragover
+	0xe0:  0x2de02, // h2
+	0xe2:  0x1b209, // plaintext
+	0xe4:  0x4f30c, // onmouseenter
+	0xe7:  0x47907, // checked
+	0xe8:  0x47003, // pre
+	0xea:  0x35f08, // multiple
+	0xeb:  0xba03,  // bdi
+	0xec:  0x33d09, // maxlength
+	0xed:  0xcf01,  // q
+	0xee:  0x61f0a, // onauxclick
+	0xf0:  0x57c03, // wbr
+	0xf2:  0x3b04,  // base
+	0xf3:  0x6e306, // option
+	0xf5:  0x41310, // ondurationchange
+	0xf7:  0x8908,  // noframes
+	0xf9:  0x40508, // dropzone
+	0xfb:  0x67505, // scope
+	0xfc:  0x8008,  // reversed
+	0xfd:  0x3ba0b, // ondragenter
+	0xfe:  0x3fa05, // start
+	0xff:  0x12f03, // xmp
+	0x100: 0x5f907, // srclang
+	0x101: 0x30703, // img
+	0x104: 0x101,   // b
+	0x105: 0x25403, // for
+	0x106: 0x10705, // aside
+	0x107: 0x44907, // oninput
+	0x108: 0x35604, // area
+	0x109: 0x2a40a, // formmethod
+	0x10a: 0x72604, // wrap
+	0x10c: 0x23c02, // rp
+	0x10d: 0x46b0a, // onkeypress
+	0x10e: 0x6802,  // tt
+	0x110: 0x34702, // mi
+	0x111: 0x36705, // muted
+	0x112: 0xf303,  // alt
+	0x113: 0x5c504, // code
+	0x114: 0x6e02,  // em
+	0x115: 0x3c50a, // ondragexit
+	0x117: 0x9f04,  // span
+	0x119: 0x6d708, // manifest
+	0x11a: 0x38708, // menuitem
+	0x11b: 0x58b07, // content
+	0x11d: 0x6c109, // onwaiting
+	0x11f: 0x4c609, // onloadend
+	0x121: 0x37e0d, // oncontextmenu
+	0x123: 0x56d06, // onblur
+	0x124: 0x3fc07, // article
+	0x125: 0x9303,  // dir
+	0x126: 0xef04,  // ping
+	0x127: 0x24c08, // required
+	0x128: 0x45509, // oninvalid
+	0x129: 0xb105,  // align
+	0x12b: 0x58a04, // icon
+	0x12c: 0x64d02, // h6
+	0x12d: 0x1c404, // cols
+	0x12e: 0x22e0a, // figcaption
+	0x12f: 0x45e09, // onkeydown
+	0x130: 0x66b08, // onsubmit
+	0x131: 0x14d09, // oncanplay
+	0x132: 0x70b03, // sup
+	0x133: 0xc01,   // p
+	0x135: 0x40a09, // onemptied
+	0x136: 0x39106, // oncopy
+	0x137: 0x19c04, // cite
+	0x138: 0x3a70a, // ondblclick
+	0x13a: 0x50b0b, // onmousemove
+	0x13c: 0x66d03, // sub
+	0x13d: 0x48703, // rel
+	0x13e: 0x5f08,  // optgroup
+	0x142: 0x9c07,  // rowspan
+	0x143: 0x37806, // source
+	0x144: 0x21608, // noscript
+	0x145: 0x1a304, // open
+	0x146: 0x20403, // ins
+	0x147: 0x2540d, // foreignObject
+	0x148: 0x5ad0a, // onpopstate
+	0x14a: 0x28d07, // enctype
+	0x14b: 0x2760e, // onautocomplete
+	0x14c: 0x35208, // textarea
+	0x14e: 0x2780c, // autocomplete
+	0x14f: 0x15702, // hr
+	0x150: 0x1de08, // controls
+	0x151: 0x10902, // id
+	0x153: 0x2360c, // onafterprint
+	0x155: 0x2610d, // foreignobject
+	0x156: 0x32707, // marquee
+	0x157: 0x59a07, // onpause
+	0x158: 0x5e602, // dl
+	0x159: 0x5206,  // height
+	0x15a: 0x34703, // min
+	0x15b: 0x9307,  // dirname
+	0x15c: 0x1f209, // translate
+	0x15d: 0x5604,  // html
+	0x15e: 0x34709, // minlength
+	0x15f: 0x48607, // preload
+	0x160: 0x71408, // template
+	0x161: 0x3df0b, // ondragleave
+	0x162: 0x3a02,  // rb
+	0x164: 0x5c003, // src
+	0x165: 0x6dd06, // strong
+	0x167: 0x7804,  // samp
+	0x168: 0x6f307, // address
+	0x169: 0x55108, // ononline
+	0x16b: 0x1310b, // placeholder
+	0x16c: 0x2c406, // target
+	0x16d: 0x20605, // small
+	0x16e: 0x6ca07, // onwheel
+	0x16f: 0x1c90a, // annotation
+	0x170: 0x4740a, // spellcheck
+	0x171: 0x7207,  // details
+	0x172: 0x10306, // canvas
+	0x173: 0x12109, // autofocus
+	0x174: 0xc05,   // param
+	0x176: 0x46308, // download
+	0x177: 0x45203, // del
+	0x178: 0x36c07, // onclose
+	0x179: 0xb903,  // kbd
+	0x17a: 0x31906, // applet
+	0x17b: 0x2e004, // href
+	0x17c: 0x5f108, // onresize
+	0x17e: 0x49d0c, // onloadeddata
+	0x180: 0xcc02,  // tr
+	0x181: 0x2c00a, // formtarget
+	0x182: 0x11005, // title
+	0x183: 0x6ff05, // style
+	0x184: 0xd206,  // strike
+	0x185: 0x59e06, // usemap
+	0x186: 0x2fc06, // iframe
+	0x187: 0x1004,  // main
+	0x189: 0x7b07,  // picture
+	0x18c: 0x31605, // ismap
+	0x18e: 0x4a504, // data
+	0x18f: 0x5905,  // label
+	0x191: 0x3d10e, // referrerpolicy
+	0x192: 0x15602, // th
+	0x194: 0x53606, // prompt
+	0x195: 0x56807, // section
+	0x197: 0x6d107, // optimum
+	0x198: 0x2db04, // high
+	0x199: 0x15c02, // h1
+	0x19a: 0x65909, // onstalled
+	0x19b: 0x16d03, // var
+	0x19c: 0x4204,  // time
+	0x19e: 0x67402, // ms
+	0x19f: 0x33106, // header
+	0x1a0: 0x4da09, // onmessage
+	0x1a1: 0x1a605, // nonce
+	0x1a2: 0x26e0a, // formaction
+	0x1a3: 0x22006, // center
+	0x1a4: 0x3704,  // nobr
+	0x1a5: 0x59505, // table
+	0x1a6: 0x4a907, // listing
+	0x1a7: 0x18106, // legend
+	0x1a9: 0x29b09, // challenge
+	0x1aa: 0x24806, // figure
+	0x1ab: 0xe605,  // media
+	0x1ae: 0xd904,  // type
+	0x1af: 0x3f04,  // font
+	0x1b0: 0x4da0e, // onmessageerror
+	0x1b1: 0x37108, // seamless
+	0x1b2: 0x8703,  // dfn
+	0x1b3: 0x5c705, // defer
+	0x1b4: 0xc303,  // low
+	0x1b5: 0x19a03, // rtc
+	0x1b6: 0x5230b, // onmouseover
+	0x1b7: 0x2b20a, // novalidate
+	0x1b8: 0x71c0a, // workertype
+	0x1ba: 0x3cd07, // itemref
+	0x1bd: 0x1,     // a
+	0x1be: 0x31803, // map
+	0x1bf: 0x400c,  // ontimeupdate
+	0x1c0: 0x15e07, // bgsound
+	0x1c1: 0x3206,  // keygen
+	0x1c2: 0x2705,  // tbody
+	0x1c5: 0x64406, // onshow
+	0x1c7: 0x2501,  // s
+	0x1c8: 0x6607,  // pattern
+	0x1cc: 0x14d10, // oncanplaythrough
+	0x1ce: 0x2d702, // dd
+	0x1cf: 0x6f906, // srcset
+	0x1d0: 0x17003, // big
+	0x1d2: 0x65108, // sortable
+	0x1d3: 0x48007, // onkeyup
+	0x1d5: 0x5a406, // onplay
+	0x1d7: 0x4b804, // meta
+	0x1d8: 0x40306, // ondrop
+	0x1da: 0x60008, // onscroll
+	0x1db: 0x1fb0b, // crossorigin
+	0x1dc: 0x5730a, // onpageshow
+	0x1dd: 0x4,     // abbr
+	0x1de: 0x9202,  // td
+	0x1df: 0x58b0f, // contenteditable
+	0x1e0: 0x27206, // action
+	0x1e1: 0x1400b, // playsinline
+	0x1e2: 0x43107, // onfocus
+	0x1e3: 0x2e008, // hreflang
+	0x1e5: 0x5160a, // onmouseout
+	0x1e6: 0x5ea07, // onreset
+	0x1e7: 0x13c08, // autoplay
+	0x1e8: 0x63109, // onseeking
+	0x1ea: 0x67506, // scoped
+	0x1ec: 0x30a,   // radiogroup
+	0x1ee: 0x3800b, // contextmenu
+	0x1ef: 0x52e09, // onmouseup
+	0x1f1: 0x2ca06, // hgroup
+	0x1f2: 0x2080f, // allowfullscreen
+	0x1f3: 0x4be08, // tabindex
+	0x1f6: 0x30f07, // isindex
+	0x1f7: 0x1a0e,  // accept-charset
+	0x1f8: 0x2ae0e, // formnovalidate
+	0x1fb: 0x1c90e, // annotation-xml
+	0x1fc: 0x6e05,  // embed
+	0x1fd: 0x21806, // script
+	0x1fe: 0xbb06,  // dialog
+	0x1ff: 0x1d707, // command
+}
+
+const atomText = "abbradiogrouparamainavalueaccept-charsetbodyaccesskeygenobrb" +
+	"asefontimeupdateviacacheightmlabelooptgroupatternoembedetail" +
+	"sampictureversedfnoframesetdirnameterowspanomoduleacronymali" +
+	"gnmarkbdialogallowpaymentrequestrikeytypeallowusermediagroup" +
+	"ingaltfooterubyasyncanvasidefaultitleaudioncancelautofocusan" +
+	"dboxmplaceholderautoplaysinlinebdoncanplaythrough1bgsoundisa" +
+	"bledivarbigblinkindraggablegendblockquotebuttonabortcitempro" +
+	"penoncecolgrouplaintextrackcolorcolspannotation-xmlcommandco" +
+	"ntrolshapecoordslotranslatecrossoriginsmallowfullscreenoscri" +
+	"ptfacenterfieldsetfigcaptionafterprintegrityfigurequiredfore" +
+	"ignObjectforeignobjectformactionautocompleteerrorformenctype" +
+	"mustmatchallengeformmethodformnovalidatetimeformtargethgroup" +
+	"osterhiddenhigh2hreflanghttp-equivideonclickiframeimageimgly" +
+	"ph3isindexismappletitemtypemarqueematheadersortedmaxlength4m" +
+	"inlength5mtextareadonlymultiplemutedoncloseamlessourceoncont" +
+	"extmenuitemidoncopyoncuechangeoncutondblclickondragendondrag" +
+	"enterondragexitemreferrerpolicyondragleaveondragoverondragst" +
+	"articleondropzonemptiedondurationchangeonendedonerroronfocus" +
+	"paceronhashchangeoninputmodeloninvalidonkeydownloadonkeypres" +
+	"spellcheckedonkeyupreloadonlanguagechangeonloadeddatalisting" +
+	"onloadedmetadatabindexonloadendonloadstartonmessageerroronmo" +
+	"usedownonmouseenteronmouseleaveonmousemoveonmouseoutputonmou" +
+	"seoveronmouseupromptonmousewheelonofflineononlineonpagehides" +
+	"classectionbluronpageshowbronpastepublicontenteditableonpaus" +
+	"emaponplayingonpopstateonprogressrcdocodeferonratechangeonre" +
+	"jectionhandledonresetonresizesrclangonscrollonsecuritypolicy" +
+	"violationauxclickonseekedonseekingonselectedonshowidth6onsor" +
+	"tableonstalledonstorageonsubmitemscopedonsuspendontoggleonun" +
+	"handledrejectionbeforeprintonunloadonvolumechangeonwaitingon" +
+	"wheeloptimumanifestrongoptionbeforeunloaddressrcsetstylesumm" +
+	"arysupsvgsystemplateworkertypewrap"
diff --git a/vendor/golang.org/x/net/html/const.go b/vendor/golang.org/x/net/html/const.go
new file mode 100644
index 00000000..a3a918f0
--- /dev/null
+++ b/vendor/golang.org/x/net/html/const.go
@@ -0,0 +1,112 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package html
+
+// Section 12.2.4.2 of the HTML5 specification says "The following elements
+// have varying levels of special parsing rules".
+// https://html.spec.whatwg.org/multipage/syntax.html#the-stack-of-open-elements
+var isSpecialElementMap = map[string]bool{
+	"address":    true,
+	"applet":     true,
+	"area":       true,
+	"article":    true,
+	"aside":      true,
+	"base":       true,
+	"basefont":   true,
+	"bgsound":    true,
+	"blockquote": true,
+	"body":       true,
+	"br":         true,
+	"button":     true,
+	"caption":    true,
+	"center":     true,
+	"col":        true,
+	"colgroup":   true,
+	"dd":         true,
+	"details":    true,
+	"dir":        true,
+	"div":        true,
+	"dl":         true,
+	"dt":         true,
+	"embed":      true,
+	"fieldset":   true,
+	"figcaption": true,
+	"figure":     true,
+	"footer":     true,
+	"form":       true,
+	"frame":      true,
+	"frameset":   true,
+	"h1":         true,
+	"h2":         true,
+	"h3":         true,
+	"h4":         true,
+	"h5":         true,
+	"h6":         true,
+	"head":       true,
+	"header":     true,
+	"hgroup":     true,
+	"hr":         true,
+	"html":       true,
+	"iframe":     true,
+	"img":        true,
+	"input":      true,
+	"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 "math":
+		switch element.Data {
+		case "mi", "mo", "mn", "ms", "mtext", "annotation-xml":
+			return true
+		}
+	case "svg":
+		switch element.Data {
+		case "foreignObject", "desc", "title":
+			return true
+		}
+	}
+	return false
+}
diff --git a/vendor/golang.org/x/net/html/doc.go b/vendor/golang.org/x/net/html/doc.go
new file mode 100644
index 00000000..822ed42a
--- /dev/null
+++ b/vendor/golang.org/x/net/html/doc.go
@@ -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 "&lt;") are unescaped, tag names and attribute keys are
+lower-cased, and attributes are collected into a []Attribute. For example:
+
+	for {
+		if z.Next() == html.ErrorToken {
+			// Returning io.EOF indicates success.
+			return z.Err()
+		}
+		emitToken(z.Token())
+	}
+
+The low-level API performs fewer allocations and copies, but the contents of
+the []byte values returned by Text, TagName and TagAttr may change on the next
+call to Next. For example, to extract an HTML page's anchor text:
+
+	depth := 0
+	for {
+		tt := z.Next()
+		switch tt {
+		case html.ErrorToken:
+			return z.Err()
+		case html.TextToken:
+			if depth > 0 {
+				// emitBytes should copy the []byte it receives,
+				// if it doesn't process it immediately.
+				emitBytes(z.Text())
+			}
+		case html.StartTagToken, html.EndTagToken:
+			tn, _ := z.TagName()
+			if len(tn) == 1 && tn[0] == 'a' {
+				if tt == html.StartTagToken {
+					depth++
+				} else {
+					depth--
+				}
+			}
+		}
+	}
+
+Parsing is done by calling Parse with an io.Reader, which returns the root of
+the parse tree (the document element) as a *Node. It is the caller's
+responsibility to ensure that the Reader provides UTF-8 encoded HTML. For
+example, to process each anchor node in depth-first order:
+
+	doc, err := html.Parse(r)
+	if err != nil {
+		// ...
+	}
+	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?
diff --git a/vendor/golang.org/x/net/html/doctype.go b/vendor/golang.org/x/net/html/doctype.go
new file mode 100644
index 00000000..c484e5a9
--- /dev/null
+++ b/vendor/golang.org/x/net/html/doctype.go
@@ -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//",
+}
diff --git a/vendor/golang.org/x/net/html/entity.go b/vendor/golang.org/x/net/html/entity.go
new file mode 100644
index 00000000..b628880a
--- /dev/null
+++ b/vendor/golang.org/x/net/html/entity.go
@@ -0,0 +1,2253 @@
+// 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
+
+// All entities that do not end with ';' are 6 or fewer bytes long.
+const longestEntityWithoutSemicolon = 6
+
+// entity is a map from HTML entity names to their values. The semicolon matters:
+// https://html.spec.whatwg.org/multipage/syntax.html#named-character-references
+// lists both "amp" and "amp;" as two separate entries.
+//
+// Note that the HTML5 list is larger than the HTML4 list at
+// http://www.w3.org/TR/html4/sgml/entities.html
+var entity = map[string]rune{
+	"AElig;":                           '\U000000C6',
+	"AMP;":                             '\U00000026',
+	"Aacute;":                          '\U000000C1',
+	"Abreve;":                          '\U00000102',
+	"Acirc;":                           '\U000000C2',
+	"Acy;":                             '\U00000410',
+	"Afr;":                             '\U0001D504',
+	"Agrave;":                          '\U000000C0',
+	"Alpha;":                           '\U00000391',
+	"Amacr;":                           '\U00000100',
+	"And;":                             '\U00002A53',
+	"Aogon;":                           '\U00000104',
+	"Aopf;":                            '\U0001D538',
+	"ApplyFunction;":                   '\U00002061',
+	"Aring;":                           '\U000000C5',
+	"Ascr;":                            '\U0001D49C',
+	"Assign;":                          '\U00002254',
+	"Atilde;":                          '\U000000C3',
+	"Auml;":                            '\U000000C4',
+	"Backslash;":                       '\U00002216',
+	"Barv;":                            '\U00002AE7',
+	"Barwed;":                          '\U00002306',
+	"Bcy;":                             '\U00000411',
+	"Because;":                         '\U00002235',
+	"Bernoullis;":                      '\U0000212C',
+	"Beta;":                            '\U00000392',
+	"Bfr;":                             '\U0001D505',
+	"Bopf;":                            '\U0001D539',
+	"Breve;":                           '\U000002D8',
+	"Bscr;":                            '\U0000212C',
+	"Bumpeq;":                          '\U0000224E',
+	"CHcy;":                            '\U00000427',
+	"COPY;":                            '\U000000A9',
+	"Cacute;":                          '\U00000106',
+	"Cap;":                             '\U000022D2',
+	"CapitalDifferentialD;":            '\U00002145',
+	"Cayleys;":                         '\U0000212D',
+	"Ccaron;":                          '\U0000010C',
+	"Ccedil;":                          '\U000000C7',
+	"Ccirc;":                           '\U00000108',
+	"Cconint;":                         '\U00002230',
+	"Cdot;":                            '\U0000010A',
+	"Cedilla;":                         '\U000000B8',
+	"CenterDot;":                       '\U000000B7',
+	"Cfr;":                             '\U0000212D',
+	"Chi;":                             '\U000003A7',
+	"CircleDot;":                       '\U00002299',
+	"CircleMinus;":                     '\U00002296',
+	"CirclePlus;":                      '\U00002295',
+	"CircleTimes;":                     '\U00002297',
+	"ClockwiseContourIntegral;":        '\U00002232',
+	"CloseCurlyDoubleQuote;":           '\U0000201D',
+	"CloseCurlyQuote;":                 '\U00002019',
+	"Colon;":                           '\U00002237',
+	"Colone;":                          '\U00002A74',
+	"Congruent;":                       '\U00002261',
+	"Conint;":                          '\U0000222F',
+	"ContourIntegral;":                 '\U0000222E',
+	"Copf;":                            '\U00002102',
+	"Coproduct;":                       '\U00002210',
+	"CounterClockwiseContourIntegral;": '\U00002233',
+	"Cross;":                           '\U00002A2F',
+	"Cscr;":                            '\U0001D49E',
+	"Cup;":                             '\U000022D3',
+	"CupCap;":                          '\U0000224D',
+	"DD;":                              '\U00002145',
+	"DDotrahd;":                        '\U00002911',
+	"DJcy;":                            '\U00000402',
+	"DScy;":                            '\U00000405',
+	"DZcy;":                            '\U0000040F',
+	"Dagger;":                          '\U00002021',
+	"Darr;":                            '\U000021A1',
+	"Dashv;":                           '\U00002AE4',
+	"Dcaron;":                          '\U0000010E',
+	"Dcy;":                             '\U00000414',
+	"Del;":                             '\U00002207',
+	"Delta;":                           '\U00000394',
+	"Dfr;":                             '\U0001D507',
+	"DiacriticalAcute;":                '\U000000B4',
+	"DiacriticalDot;":                  '\U000002D9',
+	"DiacriticalDoubleAcute;":          '\U000002DD',
+	"DiacriticalGrave;":                '\U00000060',
+	"DiacriticalTilde;":                '\U000002DC',
+	"Diamond;":                         '\U000022C4',
+	"DifferentialD;":                   '\U00002146',
+	"Dopf;":                            '\U0001D53B',
+	"Dot;":                             '\U000000A8',
+	"DotDot;":                          '\U000020DC',
+	"DotEqual;":                        '\U00002250',
+	"DoubleContourIntegral;":           '\U0000222F',
+	"DoubleDot;":                       '\U000000A8',
+	"DoubleDownArrow;":                 '\U000021D3',
+	"DoubleLeftArrow;":                 '\U000021D0',
+	"DoubleLeftRightArrow;":            '\U000021D4',
+	"DoubleLeftTee;":                   '\U00002AE4',
+	"DoubleLongLeftArrow;":             '\U000027F8',
+	"DoubleLongLeftRightArrow;":        '\U000027FA',
+	"DoubleLongRightArrow;":            '\U000027F9',
+	"DoubleRightArrow;":                '\U000021D2',
+	"DoubleRightTee;":                  '\U000022A8',
+	"DoubleUpArrow;":                   '\U000021D1',
+	"DoubleUpDownArrow;":               '\U000021D5',
+	"DoubleVerticalBar;":               '\U00002225',
+	"DownArrow;":                       '\U00002193',
+	"DownArrowBar;":                    '\U00002913',
+	"DownArrowUpArrow;":                '\U000021F5',
+	"DownBreve;":                       '\U00000311',
+	"DownLeftRightVector;":             '\U00002950',
+	"DownLeftTeeVector;":               '\U0000295E',
+	"DownLeftVector;":                  '\U000021BD',
+	"DownLeftVectorBar;":               '\U00002956',
+	"DownRightTeeVector;":              '\U0000295F',
+	"DownRightVector;":                 '\U000021C1',
+	"DownRightVectorBar;":              '\U00002957',
+	"DownTee;":                         '\U000022A4',
+	"DownTeeArrow;":                    '\U000021A7',
+	"Downarrow;":                       '\U000021D3',
+	"Dscr;":                            '\U0001D49F',
+	"Dstrok;":                          '\U00000110',
+	"ENG;":                             '\U0000014A',
+	"ETH;":                             '\U000000D0',
+	"Eacute;":                          '\U000000C9',
+	"Ecaron;":                          '\U0000011A',
+	"Ecirc;":                           '\U000000CA',
+	"Ecy;":                             '\U0000042D',
+	"Edot;":                            '\U00000116',
+	"Efr;":                             '\U0001D508',
+	"Egrave;":                          '\U000000C8',
+	"Element;":                         '\U00002208',
+	"Emacr;":                           '\U00000112',
+	"EmptySmallSquare;":                '\U000025FB',
+	"EmptyVerySmallSquare;":            '\U000025AB',
+	"Eogon;":                           '\U00000118',
+	"Eopf;":                            '\U0001D53C',
+	"Epsilon;":                         '\U00000395',
+	"Equal;":                           '\U00002A75',
+	"EqualTilde;":                      '\U00002242',
+	"Equilibrium;":                     '\U000021CC',
+	"Escr;":                            '\U00002130',
+	"Esim;":                            '\U00002A73',
+	"Eta;":                             '\U00000397',
+	"Euml;":                            '\U000000CB',
+	"Exists;":                          '\U00002203',
+	"ExponentialE;":                    '\U00002147',
+	"Fcy;":                             '\U00000424',
+	"Ffr;":                             '\U0001D509',
+	"FilledSmallSquare;":               '\U000025FC',
+	"FilledVerySmallSquare;":           '\U000025AA',
+	"Fopf;":                            '\U0001D53D',
+	"ForAll;":                          '\U00002200',
+	"Fouriertrf;":                      '\U00002131',
+	"Fscr;":                            '\U00002131',
+	"GJcy;":                            '\U00000403',
+	"GT;":                              '\U0000003E',
+	"Gamma;":                           '\U00000393',
+	"Gammad;":                          '\U000003DC',
+	"Gbreve;":                          '\U0000011E',
+	"Gcedil;":                          '\U00000122',
+	"Gcirc;":                           '\U0000011C',
+	"Gcy;":                             '\U00000413',
+	"Gdot;":                            '\U00000120',
+	"Gfr;":                             '\U0001D50A',
+	"Gg;":                              '\U000022D9',
+	"Gopf;":                            '\U0001D53E',
+	"GreaterEqual;":                    '\U00002265',
+	"GreaterEqualLess;":                '\U000022DB',
+	"GreaterFullEqual;":                '\U00002267',
+	"GreaterGreater;":                  '\U00002AA2',
+	"GreaterLess;":                     '\U00002277',
+	"GreaterSlantEqual;":               '\U00002A7E',
+	"GreaterTilde;":                    '\U00002273',
+	"Gscr;":                            '\U0001D4A2',
+	"Gt;":                              '\U0000226B',
+	"HARDcy;":                          '\U0000042A',
+	"Hacek;":                           '\U000002C7',
+	"Hat;":                             '\U0000005E',
+	"Hcirc;":                           '\U00000124',
+	"Hfr;":                             '\U0000210C',
+	"HilbertSpace;":                    '\U0000210B',
+	"Hopf;":                            '\U0000210D',
+	"HorizontalLine;":                  '\U00002500',
+	"Hscr;":                            '\U0000210B',
+	"Hstrok;":                          '\U00000126',
+	"HumpDownHump;":                    '\U0000224E',
+	"HumpEqual;":                       '\U0000224F',
+	"IEcy;":                            '\U00000415',
+	"IJlig;":                           '\U00000132',
+	"IOcy;":                            '\U00000401',
+	"Iacute;":                          '\U000000CD',
+	"Icirc;":                           '\U000000CE',
+	"Icy;":                             '\U00000418',
+	"Idot;":                            '\U00000130',
+	"Ifr;":                             '\U00002111',
+	"Igrave;":                          '\U000000CC',
+	"Im;":                              '\U00002111',
+	"Imacr;":                           '\U0000012A',
+	"ImaginaryI;":                      '\U00002148',
+	"Implies;":                         '\U000021D2',
+	"Int;":                             '\U0000222C',
+	"Integral;":                        '\U0000222B',
+	"Intersection;":                    '\U000022C2',
+	"InvisibleComma;":                  '\U00002063',
+	"InvisibleTimes;":                  '\U00002062',
+	"Iogon;":                           '\U0000012E',
+	"Iopf;":                            '\U0001D540',
+	"Iota;":                            '\U00000399',
+	"Iscr;":                            '\U00002110',
+	"Itilde;":                          '\U00000128',
+	"Iukcy;":                           '\U00000406',
+	"Iuml;":                            '\U000000CF',
+	"Jcirc;":                           '\U00000134',
+	"Jcy;":                             '\U00000419',
+	"Jfr;":                             '\U0001D50D',
+	"Jopf;":                            '\U0001D541',
+	"Jscr;":                            '\U0001D4A5',
+	"Jsercy;":                          '\U00000408',
+	"Jukcy;":                           '\U00000404',
+	"KHcy;":                            '\U00000425',
+	"KJcy;":                            '\U0000040C',
+	"Kappa;":                           '\U0000039A',
+	"Kcedil;":                          '\U00000136',
+	"Kcy;":                             '\U0000041A',
+	"Kfr;":                             '\U0001D50E',
+	"Kopf;":                            '\U0001D542',
+	"Kscr;":                            '\U0001D4A6',
+	"LJcy;":                            '\U00000409',
+	"LT;":                              '\U0000003C',
+	"Lacute;":                          '\U00000139',
+	"Lambda;":                          '\U0000039B',
+	"Lang;":                            '\U000027EA',
+	"Laplacetrf;":                      '\U00002112',
+	"Larr;":                            '\U0000219E',
+	"Lcaron;":                          '\U0000013D',
+	"Lcedil;":                          '\U0000013B',
+	"Lcy;":                             '\U0000041B',
+	"LeftAngleBracket;":                '\U000027E8',
+	"LeftArrow;":                       '\U00002190',
+	"LeftArrowBar;":                    '\U000021E4',
+	"LeftArrowRightArrow;":             '\U000021C6',
+	"LeftCeiling;":                     '\U00002308',
+	"LeftDoubleBracket;":               '\U000027E6',
+	"LeftDownTeeVector;":               '\U00002961',
+	"LeftDownVector;":                  '\U000021C3',
+	"LeftDownVectorBar;":               '\U00002959',
+	"LeftFloor;":                       '\U0000230A',
+	"LeftRightArrow;":                  '\U00002194',
+	"LeftRightVector;":                 '\U0000294E',
+	"LeftTee;":                         '\U000022A3',
+	"LeftTeeArrow;":                    '\U000021A4',
+	"LeftTeeVector;":                   '\U0000295A',
+	"LeftTriangle;":                    '\U000022B2',
+	"LeftTriangleBar;":                 '\U000029CF',
+	"LeftTriangleEqual;":               '\U000022B4',
+	"LeftUpDownVector;":                '\U00002951',
+	"LeftUpTeeVector;":                 '\U00002960',
+	"LeftUpVector;":                    '\U000021BF',
+	"LeftUpVectorBar;":                 '\U00002958',
+	"LeftVector;":                      '\U000021BC',
+	"LeftVectorBar;":                   '\U00002952',
+	"Leftarrow;":                       '\U000021D0',
+	"Leftrightarrow;":                  '\U000021D4',
+	"LessEqualGreater;":                '\U000022DA',
+	"LessFullEqual;":                   '\U00002266',
+	"LessGreater;":                     '\U00002276',
+	"LessLess;":                        '\U00002AA1',
+	"LessSlantEqual;":                  '\U00002A7D',
+	"LessTilde;":                       '\U00002272',
+	"Lfr;":                             '\U0001D50F',
+	"Ll;":                              '\U000022D8',
+	"Lleftarrow;":                      '\U000021DA',
+	"Lmidot;":                          '\U0000013F',
+	"LongLeftArrow;":                   '\U000027F5',
+	"LongLeftRightArrow;":              '\U000027F7',
+	"LongRightArrow;":                  '\U000027F6',
+	"Longleftarrow;":                   '\U000027F8',
+	"Longleftrightarrow;":              '\U000027FA',
+	"Longrightarrow;":                  '\U000027F9',
+	"Lopf;":                            '\U0001D543',
+	"LowerLeftArrow;":                  '\U00002199',
+	"LowerRightArrow;":                 '\U00002198',
+	"Lscr;":                            '\U00002112',
+	"Lsh;":                             '\U000021B0',
+	"Lstrok;":                          '\U00000141',
+	"Lt;":                              '\U0000226A',
+	"Map;":                             '\U00002905',
+	"Mcy;":                             '\U0000041C',
+	"MediumSpace;":                     '\U0000205F',
+	"Mellintrf;":                       '\U00002133',
+	"Mfr;":                             '\U0001D510',
+	"MinusPlus;":                       '\U00002213',
+	"Mopf;":                            '\U0001D544',
+	"Mscr;":                            '\U00002133',
+	"Mu;":                              '\U0000039C',
+	"NJcy;":                            '\U0000040A',
+	"Nacute;":                          '\U00000143',
+	"Ncaron;":                          '\U00000147',
+	"Ncedil;":                          '\U00000145',
+	"Ncy;":                             '\U0000041D',
+	"NegativeMediumSpace;":             '\U0000200B',
+	"NegativeThickSpace;":              '\U0000200B',
+	"NegativeThinSpace;":               '\U0000200B',
+	"NegativeVeryThinSpace;":           '\U0000200B',
+	"NestedGreaterGreater;":            '\U0000226B',
+	"NestedLessLess;":                  '\U0000226A',
+	"NewLine;":                         '\U0000000A',
+	"Nfr;":                             '\U0001D511',
+	"NoBreak;":                         '\U00002060',
+	"NonBreakingSpace;":                '\U000000A0',
+	"Nopf;":                            '\U00002115',
+	"Not;":                             '\U00002AEC',
+	"NotCongruent;":                    '\U00002262',
+	"NotCupCap;":                       '\U0000226D',
+	"NotDoubleVerticalBar;":            '\U00002226',
+	"NotElement;":                      '\U00002209',
+	"NotEqual;":                        '\U00002260',
+	"NotExists;":                       '\U00002204',
+	"NotGreater;":                      '\U0000226F',
+	"NotGreaterEqual;":                 '\U00002271',
+	"NotGreaterLess;":                  '\U00002279',
+	"NotGreaterTilde;":                 '\U00002275',
+	"NotLeftTriangle;":                 '\U000022EA',
+	"NotLeftTriangleEqual;":            '\U000022EC',
+	"NotLess;":                         '\U0000226E',
+	"NotLessEqual;":                    '\U00002270',
+	"NotLessGreater;":                  '\U00002278',
+	"NotLessTilde;":                    '\U00002274',
+	"NotPrecedes;":                     '\U00002280',
+	"NotPrecedesSlantEqual;":           '\U000022E0',
+	"NotReverseElement;":               '\U0000220C',
+	"NotRightTriangle;":                '\U000022EB',
+	"NotRightTriangleEqual;":           '\U000022ED',
+	"NotSquareSubsetEqual;":            '\U000022E2',
+	"NotSquareSupersetEqual;":          '\U000022E3',
+	"NotSubsetEqual;":                  '\U00002288',
+	"NotSucceeds;":                     '\U00002281',
+	"NotSucceedsSlantEqual;":           '\U000022E1',
+	"NotSupersetEqual;":                '\U00002289',
+	"NotTilde;":                        '\U00002241',
+	"NotTildeEqual;":                   '\U00002244',
+	"NotTildeFullEqual;":               '\U00002247',
+	"NotTildeTilde;":                   '\U00002249',
+	"NotVerticalBar;":                  '\U00002224',
+	"Nscr;":                            '\U0001D4A9',
+	"Ntilde;":                          '\U000000D1',
+	"Nu;":                              '\U0000039D',
+	"OElig;":                           '\U00000152',
+	"Oacute;":                          '\U000000D3',
+	"Ocirc;":                           '\U000000D4',
+	"Ocy;":                             '\U0000041E',
+	"Odblac;":                          '\U00000150',
+	"Ofr;":                             '\U0001D512',
+	"Ograve;":                          '\U000000D2',
+	"Omacr;":                           '\U0000014C',
+	"Omega;":                           '\U000003A9',
+	"Omicron;":                         '\U0000039F',
+	"Oopf;":                            '\U0001D546',
+	"OpenCurlyDoubleQuote;":            '\U0000201C',
+	"OpenCurlyQuote;":                  '\U00002018',
+	"Or;":                              '\U00002A54',
+	"Oscr;":                            '\U0001D4AA',
+	"Oslash;":                          '\U000000D8',
+	"Otilde;":                          '\U000000D5',
+	"Otimes;":                          '\U00002A37',
+	"Ouml;":                            '\U000000D6',
+	"OverBar;":                         '\U0000203E',
+	"OverBrace;":                       '\U000023DE',
+	"OverBracket;":                     '\U000023B4',
+	"OverParenthesis;":                 '\U000023DC',
+	"PartialD;":                        '\U00002202',
+	"Pcy;":                             '\U0000041F',
+	"Pfr;":                             '\U0001D513',
+	"Phi;":                             '\U000003A6',
+	"Pi;":                              '\U000003A0',
+	"PlusMinus;":                       '\U000000B1',
+	"Poincareplane;":                   '\U0000210C',
+	"Popf;":                            '\U00002119',
+	"Pr;":                              '\U00002ABB',
+	"Precedes;":                        '\U0000227A',
+	"PrecedesEqual;":                   '\U00002AAF',
+	"PrecedesSlantEqual;":              '\U0000227C',
+	"PrecedesTilde;":                   '\U0000227E',
+	"Prime;":                           '\U00002033',
+	"Product;":                         '\U0000220F',
+	"Proportion;":                      '\U00002237',
+	"Proportional;":                    '\U0000221D',
+	"Pscr;":                            '\U0001D4AB',
+	"Psi;":                             '\U000003A8',
+	"QUOT;":                            '\U00000022',
+	"Qfr;":                             '\U0001D514',
+	"Qopf;":                            '\U0000211A',
+	"Qscr;":                            '\U0001D4AC',
+	"RBarr;":                           '\U00002910',
+	"REG;":                             '\U000000AE',
+	"Racute;":                          '\U00000154',
+	"Rang;":                            '\U000027EB',
+	"Rarr;":                            '\U000021A0',
+	"Rarrtl;":                          '\U00002916',
+	"Rcaron;":                          '\U00000158',
+	"Rcedil;":                          '\U00000156',
+	"Rcy;":                             '\U00000420',
+	"Re;":                              '\U0000211C',
+	"ReverseElement;":                  '\U0000220B',
+	"ReverseEquilibrium;":              '\U000021CB',
+	"ReverseUpEquilibrium;":            '\U0000296F',
+	"Rfr;":                             '\U0000211C',
+	"Rho;":                             '\U000003A1',
+	"RightAngleBracket;":               '\U000027E9',
+	"RightArrow;":                      '\U00002192',
+	"RightArrowBar;":                   '\U000021E5',
+	"RightArrowLeftArrow;":             '\U000021C4',
+	"RightCeiling;":                    '\U00002309',
+	"RightDoubleBracket;":              '\U000027E7',
+	"RightDownTeeVector;":              '\U0000295D',
+	"RightDownVector;":                 '\U000021C2',
+	"RightDownVectorBar;":              '\U00002955',
+	"RightFloor;":                      '\U0000230B',
+	"RightTee;":                        '\U000022A2',
+	"RightTeeArrow;":                   '\U000021A6',
+	"RightTeeVector;":                  '\U0000295B',
+	"RightTriangle;":                   '\U000022B3',
+	"RightTriangleBar;":                '\U000029D0',
+	"RightTriangleEqual;":              '\U000022B5',
+	"RightUpDownVector;":               '\U0000294F',
+	"RightUpTeeVector;":                '\U0000295C',
+	"RightUpVector;":                   '\U000021BE',
+	"RightUpVectorBar;":                '\U00002954',
+	"RightVector;":                     '\U000021C0',
+	"RightVectorBar;":                  '\U00002953',
+	"Rightarrow;":                      '\U000021D2',
+	"Ropf;":                            '\U0000211D',
+	"RoundImplies;":                    '\U00002970',
+	"Rrightarrow;":                     '\U000021DB',
+	"Rscr;":                            '\U0000211B',
+	"Rsh;":                             '\U000021B1',
+	"RuleDelayed;":                     '\U000029F4',
+	"SHCHcy;":                          '\U00000429',
+	"SHcy;":                            '\U00000428',
+	"SOFTcy;":                          '\U0000042C',
+	"Sacute;":                          '\U0000015A',
+	"Sc;":                              '\U00002ABC',
+	"Scaron;":                          '\U00000160',
+	"Scedil;":                          '\U0000015E',
+	"Scirc;":                           '\U0000015C',
+	"Scy;":                             '\U00000421',
+	"Sfr;":                             '\U0001D516',
+	"ShortDownArrow;":                  '\U00002193',
+	"ShortLeftArrow;":                  '\U00002190',
+	"ShortRightArrow;":                 '\U00002192',
+	"ShortUpArrow;":                    '\U00002191',
+	"Sigma;":                           '\U000003A3',
+	"SmallCircle;":                     '\U00002218',
+	"Sopf;":                            '\U0001D54A',
+	"Sqrt;":                            '\U0000221A',
+	"Square;":                          '\U000025A1',
+	"SquareIntersection;":              '\U00002293',
+	"SquareSubset;":                    '\U0000228F',
+	"SquareSubsetEqual;":               '\U00002291',
+	"SquareSuperset;":                  '\U00002290',
+	"SquareSupersetEqual;":             '\U00002292',
+	"SquareUnion;":                     '\U00002294',
+	"Sscr;":                            '\U0001D4AE',
+	"Star;":                            '\U000022C6',
+	"Sub;":                             '\U000022D0',
+	"Subset;":                          '\U000022D0',
+	"SubsetEqual;":                     '\U00002286',
+	"Succeeds;":                        '\U0000227B',
+	"SucceedsEqual;":                   '\U00002AB0',
+	"SucceedsSlantEqual;":              '\U0000227D',
+	"SucceedsTilde;":                   '\U0000227F',
+	"SuchThat;":                        '\U0000220B',
+	"Sum;":                             '\U00002211',
+	"Sup;":                             '\U000022D1',
+	"Superset;":                        '\U00002283',
+	"SupersetEqual;":                   '\U00002287',
+	"Supset;":                          '\U000022D1',
+	"THORN;":                           '\U000000DE',
+	"TRADE;":                           '\U00002122',
+	"TSHcy;":                           '\U0000040B',
+	"TScy;":                            '\U00000426',
+	"Tab;":                             '\U00000009',
+	"Tau;":                             '\U000003A4',
+	"Tcaron;":                          '\U00000164',
+	"Tcedil;":                          '\U00000162',
+	"Tcy;":                             '\U00000422',
+	"Tfr;":                             '\U0001D517',
+	"Therefore;":                       '\U00002234',
+	"Theta;":                           '\U00000398',
+	"ThinSpace;":                       '\U00002009',
+	"Tilde;":                           '\U0000223C',
+	"TildeEqual;":                      '\U00002243',
+	"TildeFullEqual;":                  '\U00002245',
+	"TildeTilde;":                      '\U00002248',
+	"Topf;":                            '\U0001D54B',
+	"TripleDot;":                       '\U000020DB',
+	"Tscr;":                            '\U0001D4AF',
+	"Tstrok;":                          '\U00000166',
+	"Uacute;":                          '\U000000DA',
+	"Uarr;":                            '\U0000219F',
+	"Uarrocir;":                        '\U00002949',
+	"Ubrcy;":                           '\U0000040E',
+	"Ubreve;":                          '\U0000016C',
+	"Ucirc;":                           '\U000000DB',
+	"Ucy;":                             '\U00000423',
+	"Udblac;":                          '\U00000170',
+	"Ufr;":                             '\U0001D518',
+	"Ugrave;":                          '\U000000D9',
+	"Umacr;":                           '\U0000016A',
+	"UnderBar;":                        '\U0000005F',
+	"UnderBrace;":                      '\U000023DF',
+	"UnderBracket;":                    '\U000023B5',
+	"UnderParenthesis;":                '\U000023DD',
+	"Union;":                           '\U000022C3',
+	"UnionPlus;":                       '\U0000228E',
+	"Uogon;":                           '\U00000172',
+	"Uopf;":                            '\U0001D54C',
+	"UpArrow;":                         '\U00002191',
+	"UpArrowBar;":                      '\U00002912',
+	"UpArrowDownArrow;":                '\U000021C5',
+	"UpDownArrow;":                     '\U00002195',
+	"UpEquilibrium;":                   '\U0000296E',
+	"UpTee;":                           '\U000022A5',
+	"UpTeeArrow;":                      '\U000021A5',
+	"Uparrow;":                         '\U000021D1',
+	"Updownarrow;":                     '\U000021D5',
+	"UpperLeftArrow;":                  '\U00002196',
+	"UpperRightArrow;":                 '\U00002197',
+	"Upsi;":                            '\U000003D2',
+	"Upsilon;":                         '\U000003A5',
+	"Uring;":                           '\U0000016E',
+	"Uscr;":                            '\U0001D4B0',
+	"Utilde;":                          '\U00000168',
+	"Uuml;":                            '\U000000DC',
+	"VDash;":                           '\U000022AB',
+	"Vbar;":                            '\U00002AEB',
+	"Vcy;":                             '\U00000412',
+	"Vdash;":                           '\U000022A9',
+	"Vdashl;":                          '\U00002AE6',
+	"Vee;":                             '\U000022C1',
+	"Verbar;":                          '\U00002016',
+	"Vert;":                            '\U00002016',
+	"VerticalBar;":                     '\U00002223',
+	"VerticalLine;":                    '\U0000007C',
+	"VerticalSeparator;":               '\U00002758',
+	"VerticalTilde;":                   '\U00002240',
+	"VeryThinSpace;":                   '\U0000200A',
+	"Vfr;":                             '\U0001D519',
+	"Vopf;":                            '\U0001D54D',
+	"Vscr;":                            '\U0001D4B1',
+	"Vvdash;":                          '\U000022AA',
+	"Wcirc;":                           '\U00000174',
+	"Wedge;":                           '\U000022C0',
+	"Wfr;":                             '\U0001D51A',
+	"Wopf;":                            '\U0001D54E',
+	"Wscr;":                            '\U0001D4B2',
+	"Xfr;":                             '\U0001D51B',
+	"Xi;":                              '\U0000039E',
+	"Xopf;":                            '\U0001D54F',
+	"Xscr;":                            '\U0001D4B3',
+	"YAcy;":                            '\U0000042F',
+	"YIcy;":                            '\U00000407',
+	"YUcy;":                            '\U0000042E',
+	"Yacute;":                          '\U000000DD',
+	"Ycirc;":                           '\U00000176',
+	"Ycy;":                             '\U0000042B',
+	"Yfr;":                             '\U0001D51C',
+	"Yopf;":                            '\U0001D550',
+	"Yscr;":                            '\U0001D4B4',
+	"Yuml;":                            '\U00000178',
+	"ZHcy;":                            '\U00000416',
+	"Zacute;":                          '\U00000179',
+	"Zcaron;":                          '\U0000017D',
+	"Zcy;":                             '\U00000417',
+	"Zdot;":                            '\U0000017B',
+	"ZeroWidthSpace;":                  '\U0000200B',
+	"Zeta;":                            '\U00000396',
+	"Zfr;":                             '\U00002128',
+	"Zopf;":                            '\U00002124',
+	"Zscr;":                            '\U0001D4B5',
+	"aacute;":                          '\U000000E1',
+	"abreve;":                          '\U00000103',
+	"ac;":                              '\U0000223E',
+	"acd;":                             '\U0000223F',
+	"acirc;":                           '\U000000E2',
+	"acute;":                           '\U000000B4',
+	"acy;":                             '\U00000430',
+	"aelig;":                           '\U000000E6',
+	"af;":                              '\U00002061',
+	"afr;":                             '\U0001D51E',
+	"agrave;":                          '\U000000E0',
+	"alefsym;":                         '\U00002135',
+	"aleph;":                           '\U00002135',
+	"alpha;":                           '\U000003B1',
+	"amacr;":                           '\U00000101',
+	"amalg;":                           '\U00002A3F',
+	"amp;":                             '\U00000026',
+	"and;":                             '\U00002227',
+	"andand;":                          '\U00002A55',
+	"andd;":                            '\U00002A5C',
+	"andslope;":                        '\U00002A58',
+	"andv;":                            '\U00002A5A',
+	"ang;":                             '\U00002220',
+	"ange;":                            '\U000029A4',
+	"angle;":                           '\U00002220',
+	"angmsd;":                          '\U00002221',
+	"angmsdaa;":                        '\U000029A8',
+	"angmsdab;":                        '\U000029A9',
+	"angmsdac;":                        '\U000029AA',
+	"angmsdad;":                        '\U000029AB',
+	"angmsdae;":                        '\U000029AC',
+	"angmsdaf;":                        '\U000029AD',
+	"angmsdag;":                        '\U000029AE',
+	"angmsdah;":                        '\U000029AF',
+	"angrt;":                           '\U0000221F',
+	"angrtvb;":                         '\U000022BE',
+	"angrtvbd;":                        '\U0000299D',
+	"angsph;":                          '\U00002222',
+	"angst;":                           '\U000000C5',
+	"angzarr;":                         '\U0000237C',
+	"aogon;":                           '\U00000105',
+	"aopf;":                            '\U0001D552',
+	"ap;":                              '\U00002248',
+	"apE;":                             '\U00002A70',
+	"apacir;":                          '\U00002A6F',
+	"ape;":                             '\U0000224A',
+	"apid;":                            '\U0000224B',
+	"apos;":                            '\U00000027',
+	"approx;":                          '\U00002248',
+	"approxeq;":                        '\U0000224A',
+	"aring;":                           '\U000000E5',
+	"ascr;":                            '\U0001D4B6',
+	"ast;":                             '\U0000002A',
+	"asymp;":                           '\U00002248',
+	"asympeq;":                         '\U0000224D',
+	"atilde;":                          '\U000000E3',
+	"auml;":                            '\U000000E4',
+	"awconint;":                        '\U00002233',
+	"awint;":                           '\U00002A11',
+	"bNot;":                            '\U00002AED',
+	"backcong;":                        '\U0000224C',
+	"backepsilon;":                     '\U000003F6',
+	"backprime;":                       '\U00002035',
+	"backsim;":                         '\U0000223D',
+	"backsimeq;":                       '\U000022CD',
+	"barvee;":                          '\U000022BD',
+	"barwed;":                          '\U00002305',
+	"barwedge;":                        '\U00002305',
+	"bbrk;":                            '\U000023B5',
+	"bbrktbrk;":                        '\U000023B6',
+	"bcong;":                           '\U0000224C',
+	"bcy;":                             '\U00000431',
+	"bdquo;":                           '\U0000201E',
+	"becaus;":                          '\U00002235',
+	"because;":                         '\U00002235',
+	"bemptyv;":                         '\U000029B0',
+	"bepsi;":                           '\U000003F6',
+	"bernou;":                          '\U0000212C',
+	"beta;":                            '\U000003B2',
+	"beth;":                            '\U00002136',
+	"between;":                         '\U0000226C',
+	"bfr;":                             '\U0001D51F',
+	"bigcap;":                          '\U000022C2',
+	"bigcirc;":                         '\U000025EF',
+	"bigcup;":                          '\U000022C3',
+	"bigodot;":                         '\U00002A00',
+	"bigoplus;":                        '\U00002A01',
+	"bigotimes;":                       '\U00002A02',
+	"bigsqcup;":                        '\U00002A06',
+	"bigstar;":                         '\U00002605',
+	"bigtriangledown;":                 '\U000025BD',
+	"bigtriangleup;":                   '\U000025B3',
+	"biguplus;":                        '\U00002A04',
+	"bigvee;":                          '\U000022C1',
+	"bigwedge;":                        '\U000022C0',
+	"bkarow;":                          '\U0000290D',
+	"blacklozenge;":                    '\U000029EB',
+	"blacksquare;":                     '\U000025AA',
+	"blacktriangle;":                   '\U000025B4',
+	"blacktriangledown;":               '\U000025BE',
+	"blacktriangleleft;":               '\U000025C2',
+	"blacktriangleright;":              '\U000025B8',
+	"blank;":                           '\U00002423',
+	"blk12;":                           '\U00002592',
+	"blk14;":                           '\U00002591',
+	"blk34;":                           '\U00002593',
+	"block;":                           '\U00002588',
+	"bnot;":                            '\U00002310',
+	"bopf;":                            '\U0001D553',
+	"bot;":                             '\U000022A5',
+	"bottom;":                          '\U000022A5',
+	"bowtie;":                          '\U000022C8',
+	"boxDL;":                           '\U00002557',
+	"boxDR;":                           '\U00002554',
+	"boxDl;":                           '\U00002556',
+	"boxDr;":                           '\U00002553',
+	"boxH;":                            '\U00002550',
+	"boxHD;":                           '\U00002566',
+	"boxHU;":                           '\U00002569',
+	"boxHd;":                           '\U00002564',
+	"boxHu;":                           '\U00002567',
+	"boxUL;":                           '\U0000255D',
+	"boxUR;":                           '\U0000255A',
+	"boxUl;":                           '\U0000255C',
+	"boxUr;":                           '\U00002559',
+	"boxV;":                            '\U00002551',
+	"boxVH;":                           '\U0000256C',
+	"boxVL;":                           '\U00002563',
+	"boxVR;":                           '\U00002560',
+	"boxVh;":                           '\U0000256B',
+	"boxVl;":                           '\U00002562',
+	"boxVr;":                           '\U0000255F',
+	"boxbox;":                          '\U000029C9',
+	"boxdL;":                           '\U00002555',
+	"boxdR;":                           '\U00002552',
+	"boxdl;":                           '\U00002510',
+	"boxdr;":                           '\U0000250C',
+	"boxh;":                            '\U00002500',
+	"boxhD;":                           '\U00002565',
+	"boxhU;":                           '\U00002568',
+	"boxhd;":                           '\U0000252C',
+	"boxhu;":                           '\U00002534',
+	"boxminus;":                        '\U0000229F',
+	"boxplus;":                         '\U0000229E',
+	"boxtimes;":                        '\U000022A0',
+	"boxuL;":                           '\U0000255B',
+	"boxuR;":                           '\U00002558',
+	"boxul;":                           '\U00002518',
+	"boxur;":                           '\U00002514',
+	"boxv;":                            '\U00002502',
+	"boxvH;":                           '\U0000256A',
+	"boxvL;":                           '\U00002561',
+	"boxvR;":                           '\U0000255E',
+	"boxvh;":                           '\U0000253C',
+	"boxvl;":                           '\U00002524',
+	"boxvr;":                           '\U0000251C',
+	"bprime;":                          '\U00002035',
+	"breve;":                           '\U000002D8',
+	"brvbar;":                          '\U000000A6',
+	"bscr;":                            '\U0001D4B7',
+	"bsemi;":                           '\U0000204F',
+	"bsim;":                            '\U0000223D',
+	"bsime;":                           '\U000022CD',
+	"bsol;":                            '\U0000005C',
+	"bsolb;":                           '\U000029C5',
+	"bsolhsub;":                        '\U000027C8',
+	"bull;":                            '\U00002022',
+	"bullet;":                          '\U00002022',
+	"bump;":                            '\U0000224E',
+	"bumpE;":                           '\U00002AAE',
+	"bumpe;":                           '\U0000224F',
+	"bumpeq;":                          '\U0000224F',
+	"cacute;":                          '\U00000107',
+	"cap;":                             '\U00002229',
+	"capand;":                          '\U00002A44',
+	"capbrcup;":                        '\U00002A49',
+	"capcap;":                          '\U00002A4B',
+	"capcup;":                          '\U00002A47',
+	"capdot;":                          '\U00002A40',
+	"caret;":                           '\U00002041',
+	"caron;":                           '\U000002C7',
+	"ccaps;":                           '\U00002A4D',
+	"ccaron;":                          '\U0000010D',
+	"ccedil;":                          '\U000000E7',
+	"ccirc;":                           '\U00000109',
+	"ccups;":                           '\U00002A4C',
+	"ccupssm;":                         '\U00002A50',
+	"cdot;":                            '\U0000010B',
+	"cedil;":                           '\U000000B8',
+	"cemptyv;":                         '\U000029B2',
+	"cent;":                            '\U000000A2',
+	"centerdot;":                       '\U000000B7',
+	"cfr;":                             '\U0001D520',
+	"chcy;":                            '\U00000447',
+	"check;":                           '\U00002713',
+	"checkmark;":                       '\U00002713',
+	"chi;":                             '\U000003C7',
+	"cir;":                             '\U000025CB',
+	"cirE;":                            '\U000029C3',
+	"circ;":                            '\U000002C6',
+	"circeq;":                          '\U00002257',
+	"circlearrowleft;":                 '\U000021BA',
+	"circlearrowright;":                '\U000021BB',
+	"circledR;":                        '\U000000AE',
+	"circledS;":                        '\U000024C8',
+	"circledast;":                      '\U0000229B',
+	"circledcirc;":                     '\U0000229A',
+	"circleddash;":                     '\U0000229D',
+	"cire;":                            '\U00002257',
+	"cirfnint;":                        '\U00002A10',
+	"cirmid;":                          '\U00002AEF',
+	"cirscir;":                         '\U000029C2',
+	"clubs;":                           '\U00002663',
+	"clubsuit;":                        '\U00002663',
+	"colon;":                           '\U0000003A',
+	"colone;":                          '\U00002254',
+	"coloneq;":                         '\U00002254',
+	"comma;":                           '\U0000002C',
+	"commat;":                          '\U00000040',
+	"comp;":                            '\U00002201',
+	"compfn;":                          '\U00002218',
+	"complement;":                      '\U00002201',
+	"complexes;":                       '\U00002102',
+	"cong;":                            '\U00002245',
+	"congdot;":                         '\U00002A6D',
+	"conint;":                          '\U0000222E',
+	"copf;":                            '\U0001D554',
+	"coprod;":                          '\U00002210',
+	"copy;":                            '\U000000A9',
+	"copysr;":                          '\U00002117',
+	"crarr;":                           '\U000021B5',
+	"cross;":                           '\U00002717',
+	"cscr;":                            '\U0001D4B8',
+	"csub;":                            '\U00002ACF',
+	"csube;":                           '\U00002AD1',
+	"csup;":                            '\U00002AD0',
+	"csupe;":                           '\U00002AD2',
+	"ctdot;":                           '\U000022EF',
+	"cudarrl;":                         '\U00002938',
+	"cudarrr;":                         '\U00002935',
+	"cuepr;":                           '\U000022DE',
+	"cuesc;":                           '\U000022DF',
+	"cularr;":                          '\U000021B6',
+	"cularrp;":                         '\U0000293D',
+	"cup;":                             '\U0000222A',
+	"cupbrcap;":                        '\U00002A48',
+	"cupcap;":                          '\U00002A46',
+	"cupcup;":                          '\U00002A4A',
+	"cupdot;":                          '\U0000228D',
+	"cupor;":                           '\U00002A45',
+	"curarr;":                          '\U000021B7',
+	"curarrm;":                         '\U0000293C',
+	"curlyeqprec;":                     '\U000022DE',
+	"curlyeqsucc;":                     '\U000022DF',
+	"curlyvee;":                        '\U000022CE',
+	"curlywedge;":                      '\U000022CF',
+	"curren;":                          '\U000000A4',
+	"curvearrowleft;":                  '\U000021B6',
+	"curvearrowright;":                 '\U000021B7',
+	"cuvee;":                           '\U000022CE',
+	"cuwed;":                           '\U000022CF',
+	"cwconint;":                        '\U00002232',
+	"cwint;":                           '\U00002231',
+	"cylcty;":                          '\U0000232D',
+	"dArr;":                            '\U000021D3',
+	"dHar;":                            '\U00002965',
+	"dagger;":                          '\U00002020',
+	"daleth;":                          '\U00002138',
+	"darr;":                            '\U00002193',
+	"dash;":                            '\U00002010',
+	"dashv;":                           '\U000022A3',
+	"dbkarow;":                         '\U0000290F',
+	"dblac;":                           '\U000002DD',
+	"dcaron;":                          '\U0000010F',
+	"dcy;":                             '\U00000434',
+	"dd;":                              '\U00002146',
+	"ddagger;":                         '\U00002021',
+	"ddarr;":                           '\U000021CA',
+	"ddotseq;":                         '\U00002A77',
+	"deg;":                             '\U000000B0',
+	"delta;":                           '\U000003B4',
+	"demptyv;":                         '\U000029B1',
+	"dfisht;":                          '\U0000297F',
+	"dfr;":                             '\U0001D521',
+	"dharl;":                           '\U000021C3',
+	"dharr;":                           '\U000021C2',
+	"diam;":                            '\U000022C4',
+	"diamond;":                         '\U000022C4',
+	"diamondsuit;":                     '\U00002666',
+	"diams;":                           '\U00002666',
+	"die;":                             '\U000000A8',
+	"digamma;":                         '\U000003DD',
+	"disin;":                           '\U000022F2',
+	"div;":                             '\U000000F7',
+	"divide;":                          '\U000000F7',
+	"divideontimes;":                   '\U000022C7',
+	"divonx;":                          '\U000022C7',
+	"djcy;":                            '\U00000452',
+	"dlcorn;":                          '\U0000231E',
+	"dlcrop;":                          '\U0000230D',
+	"dollar;":                          '\U00000024',
+	"dopf;":                            '\U0001D555',
+	"dot;":                             '\U000002D9',
+	"doteq;":                           '\U00002250',
+	"doteqdot;":                        '\U00002251',
+	"dotminus;":                        '\U00002238',
+	"dotplus;":                         '\U00002214',
+	"dotsquare;":                       '\U000022A1',
+	"doublebarwedge;":                  '\U00002306',
+	"downarrow;":                       '\U00002193',
+	"downdownarrows;":                  '\U000021CA',
+	"downharpoonleft;":                 '\U000021C3',
+	"downharpoonright;":                '\U000021C2',
+	"drbkarow;":                        '\U00002910',
+	"drcorn;":                          '\U0000231F',
+	"drcrop;":                          '\U0000230C',
+	"dscr;":                            '\U0001D4B9',
+	"dscy;":                            '\U00000455',
+	"dsol;":                            '\U000029F6',
+	"dstrok;":                          '\U00000111',
+	"dtdot;":                           '\U000022F1',
+	"dtri;":                            '\U000025BF',
+	"dtrif;":                           '\U000025BE',
+	"duarr;":                           '\U000021F5',
+	"duhar;":                           '\U0000296F',
+	"dwangle;":                         '\U000029A6',
+	"dzcy;":                            '\U0000045F',
+	"dzigrarr;":                        '\U000027FF',
+	"eDDot;":                           '\U00002A77',
+	"eDot;":                            '\U00002251',
+	"eacute;":                          '\U000000E9',
+	"easter;":                          '\U00002A6E',
+	"ecaron;":                          '\U0000011B',
+	"ecir;":                            '\U00002256',
+	"ecirc;":                           '\U000000EA',
+	"ecolon;":                          '\U00002255',
+	"ecy;":                             '\U0000044D',
+	"edot;":                            '\U00000117',
+	"ee;":                              '\U00002147',
+	"efDot;":                           '\U00002252',
+	"efr;":                             '\U0001D522',
+	"eg;":                              '\U00002A9A',
+	"egrave;":                          '\U000000E8',
+	"egs;":                             '\U00002A96',
+	"egsdot;":                          '\U00002A98',
+	"el;":                              '\U00002A99',
+	"elinters;":                        '\U000023E7',
+	"ell;":                             '\U00002113',
+	"els;":                             '\U00002A95',
+	"elsdot;":                          '\U00002A97',
+	"emacr;":                           '\U00000113',
+	"empty;":                           '\U00002205',
+	"emptyset;":                        '\U00002205',
+	"emptyv;":                          '\U00002205',
+	"emsp;":                            '\U00002003',
+	"emsp13;":                          '\U00002004',
+	"emsp14;":                          '\U00002005',
+	"eng;":                             '\U0000014B',
+	"ensp;":                            '\U00002002',
+	"eogon;":                           '\U00000119',
+	"eopf;":                            '\U0001D556',
+	"epar;":                            '\U000022D5',
+	"eparsl;":                          '\U000029E3',
+	"eplus;":                           '\U00002A71',
+	"epsi;":                            '\U000003B5',
+	"epsilon;":                         '\U000003B5',
+	"epsiv;":                           '\U000003F5',
+	"eqcirc;":                          '\U00002256',
+	"eqcolon;":                         '\U00002255',
+	"eqsim;":                           '\U00002242',
+	"eqslantgtr;":                      '\U00002A96',
+	"eqslantless;":                     '\U00002A95',
+	"equals;":                          '\U0000003D',
+	"equest;":                          '\U0000225F',
+	"equiv;":                           '\U00002261',
+	"equivDD;":                         '\U00002A78',
+	"eqvparsl;":                        '\U000029E5',
+	"erDot;":                           '\U00002253',
+	"erarr;":                           '\U00002971',
+	"escr;":                            '\U0000212F',
+	"esdot;":                           '\U00002250',
+	"esim;":                            '\U00002242',
+	"eta;":                             '\U000003B7',
+	"eth;":                             '\U000000F0',
+	"euml;":                            '\U000000EB',
+	"euro;":                            '\U000020AC',
+	"excl;":                            '\U00000021',
+	"exist;":                           '\U00002203',
+	"expectation;":                     '\U00002130',
+	"exponentiale;":                    '\U00002147',
+	"fallingdotseq;":                   '\U00002252',
+	"fcy;":                             '\U00000444',
+	"female;":                          '\U00002640',
+	"ffilig;":                          '\U0000FB03',
+	"fflig;":                           '\U0000FB00',
+	"ffllig;":                          '\U0000FB04',
+	"ffr;":                             '\U0001D523',
+	"filig;":                           '\U0000FB01',
+	"flat;":                            '\U0000266D',
+	"fllig;":                           '\U0000FB02',
+	"fltns;":                           '\U000025B1',
+	"fnof;":                            '\U00000192',
+	"fopf;":                            '\U0001D557',
+	"forall;":                          '\U00002200',
+	"fork;":                            '\U000022D4',
+	"forkv;":                           '\U00002AD9',
+	"fpartint;":                        '\U00002A0D',
+	"frac12;":                          '\U000000BD',
+	"frac13;":                          '\U00002153',
+	"frac14;":                          '\U000000BC',
+	"frac15;":                          '\U00002155',
+	"frac16;":                          '\U00002159',
+	"frac18;":                          '\U0000215B',
+	"frac23;":                          '\U00002154',
+	"frac25;":                          '\U00002156',
+	"frac34;":                          '\U000000BE',
+	"frac35;":                          '\U00002157',
+	"frac38;":                          '\U0000215C',
+	"frac45;":                          '\U00002158',
+	"frac56;":                          '\U0000215A',
+	"frac58;":                          '\U0000215D',
+	"frac78;":                          '\U0000215E',
+	"frasl;":                           '\U00002044',
+	"frown;":                           '\U00002322',
+	"fscr;":                            '\U0001D4BB',
+	"gE;":                              '\U00002267',
+	"gEl;":                             '\U00002A8C',
+	"gacute;":                          '\U000001F5',
+	"gamma;":                           '\U000003B3',
+	"gammad;":                          '\U000003DD',
+	"gap;":                             '\U00002A86',
+	"gbreve;":                          '\U0000011F',
+	"gcirc;":                           '\U0000011D',
+	"gcy;":                             '\U00000433',
+	"gdot;":                            '\U00000121',
+	"ge;":                              '\U00002265',
+	"gel;":                             '\U000022DB',
+	"geq;":                             '\U00002265',
+	"geqq;":                            '\U00002267',
+	"geqslant;":                        '\U00002A7E',
+	"ges;":                             '\U00002A7E',
+	"gescc;":                           '\U00002AA9',
+	"gesdot;":                          '\U00002A80',
+	"gesdoto;":                         '\U00002A82',
+	"gesdotol;":                        '\U00002A84',
+	"gesles;":                          '\U00002A94',
+	"gfr;":                             '\U0001D524',
+	"gg;":                              '\U0000226B',
+	"ggg;":                             '\U000022D9',
+	"gimel;":                           '\U00002137',
+	"gjcy;":                            '\U00000453',
+	"gl;":                              '\U00002277',
+	"glE;":                             '\U00002A92',
+	"gla;":                             '\U00002AA5',
+	"glj;":                             '\U00002AA4',
+	"gnE;":                             '\U00002269',
+	"gnap;":                            '\U00002A8A',
+	"gnapprox;":                        '\U00002A8A',
+	"gne;":                             '\U00002A88',
+	"gneq;":                            '\U00002A88',
+	"gneqq;":                           '\U00002269',
+	"gnsim;":                           '\U000022E7',
+	"gopf;":                            '\U0001D558',
+	"grave;":                           '\U00000060',
+	"gscr;":                            '\U0000210A',
+	"gsim;":                            '\U00002273',
+	"gsime;":                           '\U00002A8E',
+	"gsiml;":                           '\U00002A90',
+	"gt;":                              '\U0000003E',
+	"gtcc;":                            '\U00002AA7',
+	"gtcir;":                           '\U00002A7A',
+	"gtdot;":                           '\U000022D7',
+	"gtlPar;":                          '\U00002995',
+	"gtquest;":                         '\U00002A7C',
+	"gtrapprox;":                       '\U00002A86',
+	"gtrarr;":                          '\U00002978',
+	"gtrdot;":                          '\U000022D7',
+	"gtreqless;":                       '\U000022DB',
+	"gtreqqless;":                      '\U00002A8C',
+	"gtrless;":                         '\U00002277',
+	"gtrsim;":                          '\U00002273',
+	"hArr;":                            '\U000021D4',
+	"hairsp;":                          '\U0000200A',
+	"half;":                            '\U000000BD',
+	"hamilt;":                          '\U0000210B',
+	"hardcy;":                          '\U0000044A',
+	"harr;":                            '\U00002194',
+	"harrcir;":                         '\U00002948',
+	"harrw;":                           '\U000021AD',
+	"hbar;":                            '\U0000210F',
+	"hcirc;":                           '\U00000125',
+	"hearts;":                          '\U00002665',
+	"heartsuit;":                       '\U00002665',
+	"hellip;":                          '\U00002026',
+	"hercon;":                          '\U000022B9',
+	"hfr;":                             '\U0001D525',
+	"hksearow;":                        '\U00002925',
+	"hkswarow;":                        '\U00002926',
+	"hoarr;":                           '\U000021FF',
+	"homtht;":                          '\U0000223B',
+	"hookleftarrow;":                   '\U000021A9',
+	"hookrightarrow;":                  '\U000021AA',
+	"hopf;":                            '\U0001D559',
+	"horbar;":                          '\U00002015',
+	"hscr;":                            '\U0001D4BD',
+	"hslash;":                          '\U0000210F',
+	"hstrok;":                          '\U00000127',
+	"hybull;":                          '\U00002043',
+	"hyphen;":                          '\U00002010',
+	"iacute;":                          '\U000000ED',
+	"ic;":                              '\U00002063',
+	"icirc;":                           '\U000000EE',
+	"icy;":                             '\U00000438',
+	"iecy;":                            '\U00000435',
+	"iexcl;":                           '\U000000A1',
+	"iff;":                             '\U000021D4',
+	"ifr;":                             '\U0001D526',
+	"igrave;":                          '\U000000EC',
+	"ii;":                              '\U00002148',
+	"iiiint;":                          '\U00002A0C',
+	"iiint;":                           '\U0000222D',
+	"iinfin;":                          '\U000029DC',
+	"iiota;":                           '\U00002129',
+	"ijlig;":                           '\U00000133',
+	"imacr;":                           '\U0000012B',
+	"image;":                           '\U00002111',
+	"imagline;":                        '\U00002110',
+	"imagpart;":                        '\U00002111',
+	"imath;":                           '\U00000131',
+	"imof;":                            '\U000022B7',
+	"imped;":                           '\U000001B5',
+	"in;":                              '\U00002208',
+	"incare;":                          '\U00002105',
+	"infin;":                           '\U0000221E',
+	"infintie;":                        '\U000029DD',
+	"inodot;":                          '\U00000131',
+	"int;":                             '\U0000222B',
+	"intcal;":                          '\U000022BA',
+	"integers;":                        '\U00002124',
+	"intercal;":                        '\U000022BA',
+	"intlarhk;":                        '\U00002A17',
+	"intprod;":                         '\U00002A3C',
+	"iocy;":                            '\U00000451',
+	"iogon;":                           '\U0000012F',
+	"iopf;":                            '\U0001D55A',
+	"iota;":                            '\U000003B9',
+	"iprod;":                           '\U00002A3C',
+	"iquest;":                          '\U000000BF',
+	"iscr;":                            '\U0001D4BE',
+	"isin;":                            '\U00002208',
+	"isinE;":                           '\U000022F9',
+	"isindot;":                         '\U000022F5',
+	"isins;":                           '\U000022F4',
+	"isinsv;":                          '\U000022F3',
+	"isinv;":                           '\U00002208',
+	"it;":                              '\U00002062',
+	"itilde;":                          '\U00000129',
+	"iukcy;":                           '\U00000456',
+	"iuml;":                            '\U000000EF',
+	"jcirc;":                           '\U00000135',
+	"jcy;":                             '\U00000439',
+	"jfr;":                             '\U0001D527',
+	"jmath;":                           '\U00000237',
+	"jopf;":                            '\U0001D55B',
+	"jscr;":                            '\U0001D4BF',
+	"jsercy;":                          '\U00000458',
+	"jukcy;":                           '\U00000454',
+	"kappa;":                           '\U000003BA',
+	"kappav;":                          '\U000003F0',
+	"kcedil;":                          '\U00000137',
+	"kcy;":                             '\U0000043A',
+	"kfr;":                             '\U0001D528',
+	"kgreen;":                          '\U00000138',
+	"khcy;":                            '\U00000445',
+	"kjcy;":                            '\U0000045C',
+	"kopf;":                            '\U0001D55C',
+	"kscr;":                            '\U0001D4C0',
+	"lAarr;":                           '\U000021DA',
+	"lArr;":                            '\U000021D0',
+	"lAtail;":                          '\U0000291B',
+	"lBarr;":                           '\U0000290E',
+	"lE;":                              '\U00002266',
+	"lEg;":                             '\U00002A8B',
+	"lHar;":                            '\U00002962',
+	"lacute;":                          '\U0000013A',
+	"laemptyv;":                        '\U000029B4',
+	"lagran;":                          '\U00002112',
+	"lambda;":                          '\U000003BB',
+	"lang;":                            '\U000027E8',
+	"langd;":                           '\U00002991',
+	"langle;":                          '\U000027E8',
+	"lap;":                             '\U00002A85',
+	"laquo;":                           '\U000000AB',
+	"larr;":                            '\U00002190',
+	"larrb;":                           '\U000021E4',
+	"larrbfs;":                         '\U0000291F',
+	"larrfs;":                          '\U0000291D',
+	"larrhk;":                          '\U000021A9',
+	"larrlp;":                          '\U000021AB',
+	"larrpl;":                          '\U00002939',
+	"larrsim;":                         '\U00002973',
+	"larrtl;":                          '\U000021A2',
+	"lat;":                             '\U00002AAB',
+	"latail;":                          '\U00002919',
+	"late;":                            '\U00002AAD',
+	"lbarr;":                           '\U0000290C',
+	"lbbrk;":                           '\U00002772',
+	"lbrace;":                          '\U0000007B',
+	"lbrack;":                          '\U0000005B',
+	"lbrke;":                           '\U0000298B',
+	"lbrksld;":                         '\U0000298F',
+	"lbrkslu;":                         '\U0000298D',
+	"lcaron;":                          '\U0000013E',
+	"lcedil;":                          '\U0000013C',
+	"lceil;":                           '\U00002308',
+	"lcub;":                            '\U0000007B',
+	"lcy;":                             '\U0000043B',
+	"ldca;":                            '\U00002936',
+	"ldquo;":                           '\U0000201C',
+	"ldquor;":                          '\U0000201E',
+	"ldrdhar;":                         '\U00002967',
+	"ldrushar;":                        '\U0000294B',
+	"ldsh;":                            '\U000021B2',
+	"le;":                              '\U00002264',
+	"leftarrow;":                       '\U00002190',
+	"leftarrowtail;":                   '\U000021A2',
+	"leftharpoondown;":                 '\U000021BD',
+	"leftharpoonup;":                   '\U000021BC',
+	"leftleftarrows;":                  '\U000021C7',
+	"leftrightarrow;":                  '\U00002194',
+	"leftrightarrows;":                 '\U000021C6',
+	"leftrightharpoons;":               '\U000021CB',
+	"leftrightsquigarrow;":             '\U000021AD',
+	"leftthreetimes;":                  '\U000022CB',
+	"leg;":                             '\U000022DA',
+	"leq;":                             '\U00002264',
+	"leqq;":                            '\U00002266',
+	"leqslant;":                        '\U00002A7D',
+	"les;":                             '\U00002A7D',
+	"lescc;":                           '\U00002AA8',
+	"lesdot;":                          '\U00002A7F',
+	"lesdoto;":                         '\U00002A81',
+	"lesdotor;":                        '\U00002A83',
+	"lesges;":                          '\U00002A93',
+	"lessapprox;":                      '\U00002A85',
+	"lessdot;":                         '\U000022D6',
+	"lesseqgtr;":                       '\U000022DA',
+	"lesseqqgtr;":                      '\U00002A8B',
+	"lessgtr;":                         '\U00002276',
+	"lesssim;":                         '\U00002272',
+	"lfisht;":                          '\U0000297C',
+	"lfloor;":                          '\U0000230A',
+	"lfr;":                             '\U0001D529',
+	"lg;":                              '\U00002276',
+	"lgE;":                             '\U00002A91',
+	"lhard;":                           '\U000021BD',
+	"lharu;":                           '\U000021BC',
+	"lharul;":                          '\U0000296A',
+	"lhblk;":                           '\U00002584',
+	"ljcy;":                            '\U00000459',
+	"ll;":                              '\U0000226A',
+	"llarr;":                           '\U000021C7',
+	"llcorner;":                        '\U0000231E',
+	"llhard;":                          '\U0000296B',
+	"lltri;":                           '\U000025FA',
+	"lmidot;":                          '\U00000140',
+	"lmoust;":                          '\U000023B0',
+	"lmoustache;":                      '\U000023B0',
+	"lnE;":                             '\U00002268',
+	"lnap;":                            '\U00002A89',
+	"lnapprox;":                        '\U00002A89',
+	"lne;":                             '\U00002A87',
+	"lneq;":                            '\U00002A87',
+	"lneqq;":                           '\U00002268',
+	"lnsim;":                           '\U000022E6',
+	"loang;":                           '\U000027EC',
+	"loarr;":                           '\U000021FD',
+	"lobrk;":                           '\U000027E6',
+	"longleftarrow;":                   '\U000027F5',
+	"longleftrightarrow;":              '\U000027F7',
+	"longmapsto;":                      '\U000027FC',
+	"longrightarrow;":                  '\U000027F6',
+	"looparrowleft;":                   '\U000021AB',
+	"looparrowright;":                  '\U000021AC',
+	"lopar;":                           '\U00002985',
+	"lopf;":                            '\U0001D55D',
+	"loplus;":                          '\U00002A2D',
+	"lotimes;":                         '\U00002A34',
+	"lowast;":                          '\U00002217',
+	"lowbar;":                          '\U0000005F',
+	"loz;":                             '\U000025CA',
+	"lozenge;":                         '\U000025CA',
+	"lozf;":                            '\U000029EB',
+	"lpar;":                            '\U00000028',
+	"lparlt;":                          '\U00002993',
+	"lrarr;":                           '\U000021C6',
+	"lrcorner;":                        '\U0000231F',
+	"lrhar;":                           '\U000021CB',
+	"lrhard;":                          '\U0000296D',
+	"lrm;":                             '\U0000200E',
+	"lrtri;":                           '\U000022BF',
+	"lsaquo;":                          '\U00002039',
+	"lscr;":                            '\U0001D4C1',
+	"lsh;":                             '\U000021B0',
+	"lsim;":                            '\U00002272',
+	"lsime;":                           '\U00002A8D',
+	"lsimg;":                           '\U00002A8F',
+	"lsqb;":                            '\U0000005B',
+	"lsquo;":                           '\U00002018',
+	"lsquor;":                          '\U0000201A',
+	"lstrok;":                          '\U00000142',
+	"lt;":                              '\U0000003C',
+	"ltcc;":                            '\U00002AA6',
+	"ltcir;":                           '\U00002A79',
+	"ltdot;":                           '\U000022D6',
+	"lthree;":                          '\U000022CB',
+	"ltimes;":                          '\U000022C9',
+	"ltlarr;":                          '\U00002976',
+	"ltquest;":                         '\U00002A7B',
+	"ltrPar;":                          '\U00002996',
+	"ltri;":                            '\U000025C3',
+	"ltrie;":                           '\U000022B4',
+	"ltrif;":                           '\U000025C2',
+	"lurdshar;":                        '\U0000294A',
+	"luruhar;":                         '\U00002966',
+	"mDDot;":                           '\U0000223A',
+	"macr;":                            '\U000000AF',
+	"male;":                            '\U00002642',
+	"malt;":                            '\U00002720',
+	"maltese;":                         '\U00002720',
+	"map;":                             '\U000021A6',
+	"mapsto;":                          '\U000021A6',
+	"mapstodown;":                      '\U000021A7',
+	"mapstoleft;":                      '\U000021A4',
+	"mapstoup;":                        '\U000021A5',
+	"marker;":                          '\U000025AE',
+	"mcomma;":                          '\U00002A29',
+	"mcy;":                             '\U0000043C',
+	"mdash;":                           '\U00002014',
+	"measuredangle;":                   '\U00002221',
+	"mfr;":                             '\U0001D52A',
+	"mho;":                             '\U00002127',
+	"micro;":                           '\U000000B5',
+	"mid;":                             '\U00002223',
+	"midast;":                          '\U0000002A',
+	"midcir;":                          '\U00002AF0',
+	"middot;":                          '\U000000B7',
+	"minus;":                           '\U00002212',
+	"minusb;":                          '\U0000229F',
+	"minusd;":                          '\U00002238',
+	"minusdu;":                         '\U00002A2A',
+	"mlcp;":                            '\U00002ADB',
+	"mldr;":                            '\U00002026',
+	"mnplus;":                          '\U00002213',
+	"models;":                          '\U000022A7',
+	"mopf;":                            '\U0001D55E',
+	"mp;":                              '\U00002213',
+	"mscr;":                            '\U0001D4C2',
+	"mstpos;":                          '\U0000223E',
+	"mu;":                              '\U000003BC',
+	"multimap;":                        '\U000022B8',
+	"mumap;":                           '\U000022B8',
+	"nLeftarrow;":                      '\U000021CD',
+	"nLeftrightarrow;":                 '\U000021CE',
+	"nRightarrow;":                     '\U000021CF',
+	"nVDash;":                          '\U000022AF',
+	"nVdash;":                          '\U000022AE',
+	"nabla;":                           '\U00002207',
+	"nacute;":                          '\U00000144',
+	"nap;":                             '\U00002249',
+	"napos;":                           '\U00000149',
+	"napprox;":                         '\U00002249',
+	"natur;":                           '\U0000266E',
+	"natural;":                         '\U0000266E',
+	"naturals;":                        '\U00002115',
+	"nbsp;":                            '\U000000A0',
+	"ncap;":                            '\U00002A43',
+	"ncaron;":                          '\U00000148',
+	"ncedil;":                          '\U00000146',
+	"ncong;":                           '\U00002247',
+	"ncup;":                            '\U00002A42',
+	"ncy;":                             '\U0000043D',
+	"ndash;":                           '\U00002013',
+	"ne;":                              '\U00002260',
+	"neArr;":                           '\U000021D7',
+	"nearhk;":                          '\U00002924',
+	"nearr;":                           '\U00002197',
+	"nearrow;":                         '\U00002197',
+	"nequiv;":                          '\U00002262',
+	"nesear;":                          '\U00002928',
+	"nexist;":                          '\U00002204',
+	"nexists;":                         '\U00002204',
+	"nfr;":                             '\U0001D52B',
+	"nge;":                             '\U00002271',
+	"ngeq;":                            '\U00002271',
+	"ngsim;":                           '\U00002275',
+	"ngt;":                             '\U0000226F',
+	"ngtr;":                            '\U0000226F',
+	"nhArr;":                           '\U000021CE',
+	"nharr;":                           '\U000021AE',
+	"nhpar;":                           '\U00002AF2',
+	"ni;":                              '\U0000220B',
+	"nis;":                             '\U000022FC',
+	"nisd;":                            '\U000022FA',
+	"niv;":                             '\U0000220B',
+	"njcy;":                            '\U0000045A',
+	"nlArr;":                           '\U000021CD',
+	"nlarr;":                           '\U0000219A',
+	"nldr;":                            '\U00002025',
+	"nle;":                             '\U00002270',
+	"nleftarrow;":                      '\U0000219A',
+	"nleftrightarrow;":                 '\U000021AE',
+	"nleq;":                            '\U00002270',
+	"nless;":                           '\U0000226E',
+	"nlsim;":                           '\U00002274',
+	"nlt;":                             '\U0000226E',
+	"nltri;":                           '\U000022EA',
+	"nltrie;":                          '\U000022EC',
+	"nmid;":                            '\U00002224',
+	"nopf;":                            '\U0001D55F',
+	"not;":                             '\U000000AC',
+	"notin;":                           '\U00002209',
+	"notinva;":                         '\U00002209',
+	"notinvb;":                         '\U000022F7',
+	"notinvc;":                         '\U000022F6',
+	"notni;":                           '\U0000220C',
+	"notniva;":                         '\U0000220C',
+	"notnivb;":                         '\U000022FE',
+	"notnivc;":                         '\U000022FD',
+	"npar;":                            '\U00002226',
+	"nparallel;":                       '\U00002226',
+	"npolint;":                         '\U00002A14',
+	"npr;":                             '\U00002280',
+	"nprcue;":                          '\U000022E0',
+	"nprec;":                           '\U00002280',
+	"nrArr;":                           '\U000021CF',
+	"nrarr;":                           '\U0000219B',
+	"nrightarrow;":                     '\U0000219B',
+	"nrtri;":                           '\U000022EB',
+	"nrtrie;":                          '\U000022ED',
+	"nsc;":                             '\U00002281',
+	"nsccue;":                          '\U000022E1',
+	"nscr;":                            '\U0001D4C3',
+	"nshortmid;":                       '\U00002224',
+	"nshortparallel;":                  '\U00002226',
+	"nsim;":                            '\U00002241',
+	"nsime;":                           '\U00002244',
+	"nsimeq;":                          '\U00002244',
+	"nsmid;":                           '\U00002224',
+	"nspar;":                           '\U00002226',
+	"nsqsube;":                         '\U000022E2',
+	"nsqsupe;":                         '\U000022E3',
+	"nsub;":                            '\U00002284',
+	"nsube;":                           '\U00002288',
+	"nsubseteq;":                       '\U00002288',
+	"nsucc;":                           '\U00002281',
+	"nsup;":                            '\U00002285',
+	"nsupe;":                           '\U00002289',
+	"nsupseteq;":                       '\U00002289',
+	"ntgl;":                            '\U00002279',
+	"ntilde;":                          '\U000000F1',
+	"ntlg;":                            '\U00002278',
+	"ntriangleleft;":                   '\U000022EA',
+	"ntrianglelefteq;":                 '\U000022EC',
+	"ntriangleright;":                  '\U000022EB',
+	"ntrianglerighteq;":                '\U000022ED',
+	"nu;":                              '\U000003BD',
+	"num;":                             '\U00000023',
+	"numero;":                          '\U00002116',
+	"numsp;":                           '\U00002007',
+	"nvDash;":                          '\U000022AD',
+	"nvHarr;":                          '\U00002904',
+	"nvdash;":                          '\U000022AC',
+	"nvinfin;":                         '\U000029DE',
+	"nvlArr;":                          '\U00002902',
+	"nvrArr;":                          '\U00002903',
+	"nwArr;":                           '\U000021D6',
+	"nwarhk;":                          '\U00002923',
+	"nwarr;":                           '\U00002196',
+	"nwarrow;":                         '\U00002196',
+	"nwnear;":                          '\U00002927',
+	"oS;":                              '\U000024C8',
+	"oacute;":                          '\U000000F3',
+	"oast;":                            '\U0000229B',
+	"ocir;":                            '\U0000229A',
+	"ocirc;":                           '\U000000F4',
+	"ocy;":                             '\U0000043E',
+	"odash;":                           '\U0000229D',
+	"odblac;":                          '\U00000151',
+	"odiv;":                            '\U00002A38',
+	"odot;":                            '\U00002299',
+	"odsold;":                          '\U000029BC',
+	"oelig;":                           '\U00000153',
+	"ofcir;":                           '\U000029BF',
+	"ofr;":                             '\U0001D52C',
+	"ogon;":                            '\U000002DB',
+	"ograve;":                          '\U000000F2',
+	"ogt;":                             '\U000029C1',
+	"ohbar;":                           '\U000029B5',
+	"ohm;":                             '\U000003A9',
+	"oint;":                            '\U0000222E',
+	"olarr;":                           '\U000021BA',
+	"olcir;":                           '\U000029BE',
+	"olcross;":                         '\U000029BB',
+	"oline;":                           '\U0000203E',
+	"olt;":                             '\U000029C0',
+	"omacr;":                           '\U0000014D',
+	"omega;":                           '\U000003C9',
+	"omicron;":                         '\U000003BF',
+	"omid;":                            '\U000029B6',
+	"ominus;":                          '\U00002296',
+	"oopf;":                            '\U0001D560',
+	"opar;":                            '\U000029B7',
+	"operp;":                           '\U000029B9',
+	"oplus;":                           '\U00002295',
+	"or;":                              '\U00002228',
+	"orarr;":                           '\U000021BB',
+	"ord;":                             '\U00002A5D',
+	"order;":                           '\U00002134',
+	"orderof;":                         '\U00002134',
+	"ordf;":                            '\U000000AA',
+	"ordm;":                            '\U000000BA',
+	"origof;":                          '\U000022B6',
+	"oror;":                            '\U00002A56',
+	"orslope;":                         '\U00002A57',
+	"orv;":                             '\U00002A5B',
+	"oscr;":                            '\U00002134',
+	"oslash;":                          '\U000000F8',
+	"osol;":                            '\U00002298',
+	"otilde;":                          '\U000000F5',
+	"otimes;":                          '\U00002297',
+	"otimesas;":                        '\U00002A36',
+	"ouml;":                            '\U000000F6',
+	"ovbar;":                           '\U0000233D',
+	"par;":                             '\U00002225',
+	"para;":                            '\U000000B6',
+	"parallel;":                        '\U00002225',
+	"parsim;":                          '\U00002AF3',
+	"parsl;":                           '\U00002AFD',
+	"part;":                            '\U00002202',
+	"pcy;":                             '\U0000043F',
+	"percnt;":                          '\U00000025',
+	"period;":                          '\U0000002E',
+	"permil;":                          '\U00002030',
+	"perp;":                            '\U000022A5',
+	"pertenk;":                         '\U00002031',
+	"pfr;":                             '\U0001D52D',
+	"phi;":                             '\U000003C6',
+	"phiv;":                            '\U000003D5',
+	"phmmat;":                          '\U00002133',
+	"phone;":                           '\U0000260E',
+	"pi;":                              '\U000003C0',
+	"pitchfork;":                       '\U000022D4',
+	"piv;":                             '\U000003D6',
+	"planck;":                          '\U0000210F',
+	"planckh;":                         '\U0000210E',
+	"plankv;":                          '\U0000210F',
+	"plus;":                            '\U0000002B',
+	"plusacir;":                        '\U00002A23',
+	"plusb;":                           '\U0000229E',
+	"pluscir;":                         '\U00002A22',
+	"plusdo;":                          '\U00002214',
+	"plusdu;":                          '\U00002A25',
+	"pluse;":                           '\U00002A72',
+	"plusmn;":                          '\U000000B1',
+	"plussim;":                         '\U00002A26',
+	"plustwo;":                         '\U00002A27',
+	"pm;":                              '\U000000B1',
+	"pointint;":                        '\U00002A15',
+	"popf;":                            '\U0001D561',
+	"pound;":                           '\U000000A3',
+	"pr;":                              '\U0000227A',
+	"prE;":                             '\U00002AB3',
+	"prap;":                            '\U00002AB7',
+	"prcue;":                           '\U0000227C',
+	"pre;":                             '\U00002AAF',
+	"prec;":                            '\U0000227A',
+	"precapprox;":                      '\U00002AB7',
+	"preccurlyeq;":                     '\U0000227C',
+	"preceq;":                          '\U00002AAF',
+	"precnapprox;":                     '\U00002AB9',
+	"precneqq;":                        '\U00002AB5',
+	"precnsim;":                        '\U000022E8',
+	"precsim;":                         '\U0000227E',
+	"prime;":                           '\U00002032',
+	"primes;":                          '\U00002119',
+	"prnE;":                            '\U00002AB5',
+	"prnap;":                           '\U00002AB9',
+	"prnsim;":                          '\U000022E8',
+	"prod;":                            '\U0000220F',
+	"profalar;":                        '\U0000232E',
+	"profline;":                        '\U00002312',
+	"profsurf;":                        '\U00002313',
+	"prop;":                            '\U0000221D',
+	"propto;":                          '\U0000221D',
+	"prsim;":                           '\U0000227E',
+	"prurel;":                          '\U000022B0',
+	"pscr;":                            '\U0001D4C5',
+	"psi;":                             '\U000003C8',
+	"puncsp;":                          '\U00002008',
+	"qfr;":                             '\U0001D52E',
+	"qint;":                            '\U00002A0C',
+	"qopf;":                            '\U0001D562',
+	"qprime;":                          '\U00002057',
+	"qscr;":                            '\U0001D4C6',
+	"quaternions;":                     '\U0000210D',
+	"quatint;":                         '\U00002A16',
+	"quest;":                           '\U0000003F',
+	"questeq;":                         '\U0000225F',
+	"quot;":                            '\U00000022',
+	"rAarr;":                           '\U000021DB',
+	"rArr;":                            '\U000021D2',
+	"rAtail;":                          '\U0000291C',
+	"rBarr;":                           '\U0000290F',
+	"rHar;":                            '\U00002964',
+	"racute;":                          '\U00000155',
+	"radic;":                           '\U0000221A',
+	"raemptyv;":                        '\U000029B3',
+	"rang;":                            '\U000027E9',
+	"rangd;":                           '\U00002992',
+	"range;":                           '\U000029A5',
+	"rangle;":                          '\U000027E9',
+	"raquo;":                           '\U000000BB',
+	"rarr;":                            '\U00002192',
+	"rarrap;":                          '\U00002975',
+	"rarrb;":                           '\U000021E5',
+	"rarrbfs;":                         '\U00002920',
+	"rarrc;":                           '\U00002933',
+	"rarrfs;":                          '\U0000291E',
+	"rarrhk;":                          '\U000021AA',
+	"rarrlp;":                          '\U000021AC',
+	"rarrpl;":                          '\U00002945',
+	"rarrsim;":                         '\U00002974',
+	"rarrtl;":                          '\U000021A3',
+	"rarrw;":                           '\U0000219D',
+	"ratail;":                          '\U0000291A',
+	"ratio;":                           '\U00002236',
+	"rationals;":                       '\U0000211A',
+	"rbarr;":                           '\U0000290D',
+	"rbbrk;":                           '\U00002773',
+	"rbrace;":                          '\U0000007D',
+	"rbrack;":                          '\U0000005D',
+	"rbrke;":                           '\U0000298C',
+	"rbrksld;":                         '\U0000298E',
+	"rbrkslu;":                         '\U00002990',
+	"rcaron;":                          '\U00000159',
+	"rcedil;":                          '\U00000157',
+	"rceil;":                           '\U00002309',
+	"rcub;":                            '\U0000007D',
+	"rcy;":                             '\U00000440',
+	"rdca;":                            '\U00002937',
+	"rdldhar;":                         '\U00002969',
+	"rdquo;":                           '\U0000201D',
+	"rdquor;":                          '\U0000201D',
+	"rdsh;":                            '\U000021B3',
+	"real;":                            '\U0000211C',
+	"realine;":                         '\U0000211B',
+	"realpart;":                        '\U0000211C',
+	"reals;":                           '\U0000211D',
+	"rect;":                            '\U000025AD',
+	"reg;":                             '\U000000AE',
+	"rfisht;":                          '\U0000297D',
+	"rfloor;":                          '\U0000230B',
+	"rfr;":                             '\U0001D52F',
+	"rhard;":                           '\U000021C1',
+	"rharu;":                           '\U000021C0',
+	"rharul;":                          '\U0000296C',
+	"rho;":                             '\U000003C1',
+	"rhov;":                            '\U000003F1',
+	"rightarrow;":                      '\U00002192',
+	"rightarrowtail;":                  '\U000021A3',
+	"rightharpoondown;":                '\U000021C1',
+	"rightharpoonup;":                  '\U000021C0',
+	"rightleftarrows;":                 '\U000021C4',
+	"rightleftharpoons;":               '\U000021CC',
+	"rightrightarrows;":                '\U000021C9',
+	"rightsquigarrow;":                 '\U0000219D',
+	"rightthreetimes;":                 '\U000022CC',
+	"ring;":                            '\U000002DA',
+	"risingdotseq;":                    '\U00002253',
+	"rlarr;":                           '\U000021C4',
+	"rlhar;":                           '\U000021CC',
+	"rlm;":                             '\U0000200F',
+	"rmoust;":                          '\U000023B1',
+	"rmoustache;":                      '\U000023B1',
+	"rnmid;":                           '\U00002AEE',
+	"roang;":                           '\U000027ED',
+	"roarr;":                           '\U000021FE',
+	"robrk;":                           '\U000027E7',
+	"ropar;":                           '\U00002986',
+	"ropf;":                            '\U0001D563',
+	"roplus;":                          '\U00002A2E',
+	"rotimes;":                         '\U00002A35',
+	"rpar;":                            '\U00000029',
+	"rpargt;":                          '\U00002994',
+	"rppolint;":                        '\U00002A12',
+	"rrarr;":                           '\U000021C9',
+	"rsaquo;":                          '\U0000203A',
+	"rscr;":                            '\U0001D4C7',
+	"rsh;":                             '\U000021B1',
+	"rsqb;":                            '\U0000005D',
+	"rsquo;":                           '\U00002019',
+	"rsquor;":                          '\U00002019',
+	"rthree;":                          '\U000022CC',
+	"rtimes;":                          '\U000022CA',
+	"rtri;":                            '\U000025B9',
+	"rtrie;":                           '\U000022B5',
+	"rtrif;":                           '\U000025B8',
+	"rtriltri;":                        '\U000029CE',
+	"ruluhar;":                         '\U00002968',
+	"rx;":                              '\U0000211E',
+	"sacute;":                          '\U0000015B',
+	"sbquo;":                           '\U0000201A',
+	"sc;":                              '\U0000227B',
+	"scE;":                             '\U00002AB4',
+	"scap;":                            '\U00002AB8',
+	"scaron;":                          '\U00000161',
+	"sccue;":                           '\U0000227D',
+	"sce;":                             '\U00002AB0',
+	"scedil;":                          '\U0000015F',
+	"scirc;":                           '\U0000015D',
+	"scnE;":                            '\U00002AB6',
+	"scnap;":                           '\U00002ABA',
+	"scnsim;":                          '\U000022E9',
+	"scpolint;":                        '\U00002A13',
+	"scsim;":                           '\U0000227F',
+	"scy;":                             '\U00000441',
+	"sdot;":                            '\U000022C5',
+	"sdotb;":                           '\U000022A1',
+	"sdote;":                           '\U00002A66',
+	"seArr;":                           '\U000021D8',
+	"searhk;":                          '\U00002925',
+	"searr;":                           '\U00002198',
+	"searrow;":                         '\U00002198',
+	"sect;":                            '\U000000A7',
+	"semi;":                            '\U0000003B',
+	"seswar;":                          '\U00002929',
+	"setminus;":                        '\U00002216',
+	"setmn;":                           '\U00002216',
+	"sext;":                            '\U00002736',
+	"sfr;":                             '\U0001D530',
+	"sfrown;":                          '\U00002322',
+	"sharp;":                           '\U0000266F',
+	"shchcy;":                          '\U00000449',
+	"shcy;":                            '\U00000448',
+	"shortmid;":                        '\U00002223',
+	"shortparallel;":                   '\U00002225',
+	"shy;":                             '\U000000AD',
+	"sigma;":                           '\U000003C3',
+	"sigmaf;":                          '\U000003C2',
+	"sigmav;":                          '\U000003C2',
+	"sim;":                             '\U0000223C',
+	"simdot;":                          '\U00002A6A',
+	"sime;":                            '\U00002243',
+	"simeq;":                           '\U00002243',
+	"simg;":                            '\U00002A9E',
+	"simgE;":                           '\U00002AA0',
+	"siml;":                            '\U00002A9D',
+	"simlE;":                           '\U00002A9F',
+	"simne;":                           '\U00002246',
+	"simplus;":                         '\U00002A24',
+	"simrarr;":                         '\U00002972',
+	"slarr;":                           '\U00002190',
+	"smallsetminus;":                   '\U00002216',
+	"smashp;":                          '\U00002A33',
+	"smeparsl;":                        '\U000029E4',
+	"smid;":                            '\U00002223',
+	"smile;":                           '\U00002323',
+	"smt;":                             '\U00002AAA',
+	"smte;":                            '\U00002AAC',
+	"softcy;":                          '\U0000044C',
+	"sol;":                             '\U0000002F',
+	"solb;":                            '\U000029C4',
+	"solbar;":                          '\U0000233F',
+	"sopf;":                            '\U0001D564',
+	"spades;":                          '\U00002660',
+	"spadesuit;":                       '\U00002660',
+	"spar;":                            '\U00002225',
+	"sqcap;":                           '\U00002293',
+	"sqcup;":                           '\U00002294',
+	"sqsub;":                           '\U0000228F',
+	"sqsube;":                          '\U00002291',
+	"sqsubset;":                        '\U0000228F',
+	"sqsubseteq;":                      '\U00002291',
+	"sqsup;":                           '\U00002290',
+	"sqsupe;":                          '\U00002292',
+	"sqsupset;":                        '\U00002290',
+	"sqsupseteq;":                      '\U00002292',
+	"squ;":                             '\U000025A1',
+	"square;":                          '\U000025A1',
+	"squarf;":                          '\U000025AA',
+	"squf;":                            '\U000025AA',
+	"srarr;":                           '\U00002192',
+	"sscr;":                            '\U0001D4C8',
+	"ssetmn;":                          '\U00002216',
+	"ssmile;":                          '\U00002323',
+	"sstarf;":                          '\U000022C6',
+	"star;":                            '\U00002606',
+	"starf;":                           '\U00002605',
+	"straightepsilon;":                 '\U000003F5',
+	"straightphi;":                     '\U000003D5',
+	"strns;":                           '\U000000AF',
+	"sub;":                             '\U00002282',
+	"subE;":                            '\U00002AC5',
+	"subdot;":                          '\U00002ABD',
+	"sube;":                            '\U00002286',
+	"subedot;":                         '\U00002AC3',
+	"submult;":                         '\U00002AC1',
+	"subnE;":                           '\U00002ACB',
+	"subne;":                           '\U0000228A',
+	"subplus;":                         '\U00002ABF',
+	"subrarr;":                         '\U00002979',
+	"subset;":                          '\U00002282',
+	"subseteq;":                        '\U00002286',
+	"subseteqq;":                       '\U00002AC5',
+	"subsetneq;":                       '\U0000228A',
+	"subsetneqq;":                      '\U00002ACB',
+	"subsim;":                          '\U00002AC7',
+	"subsub;":                          '\U00002AD5',
+	"subsup;":                          '\U00002AD3',
+	"succ;":                            '\U0000227B',
+	"succapprox;":                      '\U00002AB8',
+	"succcurlyeq;":                     '\U0000227D',
+	"succeq;":                          '\U00002AB0',
+	"succnapprox;":                     '\U00002ABA',
+	"succneqq;":                        '\U00002AB6',
+	"succnsim;":                        '\U000022E9',
+	"succsim;":                         '\U0000227F',
+	"sum;":                             '\U00002211',
+	"sung;":                            '\U0000266A',
+	"sup;":                             '\U00002283',
+	"sup1;":                            '\U000000B9',
+	"sup2;":                            '\U000000B2',
+	"sup3;":                            '\U000000B3',
+	"supE;":                            '\U00002AC6',
+	"supdot;":                          '\U00002ABE',
+	"supdsub;":                         '\U00002AD8',
+	"supe;":                            '\U00002287',
+	"supedot;":                         '\U00002AC4',
+	"suphsol;":                         '\U000027C9',
+	"suphsub;":                         '\U00002AD7',
+	"suplarr;":                         '\U0000297B',
+	"supmult;":                         '\U00002AC2',
+	"supnE;":                           '\U00002ACC',
+	"supne;":                           '\U0000228B',
+	"supplus;":                         '\U00002AC0',
+	"supset;":                          '\U00002283',
+	"supseteq;":                        '\U00002287',
+	"supseteqq;":                       '\U00002AC6',
+	"supsetneq;":                       '\U0000228B',
+	"supsetneqq;":                      '\U00002ACC',
+	"supsim;":                          '\U00002AC8',
+	"supsub;":                          '\U00002AD4',
+	"supsup;":                          '\U00002AD6',
+	"swArr;":                           '\U000021D9',
+	"swarhk;":                          '\U00002926',
+	"swarr;":                           '\U00002199',
+	"swarrow;":                         '\U00002199',
+	"swnwar;":                          '\U0000292A',
+	"szlig;":                           '\U000000DF',
+	"target;":                          '\U00002316',
+	"tau;":                             '\U000003C4',
+	"tbrk;":                            '\U000023B4',
+	"tcaron;":                          '\U00000165',
+	"tcedil;":                          '\U00000163',
+	"tcy;":                             '\U00000442',
+	"tdot;":                            '\U000020DB',
+	"telrec;":                          '\U00002315',
+	"tfr;":                             '\U0001D531',
+	"there4;":                          '\U00002234',
+	"therefore;":                       '\U00002234',
+	"theta;":                           '\U000003B8',
+	"thetasym;":                        '\U000003D1',
+	"thetav;":                          '\U000003D1',
+	"thickapprox;":                     '\U00002248',
+	"thicksim;":                        '\U0000223C',
+	"thinsp;":                          '\U00002009',
+	"thkap;":                           '\U00002248',
+	"thksim;":                          '\U0000223C',
+	"thorn;":                           '\U000000FE',
+	"tilde;":                           '\U000002DC',
+	"times;":                           '\U000000D7',
+	"timesb;":                          '\U000022A0',
+	"timesbar;":                        '\U00002A31',
+	"timesd;":                          '\U00002A30',
+	"tint;":                            '\U0000222D',
+	"toea;":                            '\U00002928',
+	"top;":                             '\U000022A4',
+	"topbot;":                          '\U00002336',
+	"topcir;":                          '\U00002AF1',
+	"topf;":                            '\U0001D565',
+	"topfork;":                         '\U00002ADA',
+	"tosa;":                            '\U00002929',
+	"tprime;":                          '\U00002034',
+	"trade;":                           '\U00002122',
+	"triangle;":                        '\U000025B5',
+	"triangledown;":                    '\U000025BF',
+	"triangleleft;":                    '\U000025C3',
+	"trianglelefteq;":                  '\U000022B4',
+	"triangleq;":                       '\U0000225C',
+	"triangleright;":                   '\U000025B9',
+	"trianglerighteq;":                 '\U000022B5',
+	"tridot;":                          '\U000025EC',
+	"trie;":                            '\U0000225C',
+	"triminus;":                        '\U00002A3A',
+	"triplus;":                         '\U00002A39',
+	"trisb;":                           '\U000029CD',
+	"tritime;":                         '\U00002A3B',
+	"trpezium;":                        '\U000023E2',
+	"tscr;":                            '\U0001D4C9',
+	"tscy;":                            '\U00000446',
+	"tshcy;":                           '\U0000045B',
+	"tstrok;":                          '\U00000167',
+	"twixt;":                           '\U0000226C',
+	"twoheadleftarrow;":                '\U0000219E',
+	"twoheadrightarrow;":               '\U000021A0',
+	"uArr;":                            '\U000021D1',
+	"uHar;":                            '\U00002963',
+	"uacute;":                          '\U000000FA',
+	"uarr;":                            '\U00002191',
+	"ubrcy;":                           '\U0000045E',
+	"ubreve;":                          '\U0000016D',
+	"ucirc;":                           '\U000000FB',
+	"ucy;":                             '\U00000443',
+	"udarr;":                           '\U000021C5',
+	"udblac;":                          '\U00000171',
+	"udhar;":                           '\U0000296E',
+	"ufisht;":                          '\U0000297E',
+	"ufr;":                             '\U0001D532',
+	"ugrave;":                          '\U000000F9',
+	"uharl;":                           '\U000021BF',
+	"uharr;":                           '\U000021BE',
+	"uhblk;":                           '\U00002580',
+	"ulcorn;":                          '\U0000231C',
+	"ulcorner;":                        '\U0000231C',
+	"ulcrop;":                          '\U0000230F',
+	"ultri;":                           '\U000025F8',
+	"umacr;":                           '\U0000016B',
+	"uml;":                             '\U000000A8',
+	"uogon;":                           '\U00000173',
+	"uopf;":                            '\U0001D566',
+	"uparrow;":                         '\U00002191',
+	"updownarrow;":                     '\U00002195',
+	"upharpoonleft;":                   '\U000021BF',
+	"upharpoonright;":                  '\U000021BE',
+	"uplus;":                           '\U0000228E',
+	"upsi;":                            '\U000003C5',
+	"upsih;":                           '\U000003D2',
+	"upsilon;":                         '\U000003C5',
+	"upuparrows;":                      '\U000021C8',
+	"urcorn;":                          '\U0000231D',
+	"urcorner;":                        '\U0000231D',
+	"urcrop;":                          '\U0000230E',
+	"uring;":                           '\U0000016F',
+	"urtri;":                           '\U000025F9',
+	"uscr;":                            '\U0001D4CA',
+	"utdot;":                           '\U000022F0',
+	"utilde;":                          '\U00000169',
+	"utri;":                            '\U000025B5',
+	"utrif;":                           '\U000025B4',
+	"uuarr;":                           '\U000021C8',
+	"uuml;":                            '\U000000FC',
+	"uwangle;":                         '\U000029A7',
+	"vArr;":                            '\U000021D5',
+	"vBar;":                            '\U00002AE8',
+	"vBarv;":                           '\U00002AE9',
+	"vDash;":                           '\U000022A8',
+	"vangrt;":                          '\U0000299C',
+	"varepsilon;":                      '\U000003F5',
+	"varkappa;":                        '\U000003F0',
+	"varnothing;":                      '\U00002205',
+	"varphi;":                          '\U000003D5',
+	"varpi;":                           '\U000003D6',
+	"varpropto;":                       '\U0000221D',
+	"varr;":                            '\U00002195',
+	"varrho;":                          '\U000003F1',
+	"varsigma;":                        '\U000003C2',
+	"vartheta;":                        '\U000003D1',
+	"vartriangleleft;":                 '\U000022B2',
+	"vartriangleright;":                '\U000022B3',
+	"vcy;":                             '\U00000432',
+	"vdash;":                           '\U000022A2',
+	"vee;":                             '\U00002228',
+	"veebar;":                          '\U000022BB',
+	"veeeq;":                           '\U0000225A',
+	"vellip;":                          '\U000022EE',
+	"verbar;":                          '\U0000007C',
+	"vert;":                            '\U0000007C',
+	"vfr;":                             '\U0001D533',
+	"vltri;":                           '\U000022B2',
+	"vopf;":                            '\U0001D567',
+	"vprop;":                           '\U0000221D',
+	"vrtri;":                           '\U000022B3',
+	"vscr;":                            '\U0001D4CB',
+	"vzigzag;":                         '\U0000299A',
+	"wcirc;":                           '\U00000175',
+	"wedbar;":                          '\U00002A5F',
+	"wedge;":                           '\U00002227',
+	"wedgeq;":                          '\U00002259',
+	"weierp;":                          '\U00002118',
+	"wfr;":                             '\U0001D534',
+	"wopf;":                            '\U0001D568',
+	"wp;":                              '\U00002118',
+	"wr;":                              '\U00002240',
+	"wreath;":                          '\U00002240',
+	"wscr;":                            '\U0001D4CC',
+	"xcap;":                            '\U000022C2',
+	"xcirc;":                           '\U000025EF',
+	"xcup;":                            '\U000022C3',
+	"xdtri;":                           '\U000025BD',
+	"xfr;":                             '\U0001D535',
+	"xhArr;":                           '\U000027FA',
+	"xharr;":                           '\U000027F7',
+	"xi;":                              '\U000003BE',
+	"xlArr;":                           '\U000027F8',
+	"xlarr;":                           '\U000027F5',
+	"xmap;":                            '\U000027FC',
+	"xnis;":                            '\U000022FB',
+	"xodot;":                           '\U00002A00',
+	"xopf;":                            '\U0001D569',
+	"xoplus;":                          '\U00002A01',
+	"xotime;":                          '\U00002A02',
+	"xrArr;":                           '\U000027F9',
+	"xrarr;":                           '\U000027F6',
+	"xscr;":                            '\U0001D4CD',
+	"xsqcup;":                          '\U00002A06',
+	"xuplus;":                          '\U00002A04',
+	"xutri;":                           '\U000025B3',
+	"xvee;":                            '\U000022C1',
+	"xwedge;":                          '\U000022C0',
+	"yacute;":                          '\U000000FD',
+	"yacy;":                            '\U0000044F',
+	"ycirc;":                           '\U00000177',
+	"ycy;":                             '\U0000044B',
+	"yen;":                             '\U000000A5',
+	"yfr;":                             '\U0001D536',
+	"yicy;":                            '\U00000457',
+	"yopf;":                            '\U0001D56A',
+	"yscr;":                            '\U0001D4CE',
+	"yucy;":                            '\U0000044E',
+	"yuml;":                            '\U000000FF',
+	"zacute;":                          '\U0000017A',
+	"zcaron;":                          '\U0000017E',
+	"zcy;":                             '\U00000437',
+	"zdot;":                            '\U0000017C',
+	"zeetrf;":                          '\U00002128',
+	"zeta;":                            '\U000003B6',
+	"zfr;":                             '\U0001D537',
+	"zhcy;":                            '\U00000436',
+	"zigrarr;":                         '\U000021DD',
+	"zopf;":                            '\U0001D56B',
+	"zscr;":                            '\U0001D4CF',
+	"zwj;":                             '\U0000200D',
+	"zwnj;":                            '\U0000200C',
+	"AElig":                            '\U000000C6',
+	"AMP":                              '\U00000026',
+	"Aacute":                           '\U000000C1',
+	"Acirc":                            '\U000000C2',
+	"Agrave":                           '\U000000C0',
+	"Aring":                            '\U000000C5',
+	"Atilde":                           '\U000000C3',
+	"Auml":                             '\U000000C4',
+	"COPY":                             '\U000000A9',
+	"Ccedil":                           '\U000000C7',
+	"ETH":                              '\U000000D0',
+	"Eacute":                           '\U000000C9',
+	"Ecirc":                            '\U000000CA',
+	"Egrave":                           '\U000000C8',
+	"Euml":                             '\U000000CB',
+	"GT":                               '\U0000003E',
+	"Iacute":                           '\U000000CD',
+	"Icirc":                            '\U000000CE',
+	"Igrave":                           '\U000000CC',
+	"Iuml":                             '\U000000CF',
+	"LT":                               '\U0000003C',
+	"Ntilde":                           '\U000000D1',
+	"Oacute":                           '\U000000D3',
+	"Ocirc":                            '\U000000D4',
+	"Ograve":                           '\U000000D2',
+	"Oslash":                           '\U000000D8',
+	"Otilde":                           '\U000000D5',
+	"Ouml":                             '\U000000D6',
+	"QUOT":                             '\U00000022',
+	"REG":                              '\U000000AE',
+	"THORN":                            '\U000000DE',
+	"Uacute":                           '\U000000DA',
+	"Ucirc":                            '\U000000DB',
+	"Ugrave":                           '\U000000D9',
+	"Uuml":                             '\U000000DC',
+	"Yacute":                           '\U000000DD',
+	"aacute":                           '\U000000E1',
+	"acirc":                            '\U000000E2',
+	"acute":                            '\U000000B4',
+	"aelig":                            '\U000000E6',
+	"agrave":                           '\U000000E0',
+	"amp":                              '\U00000026',
+	"aring":                            '\U000000E5',
+	"atilde":                           '\U000000E3',
+	"auml":                             '\U000000E4',
+	"brvbar":                           '\U000000A6',
+	"ccedil":                           '\U000000E7',
+	"cedil":                            '\U000000B8',
+	"cent":                             '\U000000A2',
+	"copy":                             '\U000000A9',
+	"curren":                           '\U000000A4',
+	"deg":                              '\U000000B0',
+	"divide":                           '\U000000F7',
+	"eacute":                           '\U000000E9',
+	"ecirc":                            '\U000000EA',
+	"egrave":                           '\U000000E8',
+	"eth":                              '\U000000F0',
+	"euml":                             '\U000000EB',
+	"frac12":                           '\U000000BD',
+	"frac14":                           '\U000000BC',
+	"frac34":                           '\U000000BE',
+	"gt":                               '\U0000003E',
+	"iacute":                           '\U000000ED',
+	"icirc":                            '\U000000EE',
+	"iexcl":                            '\U000000A1',
+	"igrave":                           '\U000000EC',
+	"iquest":                           '\U000000BF',
+	"iuml":                             '\U000000EF',
+	"laquo":                            '\U000000AB',
+	"lt":                               '\U0000003C',
+	"macr":                             '\U000000AF',
+	"micro":                            '\U000000B5',
+	"middot":                           '\U000000B7',
+	"nbsp":                             '\U000000A0',
+	"not":                              '\U000000AC',
+	"ntilde":                           '\U000000F1',
+	"oacute":                           '\U000000F3',
+	"ocirc":                            '\U000000F4',
+	"ograve":                           '\U000000F2',
+	"ordf":                             '\U000000AA',
+	"ordm":                             '\U000000BA',
+	"oslash":                           '\U000000F8',
+	"otilde":                           '\U000000F5',
+	"ouml":                             '\U000000F6',
+	"para":                             '\U000000B6',
+	"plusmn":                           '\U000000B1',
+	"pound":                            '\U000000A3',
+	"quot":                             '\U00000022',
+	"raquo":                            '\U000000BB',
+	"reg":                              '\U000000AE',
+	"sect":                             '\U000000A7',
+	"shy":                              '\U000000AD',
+	"sup1":                             '\U000000B9',
+	"sup2":                             '\U000000B2',
+	"sup3":                             '\U000000B3',
+	"szlig":                            '\U000000DF',
+	"thorn":                            '\U000000FE',
+	"times":                            '\U000000D7',
+	"uacute":                           '\U000000FA',
+	"ucirc":                            '\U000000FB',
+	"ugrave":                           '\U000000F9',
+	"uml":                              '\U000000A8',
+	"uuml":                             '\U000000FC',
+	"yacute":                           '\U000000FD',
+	"yen":                              '\U000000A5',
+	"yuml":                             '\U000000FF',
+}
+
+// HTML entities that are two unicode codepoints.
+var entity2 = map[string][2]rune{
+	// TODO(nigeltao): Handle replacements that are wider than their names.
+	// "nLt;":                     {'\u226A', '\u20D2'},
+	// "nGt;":                     {'\u226B', '\u20D2'},
+	"NotEqualTilde;":           {'\u2242', '\u0338'},
+	"NotGreaterFullEqual;":     {'\u2267', '\u0338'},
+	"NotGreaterGreater;":       {'\u226B', '\u0338'},
+	"NotGreaterSlantEqual;":    {'\u2A7E', '\u0338'},
+	"NotHumpDownHump;":         {'\u224E', '\u0338'},
+	"NotHumpEqual;":            {'\u224F', '\u0338'},
+	"NotLeftTriangleBar;":      {'\u29CF', '\u0338'},
+	"NotLessLess;":             {'\u226A', '\u0338'},
+	"NotLessSlantEqual;":       {'\u2A7D', '\u0338'},
+	"NotNestedGreaterGreater;": {'\u2AA2', '\u0338'},
+	"NotNestedLessLess;":       {'\u2AA1', '\u0338'},
+	"NotPrecedesEqual;":        {'\u2AAF', '\u0338'},
+	"NotRightTriangleBar;":     {'\u29D0', '\u0338'},
+	"NotSquareSubset;":         {'\u228F', '\u0338'},
+	"NotSquareSuperset;":       {'\u2290', '\u0338'},
+	"NotSubset;":               {'\u2282', '\u20D2'},
+	"NotSucceedsEqual;":        {'\u2AB0', '\u0338'},
+	"NotSucceedsTilde;":        {'\u227F', '\u0338'},
+	"NotSuperset;":             {'\u2283', '\u20D2'},
+	"ThickSpace;":              {'\u205F', '\u200A'},
+	"acE;":                     {'\u223E', '\u0333'},
+	"bne;":                     {'\u003D', '\u20E5'},
+	"bnequiv;":                 {'\u2261', '\u20E5'},
+	"caps;":                    {'\u2229', '\uFE00'},
+	"cups;":                    {'\u222A', '\uFE00'},
+	"fjlig;":                   {'\u0066', '\u006A'},
+	"gesl;":                    {'\u22DB', '\uFE00'},
+	"gvertneqq;":               {'\u2269', '\uFE00'},
+	"gvnE;":                    {'\u2269', '\uFE00'},
+	"lates;":                   {'\u2AAD', '\uFE00'},
+	"lesg;":                    {'\u22DA', '\uFE00'},
+	"lvertneqq;":               {'\u2268', '\uFE00'},
+	"lvnE;":                    {'\u2268', '\uFE00'},
+	"nGg;":                     {'\u22D9', '\u0338'},
+	"nGtv;":                    {'\u226B', '\u0338'},
+	"nLl;":                     {'\u22D8', '\u0338'},
+	"nLtv;":                    {'\u226A', '\u0338'},
+	"nang;":                    {'\u2220', '\u20D2'},
+	"napE;":                    {'\u2A70', '\u0338'},
+	"napid;":                   {'\u224B', '\u0338'},
+	"nbump;":                   {'\u224E', '\u0338'},
+	"nbumpe;":                  {'\u224F', '\u0338'},
+	"ncongdot;":                {'\u2A6D', '\u0338'},
+	"nedot;":                   {'\u2250', '\u0338'},
+	"nesim;":                   {'\u2242', '\u0338'},
+	"ngE;":                     {'\u2267', '\u0338'},
+	"ngeqq;":                   {'\u2267', '\u0338'},
+	"ngeqslant;":               {'\u2A7E', '\u0338'},
+	"nges;":                    {'\u2A7E', '\u0338'},
+	"nlE;":                     {'\u2266', '\u0338'},
+	"nleqq;":                   {'\u2266', '\u0338'},
+	"nleqslant;":               {'\u2A7D', '\u0338'},
+	"nles;":                    {'\u2A7D', '\u0338'},
+	"notinE;":                  {'\u22F9', '\u0338'},
+	"notindot;":                {'\u22F5', '\u0338'},
+	"nparsl;":                  {'\u2AFD', '\u20E5'},
+	"npart;":                   {'\u2202', '\u0338'},
+	"npre;":                    {'\u2AAF', '\u0338'},
+	"npreceq;":                 {'\u2AAF', '\u0338'},
+	"nrarrc;":                  {'\u2933', '\u0338'},
+	"nrarrw;":                  {'\u219D', '\u0338'},
+	"nsce;":                    {'\u2AB0', '\u0338'},
+	"nsubE;":                   {'\u2AC5', '\u0338'},
+	"nsubset;":                 {'\u2282', '\u20D2'},
+	"nsubseteqq;":              {'\u2AC5', '\u0338'},
+	"nsucceq;":                 {'\u2AB0', '\u0338'},
+	"nsupE;":                   {'\u2AC6', '\u0338'},
+	"nsupset;":                 {'\u2283', '\u20D2'},
+	"nsupseteqq;":              {'\u2AC6', '\u0338'},
+	"nvap;":                    {'\u224D', '\u20D2'},
+	"nvge;":                    {'\u2265', '\u20D2'},
+	"nvgt;":                    {'\u003E', '\u20D2'},
+	"nvle;":                    {'\u2264', '\u20D2'},
+	"nvlt;":                    {'\u003C', '\u20D2'},
+	"nvltrie;":                 {'\u22B4', '\u20D2'},
+	"nvrtrie;":                 {'\u22B5', '\u20D2'},
+	"nvsim;":                   {'\u223C', '\u20D2'},
+	"race;":                    {'\u223D', '\u0331'},
+	"smtes;":                   {'\u2AAC', '\uFE00'},
+	"sqcaps;":                  {'\u2293', '\uFE00'},
+	"sqcups;":                  {'\u2294', '\uFE00'},
+	"varsubsetneq;":            {'\u228A', '\uFE00'},
+	"varsubsetneqq;":           {'\u2ACB', '\uFE00'},
+	"varsupsetneq;":            {'\u228B', '\uFE00'},
+	"varsupsetneqq;":           {'\u2ACC', '\uFE00'},
+	"vnsub;":                   {'\u2282', '\u20D2'},
+	"vnsup;":                   {'\u2283', '\u20D2'},
+	"vsubnE;":                  {'\u2ACB', '\uFE00'},
+	"vsubne;":                  {'\u228A', '\uFE00'},
+	"vsupnE;":                  {'\u2ACC', '\uFE00'},
+	"vsupne;":                  {'\u228B', '\uFE00'},
+}
diff --git a/vendor/golang.org/x/net/html/escape.go b/vendor/golang.org/x/net/html/escape.go
new file mode 100644
index 00000000..d8561396
--- /dev/null
+++ b/vendor/golang.org/x/net/html/escape.go
@@ -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 "&lt;" from b[src:] and writes the
+// corresponding "<" to b[dst:], returning the incremented dst and src cursors.
+// Precondition: b[src] == '&' && dst <= src.
+// attribute should be true if parsing an attribute value.
+func unescapeEntity(b []byte, dst, src int, attribute bool) (dst1, src1 int) {
+	// https://html.spec.whatwg.org/multipage/syntax.html#consume-a-character-reference
+
+	// i starts at 1 because we already know that s[0] == '&'.
+	i, s := 1, b[src:]
+
+	if len(s) <= 1 {
+		b[dst] = b[src]
+		return dst + 1, src + 1
+	}
+
+	if s[i] == '#' {
+		if len(s) <= 3 { // We need to have at least "&#.".
+			b[dst] = b[src]
+			return dst + 1, src + 1
+		}
+		i++
+		c := s[i]
+		hex := false
+		if c == 'x' || c == 'X' {
+			hex = true
+			i++
+		}
+
+		x := '\x00'
+		for i < len(s) {
+			c = s[i]
+			i++
+			if hex {
+				if '0' <= c && c <= '9' {
+					x = 16*x + rune(c) - '0'
+					continue
+				} else if 'a' <= c && c <= 'f' {
+					x = 16*x + rune(c) - 'a' + 10
+					continue
+				} else if 'A' <= c && c <= 'F' {
+					x = 16*x + rune(c) - 'A' + 10
+					continue
+				}
+			} else if '0' <= c && c <= '9' {
+				x = 10*x + rune(c) - '0'
+				continue
+			}
+			if c != ';' {
+				i--
+			}
+			break
+		}
+
+		if i <= 3 { // No characters matched.
+			b[dst] = b[src]
+			return dst + 1, src + 1
+		}
+
+		if 0x80 <= x && x <= 0x9F {
+			// Replace characters from Windows-1252 with UTF-8 equivalents.
+			x = replacementTable[x-0x80]
+		} else if x == 0 || (0xD800 <= x && x <= 0xDFFF) || x > 0x10FFFF {
+			// Replace invalid characters with the replacement character.
+			x = '\uFFFD'
+		}
+
+		return dst + utf8.EncodeRune(b[dst:], x), src + i
+	}
+
+	// Consume the maximum number of characters possible, with the
+	// consumed characters matching one of the named references.
+
+	for i < len(s) {
+		c := s[i]
+		i++
+		// Lower-cased characters are more common in entities, so we check for them first.
+		if 'a' <= c && c <= 'z' || 'A' <= c && c <= 'Z' || '0' <= c && c <= '9' {
+			continue
+		}
+		if c != ';' {
+			i--
+		}
+		break
+	}
+
+	entityName := string(s[1:i])
+	if entityName == "" {
+		// No-op.
+	} else if attribute && entityName[len(entityName)-1] != ';' && len(s) > i && s[i] == '=' {
+		// No-op.
+	} else if x := entity[entityName]; x != 0 {
+		return dst + utf8.EncodeRune(b[dst:], x), src + i
+	} else if x := entity2[entityName]; x[0] != 0 {
+		dst1 := dst + utf8.EncodeRune(b[dst:], x[0])
+		return dst1 + utf8.EncodeRune(b[dst1:], x[1]), src + i
+	} else if !attribute {
+		maxLen := len(entityName) - 1
+		if maxLen > longestEntityWithoutSemicolon {
+			maxLen = longestEntityWithoutSemicolon
+		}
+		for j := maxLen; j > 1; j-- {
+			if x := entity[entityName[:j]]; x != 0 {
+				return dst + utf8.EncodeRune(b[dst:], x), src + j + 1
+			}
+		}
+	}
+
+	dst1, src1 = dst+i, src+i
+	copy(b[dst:dst1], b[src:src1])
+	return dst1, src1
+}
+
+// unescape unescapes b's entities in-place, so that "a&lt;b" becomes "a<b".
+// attribute should be true if parsing an attribute value.
+func unescape(b []byte, attribute bool) []byte {
+	for i, c := range b {
+		if c == '&' {
+			dst, src := unescapeEntity(b, i, i, attribute)
+			for src < len(b) {
+				c := b[src]
+				if c == '&' {
+					dst, src = unescapeEntity(b, dst, src, attribute)
+				} else {
+					b[dst] = c
+					dst, src = dst+1, src+1
+				}
+			}
+			return b[0:dst]
+		}
+	}
+	return b
+}
+
+// lower lower-cases the A-Z bytes in b in-place, so that "aBc" becomes "abc".
+func lower(b []byte) []byte {
+	for i, c := range b {
+		if 'A' <= c && c <= 'Z' {
+			b[i] = c + 'a' - 'A'
+		}
+	}
+	return b
+}
+
+const escapedChars = "&'<>\"\r"
+
+func escape(w writer, s string) error {
+	i := strings.IndexAny(s, escapedChars)
+	for i != -1 {
+		if _, err := w.WriteString(s[:i]); err != nil {
+			return err
+		}
+		var esc string
+		switch s[i] {
+		case '&':
+			esc = "&amp;"
+		case '\'':
+			// "&#39;" is shorter than "&apos;" and apos was not in HTML until HTML5.
+			esc = "&#39;"
+		case '<':
+			esc = "&lt;"
+		case '>':
+			esc = "&gt;"
+		case '"':
+			// "&#34;" is shorter than "&quot;".
+			esc = "&#34;"
+		case '\r':
+			esc = "&#13;"
+		default:
+			panic("unrecognized escape character")
+		}
+		s = s[i+1:]
+		if _, err := w.WriteString(esc); err != nil {
+			return err
+		}
+		i = strings.IndexAny(s, escapedChars)
+	}
+	_, err := w.WriteString(s)
+	return err
+}
+
+// EscapeString escapes special characters like "<" to become "&lt;". It
+// escapes only five such characters: <, >, &, ' and ".
+// UnescapeString(EscapeString(s)) == s always holds, but the converse isn't
+// always true.
+func EscapeString(s string) string {
+	if strings.IndexAny(s, escapedChars) == -1 {
+		return s
+	}
+	var buf bytes.Buffer
+	escape(&buf, s)
+	return buf.String()
+}
+
+// UnescapeString unescapes entities like "&lt;" to become "<". It unescapes a
+// larger range of entities than EscapeString escapes. For example, "&aacute;"
+// unescapes to "á", as does "&#225;" and "&xE1;".
+// UnescapeString(EscapeString(s)) == s always holds, but the converse isn't
+// always true.
+func UnescapeString(s string) string {
+	for _, c := range s {
+		if c == '&' {
+			return string(unescape([]byte(s), false))
+		}
+	}
+	return s
+}
diff --git a/vendor/golang.org/x/net/html/foreign.go b/vendor/golang.org/x/net/html/foreign.go
new file mode 100644
index 00000000..01477a96
--- /dev/null
+++ b/vendor/golang.org/x/net/html/foreign.go
@@ -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.6.5.
+var breakout = map[string]bool{
+	"b":          true,
+	"big":        true,
+	"blockquote": true,
+	"body":       true,
+	"br":         true,
+	"center":     true,
+	"code":       true,
+	"dd":         true,
+	"div":        true,
+	"dl":         true,
+	"dt":         true,
+	"em":         true,
+	"embed":      true,
+	"h1":         true,
+	"h2":         true,
+	"h3":         true,
+	"h4":         true,
+	"h5":         true,
+	"h6":         true,
+	"head":       true,
+	"hr":         true,
+	"i":          true,
+	"img":        true,
+	"li":         true,
+	"listing":    true,
+	"menu":       true,
+	"meta":       true,
+	"nobr":       true,
+	"ol":         true,
+	"p":          true,
+	"pre":        true,
+	"ruby":       true,
+	"s":          true,
+	"small":      true,
+	"span":       true,
+	"strong":     true,
+	"strike":     true,
+	"sub":        true,
+	"sup":        true,
+	"table":      true,
+	"tt":         true,
+	"u":          true,
+	"ul":         true,
+	"var":        true,
+}
+
+// Section 12.2.6.5.
+var svgTagNameAdjustments = map[string]string{
+	"altglyph":            "altGlyph",
+	"altglyphdef":         "altGlyphDef",
+	"altglyphitem":        "altGlyphItem",
+	"animatecolor":        "animateColor",
+	"animatemotion":       "animateMotion",
+	"animatetransform":    "animateTransform",
+	"clippath":            "clipPath",
+	"feblend":             "feBlend",
+	"fecolormatrix":       "feColorMatrix",
+	"fecomponenttransfer": "feComponentTransfer",
+	"fecomposite":         "feComposite",
+	"feconvolvematrix":    "feConvolveMatrix",
+	"fediffuselighting":   "feDiffuseLighting",
+	"fedisplacementmap":   "feDisplacementMap",
+	"fedistantlight":      "feDistantLight",
+	"feflood":             "feFlood",
+	"fefunca":             "feFuncA",
+	"fefuncb":             "feFuncB",
+	"fefuncg":             "feFuncG",
+	"fefuncr":             "feFuncR",
+	"fegaussianblur":      "feGaussianBlur",
+	"feimage":             "feImage",
+	"femerge":             "feMerge",
+	"femergenode":         "feMergeNode",
+	"femorphology":        "feMorphology",
+	"feoffset":            "feOffset",
+	"fepointlight":        "fePointLight",
+	"fespecularlighting":  "feSpecularLighting",
+	"fespotlight":         "feSpotLight",
+	"fetile":              "feTile",
+	"feturbulence":        "feTurbulence",
+	"foreignobject":       "foreignObject",
+	"glyphref":            "glyphRef",
+	"lineargradient":      "linearGradient",
+	"radialgradient":      "radialGradient",
+	"textpath":            "textPath",
+}
+
+// Section 12.2.6.1
+var mathMLAttributeAdjustments = map[string]string{
+	"definitionurl": "definitionURL",
+}
+
+var svgAttributeAdjustments = map[string]string{
+	"attributename":             "attributeName",
+	"attributetype":             "attributeType",
+	"basefrequency":             "baseFrequency",
+	"baseprofile":               "baseProfile",
+	"calcmode":                  "calcMode",
+	"clippathunits":             "clipPathUnits",
+	"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",
+}
diff --git a/vendor/golang.org/x/net/html/node.go b/vendor/golang.org/x/net/html/node.go
new file mode 100644
index 00000000..633ee15d
--- /dev/null
+++ b/vendor/golang.org/x/net/html/node.go
@@ -0,0 +1,220 @@
+// 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.4.3 says "The markers are inserted when entering applet,
+// object, marquee, template, td, th, and caption elements, and are used
+// to prevent formatting from "leaking" into applet, object, marquee,
+// template, td, th, and caption elements".
+var scopeMarker = Node{Type: scopeMarkerNode}
+
+// A Node consists of a NodeType and some Data (tag name for element nodes,
+// content for text) and are part of a tree of Nodes. Element nodes may also
+// have a Namespace and contain a slice of Attributes. Data is unescaped, so
+// that it looks like "a<b" rather than "a&lt;b". For element nodes, DataAtom
+// is the atom for Data, or zero if Data is not a known tag name.
+//
+// An empty Namespace implies a "http://www.w3.org/1999/xhtml" namespace.
+// Similarly, "math" is short for "http://www.w3.org/1998/Math/MathML", and
+// "svg" is short for "http://www.w3.org/2000/svg".
+type Node struct {
+	Parent, FirstChild, LastChild, PrevSibling, NextSibling *Node
+
+	Type      NodeType
+	DataAtom  atom.Atom
+	Data      string
+	Namespace string
+	Attr      []Attribute
+}
+
+// InsertBefore inserts newChild as a child of n, immediately before oldChild
+// in the sequence of n's children. oldChild may be nil, in which case newChild
+// is appended to the end of n's children.
+//
+// It will panic if newChild already has a parent or siblings.
+func (n *Node) InsertBefore(newChild, oldChild *Node) {
+	if newChild.Parent != nil || newChild.PrevSibling != nil || newChild.NextSibling != nil {
+		panic("html: InsertBefore called for an attached child Node")
+	}
+	var prev, next *Node
+	if oldChild != nil {
+		prev, next = oldChild.PrevSibling, oldChild
+	} else {
+		prev = n.LastChild
+	}
+	if prev != nil {
+		prev.NextSibling = newChild
+	} else {
+		n.FirstChild = newChild
+	}
+	if next != nil {
+		next.PrevSibling = newChild
+	} else {
+		n.LastChild = newChild
+	}
+	newChild.Parent = n
+	newChild.PrevSibling = prev
+	newChild.NextSibling = next
+}
+
+// AppendChild adds a node c as a child of n.
+//
+// It will panic if c already has a parent or siblings.
+func (n *Node) AppendChild(c *Node) {
+	if c.Parent != nil || c.PrevSibling != nil || c.NextSibling != nil {
+		panic("html: AppendChild called for an attached child Node")
+	}
+	last := n.LastChild
+	if last != nil {
+		last.NextSibling = c
+	} else {
+		n.FirstChild = c
+	}
+	n.LastChild = c
+	c.Parent = n
+	c.PrevSibling = last
+}
+
+// RemoveChild removes a node c that is a child of n. Afterwards, c will have
+// no parent and no siblings.
+//
+// It will panic if c's parent is not n.
+func (n *Node) RemoveChild(c *Node) {
+	if c.Parent != n {
+		panic("html: RemoveChild called for a non-child Node")
+	}
+	if n.FirstChild == c {
+		n.FirstChild = c.NextSibling
+	}
+	if c.NextSibling != nil {
+		c.NextSibling.PrevSibling = c.PrevSibling
+	}
+	if n.LastChild == c {
+		n.LastChild = c.PrevSibling
+	}
+	if c.PrevSibling != nil {
+		c.PrevSibling.NextSibling = c.NextSibling
+	}
+	c.Parent = nil
+	c.PrevSibling = nil
+	c.NextSibling = nil
+}
+
+// reparentChildren reparents all of src's child nodes to dst.
+func reparentChildren(dst, src *Node) {
+	for {
+		child := src.FirstChild
+		if child == nil {
+			break
+		}
+		src.RemoveChild(child)
+		dst.AppendChild(child)
+	}
+}
+
+// clone returns a new node with the same type, data and attributes.
+// The clone has no parent, no siblings and no children.
+func (n *Node) clone() *Node {
+	m := &Node{
+		Type:     n.Type,
+		DataAtom: n.DataAtom,
+		Data:     n.Data,
+		Attr:     make([]Attribute, len(n.Attr)),
+	}
+	copy(m.Attr, n.Attr)
+	return m
+}
+
+// nodeStack is a stack of nodes.
+type nodeStack []*Node
+
+// pop pops the stack. It will panic if s is empty.
+func (s *nodeStack) pop() *Node {
+	i := len(*s)
+	n := (*s)[i-1]
+	*s = (*s)[:i-1]
+	return n
+}
+
+// top returns the most recently pushed node, or nil if s is empty.
+func (s *nodeStack) top() *Node {
+	if i := len(*s); i > 0 {
+		return (*s)[i-1]
+	}
+	return nil
+}
+
+// index returns the index of the top-most occurrence of n in the stack, or -1
+// if n is not present.
+func (s *nodeStack) index(n *Node) int {
+	for i := len(*s) - 1; i >= 0; i-- {
+		if (*s)[i] == n {
+			return i
+		}
+	}
+	return -1
+}
+
+// contains returns whether a is within s.
+func (s *nodeStack) contains(a atom.Atom) bool {
+	for _, n := range *s {
+		if n.DataAtom == a && n.Namespace == "" {
+			return true
+		}
+	}
+	return false
+}
+
+// insert inserts a node at the given index.
+func (s *nodeStack) insert(i int, n *Node) {
+	(*s) = append(*s, nil)
+	copy((*s)[i+1:], (*s)[i:])
+	(*s)[i] = n
+}
+
+// remove removes a node from the stack. It is a no-op if n is not present.
+func (s *nodeStack) remove(n *Node) {
+	i := s.index(n)
+	if i == -1 {
+		return
+	}
+	copy((*s)[i:], (*s)[i+1:])
+	j := len(*s) - 1
+	(*s)[j] = nil
+	*s = (*s)[:j]
+}
+
+type insertionModeStack []insertionMode
+
+func (s *insertionModeStack) pop() (im insertionMode) {
+	i := len(*s)
+	im = (*s)[i-1]
+	*s = (*s)[:i-1]
+	return im
+}
+
+func (s *insertionModeStack) top() insertionMode {
+	if i := len(*s); i > 0 {
+		return (*s)[i-1]
+	}
+	return nil
+}
diff --git a/vendor/golang.org/x/net/html/parse.go b/vendor/golang.org/x/net/html/parse.go
new file mode 100644
index 00000000..ca2cb587
--- /dev/null
+++ b/vendor/golang.org/x/net/html/parse.go
@@ -0,0 +1,2324 @@
+// Copyright 2010 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package html
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"strings"
+
+	a "golang.org/x/net/html/atom"
+)
+
+// A parser implements the HTML5 parsing algorithm:
+// https://html.spec.whatwg.org/multipage/syntax.html#tree-construction
+type parser struct {
+	// tokenizer provides the tokens for the parser.
+	tokenizer *Tokenizer
+	// tok is the most recently read token.
+	tok Token
+	// Self-closing tags like <hr/> are treated as start tags, except that
+	// hasSelfClosingToken is set while they are being processed.
+	hasSelfClosingToken bool
+	// doc is the document root element.
+	doc *Node
+	// The stack of open elements (section 12.2.4.2) and active formatting
+	// elements (section 12.2.4.3).
+	oe, afe nodeStack
+	// Element pointers (section 12.2.4.4).
+	head, form *Node
+	// Other parsing state flags (section 12.2.4.5).
+	scripting, framesetOK bool
+	// The stack of template insertion modes
+	templateStack insertionModeStack
+	// im is the current insertion mode.
+	im insertionMode
+	// originalIM is the insertion mode to go back to after completing a text
+	// or inTableText insertion mode.
+	originalIM insertionMode
+	// fosterParenting is whether new elements should be inserted according to
+	// the foster parenting rules (section 12.2.6.1).
+	fosterParenting bool
+	// quirks is whether the parser is operating in "quirks mode."
+	quirks bool
+	// fragment is whether the parser is parsing an HTML fragment.
+	fragment bool
+	// context is the context element when parsing an HTML fragment
+	// (section 12.4).
+	context *Node
+}
+
+func (p *parser) top() *Node {
+	if n := p.oe.top(); n != nil {
+		return n
+	}
+	return p.doc
+}
+
+// Stop tags for use in popUntil. These come from section 12.2.4.2.
+var (
+	defaultScopeStopTags = map[string][]a.Atom{
+		"":     {a.Applet, a.Caption, a.Html, a.Table, a.Td, a.Th, a.Marquee, a.Object, a.Template},
+		"math": {a.AnnotationXml, a.Mi, a.Mn, a.Mo, a.Ms, a.Mtext},
+		"svg":  {a.Desc, a.ForeignObject, a.Title},
+	}
+)
+
+type scope int
+
+const (
+	defaultScope scope = iota
+	listItemScope
+	buttonScope
+	tableScope
+	tableRowScope
+	tableBodyScope
+	selectScope
+)
+
+// popUntil pops the stack of open elements at the highest element whose tag
+// is in matchTags, provided there is no higher element in the scope's stop
+// tags (as defined in section 12.2.4.2). It returns whether or not there was
+// such an element. If there was not, popUntil leaves the stack unchanged.
+//
+// For example, the set of stop tags for table scope is: "html", "table". If
+// the stack was:
+// ["html", "body", "font", "table", "b", "i", "u"]
+// then popUntil(tableScope, "font") would return false, but
+// popUntil(tableScope, "i") would return true and the stack would become:
+// ["html", "body", "font", "table", "b"]
+//
+// If an element's tag is in both the stop tags and matchTags, then the stack
+// will be popped and the function returns true (provided, of course, there was
+// no higher element in the stack that was also in the stop tags). For example,
+// popUntil(tableScope, "table") returns true and leaves:
+// ["html", "body", "font"]
+func (p *parser) popUntil(s scope, matchTags ...a.Atom) bool {
+	if i := p.indexOfElementInScope(s, matchTags...); i != -1 {
+		p.oe = p.oe[:i]
+		return true
+	}
+	return false
+}
+
+// indexOfElementInScope returns the index in p.oe of the highest element whose
+// tag is in matchTags that is in scope. If no matching element is in scope, it
+// returns -1.
+func (p *parser) indexOfElementInScope(s scope, matchTags ...a.Atom) int {
+	for i := len(p.oe) - 1; i >= 0; i-- {
+		tagAtom := p.oe[i].DataAtom
+		if p.oe[i].Namespace == "" {
+			for _, t := range matchTags {
+				if t == tagAtom {
+					return i
+				}
+			}
+			switch s {
+			case defaultScope:
+				// No-op.
+			case listItemScope:
+				if tagAtom == a.Ol || tagAtom == a.Ul {
+					return -1
+				}
+			case buttonScope:
+				if tagAtom == a.Button {
+					return -1
+				}
+			case tableScope:
+				if tagAtom == a.Html || tagAtom == a.Table || tagAtom == a.Template {
+					return -1
+				}
+			case selectScope:
+				if tagAtom != a.Optgroup && tagAtom != a.Option {
+					return -1
+				}
+			default:
+				panic("unreachable")
+			}
+		}
+		switch s {
+		case defaultScope, listItemScope, buttonScope:
+			for _, t := range defaultScopeStopTags[p.oe[i].Namespace] {
+				if t == tagAtom {
+					return -1
+				}
+			}
+		}
+	}
+	return -1
+}
+
+// elementInScope is like popUntil, except that it doesn't modify the stack of
+// open elements.
+func (p *parser) elementInScope(s scope, matchTags ...a.Atom) bool {
+	return p.indexOfElementInScope(s, matchTags...) != -1
+}
+
+// clearStackToContext pops elements off the stack of open elements until a
+// scope-defined element is found.
+func (p *parser) clearStackToContext(s scope) {
+	for i := len(p.oe) - 1; i >= 0; i-- {
+		tagAtom := p.oe[i].DataAtom
+		switch s {
+		case tableScope:
+			if tagAtom == a.Html || tagAtom == a.Table || tagAtom == a.Template {
+				p.oe = p.oe[:i+1]
+				return
+			}
+		case tableRowScope:
+			if tagAtom == a.Html || tagAtom == a.Tr || tagAtom == a.Template {
+				p.oe = p.oe[:i+1]
+				return
+			}
+		case tableBodyScope:
+			if tagAtom == a.Html || tagAtom == a.Tbody || tagAtom == a.Tfoot || tagAtom == a.Thead || tagAtom == a.Template {
+				p.oe = p.oe[:i+1]
+				return
+			}
+		default:
+			panic("unreachable")
+		}
+	}
+}
+
+// generateImpliedEndTags pops nodes off the stack of open elements as long as
+// the top node has a tag name of dd, dt, li, optgroup, option, p, rb, rp, rt or rtc.
+// If exceptions are specified, nodes with that name will not be popped off.
+func (p *parser) generateImpliedEndTags(exceptions ...string) {
+	var i int
+loop:
+	for i = len(p.oe) - 1; i >= 0; i-- {
+		n := p.oe[i]
+		if n.Type == ElementNode {
+			switch n.DataAtom {
+			case a.Dd, a.Dt, a.Li, a.Optgroup, a.Option, a.P, a.Rb, a.Rp, a.Rt, a.Rtc:
+				for _, except := range exceptions {
+					if n.Data == except {
+						break loop
+					}
+				}
+				continue
+			}
+		}
+		break
+	}
+
+	p.oe = p.oe[:i+1]
+}
+
+// addChild adds a child node n to the top element, and pushes n onto the stack
+// of open elements if it is an element node.
+func (p *parser) addChild(n *Node) {
+	if p.shouldFosterParent() {
+		p.fosterParent(n)
+	} else {
+		p.top().AppendChild(n)
+	}
+
+	if n.Type == ElementNode {
+		p.oe = append(p.oe, n)
+	}
+}
+
+// shouldFosterParent returns whether the next node to be added should be
+// foster parented.
+func (p *parser) shouldFosterParent() bool {
+	if p.fosterParenting {
+		switch p.top().DataAtom {
+		case a.Table, a.Tbody, a.Tfoot, a.Thead, a.Tr:
+			return true
+		}
+	}
+	return false
+}
+
+// fosterParent adds a child node according to the foster parenting rules.
+// Section 12.2.6.1, "foster parenting".
+func (p *parser) fosterParent(n *Node) {
+	var table, parent, prev, template *Node
+	var i int
+	for i = len(p.oe) - 1; i >= 0; i-- {
+		if p.oe[i].DataAtom == a.Table {
+			table = p.oe[i]
+			break
+		}
+	}
+
+	var j int
+	for j = len(p.oe) - 1; j >= 0; j-- {
+		if p.oe[j].DataAtom == a.Template {
+			template = p.oe[j]
+			break
+		}
+	}
+
+	if template != nil && (table == nil || j > i) {
+		template.AppendChild(n)
+		return
+	}
+
+	if table == nil {
+		// The foster parent is the html element.
+		parent = p.oe[0]
+	} else {
+		parent = table.Parent
+	}
+	if parent == nil {
+		parent = p.oe[i-1]
+	}
+
+	if table != nil {
+		prev = table.PrevSibling
+	} else {
+		prev = parent.LastChild
+	}
+	if prev != nil && prev.Type == TextNode && n.Type == TextNode {
+		prev.Data += n.Data
+		return
+	}
+
+	parent.InsertBefore(n, table)
+}
+
+// addText adds text to the preceding node if it is a text node, or else it
+// calls addChild with a new text node.
+func (p *parser) addText(text string) {
+	if text == "" {
+		return
+	}
+
+	if p.shouldFosterParent() {
+		p.fosterParent(&Node{
+			Type: TextNode,
+			Data: text,
+		})
+		return
+	}
+
+	t := p.top()
+	if n := t.LastChild; n != nil && n.Type == TextNode {
+		n.Data += text
+		return
+	}
+	p.addChild(&Node{
+		Type: TextNode,
+		Data: text,
+	})
+}
+
+// addElement adds a child element based on the current token.
+func (p *parser) addElement() {
+	p.addChild(&Node{
+		Type:     ElementNode,
+		DataAtom: p.tok.DataAtom,
+		Data:     p.tok.Data,
+		Attr:     p.tok.Attr,
+	})
+}
+
+// Section 12.2.4.3.
+func (p *parser) addFormattingElement() {
+	tagAtom, attr := p.tok.DataAtom, p.tok.Attr
+	p.addElement()
+
+	// Implement the Noah's Ark clause, but with three per family instead of two.
+	identicalElements := 0
+findIdenticalElements:
+	for i := len(p.afe) - 1; i >= 0; i-- {
+		n := p.afe[i]
+		if n.Type == scopeMarkerNode {
+			break
+		}
+		if n.Type != ElementNode {
+			continue
+		}
+		if n.Namespace != "" {
+			continue
+		}
+		if n.DataAtom != tagAtom {
+			continue
+		}
+		if len(n.Attr) != len(attr) {
+			continue
+		}
+	compareAttributes:
+		for _, t0 := range n.Attr {
+			for _, t1 := range attr {
+				if t0.Key == t1.Key && t0.Namespace == t1.Namespace && t0.Val == t1.Val {
+					// Found a match for this attribute, continue with the next attribute.
+					continue compareAttributes
+				}
+			}
+			// If we get here, there is no attribute that matches a.
+			// Therefore the element is not identical to the new one.
+			continue findIdenticalElements
+		}
+
+		identicalElements++
+		if identicalElements >= 3 {
+			p.afe.remove(n)
+		}
+	}
+
+	p.afe = append(p.afe, p.top())
+}
+
+// Section 12.2.4.3.
+func (p *parser) clearActiveFormattingElements() {
+	for {
+		n := p.afe.pop()
+		if len(p.afe) == 0 || n.Type == scopeMarkerNode {
+			return
+		}
+	}
+}
+
+// Section 12.2.4.3.
+func (p *parser) reconstructActiveFormattingElements() {
+	n := p.afe.top()
+	if n == nil {
+		return
+	}
+	if n.Type == scopeMarkerNode || p.oe.index(n) != -1 {
+		return
+	}
+	i := len(p.afe) - 1
+	for n.Type != scopeMarkerNode && p.oe.index(n) == -1 {
+		if i == 0 {
+			i = -1
+			break
+		}
+		i--
+		n = p.afe[i]
+	}
+	for {
+		i++
+		clone := p.afe[i].clone()
+		p.addChild(clone)
+		p.afe[i] = clone
+		if i == len(p.afe)-1 {
+			break
+		}
+	}
+}
+
+// Section 12.2.5.
+func (p *parser) acknowledgeSelfClosingTag() {
+	p.hasSelfClosingToken = false
+}
+
+// An insertion mode (section 12.2.4.1) is the state transition function from
+// a particular state in the HTML5 parser's state machine. It updates the
+// parser's fields depending on parser.tok (where ErrorToken means EOF).
+// It returns whether the token was consumed.
+type insertionMode func(*parser) bool
+
+// setOriginalIM sets the insertion mode to return to after completing a text or
+// inTableText insertion mode.
+// Section 12.2.4.1, "using the rules for".
+func (p *parser) setOriginalIM() {
+	if p.originalIM != nil {
+		panic("html: bad parser state: originalIM was set twice")
+	}
+	p.originalIM = p.im
+}
+
+// Section 12.2.4.1, "reset the insertion mode".
+func (p *parser) resetInsertionMode() {
+	for i := len(p.oe) - 1; i >= 0; i-- {
+		n := p.oe[i]
+		last := i == 0
+		if last && p.context != nil {
+			n = p.context
+		}
+
+		switch n.DataAtom {
+		case a.Select:
+			if !last {
+				for ancestor, first := n, p.oe[0]; ancestor != first; {
+					ancestor = p.oe[p.oe.index(ancestor)-1]
+					switch ancestor.DataAtom {
+					case a.Template:
+						p.im = inSelectIM
+						return
+					case a.Table:
+						p.im = inSelectInTableIM
+						return
+					}
+				}
+			}
+			p.im = inSelectIM
+		case a.Td, a.Th:
+			// TODO: remove this divergence from the HTML5 spec.
+			//
+			// See https://bugs.chromium.org/p/chromium/issues/detail?id=829668
+			p.im = inCellIM
+		case a.Tr:
+			p.im = inRowIM
+		case a.Tbody, a.Thead, a.Tfoot:
+			p.im = inTableBodyIM
+		case a.Caption:
+			p.im = inCaptionIM
+		case a.Colgroup:
+			p.im = inColumnGroupIM
+		case a.Table:
+			p.im = inTableIM
+		case a.Template:
+			// TODO: remove this divergence from the HTML5 spec.
+			if n.Namespace != "" {
+				continue
+			}
+			p.im = p.templateStack.top()
+		case a.Head:
+			// TODO: remove this divergence from the HTML5 spec.
+			//
+			// See https://bugs.chromium.org/p/chromium/issues/detail?id=829668
+			p.im = inHeadIM
+		case a.Body:
+			p.im = inBodyIM
+		case a.Frameset:
+			p.im = inFramesetIM
+		case a.Html:
+			if p.head == nil {
+				p.im = beforeHeadIM
+			} else {
+				p.im = afterHeadIM
+			}
+		default:
+			if last {
+				p.im = inBodyIM
+				return
+			}
+			continue
+		}
+		return
+	}
+}
+
+const whitespace = " \t\r\n\f"
+
+// Section 12.2.6.4.1.
+func initialIM(p *parser) bool {
+	switch p.tok.Type {
+	case TextToken:
+		p.tok.Data = strings.TrimLeft(p.tok.Data, whitespace)
+		if len(p.tok.Data) == 0 {
+			// It was all whitespace, so ignore it.
+			return true
+		}
+	case CommentToken:
+		p.doc.AppendChild(&Node{
+			Type: CommentNode,
+			Data: p.tok.Data,
+		})
+		return true
+	case DoctypeToken:
+		n, quirks := parseDoctype(p.tok.Data)
+		p.doc.AppendChild(n)
+		p.quirks = quirks
+		p.im = beforeHTMLIM
+		return true
+	}
+	p.quirks = true
+	p.im = beforeHTMLIM
+	return false
+}
+
+// Section 12.2.6.4.2.
+func beforeHTMLIM(p *parser) bool {
+	switch p.tok.Type {
+	case DoctypeToken:
+		// Ignore the token.
+		return true
+	case TextToken:
+		p.tok.Data = strings.TrimLeft(p.tok.Data, whitespace)
+		if len(p.tok.Data) == 0 {
+			// It was all whitespace, so ignore it.
+			return true
+		}
+	case StartTagToken:
+		if p.tok.DataAtom == a.Html {
+			p.addElement()
+			p.im = beforeHeadIM
+			return true
+		}
+	case EndTagToken:
+		switch p.tok.DataAtom {
+		case a.Head, a.Body, a.Html, a.Br:
+			p.parseImpliedToken(StartTagToken, a.Html, a.Html.String())
+			return false
+		default:
+			// Ignore the token.
+			return true
+		}
+	case CommentToken:
+		p.doc.AppendChild(&Node{
+			Type: CommentNode,
+			Data: p.tok.Data,
+		})
+		return true
+	}
+	p.parseImpliedToken(StartTagToken, a.Html, a.Html.String())
+	return false
+}
+
+// Section 12.2.6.4.3.
+func beforeHeadIM(p *parser) bool {
+	switch p.tok.Type {
+	case TextToken:
+		p.tok.Data = strings.TrimLeft(p.tok.Data, whitespace)
+		if len(p.tok.Data) == 0 {
+			// It was all whitespace, so ignore it.
+			return true
+		}
+	case StartTagToken:
+		switch p.tok.DataAtom {
+		case a.Head:
+			p.addElement()
+			p.head = p.top()
+			p.im = inHeadIM
+			return true
+		case a.Html:
+			return inBodyIM(p)
+		}
+	case EndTagToken:
+		switch p.tok.DataAtom {
+		case a.Head, a.Body, a.Html, a.Br:
+			p.parseImpliedToken(StartTagToken, a.Head, a.Head.String())
+			return false
+		default:
+			// Ignore the token.
+			return true
+		}
+	case CommentToken:
+		p.addChild(&Node{
+			Type: CommentNode,
+			Data: p.tok.Data,
+		})
+		return true
+	case DoctypeToken:
+		// Ignore the token.
+		return true
+	}
+
+	p.parseImpliedToken(StartTagToken, a.Head, a.Head.String())
+	return false
+}
+
+// Section 12.2.6.4.4.
+func inHeadIM(p *parser) bool {
+	switch p.tok.Type {
+	case TextToken:
+		s := strings.TrimLeft(p.tok.Data, whitespace)
+		if len(s) < len(p.tok.Data) {
+			// Add the initial whitespace to the current node.
+			p.addText(p.tok.Data[:len(p.tok.Data)-len(s)])
+			if s == "" {
+				return true
+			}
+			p.tok.Data = s
+		}
+	case StartTagToken:
+		switch p.tok.DataAtom {
+		case a.Html:
+			return inBodyIM(p)
+		case a.Base, a.Basefont, a.Bgsound, a.Command, a.Link, a.Meta:
+			p.addElement()
+			p.oe.pop()
+			p.acknowledgeSelfClosingTag()
+			return true
+		case a.Script, a.Title, a.Noscript, a.Noframes, a.Style:
+			p.addElement()
+			p.setOriginalIM()
+			p.im = textIM
+			return true
+		case a.Head:
+			// Ignore the token.
+			return true
+		case a.Template:
+			p.addElement()
+			p.afe = append(p.afe, &scopeMarker)
+			p.framesetOK = false
+			p.im = inTemplateIM
+			p.templateStack = append(p.templateStack, inTemplateIM)
+			return true
+		}
+	case EndTagToken:
+		switch p.tok.DataAtom {
+		case a.Head:
+			p.oe.pop()
+			p.im = afterHeadIM
+			return true
+		case a.Body, a.Html, a.Br:
+			p.parseImpliedToken(EndTagToken, a.Head, a.Head.String())
+			return false
+		case a.Template:
+			if !p.oe.contains(a.Template) {
+				return true
+			}
+			// TODO: remove this divergence from the HTML5 spec.
+			//
+			// See https://bugs.chromium.org/p/chromium/issues/detail?id=829668
+			p.generateImpliedEndTags()
+			for i := len(p.oe) - 1; i >= 0; i-- {
+				if n := p.oe[i]; n.Namespace == "" && n.DataAtom == a.Template {
+					p.oe = p.oe[:i]
+					break
+				}
+			}
+			p.clearActiveFormattingElements()
+			p.templateStack.pop()
+			p.resetInsertionMode()
+			return true
+		default:
+			// Ignore the token.
+			return true
+		}
+	case CommentToken:
+		p.addChild(&Node{
+			Type: CommentNode,
+			Data: p.tok.Data,
+		})
+		return true
+	case DoctypeToken:
+		// Ignore the token.
+		return true
+	}
+
+	p.parseImpliedToken(EndTagToken, a.Head, a.Head.String())
+	return false
+}
+
+// Section 12.2.6.4.6.
+func afterHeadIM(p *parser) bool {
+	switch p.tok.Type {
+	case TextToken:
+		s := strings.TrimLeft(p.tok.Data, whitespace)
+		if len(s) < len(p.tok.Data) {
+			// Add the initial whitespace to the current node.
+			p.addText(p.tok.Data[:len(p.tok.Data)-len(s)])
+			if s == "" {
+				return true
+			}
+			p.tok.Data = s
+		}
+	case StartTagToken:
+		switch p.tok.DataAtom {
+		case a.Html:
+			return inBodyIM(p)
+		case a.Body:
+			p.addElement()
+			p.framesetOK = false
+			p.im = inBodyIM
+			return true
+		case a.Frameset:
+			p.addElement()
+			p.im = inFramesetIM
+			return true
+		case a.Base, a.Basefont, a.Bgsound, a.Link, a.Meta, a.Noframes, a.Script, a.Style, a.Template, a.Title:
+			p.oe = append(p.oe, p.head)
+			defer p.oe.remove(p.head)
+			return inHeadIM(p)
+		case a.Head:
+			// Ignore the token.
+			return true
+		}
+	case EndTagToken:
+		switch p.tok.DataAtom {
+		case a.Body, a.Html, a.Br:
+			// Drop down to creating an implied <body> tag.
+		case a.Template:
+			return inHeadIM(p)
+		default:
+			// Ignore the token.
+			return true
+		}
+	case CommentToken:
+		p.addChild(&Node{
+			Type: CommentNode,
+			Data: p.tok.Data,
+		})
+		return true
+	case DoctypeToken:
+		// Ignore the token.
+		return true
+	}
+
+	p.parseImpliedToken(StartTagToken, a.Body, a.Body.String())
+	p.framesetOK = true
+	return false
+}
+
+// copyAttributes copies attributes of src not found on dst to dst.
+func copyAttributes(dst *Node, src Token) {
+	if len(src.Attr) == 0 {
+		return
+	}
+	attr := map[string]string{}
+	for _, t := range dst.Attr {
+		attr[t.Key] = t.Val
+	}
+	for _, t := range src.Attr {
+		if _, ok := attr[t.Key]; !ok {
+			dst.Attr = append(dst.Attr, t)
+			attr[t.Key] = t.Val
+		}
+	}
+}
+
+// Section 12.2.6.4.7.
+func inBodyIM(p *parser) bool {
+	switch p.tok.Type {
+	case TextToken:
+		d := p.tok.Data
+		switch n := p.oe.top(); n.DataAtom {
+		case a.Pre, a.Listing:
+			if n.FirstChild == nil {
+				// Ignore a newline at the start of a <pre> block.
+				if d != "" && d[0] == '\r' {
+					d = d[1:]
+				}
+				if d != "" && d[0] == '\n' {
+					d = d[1:]
+				}
+			}
+		}
+		d = strings.Replace(d, "\x00", "", -1)
+		if d == "" {
+			return true
+		}
+		p.reconstructActiveFormattingElements()
+		p.addText(d)
+		if p.framesetOK && strings.TrimLeft(d, whitespace) != "" {
+			// There were non-whitespace characters inserted.
+			p.framesetOK = false
+		}
+	case StartTagToken:
+		switch p.tok.DataAtom {
+		case a.Html:
+			if p.oe.contains(a.Template) {
+				return true
+			}
+			copyAttributes(p.oe[0], p.tok)
+		case a.Base, a.Basefont, a.Bgsound, a.Command, a.Link, a.Meta, a.Noframes, a.Script, a.Style, a.Template, a.Title:
+			return inHeadIM(p)
+		case a.Body:
+			if p.oe.contains(a.Template) {
+				return true
+			}
+			if len(p.oe) >= 2 {
+				body := p.oe[1]
+				if body.Type == ElementNode && body.DataAtom == a.Body {
+					p.framesetOK = false
+					copyAttributes(body, p.tok)
+				}
+			}
+		case a.Frameset:
+			if !p.framesetOK || len(p.oe) < 2 || p.oe[1].DataAtom != a.Body {
+				// Ignore the token.
+				return true
+			}
+			body := p.oe[1]
+			if body.Parent != nil {
+				body.Parent.RemoveChild(body)
+			}
+			p.oe = p.oe[:1]
+			p.addElement()
+			p.im = inFramesetIM
+			return true
+		case a.Address, a.Article, a.Aside, a.Blockquote, a.Center, a.Details, a.Dir, a.Div, a.Dl, a.Fieldset, a.Figcaption, a.Figure, a.Footer, a.Header, a.Hgroup, a.Menu, a.Nav, a.Ol, a.P, a.Section, a.Summary, a.Ul:
+			p.popUntil(buttonScope, a.P)
+			p.addElement()
+		case a.H1, a.H2, a.H3, a.H4, a.H5, a.H6:
+			p.popUntil(buttonScope, a.P)
+			switch n := p.top(); n.DataAtom {
+			case a.H1, a.H2, a.H3, a.H4, a.H5, a.H6:
+				p.oe.pop()
+			}
+			p.addElement()
+		case a.Pre, a.Listing:
+			p.popUntil(buttonScope, a.P)
+			p.addElement()
+			// The newline, if any, will be dealt with by the TextToken case.
+			p.framesetOK = false
+		case a.Form:
+			if p.form != nil && !p.oe.contains(a.Template) {
+				// Ignore the token
+				return true
+			}
+			p.popUntil(buttonScope, a.P)
+			p.addElement()
+			if !p.oe.contains(a.Template) {
+				p.form = p.top()
+			}
+		case a.Li:
+			p.framesetOK = false
+			for i := len(p.oe) - 1; i >= 0; i-- {
+				node := p.oe[i]
+				switch node.DataAtom {
+				case a.Li:
+					p.oe = p.oe[:i]
+				case a.Address, a.Div, a.P:
+					continue
+				default:
+					if !isSpecialElement(node) {
+						continue
+					}
+				}
+				break
+			}
+			p.popUntil(buttonScope, a.P)
+			p.addElement()
+		case a.Dd, a.Dt:
+			p.framesetOK = false
+			for i := len(p.oe) - 1; i >= 0; i-- {
+				node := p.oe[i]
+				switch node.DataAtom {
+				case a.Dd, a.Dt:
+					p.oe = p.oe[:i]
+				case a.Address, a.Div, a.P:
+					continue
+				default:
+					if !isSpecialElement(node) {
+						continue
+					}
+				}
+				break
+			}
+			p.popUntil(buttonScope, a.P)
+			p.addElement()
+		case a.Plaintext:
+			p.popUntil(buttonScope, a.P)
+			p.addElement()
+		case a.Button:
+			p.popUntil(defaultScope, a.Button)
+			p.reconstructActiveFormattingElements()
+			p.addElement()
+			p.framesetOK = false
+		case a.A:
+			for i := len(p.afe) - 1; i >= 0 && p.afe[i].Type != scopeMarkerNode; i-- {
+				if n := p.afe[i]; n.Type == ElementNode && n.DataAtom == a.A {
+					p.inBodyEndTagFormatting(a.A)
+					p.oe.remove(n)
+					p.afe.remove(n)
+					break
+				}
+			}
+			p.reconstructActiveFormattingElements()
+			p.addFormattingElement()
+		case a.B, a.Big, a.Code, a.Em, a.Font, a.I, a.S, a.Small, a.Strike, a.Strong, a.Tt, a.U:
+			p.reconstructActiveFormattingElements()
+			p.addFormattingElement()
+		case a.Nobr:
+			p.reconstructActiveFormattingElements()
+			if p.elementInScope(defaultScope, a.Nobr) {
+				p.inBodyEndTagFormatting(a.Nobr)
+				p.reconstructActiveFormattingElements()
+			}
+			p.addFormattingElement()
+		case a.Applet, a.Marquee, a.Object:
+			p.reconstructActiveFormattingElements()
+			p.addElement()
+			p.afe = append(p.afe, &scopeMarker)
+			p.framesetOK = false
+		case a.Table:
+			if !p.quirks {
+				p.popUntil(buttonScope, a.P)
+			}
+			p.addElement()
+			p.framesetOK = false
+			p.im = inTableIM
+			return true
+		case a.Area, a.Br, a.Embed, a.Img, a.Input, a.Keygen, a.Wbr:
+			p.reconstructActiveFormattingElements()
+			p.addElement()
+			p.oe.pop()
+			p.acknowledgeSelfClosingTag()
+			if p.tok.DataAtom == a.Input {
+				for _, t := range p.tok.Attr {
+					if t.Key == "type" {
+						if strings.ToLower(t.Val) == "hidden" {
+							// Skip setting framesetOK = false
+							return true
+						}
+					}
+				}
+			}
+			p.framesetOK = false
+		case a.Param, a.Source, a.Track:
+			p.addElement()
+			p.oe.pop()
+			p.acknowledgeSelfClosingTag()
+		case a.Hr:
+			p.popUntil(buttonScope, a.P)
+			p.addElement()
+			p.oe.pop()
+			p.acknowledgeSelfClosingTag()
+			p.framesetOK = false
+		case a.Image:
+			p.tok.DataAtom = a.Img
+			p.tok.Data = a.Img.String()
+			return false
+		case a.Isindex:
+			if p.form != nil {
+				// Ignore the token.
+				return true
+			}
+			action := ""
+			prompt := "This is a searchable index. Enter search keywords: "
+			attr := []Attribute{{Key: "name", Val: "isindex"}}
+			for _, t := range p.tok.Attr {
+				switch t.Key {
+				case "action":
+					action = t.Val
+				case "name":
+					// Ignore the attribute.
+				case "prompt":
+					prompt = t.Val
+				default:
+					attr = append(attr, t)
+				}
+			}
+			p.acknowledgeSelfClosingTag()
+			p.popUntil(buttonScope, a.P)
+			p.parseImpliedToken(StartTagToken, a.Form, a.Form.String())
+			if p.form == nil {
+				// NOTE: The 'isindex' element has been removed,
+				// and the 'template' element has not been designed to be
+				// collaborative with the index element.
+				//
+				// Ignore the token.
+				return true
+			}
+			if action != "" {
+				p.form.Attr = []Attribute{{Key: "action", Val: action}}
+			}
+			p.parseImpliedToken(StartTagToken, a.Hr, a.Hr.String())
+			p.parseImpliedToken(StartTagToken, a.Label, a.Label.String())
+			p.addText(prompt)
+			p.addChild(&Node{
+				Type:     ElementNode,
+				DataAtom: a.Input,
+				Data:     a.Input.String(),
+				Attr:     attr,
+			})
+			p.oe.pop()
+			p.parseImpliedToken(EndTagToken, a.Label, a.Label.String())
+			p.parseImpliedToken(StartTagToken, a.Hr, a.Hr.String())
+			p.parseImpliedToken(EndTagToken, a.Form, a.Form.String())
+		case a.Textarea:
+			p.addElement()
+			p.setOriginalIM()
+			p.framesetOK = false
+			p.im = textIM
+		case a.Xmp:
+			p.popUntil(buttonScope, a.P)
+			p.reconstructActiveFormattingElements()
+			p.framesetOK = false
+			p.addElement()
+			p.setOriginalIM()
+			p.im = textIM
+		case a.Iframe:
+			p.framesetOK = false
+			p.addElement()
+			p.setOriginalIM()
+			p.im = textIM
+		case a.Noembed, a.Noscript:
+			p.addElement()
+			p.setOriginalIM()
+			p.im = textIM
+		case a.Select:
+			p.reconstructActiveFormattingElements()
+			p.addElement()
+			p.framesetOK = false
+			p.im = inSelectIM
+			return true
+		case a.Optgroup, a.Option:
+			if p.top().DataAtom == a.Option {
+				p.oe.pop()
+			}
+			p.reconstructActiveFormattingElements()
+			p.addElement()
+		case a.Rb, a.Rtc:
+			if p.elementInScope(defaultScope, a.Ruby) {
+				p.generateImpliedEndTags()
+			}
+			p.addElement()
+		case a.Rp, a.Rt:
+			if p.elementInScope(defaultScope, a.Ruby) {
+				p.generateImpliedEndTags("rtc")
+			}
+			p.addElement()
+		case a.Math, a.Svg:
+			p.reconstructActiveFormattingElements()
+			if p.tok.DataAtom == a.Math {
+				adjustAttributeNames(p.tok.Attr, mathMLAttributeAdjustments)
+			} else {
+				adjustAttributeNames(p.tok.Attr, svgAttributeAdjustments)
+			}
+			adjustForeignAttributes(p.tok.Attr)
+			p.addElement()
+			p.top().Namespace = p.tok.Data
+			if p.hasSelfClosingToken {
+				p.oe.pop()
+				p.acknowledgeSelfClosingTag()
+			}
+			return true
+		case a.Caption, a.Col, a.Colgroup, a.Frame, a.Head, a.Tbody, a.Td, a.Tfoot, a.Th, a.Thead, a.Tr:
+			// Ignore the token.
+		default:
+			p.reconstructActiveFormattingElements()
+			p.addElement()
+		}
+	case EndTagToken:
+		switch p.tok.DataAtom {
+		case a.Body:
+			if p.elementInScope(defaultScope, a.Body) {
+				p.im = afterBodyIM
+			}
+		case a.Html:
+			if p.elementInScope(defaultScope, a.Body) {
+				p.parseImpliedToken(EndTagToken, a.Body, a.Body.String())
+				return false
+			}
+			return true
+		case a.Address, a.Article, a.Aside, a.Blockquote, a.Button, a.Center, a.Details, a.Dir, a.Div, a.Dl, a.Fieldset, a.Figcaption, a.Figure, a.Footer, a.Header, a.Hgroup, a.Listing, a.Menu, a.Nav, a.Ol, a.Pre, a.Section, a.Summary, a.Ul:
+			p.popUntil(defaultScope, p.tok.DataAtom)
+		case a.Form:
+			if p.oe.contains(a.Template) {
+				i := p.indexOfElementInScope(defaultScope, a.Form)
+				if i == -1 {
+					// Ignore the token.
+					return true
+				}
+				p.generateImpliedEndTags()
+				if p.oe[i].DataAtom != a.Form {
+					// Ignore the token.
+					return true
+				}
+				p.popUntil(defaultScope, a.Form)
+			} else {
+				node := p.form
+				p.form = nil
+				i := p.indexOfElementInScope(defaultScope, a.Form)
+				if node == nil || i == -1 || p.oe[i] != node {
+					// Ignore the token.
+					return true
+				}
+				p.generateImpliedEndTags()
+				p.oe.remove(node)
+			}
+		case a.P:
+			if !p.elementInScope(buttonScope, a.P) {
+				p.parseImpliedToken(StartTagToken, a.P, a.P.String())
+			}
+			p.popUntil(buttonScope, a.P)
+		case a.Li:
+			p.popUntil(listItemScope, a.Li)
+		case a.Dd, a.Dt:
+			p.popUntil(defaultScope, p.tok.DataAtom)
+		case a.H1, a.H2, a.H3, a.H4, a.H5, a.H6:
+			p.popUntil(defaultScope, a.H1, a.H2, a.H3, a.H4, a.H5, a.H6)
+		case a.A, a.B, a.Big, a.Code, a.Em, a.Font, a.I, a.Nobr, a.S, a.Small, a.Strike, a.Strong, a.Tt, a.U:
+			p.inBodyEndTagFormatting(p.tok.DataAtom)
+		case a.Applet, a.Marquee, a.Object:
+			if p.popUntil(defaultScope, p.tok.DataAtom) {
+				p.clearActiveFormattingElements()
+			}
+		case a.Br:
+			p.tok.Type = StartTagToken
+			return false
+		case a.Template:
+			return inHeadIM(p)
+		default:
+			p.inBodyEndTagOther(p.tok.DataAtom)
+		}
+	case CommentToken:
+		p.addChild(&Node{
+			Type: CommentNode,
+			Data: p.tok.Data,
+		})
+	case ErrorToken:
+		// TODO: remove this divergence from the HTML5 spec.
+		if len(p.templateStack) > 0 {
+			p.im = inTemplateIM
+			return false
+		} else {
+			for _, e := range p.oe {
+				switch e.DataAtom {
+				case a.Dd, a.Dt, a.Li, a.Optgroup, a.Option, a.P, a.Rb, a.Rp, a.Rt, a.Rtc, a.Tbody, a.Td, a.Tfoot, a.Th,
+					a.Thead, a.Tr, a.Body, a.Html:
+				default:
+					return true
+				}
+			}
+		}
+	}
+
+	return true
+}
+
+func (p *parser) inBodyEndTagFormatting(tagAtom a.Atom) {
+	// This is the "adoption agency" algorithm, described at
+	// https://html.spec.whatwg.org/multipage/syntax.html#adoptionAgency
+
+	// TODO: this is a fairly literal line-by-line translation of that algorithm.
+	// Once the code successfully parses the comprehensive test suite, we should
+	// refactor this code to be more idiomatic.
+
+	// Steps 1-4. The outer loop.
+	for i := 0; i < 8; i++ {
+		// Step 5. Find the formatting element.
+		var formattingElement *Node
+		for j := len(p.afe) - 1; j >= 0; j-- {
+			if p.afe[j].Type == scopeMarkerNode {
+				break
+			}
+			if p.afe[j].DataAtom == tagAtom {
+				formattingElement = p.afe[j]
+				break
+			}
+		}
+		if formattingElement == nil {
+			p.inBodyEndTagOther(tagAtom)
+			return
+		}
+		feIndex := p.oe.index(formattingElement)
+		if feIndex == -1 {
+			p.afe.remove(formattingElement)
+			return
+		}
+		if !p.elementInScope(defaultScope, tagAtom) {
+			// Ignore the tag.
+			return
+		}
+
+		// Steps 9-10. Find the furthest block.
+		var furthestBlock *Node
+		for _, e := range p.oe[feIndex:] {
+			if isSpecialElement(e) {
+				furthestBlock = e
+				break
+			}
+		}
+		if furthestBlock == nil {
+			e := p.oe.pop()
+			for e != formattingElement {
+				e = p.oe.pop()
+			}
+			p.afe.remove(e)
+			return
+		}
+
+		// Steps 11-12. Find the common ancestor and bookmark node.
+		commonAncestor := p.oe[feIndex-1]
+		bookmark := p.afe.index(formattingElement)
+
+		// Step 13. The inner loop. Find the lastNode to reparent.
+		lastNode := furthestBlock
+		node := furthestBlock
+		x := p.oe.index(node)
+		// Steps 13.1-13.2
+		for j := 0; j < 3; j++ {
+			// Step 13.3.
+			x--
+			node = p.oe[x]
+			// Step 13.4 - 13.5.
+			if p.afe.index(node) == -1 {
+				p.oe.remove(node)
+				continue
+			}
+			// Step 13.6.
+			if node == formattingElement {
+				break
+			}
+			// Step 13.7.
+			clone := node.clone()
+			p.afe[p.afe.index(node)] = clone
+			p.oe[p.oe.index(node)] = clone
+			node = clone
+			// Step 13.8.
+			if lastNode == furthestBlock {
+				bookmark = p.afe.index(node) + 1
+			}
+			// Step 13.9.
+			if lastNode.Parent != nil {
+				lastNode.Parent.RemoveChild(lastNode)
+			}
+			node.AppendChild(lastNode)
+			// Step 13.10.
+			lastNode = node
+		}
+
+		// Step 14. Reparent lastNode to the common ancestor,
+		// or for misnested table nodes, to the foster parent.
+		if lastNode.Parent != nil {
+			lastNode.Parent.RemoveChild(lastNode)
+		}
+		switch commonAncestor.DataAtom {
+		case a.Table, a.Tbody, a.Tfoot, a.Thead, a.Tr:
+			p.fosterParent(lastNode)
+		default:
+			commonAncestor.AppendChild(lastNode)
+		}
+
+		// Steps 15-17. Reparent nodes from the furthest block's children
+		// to a clone of the formatting element.
+		clone := formattingElement.clone()
+		reparentChildren(clone, furthestBlock)
+		furthestBlock.AppendChild(clone)
+
+		// Step 18. Fix up the list of active formatting elements.
+		if oldLoc := p.afe.index(formattingElement); oldLoc != -1 && oldLoc < bookmark {
+			// Move the bookmark with the rest of the list.
+			bookmark--
+		}
+		p.afe.remove(formattingElement)
+		p.afe.insert(bookmark, clone)
+
+		// Step 19. Fix up the stack of open elements.
+		p.oe.remove(formattingElement)
+		p.oe.insert(p.oe.index(furthestBlock)+1, clone)
+	}
+}
+
+// inBodyEndTagOther performs the "any other end tag" algorithm for inBodyIM.
+// "Any other end tag" handling from 12.2.6.5 The rules for parsing tokens in foreign content
+// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inforeign
+func (p *parser) inBodyEndTagOther(tagAtom a.Atom) {
+	for i := len(p.oe) - 1; i >= 0; i-- {
+		if p.oe[i].DataAtom == tagAtom {
+			p.oe = p.oe[:i]
+			break
+		}
+		if isSpecialElement(p.oe[i]) {
+			break
+		}
+	}
+}
+
+// Section 12.2.6.4.8.
+func textIM(p *parser) bool {
+	switch p.tok.Type {
+	case ErrorToken:
+		p.oe.pop()
+	case TextToken:
+		d := p.tok.Data
+		if n := p.oe.top(); n.DataAtom == a.Textarea && n.FirstChild == nil {
+			// Ignore a newline at the start of a <textarea> block.
+			if d != "" && d[0] == '\r' {
+				d = d[1:]
+			}
+			if d != "" && d[0] == '\n' {
+				d = d[1:]
+			}
+		}
+		if d == "" {
+			return true
+		}
+		p.addText(d)
+		return true
+	case EndTagToken:
+		p.oe.pop()
+	}
+	p.im = p.originalIM
+	p.originalIM = nil
+	return p.tok.Type == EndTagToken
+}
+
+// Section 12.2.6.4.9.
+func inTableIM(p *parser) bool {
+	switch p.tok.Type {
+	case TextToken:
+		p.tok.Data = strings.Replace(p.tok.Data, "\x00", "", -1)
+		switch p.oe.top().DataAtom {
+		case a.Table, a.Tbody, a.Tfoot, a.Thead, a.Tr:
+			if strings.Trim(p.tok.Data, whitespace) == "" {
+				p.addText(p.tok.Data)
+				return true
+			}
+		}
+	case StartTagToken:
+		switch p.tok.DataAtom {
+		case a.Caption:
+			p.clearStackToContext(tableScope)
+			p.afe = append(p.afe, &scopeMarker)
+			p.addElement()
+			p.im = inCaptionIM
+			return true
+		case a.Colgroup:
+			p.clearStackToContext(tableScope)
+			p.addElement()
+			p.im = inColumnGroupIM
+			return true
+		case a.Col:
+			p.parseImpliedToken(StartTagToken, a.Colgroup, a.Colgroup.String())
+			return false
+		case a.Tbody, a.Tfoot, a.Thead:
+			p.clearStackToContext(tableScope)
+			p.addElement()
+			p.im = inTableBodyIM
+			return true
+		case a.Td, a.Th, a.Tr:
+			p.parseImpliedToken(StartTagToken, a.Tbody, a.Tbody.String())
+			return false
+		case a.Table:
+			if p.popUntil(tableScope, a.Table) {
+				p.resetInsertionMode()
+				return false
+			}
+			// Ignore the token.
+			return true
+		case a.Style, a.Script, a.Template:
+			return inHeadIM(p)
+		case a.Input:
+			for _, t := range p.tok.Attr {
+				if t.Key == "type" && strings.ToLower(t.Val) == "hidden" {
+					p.addElement()
+					p.oe.pop()
+					return true
+				}
+			}
+			// Otherwise drop down to the default action.
+		case a.Form:
+			if p.oe.contains(a.Template) || p.form != nil {
+				// Ignore the token.
+				return true
+			}
+			p.addElement()
+			p.form = p.oe.pop()
+		case a.Select:
+			p.reconstructActiveFormattingElements()
+			switch p.top().DataAtom {
+			case a.Table, a.Tbody, a.Tfoot, a.Thead, a.Tr:
+				p.fosterParenting = true
+			}
+			p.addElement()
+			p.fosterParenting = false
+			p.framesetOK = false
+			p.im = inSelectInTableIM
+			return true
+		}
+	case EndTagToken:
+		switch p.tok.DataAtom {
+		case a.Table:
+			if p.popUntil(tableScope, a.Table) {
+				p.resetInsertionMode()
+				return true
+			}
+			// Ignore the token.
+			return true
+		case a.Body, a.Caption, a.Col, a.Colgroup, a.Html, a.Tbody, a.Td, a.Tfoot, a.Th, a.Thead, a.Tr:
+			// Ignore the token.
+			return true
+		case a.Template:
+			return inHeadIM(p)
+		}
+	case CommentToken:
+		p.addChild(&Node{
+			Type: CommentNode,
+			Data: p.tok.Data,
+		})
+		return true
+	case DoctypeToken:
+		// Ignore the token.
+		return true
+	case ErrorToken:
+		return inBodyIM(p)
+	}
+
+	p.fosterParenting = true
+	defer func() { p.fosterParenting = false }()
+
+	return inBodyIM(p)
+}
+
+// Section 12.2.6.4.11.
+func inCaptionIM(p *parser) bool {
+	switch p.tok.Type {
+	case StartTagToken:
+		switch p.tok.DataAtom {
+		case a.Caption, a.Col, a.Colgroup, a.Tbody, a.Td, a.Tfoot, a.Thead, a.Tr:
+			if p.popUntil(tableScope, a.Caption) {
+				p.clearActiveFormattingElements()
+				p.im = inTableIM
+				return false
+			} else {
+				// Ignore the token.
+				return true
+			}
+		case a.Select:
+			p.reconstructActiveFormattingElements()
+			p.addElement()
+			p.framesetOK = false
+			p.im = inSelectInTableIM
+			return true
+		}
+	case EndTagToken:
+		switch p.tok.DataAtom {
+		case a.Caption:
+			if p.popUntil(tableScope, a.Caption) {
+				p.clearActiveFormattingElements()
+				p.im = inTableIM
+			}
+			return true
+		case a.Table:
+			if p.popUntil(tableScope, a.Caption) {
+				p.clearActiveFormattingElements()
+				p.im = inTableIM
+				return false
+			} else {
+				// Ignore the token.
+				return true
+			}
+		case a.Body, a.Col, a.Colgroup, a.Html, a.Tbody, a.Td, a.Tfoot, a.Th, a.Thead, a.Tr:
+			// Ignore the token.
+			return true
+		}
+	}
+	return inBodyIM(p)
+}
+
+// Section 12.2.6.4.12.
+func inColumnGroupIM(p *parser) bool {
+	switch p.tok.Type {
+	case TextToken:
+		s := strings.TrimLeft(p.tok.Data, whitespace)
+		if len(s) < len(p.tok.Data) {
+			// Add the initial whitespace to the current node.
+			p.addText(p.tok.Data[:len(p.tok.Data)-len(s)])
+			if s == "" {
+				return true
+			}
+			p.tok.Data = s
+		}
+	case CommentToken:
+		p.addChild(&Node{
+			Type: CommentNode,
+			Data: p.tok.Data,
+		})
+		return true
+	case DoctypeToken:
+		// Ignore the token.
+		return true
+	case StartTagToken:
+		switch p.tok.DataAtom {
+		case a.Html:
+			return inBodyIM(p)
+		case a.Col:
+			p.addElement()
+			p.oe.pop()
+			p.acknowledgeSelfClosingTag()
+			return true
+		case a.Template:
+			return inHeadIM(p)
+		}
+	case EndTagToken:
+		switch p.tok.DataAtom {
+		case a.Colgroup:
+			if p.oe.top().DataAtom == a.Colgroup {
+				p.oe.pop()
+				p.im = inTableIM
+			}
+			return true
+		case a.Col:
+			// Ignore the token.
+			return true
+		case a.Template:
+			return inHeadIM(p)
+		}
+	case ErrorToken:
+		return inBodyIM(p)
+	}
+	if p.oe.top().DataAtom != a.Colgroup {
+		return true
+	}
+	p.oe.pop()
+	p.im = inTableIM
+	return false
+}
+
+// Section 12.2.6.4.13.
+func inTableBodyIM(p *parser) bool {
+	switch p.tok.Type {
+	case StartTagToken:
+		switch p.tok.DataAtom {
+		case a.Tr:
+			p.clearStackToContext(tableBodyScope)
+			p.addElement()
+			p.im = inRowIM
+			return true
+		case a.Td, a.Th:
+			p.parseImpliedToken(StartTagToken, a.Tr, a.Tr.String())
+			return false
+		case a.Caption, a.Col, a.Colgroup, a.Tbody, a.Tfoot, a.Thead:
+			if p.popUntil(tableScope, a.Tbody, a.Thead, a.Tfoot) {
+				p.im = inTableIM
+				return false
+			}
+			// Ignore the token.
+			return true
+		}
+	case EndTagToken:
+		switch p.tok.DataAtom {
+		case a.Tbody, a.Tfoot, a.Thead:
+			if p.elementInScope(tableScope, p.tok.DataAtom) {
+				p.clearStackToContext(tableBodyScope)
+				p.oe.pop()
+				p.im = inTableIM
+			}
+			return true
+		case a.Table:
+			if p.popUntil(tableScope, a.Tbody, a.Thead, a.Tfoot) {
+				p.im = inTableIM
+				return false
+			}
+			// Ignore the token.
+			return true
+		case a.Body, a.Caption, a.Col, a.Colgroup, a.Html, a.Td, a.Th, a.Tr:
+			// Ignore the token.
+			return true
+		}
+	case CommentToken:
+		p.addChild(&Node{
+			Type: CommentNode,
+			Data: p.tok.Data,
+		})
+		return true
+	}
+
+	return inTableIM(p)
+}
+
+// Section 12.2.6.4.14.
+func inRowIM(p *parser) bool {
+	switch p.tok.Type {
+	case StartTagToken:
+		switch p.tok.DataAtom {
+		case a.Td, a.Th:
+			p.clearStackToContext(tableRowScope)
+			p.addElement()
+			p.afe = append(p.afe, &scopeMarker)
+			p.im = inCellIM
+			return true
+		case a.Caption, a.Col, a.Colgroup, a.Tbody, a.Tfoot, a.Thead, a.Tr:
+			if p.popUntil(tableScope, a.Tr) {
+				p.im = inTableBodyIM
+				return false
+			}
+			// Ignore the token.
+			return true
+		}
+	case EndTagToken:
+		switch p.tok.DataAtom {
+		case a.Tr:
+			if p.popUntil(tableScope, a.Tr) {
+				p.im = inTableBodyIM
+				return true
+			}
+			// Ignore the token.
+			return true
+		case a.Table:
+			if p.popUntil(tableScope, a.Tr) {
+				p.im = inTableBodyIM
+				return false
+			}
+			// Ignore the token.
+			return true
+		case a.Tbody, a.Tfoot, a.Thead:
+			if p.elementInScope(tableScope, p.tok.DataAtom) {
+				p.parseImpliedToken(EndTagToken, a.Tr, a.Tr.String())
+				return false
+			}
+			// Ignore the token.
+			return true
+		case a.Body, a.Caption, a.Col, a.Colgroup, a.Html, a.Td, a.Th:
+			// Ignore the token.
+			return true
+		}
+	}
+
+	return inTableIM(p)
+}
+
+// Section 12.2.6.4.15.
+func inCellIM(p *parser) bool {
+	switch p.tok.Type {
+	case StartTagToken:
+		switch p.tok.DataAtom {
+		case a.Caption, a.Col, a.Colgroup, a.Tbody, a.Td, a.Tfoot, a.Th, a.Thead, a.Tr:
+			if p.popUntil(tableScope, a.Td, a.Th) {
+				// Close the cell and reprocess.
+				p.clearActiveFormattingElements()
+				p.im = inRowIM
+				return false
+			}
+			// Ignore the token.
+			return true
+		case a.Select:
+			p.reconstructActiveFormattingElements()
+			p.addElement()
+			p.framesetOK = false
+			p.im = inSelectInTableIM
+			return true
+		}
+	case EndTagToken:
+		switch p.tok.DataAtom {
+		case a.Td, a.Th:
+			if !p.popUntil(tableScope, p.tok.DataAtom) {
+				// Ignore the token.
+				return true
+			}
+			p.clearActiveFormattingElements()
+			p.im = inRowIM
+			return true
+		case a.Body, a.Caption, a.Col, a.Colgroup, a.Html:
+			// Ignore the token.
+			return true
+		case a.Table, a.Tbody, a.Tfoot, a.Thead, a.Tr:
+			if !p.elementInScope(tableScope, p.tok.DataAtom) {
+				// Ignore the token.
+				return true
+			}
+			// Close the cell and reprocess.
+			p.popUntil(tableScope, a.Td, a.Th)
+			p.clearActiveFormattingElements()
+			p.im = inRowIM
+			return false
+		}
+	}
+	return inBodyIM(p)
+}
+
+// Section 12.2.6.4.16.
+func inSelectIM(p *parser) bool {
+	switch p.tok.Type {
+	case TextToken:
+		p.addText(strings.Replace(p.tok.Data, "\x00", "", -1))
+	case StartTagToken:
+		switch p.tok.DataAtom {
+		case a.Html:
+			return inBodyIM(p)
+		case a.Option:
+			if p.top().DataAtom == a.Option {
+				p.oe.pop()
+			}
+			p.addElement()
+		case a.Optgroup:
+			if p.top().DataAtom == a.Option {
+				p.oe.pop()
+			}
+			if p.top().DataAtom == a.Optgroup {
+				p.oe.pop()
+			}
+			p.addElement()
+		case a.Select:
+			if p.popUntil(selectScope, a.Select) {
+				p.resetInsertionMode()
+			} else {
+				// Ignore the token.
+				return true
+			}
+		case a.Input, a.Keygen, a.Textarea:
+			if p.elementInScope(selectScope, a.Select) {
+				p.parseImpliedToken(EndTagToken, a.Select, a.Select.String())
+				return false
+			}
+			// In order to properly ignore <textarea>, we need to change the tokenizer mode.
+			p.tokenizer.NextIsNotRawText()
+			// Ignore the token.
+			return true
+		case a.Script, a.Template:
+			return inHeadIM(p)
+		}
+	case EndTagToken:
+		switch p.tok.DataAtom {
+		case a.Option:
+			if p.top().DataAtom == a.Option {
+				p.oe.pop()
+			}
+		case a.Optgroup:
+			i := len(p.oe) - 1
+			if p.oe[i].DataAtom == a.Option {
+				i--
+			}
+			if p.oe[i].DataAtom == a.Optgroup {
+				p.oe = p.oe[:i]
+			}
+		case a.Select:
+			if p.popUntil(selectScope, a.Select) {
+				p.resetInsertionMode()
+			} else {
+				// Ignore the token.
+				return true
+			}
+		case a.Template:
+			return inHeadIM(p)
+		}
+	case CommentToken:
+		p.addChild(&Node{
+			Type: CommentNode,
+			Data: p.tok.Data,
+		})
+	case DoctypeToken:
+		// Ignore the token.
+		return true
+	case ErrorToken:
+		return inBodyIM(p)
+	}
+
+	return true
+}
+
+// Section 12.2.6.4.17.
+func inSelectInTableIM(p *parser) bool {
+	switch p.tok.Type {
+	case StartTagToken, EndTagToken:
+		switch p.tok.DataAtom {
+		case a.Caption, a.Table, a.Tbody, a.Tfoot, a.Thead, a.Tr, a.Td, a.Th:
+			if p.tok.Type == EndTagToken && !p.elementInScope(tableScope, p.tok.DataAtom) {
+				// Ignore the token.
+				return true
+			}
+			// This is like p.popUntil(selectScope, a.Select), but it also
+			// matches <math select>, not just <select>. Matching the MathML
+			// tag is arguably incorrect (conceptually), but it mimics what
+			// Chromium does.
+			for i := len(p.oe) - 1; i >= 0; i-- {
+				if n := p.oe[i]; n.DataAtom == a.Select {
+					p.oe = p.oe[:i]
+					break
+				}
+			}
+			p.resetInsertionMode()
+			return false
+		}
+	}
+	return inSelectIM(p)
+}
+
+// Section 12.2.6.4.18.
+func inTemplateIM(p *parser) bool {
+	switch p.tok.Type {
+	case TextToken, CommentToken, DoctypeToken:
+		return inBodyIM(p)
+	case StartTagToken:
+		switch p.tok.DataAtom {
+		case a.Base, a.Basefont, a.Bgsound, a.Link, a.Meta, a.Noframes, a.Script, a.Style, a.Template, a.Title:
+			return inHeadIM(p)
+		case a.Caption, a.Colgroup, a.Tbody, a.Tfoot, a.Thead:
+			p.templateStack.pop()
+			p.templateStack = append(p.templateStack, inTableIM)
+			p.im = inTableIM
+			return false
+		case a.Col:
+			p.templateStack.pop()
+			p.templateStack = append(p.templateStack, inColumnGroupIM)
+			p.im = inColumnGroupIM
+			return false
+		case a.Tr:
+			p.templateStack.pop()
+			p.templateStack = append(p.templateStack, inTableBodyIM)
+			p.im = inTableBodyIM
+			return false
+		case a.Td, a.Th:
+			p.templateStack.pop()
+			p.templateStack = append(p.templateStack, inRowIM)
+			p.im = inRowIM
+			return false
+		default:
+			p.templateStack.pop()
+			p.templateStack = append(p.templateStack, inBodyIM)
+			p.im = inBodyIM
+			return false
+		}
+	case EndTagToken:
+		switch p.tok.DataAtom {
+		case a.Template:
+			return inHeadIM(p)
+		default:
+			// Ignore the token.
+			return true
+		}
+	case ErrorToken:
+		if !p.oe.contains(a.Template) {
+			// Ignore the token.
+			return true
+		}
+		// TODO: remove this divergence from the HTML5 spec.
+		//
+		// See https://bugs.chromium.org/p/chromium/issues/detail?id=829668
+		p.generateImpliedEndTags()
+		for i := len(p.oe) - 1; i >= 0; i-- {
+			if n := p.oe[i]; n.Namespace == "" && n.DataAtom == a.Template {
+				p.oe = p.oe[:i]
+				break
+			}
+		}
+		p.clearActiveFormattingElements()
+		p.templateStack.pop()
+		p.resetInsertionMode()
+		return false
+	}
+	return false
+}
+
+// Section 12.2.6.4.19.
+func afterBodyIM(p *parser) bool {
+	switch p.tok.Type {
+	case ErrorToken:
+		// Stop parsing.
+		return true
+	case TextToken:
+		s := strings.TrimLeft(p.tok.Data, whitespace)
+		if len(s) == 0 {
+			// It was all whitespace.
+			return inBodyIM(p)
+		}
+	case StartTagToken:
+		if p.tok.DataAtom == a.Html {
+			return inBodyIM(p)
+		}
+	case EndTagToken:
+		if p.tok.DataAtom == a.Html {
+			if !p.fragment {
+				p.im = afterAfterBodyIM
+			}
+			return true
+		}
+	case CommentToken:
+		// The comment is attached to the <html> element.
+		if len(p.oe) < 1 || p.oe[0].DataAtom != a.Html {
+			panic("html: bad parser state: <html> element not found, in the after-body insertion mode")
+		}
+		p.oe[0].AppendChild(&Node{
+			Type: CommentNode,
+			Data: p.tok.Data,
+		})
+		return true
+	}
+	p.im = inBodyIM
+	return false
+}
+
+// Section 12.2.6.4.20.
+func inFramesetIM(p *parser) bool {
+	switch p.tok.Type {
+	case CommentToken:
+		p.addChild(&Node{
+			Type: CommentNode,
+			Data: p.tok.Data,
+		})
+	case TextToken:
+		// Ignore all text but whitespace.
+		s := strings.Map(func(c rune) rune {
+			switch c {
+			case ' ', '\t', '\n', '\f', '\r':
+				return c
+			}
+			return -1
+		}, p.tok.Data)
+		if s != "" {
+			p.addText(s)
+		}
+	case StartTagToken:
+		switch p.tok.DataAtom {
+		case a.Html:
+			return inBodyIM(p)
+		case a.Frameset:
+			p.addElement()
+		case a.Frame:
+			p.addElement()
+			p.oe.pop()
+			p.acknowledgeSelfClosingTag()
+		case a.Noframes:
+			return inHeadIM(p)
+		}
+	case EndTagToken:
+		switch p.tok.DataAtom {
+		case a.Frameset:
+			if p.oe.top().DataAtom != a.Html {
+				p.oe.pop()
+				if p.oe.top().DataAtom != a.Frameset {
+					p.im = afterFramesetIM
+					return true
+				}
+			}
+		}
+	default:
+		// Ignore the token.
+	}
+	return true
+}
+
+// Section 12.2.6.4.21.
+func afterFramesetIM(p *parser) bool {
+	switch p.tok.Type {
+	case CommentToken:
+		p.addChild(&Node{
+			Type: CommentNode,
+			Data: p.tok.Data,
+		})
+	case TextToken:
+		// Ignore all text but whitespace.
+		s := strings.Map(func(c rune) rune {
+			switch c {
+			case ' ', '\t', '\n', '\f', '\r':
+				return c
+			}
+			return -1
+		}, p.tok.Data)
+		if s != "" {
+			p.addText(s)
+		}
+	case StartTagToken:
+		switch p.tok.DataAtom {
+		case a.Html:
+			return inBodyIM(p)
+		case a.Noframes:
+			return inHeadIM(p)
+		}
+	case EndTagToken:
+		switch p.tok.DataAtom {
+		case a.Html:
+			p.im = afterAfterFramesetIM
+			return true
+		}
+	default:
+		// Ignore the token.
+	}
+	return true
+}
+
+// Section 12.2.6.4.22.
+func afterAfterBodyIM(p *parser) bool {
+	switch p.tok.Type {
+	case ErrorToken:
+		// Stop parsing.
+		return true
+	case TextToken:
+		s := strings.TrimLeft(p.tok.Data, whitespace)
+		if len(s) == 0 {
+			// It was all whitespace.
+			return inBodyIM(p)
+		}
+	case StartTagToken:
+		if p.tok.DataAtom == a.Html {
+			return inBodyIM(p)
+		}
+	case CommentToken:
+		p.doc.AppendChild(&Node{
+			Type: CommentNode,
+			Data: p.tok.Data,
+		})
+		return true
+	case DoctypeToken:
+		return inBodyIM(p)
+	}
+	p.im = inBodyIM
+	return false
+}
+
+// Section 12.2.6.4.23.
+func afterAfterFramesetIM(p *parser) bool {
+	switch p.tok.Type {
+	case CommentToken:
+		p.doc.AppendChild(&Node{
+			Type: CommentNode,
+			Data: p.tok.Data,
+		})
+	case TextToken:
+		// Ignore all text but whitespace.
+		s := strings.Map(func(c rune) rune {
+			switch c {
+			case ' ', '\t', '\n', '\f', '\r':
+				return c
+			}
+			return -1
+		}, p.tok.Data)
+		if s != "" {
+			p.tok.Data = s
+			return inBodyIM(p)
+		}
+	case StartTagToken:
+		switch p.tok.DataAtom {
+		case a.Html:
+			return inBodyIM(p)
+		case a.Noframes:
+			return inHeadIM(p)
+		}
+	case DoctypeToken:
+		return inBodyIM(p)
+	default:
+		// Ignore the token.
+	}
+	return true
+}
+
+const whitespaceOrNUL = whitespace + "\x00"
+
+// Section 12.2.6.5
+func parseForeignContent(p *parser) bool {
+	switch p.tok.Type {
+	case TextToken:
+		if p.framesetOK {
+			p.framesetOK = strings.TrimLeft(p.tok.Data, whitespaceOrNUL) == ""
+		}
+		p.tok.Data = strings.Replace(p.tok.Data, "\x00", "\ufffd", -1)
+		p.addText(p.tok.Data)
+	case CommentToken:
+		p.addChild(&Node{
+			Type: CommentNode,
+			Data: p.tok.Data,
+		})
+	case StartTagToken:
+		b := breakout[p.tok.Data]
+		if p.tok.DataAtom == a.Font {
+		loop:
+			for _, attr := range p.tok.Attr {
+				switch attr.Key {
+				case "color", "face", "size":
+					b = true
+					break loop
+				}
+			}
+		}
+		if b {
+			for i := len(p.oe) - 1; i >= 0; i-- {
+				n := p.oe[i]
+				if n.Namespace == "" || htmlIntegrationPoint(n) || mathMLTextIntegrationPoint(n) {
+					p.oe = p.oe[:i+1]
+					break
+				}
+			}
+			return false
+		}
+		switch p.top().Namespace {
+		case "math":
+			adjustAttributeNames(p.tok.Attr, mathMLAttributeAdjustments)
+		case "svg":
+			// Adjust SVG tag names. The tokenizer lower-cases tag names, but
+			// SVG wants e.g. "foreignObject" with a capital second "O".
+			if x := svgTagNameAdjustments[p.tok.Data]; x != "" {
+				p.tok.DataAtom = a.Lookup([]byte(x))
+				p.tok.Data = x
+			}
+			adjustAttributeNames(p.tok.Attr, svgAttributeAdjustments)
+		default:
+			panic("html: bad parser state: unexpected namespace")
+		}
+		adjustForeignAttributes(p.tok.Attr)
+		namespace := p.top().Namespace
+		p.addElement()
+		p.top().Namespace = namespace
+		if namespace != "" {
+			// Don't let the tokenizer go into raw text mode in foreign content
+			// (e.g. in an SVG <title> tag).
+			p.tokenizer.NextIsNotRawText()
+		}
+		if p.hasSelfClosingToken {
+			p.oe.pop()
+			p.acknowledgeSelfClosingTag()
+		}
+	case EndTagToken:
+		for i := len(p.oe) - 1; i >= 0; i-- {
+			if p.oe[i].Namespace == "" {
+				return p.im(p)
+			}
+			if strings.EqualFold(p.oe[i].Data, p.tok.Data) {
+				p.oe = p.oe[:i]
+				break
+			}
+		}
+		return true
+	default:
+		// Ignore the token.
+	}
+	return true
+}
+
+// Section 12.2.6.
+func (p *parser) inForeignContent() bool {
+	if len(p.oe) == 0 {
+		return false
+	}
+	n := p.oe[len(p.oe)-1]
+	if n.Namespace == "" {
+		return false
+	}
+	if mathMLTextIntegrationPoint(n) {
+		if p.tok.Type == StartTagToken && p.tok.DataAtom != a.Mglyph && p.tok.DataAtom != a.Malignmark {
+			return false
+		}
+		if p.tok.Type == TextToken {
+			return false
+		}
+	}
+	if n.Namespace == "math" && n.DataAtom == a.AnnotationXml && p.tok.Type == StartTagToken && p.tok.DataAtom == a.Svg {
+		return false
+	}
+	if htmlIntegrationPoint(n) && (p.tok.Type == StartTagToken || p.tok.Type == TextToken) {
+		return false
+	}
+	if p.tok.Type == ErrorToken {
+		return false
+	}
+	return true
+}
+
+// parseImpliedToken parses a token as though it had appeared in the parser's
+// input.
+func (p *parser) parseImpliedToken(t TokenType, dataAtom a.Atom, data string) {
+	realToken, selfClosing := p.tok, p.hasSelfClosingToken
+	p.tok = Token{
+		Type:     t,
+		DataAtom: dataAtom,
+		Data:     data,
+	}
+	p.hasSelfClosingToken = false
+	p.parseCurrentToken()
+	p.tok, p.hasSelfClosingToken = realToken, selfClosing
+}
+
+// parseCurrentToken runs the current token through the parsing routines
+// until it is consumed.
+func (p *parser) parseCurrentToken() {
+	if p.tok.Type == SelfClosingTagToken {
+		p.hasSelfClosingToken = true
+		p.tok.Type = StartTagToken
+	}
+
+	consumed := false
+	for !consumed {
+		if p.inForeignContent() {
+			consumed = parseForeignContent(p)
+		} else {
+			consumed = p.im(p)
+		}
+	}
+
+	if p.hasSelfClosingToken {
+		// This is a parse error, but ignore it.
+		p.hasSelfClosingToken = false
+	}
+}
+
+func (p *parser) parse() error {
+	// Iterate until EOF. Any other error will cause an early return.
+	var err error
+	for err != io.EOF {
+		// CDATA sections are allowed only in foreign content.
+		n := p.oe.top()
+		p.tokenizer.AllowCDATA(n != nil && n.Namespace != "")
+		// Read and parse the next token.
+		p.tokenizer.Next()
+		p.tok = p.tokenizer.Token()
+		if p.tok.Type == ErrorToken {
+			err = p.tokenizer.Err()
+			if err != nil && err != io.EOF {
+				return err
+			}
+		}
+		p.parseCurrentToken()
+	}
+	return nil
+}
+
+// Parse returns the parse tree for the HTML from the given Reader.
+//
+// It implements the HTML5 parsing algorithm
+// (https://html.spec.whatwg.org/multipage/syntax.html#tree-construction),
+// which is very complicated. The resultant tree can contain implicitly created
+// nodes that have no explicit <tag> listed in r's data, and nodes' parents can
+// differ from the nesting implied by a naive processing of start and end
+// <tag>s. Conversely, explicit <tag>s in r's data can be silently dropped,
+// with no corresponding node in the resulting tree.
+//
+// The input is assumed to be UTF-8 encoded.
+func Parse(r io.Reader) (*Node, error) {
+	p := &parser{
+		tokenizer: NewTokenizer(r),
+		doc: &Node{
+			Type: DocumentNode,
+		},
+		scripting:  true,
+		framesetOK: true,
+		im:         initialIM,
+	}
+	err := p.parse()
+	if err != nil {
+		return nil, err
+	}
+	return p.doc, nil
+}
+
+// ParseFragment parses a fragment of HTML and returns the nodes that were
+// found. If the fragment is the InnerHTML for an existing element, pass that
+// element in context.
+//
+// It has the same intricacies as Parse.
+func ParseFragment(r io.Reader, context *Node) ([]*Node, error) {
+	contextTag := ""
+	if context != nil {
+		if context.Type != ElementNode {
+			return nil, errors.New("html: ParseFragment of non-element Node")
+		}
+		// The next check isn't just context.DataAtom.String() == context.Data because
+		// it is valid to pass an element whose tag isn't a known atom. For example,
+		// DataAtom == 0 and Data = "tagfromthefuture" is perfectly consistent.
+		if context.DataAtom != a.Lookup([]byte(context.Data)) {
+			return nil, fmt.Errorf("html: inconsistent Node: DataAtom=%q, Data=%q", context.DataAtom, context.Data)
+		}
+		contextTag = context.DataAtom.String()
+	}
+	p := &parser{
+		tokenizer: NewTokenizerFragment(r, contextTag),
+		doc: &Node{
+			Type: DocumentNode,
+		},
+		scripting: true,
+		fragment:  true,
+		context:   context,
+	}
+
+	root := &Node{
+		Type:     ElementNode,
+		DataAtom: a.Html,
+		Data:     a.Html.String(),
+	}
+	p.doc.AppendChild(root)
+	p.oe = nodeStack{root}
+	if context != nil && context.DataAtom == a.Template {
+		p.templateStack = append(p.templateStack, inTemplateIM)
+	}
+	p.resetInsertionMode()
+
+	for n := context; n != nil; n = n.Parent {
+		if n.Type == ElementNode && n.DataAtom == a.Form {
+			p.form = n
+			break
+		}
+	}
+
+	err := p.parse()
+	if err != nil {
+		return nil, err
+	}
+
+	parent := p.doc
+	if context != nil {
+		parent = root
+	}
+
+	var result []*Node
+	for c := parent.FirstChild; c != nil; {
+		next := c.NextSibling
+		parent.RemoveChild(c)
+		result = append(result, c)
+		c = next
+	}
+	return result, nil
+}
diff --git a/vendor/golang.org/x/net/html/render.go b/vendor/golang.org/x/net/html/render.go
new file mode 100644
index 00000000..d34564f4
--- /dev/null
+++ b/vendor/golang.org/x/net/html/render.go
@@ -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,
+}
diff --git a/vendor/golang.org/x/net/html/token.go b/vendor/golang.org/x/net/html/token.go
new file mode 100644
index 00000000..e3c01d7c
--- /dev/null
+++ b/vendor/golang.org/x/net/html/token.go
@@ -0,0 +1,1219 @@
+// 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"
+	"errors"
+	"io"
+	"strconv"
+	"strings"
+
+	"golang.org/x/net/html/atom"
+)
+
+// A TokenType is the type of a Token.
+type TokenType uint32
+
+const (
+	// ErrorToken means that an error occurred during tokenization.
+	ErrorToken TokenType = iota
+	// TextToken means a text node.
+	TextToken
+	// A StartTagToken looks like <a>.
+	StartTagToken
+	// An EndTagToken looks like </a>.
+	EndTagToken
+	// A SelfClosingTagToken tag looks like <br/>.
+	SelfClosingTagToken
+	// A CommentToken looks like <!--x-->.
+	CommentToken
+	// A DoctypeToken looks like <!DOCTYPE x>
+	DoctypeToken
+)
+
+// ErrBufferExceeded means that the buffering limit was exceeded.
+var ErrBufferExceeded = errors.New("max buffer exceeded")
+
+// String returns a string representation of the TokenType.
+func (t TokenType) String() string {
+	switch t {
+	case ErrorToken:
+		return "Error"
+	case TextToken:
+		return "Text"
+	case StartTagToken:
+		return "StartTag"
+	case EndTagToken:
+		return "EndTag"
+	case SelfClosingTagToken:
+		return "SelfClosingTag"
+	case CommentToken:
+		return "Comment"
+	case DoctypeToken:
+		return "Doctype"
+	}
+	return "Invalid(" + strconv.Itoa(int(t)) + ")"
+}
+
+// An Attribute is an attribute namespace-key-value triple. Namespace is
+// non-empty for foreign attributes like xlink, Key is alphabetic (and hence
+// does not contain escapable characters like '&', '<' or '>'), and Val is
+// unescaped (it looks like "a<b" rather than "a&lt;b").
+//
+// Namespace is only used by the parser, not the tokenizer.
+type Attribute struct {
+	Namespace, Key, Val string
+}
+
+// A Token consists of a TokenType and some Data (tag name for start and end
+// tags, content for text, comments and doctypes). A tag Token may also contain
+// a slice of Attributes. Data is unescaped for all Tokens (it looks like "a<b"
+// rather than "a&lt;b"). For tag Tokens, DataAtom is the atom for Data, or
+// zero if Data is not a known tag name.
+type Token struct {
+	Type     TokenType
+	DataAtom atom.Atom
+	Data     string
+	Attr     []Attribute
+}
+
+// tagString returns a string representation of a tag Token's Data and Attr.
+func (t Token) tagString() string {
+	if len(t.Attr) == 0 {
+		return t.Data
+	}
+	buf := bytes.NewBufferString(t.Data)
+	for _, a := range t.Attr {
+		buf.WriteByte(' ')
+		buf.WriteString(a.Key)
+		buf.WriteString(`="`)
+		escape(buf, a.Val)
+		buf.WriteByte('"')
+	}
+	return buf.String()
+}
+
+// String returns a string representation of the Token.
+func (t Token) String() string {
+	switch t.Type {
+	case ErrorToken:
+		return ""
+	case TextToken:
+		return EscapeString(t.Data)
+	case StartTagToken:
+		return "<" + t.tagString() + ">"
+	case EndTagToken:
+		return "</" + t.tagString() + ">"
+	case SelfClosingTagToken:
+		return "<" + t.tagString() + "/>"
+	case CommentToken:
+		return "<!--" + t.Data + "-->"
+	case DoctypeToken:
+		return "<!DOCTYPE " + t.Data + ">"
+	}
+	return "Invalid(" + strconv.Itoa(int(t.Type)) + ")"
+}
+
+// span is a range of bytes in a Tokenizer's buffer. The start is inclusive,
+// the end is exclusive.
+type span struct {
+	start, end int
+}
+
+// A Tokenizer returns a stream of HTML Tokens.
+type Tokenizer struct {
+	// r is the source of the HTML text.
+	r io.Reader
+	// tt is the TokenType of the current token.
+	tt TokenType
+	// err is the first error encountered during tokenization. It is possible
+	// for tt != Error && err != nil to hold: this means that Next returned a
+	// valid token but the subsequent Next call will return an error token.
+	// For example, if the HTML text input was just "plain", then the first
+	// Next call would set z.err to io.EOF but return a TextToken, and all
+	// subsequent Next calls would return an ErrorToken.
+	// err is never reset. Once it becomes non-nil, it stays non-nil.
+	err error
+	// readErr is the error returned by the io.Reader r. It is separate from
+	// err because it is valid for an io.Reader to return (n int, err1 error)
+	// such that n > 0 && err1 != nil, and callers should always process the
+	// n > 0 bytes before considering the error err1.
+	readErr error
+	// buf[raw.start:raw.end] holds the raw bytes of the current token.
+	// buf[raw.end:] is buffered input that will yield future tokens.
+	raw span
+	buf []byte
+	// maxBuf limits the data buffered in buf. A value of 0 means unlimited.
+	maxBuf int
+	// buf[data.start:data.end] holds the raw bytes of the current token's data:
+	// a text token's text, a tag token's tag name, etc.
+	data span
+	// pendingAttr is the attribute key and value currently being tokenized.
+	// When complete, pendingAttr is pushed onto attr. nAttrReturned is
+	// incremented on each call to TagAttr.
+	pendingAttr   [2]span
+	attr          [][2]span
+	nAttrReturned int
+	// rawTag is the "script" in "</script>" that closes the next token. If
+	// non-empty, the subsequent call to Next will return a raw or RCDATA text
+	// token: one that treats "<p>" as text instead of an element.
+	// rawTag's contents are lower-cased.
+	rawTag string
+	// textIsRaw is whether the current text token's data is not escaped.
+	textIsRaw bool
+	// convertNUL is whether NUL bytes in the current token's data should
+	// be converted into \ufffd replacement characters.
+	convertNUL bool
+	// allowCDATA is whether CDATA sections are allowed in the current context.
+	allowCDATA bool
+}
+
+// AllowCDATA sets whether or not the tokenizer recognizes <![CDATA[foo]]> as
+// the text "foo". The default value is false, which means to recognize it as
+// a bogus comment "<!-- [CDATA[foo]] -->" instead.
+//
+// Strictly speaking, an HTML5 compliant tokenizer should allow CDATA if and
+// only if tokenizing foreign content, such as MathML and SVG. However,
+// tracking foreign-contentness is difficult to do purely in the tokenizer,
+// as opposed to the parser, due to HTML integration points: an <svg> element
+// can contain a <foreignObject> that is foreign-to-SVG but not foreign-to-
+// HTML. For strict compliance with the HTML5 tokenization algorithm, it is the
+// responsibility of the user of a tokenizer to call AllowCDATA as appropriate.
+// In practice, if using the tokenizer without caring whether MathML or SVG
+// CDATA is text or comments, such as tokenizing HTML to find all the anchor
+// text, it is acceptable to ignore this responsibility.
+func (z *Tokenizer) AllowCDATA(allowCDATA bool) {
+	z.allowCDATA = allowCDATA
+}
+
+// NextIsNotRawText instructs the tokenizer that the next token should not be
+// considered as 'raw text'. Some elements, such as script and title elements,
+// normally require the next token after the opening tag to be 'raw text' that
+// has no child elements. For example, tokenizing "<title>a<b>c</b>d</title>"
+// yields a start tag token for "<title>", a text token for "a<b>c</b>d", and
+// an end tag token for "</title>". There are no distinct start tag or end tag
+// tokens for the "<b>" and "</b>".
+//
+// This tokenizer implementation will generally look for raw text at the right
+// times. Strictly speaking, an HTML5 compliant tokenizer should not look for
+// raw text if in foreign content: <title> generally needs raw text, but a
+// <title> inside an <svg> does not. Another example is that a <textarea>
+// generally needs raw text, but a <textarea> is not allowed as an immediate
+// child of a <select>; in normal parsing, a <textarea> implies </select>, but
+// one cannot close the implicit element when parsing a <select>'s InnerHTML.
+// Similarly to AllowCDATA, tracking the correct moment to override raw-text-
+// ness is difficult to do purely in the tokenizer, as opposed to the parser.
+// For strict compliance with the HTML5 tokenization algorithm, it is the
+// responsibility of the user of a tokenizer to call NextIsNotRawText as
+// appropriate. In practice, like AllowCDATA, it is acceptable to ignore this
+// responsibility for basic usage.
+//
+// Note that this 'raw text' concept is different from the one offered by the
+// Tokenizer.Raw method.
+func (z *Tokenizer) NextIsNotRawText() {
+	z.rawTag = ""
+}
+
+// Err returns the error associated with the most recent ErrorToken token.
+// This is typically io.EOF, meaning the end of tokenization.
+func (z *Tokenizer) Err() error {
+	if z.tt != ErrorToken {
+		return nil
+	}
+	return z.err
+}
+
+// readByte returns the next byte from the input stream, doing a buffered read
+// from z.r into z.buf if necessary. z.buf[z.raw.start:z.raw.end] remains a contiguous byte
+// slice that holds all the bytes read so far for the current token.
+// It sets z.err if the underlying reader returns an error.
+// Pre-condition: z.err == nil.
+func (z *Tokenizer) readByte() byte {
+	if z.raw.end >= len(z.buf) {
+		// Our buffer is exhausted and we have to read from z.r. Check if the
+		// previous read resulted in an error.
+		if z.readErr != nil {
+			z.err = z.readErr
+			return 0
+		}
+		// We copy z.buf[z.raw.start:z.raw.end] to the beginning of z.buf. If the length
+		// z.raw.end - z.raw.start is more than half the capacity of z.buf, then we
+		// allocate a new buffer before the copy.
+		c := cap(z.buf)
+		d := z.raw.end - z.raw.start
+		var buf1 []byte
+		if 2*d > c {
+			buf1 = make([]byte, d, 2*c)
+		} else {
+			buf1 = z.buf[:d]
+		}
+		copy(buf1, z.buf[z.raw.start:z.raw.end])
+		if x := z.raw.start; x != 0 {
+			// Adjust the data/attr spans to refer to the same contents after the copy.
+			z.data.start -= x
+			z.data.end -= x
+			z.pendingAttr[0].start -= x
+			z.pendingAttr[0].end -= x
+			z.pendingAttr[1].start -= x
+			z.pendingAttr[1].end -= x
+			for i := range z.attr {
+				z.attr[i][0].start -= x
+				z.attr[i][0].end -= x
+				z.attr[i][1].start -= x
+				z.attr[i][1].end -= x
+			}
+		}
+		z.raw.start, z.raw.end, z.buf = 0, d, buf1[:d]
+		// Now that we have copied the live bytes to the start of the buffer,
+		// we read from z.r into the remainder.
+		var n int
+		n, z.readErr = readAtLeastOneByte(z.r, buf1[d:cap(buf1)])
+		if n == 0 {
+			z.err = z.readErr
+			return 0
+		}
+		z.buf = buf1[:d+n]
+	}
+	x := z.buf[z.raw.end]
+	z.raw.end++
+	if z.maxBuf > 0 && z.raw.end-z.raw.start >= z.maxBuf {
+		z.err = ErrBufferExceeded
+		return 0
+	}
+	return x
+}
+
+// Buffered returns a slice containing data buffered but not yet tokenized.
+func (z *Tokenizer) Buffered() []byte {
+	return z.buf[z.raw.end:]
+}
+
+// readAtLeastOneByte wraps an io.Reader so that reading cannot return (0, nil).
+// It returns io.ErrNoProgress if the underlying r.Read method returns (0, nil)
+// too many times in succession.
+func readAtLeastOneByte(r io.Reader, b []byte) (int, error) {
+	for i := 0; i < 100; i++ {
+		n, err := r.Read(b)
+		if n != 0 || err != nil {
+			return n, err
+		}
+	}
+	return 0, io.ErrNoProgress
+}
+
+// skipWhiteSpace skips past any white space.
+func (z *Tokenizer) skipWhiteSpace() {
+	if z.err != nil {
+		return
+	}
+	for {
+		c := z.readByte()
+		if z.err != nil {
+			return
+		}
+		switch c {
+		case ' ', '\n', '\r', '\t', '\f':
+			// No-op.
+		default:
+			z.raw.end--
+			return
+		}
+	}
+}
+
+// readRawOrRCDATA reads until the next "</foo>", where "foo" is z.rawTag and
+// is typically something like "script" or "textarea".
+func (z *Tokenizer) readRawOrRCDATA() {
+	if z.rawTag == "script" {
+		z.readScript()
+		z.textIsRaw = true
+		z.rawTag = ""
+		return
+	}
+loop:
+	for {
+		c := z.readByte()
+		if z.err != nil {
+			break loop
+		}
+		if c != '<' {
+			continue loop
+		}
+		c = z.readByte()
+		if z.err != nil {
+			break loop
+		}
+		if c != '/' {
+			continue loop
+		}
+		if z.readRawEndTag() || z.err != nil {
+			break loop
+		}
+	}
+	z.data.end = z.raw.end
+	// A textarea's or title's RCDATA can contain escaped entities.
+	z.textIsRaw = z.rawTag != "textarea" && z.rawTag != "title"
+	z.rawTag = ""
+}
+
+// readRawEndTag attempts to read a tag like "</foo>", where "foo" is z.rawTag.
+// If it succeeds, it backs up the input position to reconsume the tag and
+// returns true. Otherwise it returns false. The opening "</" has already been
+// consumed.
+func (z *Tokenizer) readRawEndTag() bool {
+	for i := 0; i < len(z.rawTag); i++ {
+		c := z.readByte()
+		if z.err != nil {
+			return false
+		}
+		if c != z.rawTag[i] && c != z.rawTag[i]-('a'-'A') {
+			z.raw.end--
+			return false
+		}
+	}
+	c := z.readByte()
+	if z.err != nil {
+		return false
+	}
+	switch c {
+	case ' ', '\n', '\r', '\t', '\f', '/', '>':
+		// The 3 is 2 for the leading "</" plus 1 for the trailing character c.
+		z.raw.end -= 3 + len(z.rawTag)
+		return true
+	}
+	z.raw.end--
+	return false
+}
+
+// readScript reads until the next </script> tag, following the byzantine
+// rules for escaping/hiding the closing tag.
+func (z *Tokenizer) readScript() {
+	defer func() {
+		z.data.end = z.raw.end
+	}()
+	var c byte
+
+scriptData:
+	c = z.readByte()
+	if z.err != nil {
+		return
+	}
+	if c == '<' {
+		goto scriptDataLessThanSign
+	}
+	goto scriptData
+
+scriptDataLessThanSign:
+	c = z.readByte()
+	if z.err != nil {
+		return
+	}
+	switch c {
+	case '/':
+		goto scriptDataEndTagOpen
+	case '!':
+		goto scriptDataEscapeStart
+	}
+	z.raw.end--
+	goto scriptData
+
+scriptDataEndTagOpen:
+	if z.readRawEndTag() || z.err != nil {
+		return
+	}
+	goto scriptData
+
+scriptDataEscapeStart:
+	c = z.readByte()
+	if z.err != nil {
+		return
+	}
+	if c == '-' {
+		goto scriptDataEscapeStartDash
+	}
+	z.raw.end--
+	goto scriptData
+
+scriptDataEscapeStartDash:
+	c = z.readByte()
+	if z.err != nil {
+		return
+	}
+	if c == '-' {
+		goto scriptDataEscapedDashDash
+	}
+	z.raw.end--
+	goto scriptData
+
+scriptDataEscaped:
+	c = z.readByte()
+	if z.err != nil {
+		return
+	}
+	switch c {
+	case '-':
+		goto scriptDataEscapedDash
+	case '<':
+		goto scriptDataEscapedLessThanSign
+	}
+	goto scriptDataEscaped
+
+scriptDataEscapedDash:
+	c = z.readByte()
+	if z.err != nil {
+		return
+	}
+	switch c {
+	case '-':
+		goto scriptDataEscapedDashDash
+	case '<':
+		goto scriptDataEscapedLessThanSign
+	}
+	goto scriptDataEscaped
+
+scriptDataEscapedDashDash:
+	c = z.readByte()
+	if z.err != nil {
+		return
+	}
+	switch c {
+	case '-':
+		goto scriptDataEscapedDashDash
+	case '<':
+		goto scriptDataEscapedLessThanSign
+	case '>':
+		goto scriptData
+	}
+	goto scriptDataEscaped
+
+scriptDataEscapedLessThanSign:
+	c = z.readByte()
+	if z.err != nil {
+		return
+	}
+	if c == '/' {
+		goto scriptDataEscapedEndTagOpen
+	}
+	if 'a' <= c && c <= 'z' || 'A' <= c && c <= 'Z' {
+		goto scriptDataDoubleEscapeStart
+	}
+	z.raw.end--
+	goto scriptData
+
+scriptDataEscapedEndTagOpen:
+	if z.readRawEndTag() || z.err != nil {
+		return
+	}
+	goto scriptDataEscaped
+
+scriptDataDoubleEscapeStart:
+	z.raw.end--
+	for i := 0; i < len("script"); i++ {
+		c = z.readByte()
+		if z.err != nil {
+			return
+		}
+		if c != "script"[i] && c != "SCRIPT"[i] {
+			z.raw.end--
+			goto scriptDataEscaped
+		}
+	}
+	c = z.readByte()
+	if z.err != nil {
+		return
+	}
+	switch c {
+	case ' ', '\n', '\r', '\t', '\f', '/', '>':
+		goto scriptDataDoubleEscaped
+	}
+	z.raw.end--
+	goto scriptDataEscaped
+
+scriptDataDoubleEscaped:
+	c = z.readByte()
+	if z.err != nil {
+		return
+	}
+	switch c {
+	case '-':
+		goto scriptDataDoubleEscapedDash
+	case '<':
+		goto scriptDataDoubleEscapedLessThanSign
+	}
+	goto scriptDataDoubleEscaped
+
+scriptDataDoubleEscapedDash:
+	c = z.readByte()
+	if z.err != nil {
+		return
+	}
+	switch c {
+	case '-':
+		goto scriptDataDoubleEscapedDashDash
+	case '<':
+		goto scriptDataDoubleEscapedLessThanSign
+	}
+	goto scriptDataDoubleEscaped
+
+scriptDataDoubleEscapedDashDash:
+	c = z.readByte()
+	if z.err != nil {
+		return
+	}
+	switch c {
+	case '-':
+		goto scriptDataDoubleEscapedDashDash
+	case '<':
+		goto scriptDataDoubleEscapedLessThanSign
+	case '>':
+		goto scriptData
+	}
+	goto scriptDataDoubleEscaped
+
+scriptDataDoubleEscapedLessThanSign:
+	c = z.readByte()
+	if z.err != nil {
+		return
+	}
+	if c == '/' {
+		goto scriptDataDoubleEscapeEnd
+	}
+	z.raw.end--
+	goto scriptDataDoubleEscaped
+
+scriptDataDoubleEscapeEnd:
+	if z.readRawEndTag() {
+		z.raw.end += len("</script>")
+		goto scriptDataEscaped
+	}
+	if z.err != nil {
+		return
+	}
+	goto scriptDataDoubleEscaped
+}
+
+// readComment reads the next comment token starting with "<!--". The opening
+// "<!--" has already been consumed.
+func (z *Tokenizer) readComment() {
+	z.data.start = z.raw.end
+	defer func() {
+		if z.data.end < z.data.start {
+			// It's a comment with no data, like <!-->.
+			z.data.end = z.data.start
+		}
+	}()
+	for dashCount := 2; ; {
+		c := z.readByte()
+		if z.err != nil {
+			// Ignore up to two dashes at EOF.
+			if dashCount > 2 {
+				dashCount = 2
+			}
+			z.data.end = z.raw.end - dashCount
+			return
+		}
+		switch c {
+		case '-':
+			dashCount++
+			continue
+		case '>':
+			if dashCount >= 2 {
+				z.data.end = z.raw.end - len("-->")
+				return
+			}
+		case '!':
+			if dashCount >= 2 {
+				c = z.readByte()
+				if z.err != nil {
+					z.data.end = z.raw.end
+					return
+				}
+				if c == '>' {
+					z.data.end = z.raw.end - len("--!>")
+					return
+				}
+			}
+		}
+		dashCount = 0
+	}
+}
+
+// readUntilCloseAngle reads until the next ">".
+func (z *Tokenizer) readUntilCloseAngle() {
+	z.data.start = z.raw.end
+	for {
+		c := z.readByte()
+		if z.err != nil {
+			z.data.end = z.raw.end
+			return
+		}
+		if c == '>' {
+			z.data.end = z.raw.end - len(">")
+			return
+		}
+	}
+}
+
+// readMarkupDeclaration reads the next token starting with "<!". It might be
+// a "<!--comment-->", a "<!DOCTYPE foo>", a "<![CDATA[section]]>" or
+// "<!a bogus comment". The opening "<!" has already been consumed.
+func (z *Tokenizer) readMarkupDeclaration() TokenType {
+	z.data.start = z.raw.end
+	var c [2]byte
+	for i := 0; i < 2; i++ {
+		c[i] = z.readByte()
+		if z.err != nil {
+			z.data.end = z.raw.end
+			return CommentToken
+		}
+	}
+	if c[0] == '-' && c[1] == '-' {
+		z.readComment()
+		return CommentToken
+	}
+	z.raw.end -= 2
+	if z.readDoctype() {
+		return DoctypeToken
+	}
+	if z.allowCDATA && z.readCDATA() {
+		z.convertNUL = true
+		return TextToken
+	}
+	// It's a bogus comment.
+	z.readUntilCloseAngle()
+	return CommentToken
+}
+
+// readDoctype attempts to read a doctype declaration and returns true if
+// successful. The opening "<!" has already been consumed.
+func (z *Tokenizer) readDoctype() bool {
+	const s = "DOCTYPE"
+	for i := 0; i < len(s); i++ {
+		c := z.readByte()
+		if z.err != nil {
+			z.data.end = z.raw.end
+			return false
+		}
+		if c != s[i] && c != s[i]+('a'-'A') {
+			// Back up to read the fragment of "DOCTYPE" again.
+			z.raw.end = z.data.start
+			return false
+		}
+	}
+	if z.skipWhiteSpace(); z.err != nil {
+		z.data.start = z.raw.end
+		z.data.end = z.raw.end
+		return true
+	}
+	z.readUntilCloseAngle()
+	return true
+}
+
+// readCDATA attempts to read a CDATA section and returns true if
+// successful. The opening "<!" has already been consumed.
+func (z *Tokenizer) readCDATA() bool {
+	const s = "[CDATA["
+	for i := 0; i < len(s); i++ {
+		c := z.readByte()
+		if z.err != nil {
+			z.data.end = z.raw.end
+			return false
+		}
+		if c != s[i] {
+			// Back up to read the fragment of "[CDATA[" again.
+			z.raw.end = z.data.start
+			return false
+		}
+	}
+	z.data.start = z.raw.end
+	brackets := 0
+	for {
+		c := z.readByte()
+		if z.err != nil {
+			z.data.end = z.raw.end
+			return true
+		}
+		switch c {
+		case ']':
+			brackets++
+		case '>':
+			if brackets >= 2 {
+				z.data.end = z.raw.end - len("]]>")
+				return true
+			}
+			brackets = 0
+		default:
+			brackets = 0
+		}
+	}
+}
+
+// startTagIn returns whether the start tag in z.buf[z.data.start:z.data.end]
+// case-insensitively matches any element of ss.
+func (z *Tokenizer) startTagIn(ss ...string) bool {
+loop:
+	for _, s := range ss {
+		if z.data.end-z.data.start != len(s) {
+			continue loop
+		}
+		for i := 0; i < len(s); i++ {
+			c := z.buf[z.data.start+i]
+			if 'A' <= c && c <= 'Z' {
+				c += 'a' - 'A'
+			}
+			if c != s[i] {
+				continue loop
+			}
+		}
+		return true
+	}
+	return false
+}
+
+// readStartTag reads the next start tag token. The opening "<a" has already
+// been consumed, where 'a' means anything in [A-Za-z].
+func (z *Tokenizer) readStartTag() TokenType {
+	z.readTag(true)
+	if z.err != nil {
+		return ErrorToken
+	}
+	// Several tags flag the tokenizer's next token as raw.
+	c, raw := z.buf[z.data.start], false
+	if 'A' <= c && c <= 'Z' {
+		c += 'a' - 'A'
+	}
+	switch c {
+	case 'i':
+		raw = z.startTagIn("iframe")
+	case 'n':
+		raw = z.startTagIn("noembed", "noframes", "noscript")
+	case 'p':
+		raw = z.startTagIn("plaintext")
+	case 's':
+		raw = z.startTagIn("script", "style")
+	case 't':
+		raw = z.startTagIn("textarea", "title")
+	case 'x':
+		raw = z.startTagIn("xmp")
+	}
+	if raw {
+		z.rawTag = strings.ToLower(string(z.buf[z.data.start:z.data.end]))
+	}
+	// Look for a self-closing token like "<br/>".
+	if z.err == nil && z.buf[z.raw.end-2] == '/' {
+		return SelfClosingTagToken
+	}
+	return StartTagToken
+}
+
+// readTag reads the next tag token and its attributes. If saveAttr, those
+// attributes are saved in z.attr, otherwise z.attr is set to an empty slice.
+// The opening "<a" or "</a" has already been consumed, where 'a' means anything
+// in [A-Za-z].
+func (z *Tokenizer) readTag(saveAttr bool) {
+	z.attr = z.attr[:0]
+	z.nAttrReturned = 0
+	// Read the tag name and attribute key/value pairs.
+	z.readTagName()
+	if z.skipWhiteSpace(); z.err != nil {
+		return
+	}
+	for {
+		c := z.readByte()
+		if z.err != nil || c == '>' {
+			break
+		}
+		z.raw.end--
+		z.readTagAttrKey()
+		z.readTagAttrVal()
+		// Save pendingAttr if saveAttr and that attribute has a non-empty key.
+		if saveAttr && z.pendingAttr[0].start != z.pendingAttr[0].end {
+			z.attr = append(z.attr, z.pendingAttr)
+		}
+		if z.skipWhiteSpace(); z.err != nil {
+			break
+		}
+	}
+}
+
+// readTagName sets z.data to the "div" in "<div k=v>". The reader (z.raw.end)
+// is positioned such that the first byte of the tag name (the "d" in "<div")
+// has already been consumed.
+func (z *Tokenizer) readTagName() {
+	z.data.start = z.raw.end - 1
+	for {
+		c := z.readByte()
+		if z.err != nil {
+			z.data.end = z.raw.end
+			return
+		}
+		switch c {
+		case ' ', '\n', '\r', '\t', '\f':
+			z.data.end = z.raw.end - 1
+			return
+		case '/', '>':
+			z.raw.end--
+			z.data.end = z.raw.end
+			return
+		}
+	}
+}
+
+// readTagAttrKey sets z.pendingAttr[0] to the "k" in "<div k=v>".
+// Precondition: z.err == nil.
+func (z *Tokenizer) readTagAttrKey() {
+	z.pendingAttr[0].start = z.raw.end
+	for {
+		c := z.readByte()
+		if z.err != nil {
+			z.pendingAttr[0].end = z.raw.end
+			return
+		}
+		switch c {
+		case ' ', '\n', '\r', '\t', '\f', '/':
+			z.pendingAttr[0].end = z.raw.end - 1
+			return
+		case '=', '>':
+			z.raw.end--
+			z.pendingAttr[0].end = z.raw.end
+			return
+		}
+	}
+}
+
+// readTagAttrVal sets z.pendingAttr[1] to the "v" in "<div k=v>".
+func (z *Tokenizer) readTagAttrVal() {
+	z.pendingAttr[1].start = z.raw.end
+	z.pendingAttr[1].end = z.raw.end
+	if z.skipWhiteSpace(); z.err != nil {
+		return
+	}
+	c := z.readByte()
+	if z.err != nil {
+		return
+	}
+	if c != '=' {
+		z.raw.end--
+		return
+	}
+	if z.skipWhiteSpace(); z.err != nil {
+		return
+	}
+	quote := z.readByte()
+	if z.err != nil {
+		return
+	}
+	switch quote {
+	case '>':
+		z.raw.end--
+		return
+
+	case '\'', '"':
+		z.pendingAttr[1].start = z.raw.end
+		for {
+			c := z.readByte()
+			if z.err != nil {
+				z.pendingAttr[1].end = z.raw.end
+				return
+			}
+			if c == quote {
+				z.pendingAttr[1].end = z.raw.end - 1
+				return
+			}
+		}
+
+	default:
+		z.pendingAttr[1].start = z.raw.end - 1
+		for {
+			c := z.readByte()
+			if z.err != nil {
+				z.pendingAttr[1].end = z.raw.end
+				return
+			}
+			switch c {
+			case ' ', '\n', '\r', '\t', '\f':
+				z.pendingAttr[1].end = z.raw.end - 1
+				return
+			case '>':
+				z.raw.end--
+				z.pendingAttr[1].end = z.raw.end
+				return
+			}
+		}
+	}
+}
+
+// Next scans the next token and returns its type.
+func (z *Tokenizer) Next() TokenType {
+	z.raw.start = z.raw.end
+	z.data.start = z.raw.end
+	z.data.end = z.raw.end
+	if z.err != nil {
+		z.tt = ErrorToken
+		return z.tt
+	}
+	if z.rawTag != "" {
+		if z.rawTag == "plaintext" {
+			// Read everything up to EOF.
+			for z.err == nil {
+				z.readByte()
+			}
+			z.data.end = z.raw.end
+			z.textIsRaw = true
+		} else {
+			z.readRawOrRCDATA()
+		}
+		if z.data.end > z.data.start {
+			z.tt = TextToken
+			z.convertNUL = true
+			return z.tt
+		}
+	}
+	z.textIsRaw = false
+	z.convertNUL = false
+
+loop:
+	for {
+		c := z.readByte()
+		if z.err != nil {
+			break loop
+		}
+		if c != '<' {
+			continue loop
+		}
+
+		// Check if the '<' we have just read is part of a tag, comment
+		// or doctype. If not, it's part of the accumulated text token.
+		c = z.readByte()
+		if z.err != nil {
+			break loop
+		}
+		var tokenType TokenType
+		switch {
+		case 'a' <= c && c <= 'z' || 'A' <= c && c <= 'Z':
+			tokenType = StartTagToken
+		case c == '/':
+			tokenType = EndTagToken
+		case c == '!' || c == '?':
+			// We use CommentToken to mean any of "<!--actual comments-->",
+			// "<!DOCTYPE declarations>" and "<?xml processing instructions?>".
+			tokenType = CommentToken
+		default:
+			// Reconsume the current character.
+			z.raw.end--
+			continue
+		}
+
+		// We have a non-text token, but we might have accumulated some text
+		// before that. If so, we return the text first, and return the non-
+		// text token on the subsequent call to Next.
+		if x := z.raw.end - len("<a"); z.raw.start < x {
+			z.raw.end = x
+			z.data.end = x
+			z.tt = TextToken
+			return z.tt
+		}
+		switch tokenType {
+		case StartTagToken:
+			z.tt = z.readStartTag()
+			return z.tt
+		case EndTagToken:
+			c = z.readByte()
+			if z.err != nil {
+				break loop
+			}
+			if c == '>' {
+				// "</>" does not generate a token at all. Generate an empty comment
+				// to allow passthrough clients to pick up the data using Raw.
+				// Reset the tokenizer state and start again.
+				z.tt = CommentToken
+				return z.tt
+			}
+			if 'a' <= c && c <= 'z' || 'A' <= c && c <= 'Z' {
+				z.readTag(false)
+				if z.err != nil {
+					z.tt = ErrorToken
+				} else {
+					z.tt = EndTagToken
+				}
+				return z.tt
+			}
+			z.raw.end--
+			z.readUntilCloseAngle()
+			z.tt = CommentToken
+			return z.tt
+		case CommentToken:
+			if c == '!' {
+				z.tt = z.readMarkupDeclaration()
+				return z.tt
+			}
+			z.raw.end--
+			z.readUntilCloseAngle()
+			z.tt = CommentToken
+			return z.tt
+		}
+	}
+	if z.raw.start < z.raw.end {
+		z.data.end = z.raw.end
+		z.tt = TextToken
+		return z.tt
+	}
+	z.tt = ErrorToken
+	return z.tt
+}
+
+// Raw returns the unmodified text of the current token. Calling Next, Token,
+// Text, TagName or TagAttr may change the contents of the returned slice.
+func (z *Tokenizer) Raw() []byte {
+	return z.buf[z.raw.start:z.raw.end]
+}
+
+// convertNewlines converts "\r" and "\r\n" in s to "\n".
+// The conversion happens in place, but the resulting slice may be shorter.
+func convertNewlines(s []byte) []byte {
+	for i, c := range s {
+		if c != '\r' {
+			continue
+		}
+
+		src := i + 1
+		if src >= len(s) || s[src] != '\n' {
+			s[i] = '\n'
+			continue
+		}
+
+		dst := i
+		for src < len(s) {
+			if s[src] == '\r' {
+				if src+1 < len(s) && s[src+1] == '\n' {
+					src++
+				}
+				s[dst] = '\n'
+			} else {
+				s[dst] = s[src]
+			}
+			src++
+			dst++
+		}
+		return s[:dst]
+	}
+	return s
+}
+
+var (
+	nul         = []byte("\x00")
+	replacement = []byte("\ufffd")
+)
+
+// Text returns the unescaped text of a text, comment or doctype token. The
+// contents of the returned slice may change on the next call to Next.
+func (z *Tokenizer) Text() []byte {
+	switch z.tt {
+	case TextToken, CommentToken, DoctypeToken:
+		s := z.buf[z.data.start:z.data.end]
+		z.data.start = z.raw.end
+		z.data.end = z.raw.end
+		s = convertNewlines(s)
+		if (z.convertNUL || z.tt == CommentToken) && bytes.Contains(s, nul) {
+			s = bytes.Replace(s, nul, replacement, -1)
+		}
+		if !z.textIsRaw {
+			s = unescape(s, false)
+		}
+		return s
+	}
+	return nil
+}
+
+// TagName returns the lower-cased name of a tag token (the `img` out of
+// `<IMG SRC="foo">`) and whether the tag has attributes.
+// The contents of the returned slice may change on the next call to Next.
+func (z *Tokenizer) TagName() (name []byte, hasAttr bool) {
+	if z.data.start < z.data.end {
+		switch z.tt {
+		case StartTagToken, EndTagToken, SelfClosingTagToken:
+			s := z.buf[z.data.start:z.data.end]
+			z.data.start = z.raw.end
+			z.data.end = z.raw.end
+			return lower(s), z.nAttrReturned < len(z.attr)
+		}
+	}
+	return nil, false
+}
+
+// TagAttr returns the lower-cased key and unescaped value of the next unparsed
+// attribute for the current tag token and whether there are more attributes.
+// The contents of the returned slices may change on the next call to Next.
+func (z *Tokenizer) TagAttr() (key, val []byte, moreAttr bool) {
+	if z.nAttrReturned < len(z.attr) {
+		switch z.tt {
+		case StartTagToken, SelfClosingTagToken:
+			x := z.attr[z.nAttrReturned]
+			z.nAttrReturned++
+			key = z.buf[x[0].start:x[0].end]
+			val = z.buf[x[1].start:x[1].end]
+			return lower(key), unescape(convertNewlines(val), true), z.nAttrReturned < len(z.attr)
+		}
+	}
+	return nil, nil, false
+}
+
+// Token returns the current Token. The result's Data and Attr values remain
+// valid after subsequent Next calls.
+func (z *Tokenizer) Token() Token {
+	t := Token{Type: z.tt}
+	switch z.tt {
+	case TextToken, CommentToken, DoctypeToken:
+		t.Data = string(z.Text())
+	case StartTagToken, SelfClosingTagToken, EndTagToken:
+		name, moreAttr := z.TagName()
+		for moreAttr {
+			var key, val []byte
+			key, val, moreAttr = z.TagAttr()
+			t.Attr = append(t.Attr, Attribute{"", atom.String(key), string(val)})
+		}
+		if a := atom.Lookup(name); a != 0 {
+			t.DataAtom, t.Data = a, a.String()
+		} else {
+			t.DataAtom, t.Data = 0, string(name)
+		}
+	}
+	return t
+}
+
+// SetMaxBuf sets a limit on the amount of data buffered during tokenization.
+// A value of 0 means unlimited.
+func (z *Tokenizer) SetMaxBuf(n int) {
+	z.maxBuf = n
+}
+
+// NewTokenizer returns a new HTML Tokenizer for the given Reader.
+// The input is assumed to be UTF-8 encoded.
+func NewTokenizer(r io.Reader) *Tokenizer {
+	return NewTokenizerFragment(r, "")
+}
+
+// NewTokenizerFragment returns a new HTML Tokenizer for the given Reader, for
+// tokenizing an existing element's InnerHTML fragment. contextTag is that
+// element's tag, such as "div" or "iframe".
+//
+// For example, how the InnerHTML "a<b" is tokenized depends on whether it is
+// for a <p> tag or a <script> tag.
+//
+// The input is assumed to be UTF-8 encoded.
+func NewTokenizerFragment(r io.Reader, contextTag string) *Tokenizer {
+	z := &Tokenizer{
+		r:   r,
+		buf: make([]byte, 0, 4096),
+	}
+	if contextTag != "" {
+		switch s := strings.ToLower(contextTag); s {
+		case "iframe", "noembed", "noframes", "noscript", "plaintext", "script", "style", "title", "textarea", "xmp":
+			z.rawTag = s
+		}
+	}
+	return z
+}
diff --git a/vendor/gopkg.in/tucnak/telebot.v2/.gitignore b/vendor/gopkg.in/tucnak/telebot.v2/.gitignore
new file mode 100644
index 00000000..778cd4fe
--- /dev/null
+++ b/vendor/gopkg.in/tucnak/telebot.v2/.gitignore
@@ -0,0 +1,27 @@
+# Compiled Object files, Static and Dynamic libs (Shared Objects)
+*.o
+*.a
+*.so
+
+# Folders
+_obj
+_test
+
+# Architecture specific extensions/prefixes
+*.[568vq]
+[568vq].out
+
+*.cgo1.go
+*.cgo2.c
+_cgo_defun.c
+_cgo_gotypes.go
+_cgo_export.*
+
+_testmain.go
+
+*.exe
+*.test
+*.prof
+
+.idea
+.DS_Store
diff --git a/vendor/gopkg.in/tucnak/telebot.v2/.travis.yml b/vendor/gopkg.in/tucnak/telebot.v2/.travis.yml
new file mode 100644
index 00000000..3f745a3a
--- /dev/null
+++ b/vendor/gopkg.in/tucnak/telebot.v2/.travis.yml
@@ -0,0 +1,4 @@
+language: go
+
+env:
+    - TELEBOT_SECRET=107177593:AAHBJfF3nv3pZXVjXpoowVhv_KSGw56s8zo
diff --git a/vendor/gopkg.in/tucnak/telebot.v2/LICENSE b/vendor/gopkg.in/tucnak/telebot.v2/LICENSE
new file mode 100644
index 00000000..2965b842
--- /dev/null
+++ b/vendor/gopkg.in/tucnak/telebot.v2/LICENSE
@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 llya Kowalewski
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
diff --git a/vendor/gopkg.in/tucnak/telebot.v2/README.md b/vendor/gopkg.in/tucnak/telebot.v2/README.md
new file mode 100644
index 00000000..649907c5
--- /dev/null
+++ b/vendor/gopkg.in/tucnak/telebot.v2/README.md
@@ -0,0 +1,444 @@
+# Telebot
+>"I never knew creating Telegram bots could be so _sexy_!"
+
+[![GoDoc](https://godoc.org/gopkg.in/tucnak/telebot.v2?status.svg)](https://godoc.org/gopkg.in/tucnak/telebot.v2)
+[![Travis](https://travis-ci.org/tucnak/telebot.svg?branch=v2)](https://travis-ci.org/tucnak/telebot)
+
+```bash
+go get -u gopkg.in/tucnak/telebot.v2
+```
+
+* [Overview](#overview)
+* [Getting Started](#getting-started)
+	- [Poller](#poller)
+	- [Commands](#commands)
+	- [Files](#files)
+	- [Sendable](#sendable)
+	- [Editable](#editable)
+	- [Keyboards](#keyboards)
+	- [Inline mode](#inline-mode)
+* [Contributing](#contributing)
+* [Donate](#donate)
+* [License](#license)
+
+# Overview
+Telebot is a bot framework for [Telegram Bot API](https://core.telegram.org/bots/api).
+This package provides the best of its kind API for command routing, inline query requests and keyboards, as well
+as callbacks. Actually, I went a couple steps further, so instead of making a 1:1 API wrapper I chose to focus on
+the beauty of API and performance. Some of the strong sides of telebot are:
+
+* Real concise API
+* Command routing
+* Middleware
+* Transparent File API
+* Effortless bot callbacks
+
+All the methods of telebot API are _extremely_ easy to memorize and get used to. Also, consider Telebot a
+highload-ready solution. I'll test and benchmark the most popular actions and if necessary, optimize
+against them without sacrificing API quality.
+
+# Getting Started
+Let's take a look at the minimal telebot setup:
+```go
+package main
+
+import (
+	"time"
+	"log"
+
+	tb "gopkg.in/tucnak/telebot.v2"
+)
+
+func main() {
+	b, err := tb.NewBot(tb.Settings{
+		Token:  "TOKEN_HERE",
+		// You can also set custom API URL. If field is empty it equals to "https://api.telegram.org"
+		URL: "http://195.129.111.17:8012",
+		Poller: &tb.LongPoller{Timeout: 10 * time.Second},
+	})
+
+	if err != nil {
+		log.Fatal(err)
+		return
+	}
+
+	b.Handle("/hello", func(m *tb.Message) {
+		b.Send(m.Sender, "hello world")
+	})
+
+	b.Start()
+}
+
+```
+
+Simple, innit? Telebot's routing system takes care of deliviering updates
+to their endpoints, so in order to get to handle any meaningful event,
+all you got to do is just plug your function to one of the Telebot-provided
+endpoints. You can find the full list
+[here](https://godoc.org/gopkg.in/tucnak/telebot.v2#pkg-constants).
+
+```go
+b, _ := tb.NewBot(settings)
+
+b.Handle(tb.OnText, func(m *tb.Message) {
+	// all the text messages that weren't
+	// captured by existing handlers
+})
+
+b.Handle(tb.OnPhoto, func(m *tb.Message) {
+	// photos only
+})
+
+b.Handle(tb.OnChannelPost, func (m *tb.Message) {
+	// channel posts only
+})
+
+b.Handle(tb.Query, func (q *tb.Query) {
+	// incoming inline queries
+})
+```
+
+Now there's a dozen of supported endpoints (see package consts). Let me know
+if you'd like to see some endpoint or endpoint idea implemented. This system
+is completely extensible, so I can introduce them without breaking
+backwards-compatibity.
+
+## Poller
+Telebot doesn't really care how you provide it with incoming updates, as long
+as you set it up with a Poller:
+```go
+// Poller is a provider of Updates.
+//
+// All pollers must implement Poll(), which accepts bot
+// pointer and subscription channel and start polling
+// synchronously straight away.
+type Poller interface {
+	// Poll is supposed to take the bot object
+	// subscription channel and start polling
+	// for Updates immediately.
+	//
+	// Poller must listen for stop constantly and close
+	// it as soon as it's done polling.
+	Poll(b *Bot, updates chan Update, stop chan struct{})
+}
+```
+
+Telegram Bot API supports long polling and webhook integration. I don't really
+care about webhooks, so the only concrete Poller you'll find in the library
+is the `LongPoller`. Poller means you can plug telebot into whatever existing
+bot infrastructure (load balancers?) you need, if you need to. Another great thing
+about pollers is that you can chain them, making some sort of middleware:
+```go
+poller := &tb.LongPoller{Timeout: 15 * time.Second}
+spamProtected := tb.NewMiddlewarePoller(poller, func(upd *tb.Update) bool {
+	if upd.Message == nil {
+		return true
+	}
+
+	if strings.Contains(upd.Message.Text, "spam") {
+		return false
+	}
+
+	return true
+})
+
+bot, _ := tb.NewBot(tb.Settings{
+	// ...
+	Poller: spamProtected,
+})
+
+// graceful shutdown
+go func() {
+	<-time.After(N * time.Second)
+	bot.Stop()
+})()
+
+bot.Start() // blocks until shutdown
+
+fmt.Println(poller.LastUpdateID) // 134237
+```
+
+## Commands
+When handling commands, Telebot supports both direct (`/command`) and group-like
+syntax (`/command@botname`) and will never deliver messages addressed to some
+other bot, even if [privacy mode](https://core.telegram.org/bots#privacy-mode) is off.
+For simplified deep-linking, telebot also extracts payload:
+```go
+// Command: /start <PAYLOAD>
+b.Handle("/start", func(m *tb.Message) {
+	if !m.Private() {
+		return
+	}
+
+	fmt.Println(m.Payload) // <PAYLOAD>
+})
+```
+
+## Files
+>Telegram allows files up to 20 MB in size.
+
+Telebot allows to both upload (from disk / by URL) and download (from Telegram)
+and files in bot's scope. Also, sending any kind of media with a File created
+from disk will upload the file to Telegram automatically:
+```go
+a := &tb.Audio{File: tb.FromDisk("file.ogg")}
+
+fmt.Println(a.OnDisk()) // true
+fmt.Println(a.InCloud()) // false
+
+// Will upload the file from disk and send it to recipient
+bot.Send(recipient, a)
+
+// Next time you'll be sending this very *Audio, Telebot won't
+// re-upload the same file but rather utilize its Telegram FileID
+bot.Send(otherRecipient, a)
+
+fmt.Println(a.OnDisk()) // true
+fmt.Println(a.InCloud()) // true
+fmt.Println(a.FileID) // <telegram file id: ABC-DEF1234ghIkl-zyx57W2v1u123ew11>
+```
+
+You might want to save certain `File`s in order to avoid re-uploading. Feel free
+to marshal them into whatever format, `File` only contain public fields, so no
+data will ever be lost.
+
+## Sendable
+Send is undoubteldy the most important method in Telebot. `Send()` accepts a
+`Recipient` (could be user, group or a channel) and a `Sendable`. FYI, not only
+all telebot-provided media types (`Photo`, `Audio`, `Video`, etc.) are `Sendable`,
+but you can create composite types of your own. As long as they satisfy `Sendable`,
+Telebot will be able to send them out.
+
+```go
+// Sendable is any object that can send itself.
+//
+// This is pretty cool, since it lets bots implement
+// custom Sendables for complex kind of media or
+// chat objects spanning across multiple messages.
+type Sendable interface {
+    Send(*Bot, Recipient, *SendOptions) (*Message, error)
+}
+```
+
+The only type at the time that doesn't fit `Send()` is `Album` and there is a reason
+for that. Albums were added not so long ago, so they are slightly quirky for backwards
+compatibilities sake. In fact, an `Album` can be sent, but never received. Instead,
+Telegram returns a `[]Message`, one for each media object in the album:
+```go
+p := &tb.Photo{File: tb.FromDisk("chicken.jpg")}
+v := &tb.Video{File: tb.FromURL("http://video.mp4")}
+
+msgs, err := b.SendAlbum(user, tb.Album{p, v})
+```
+
+### Send options
+Send options are objects and flags you can pass to `Send()`, `Edit()` and friends
+as optional arguments (following the recipient and the text/media). The most
+important one is called `SendOptions`, it lets you control _all_ the properties of
+the message supported by Telegram. The only drawback is that it's rather
+inconvenient to use at times, so `Send()` supports multiple shorthands:
+```go
+// regular send options
+b.Send(user, "text", &tb.SendOptions{
+	// ...
+})
+
+// ReplyMarkup is a part of SendOptions,
+// but often it's the only option you need
+b.Send(user, "text", &tb.ReplyMarkup{
+	// ...
+})
+
+// flags: no notification && no web link preview
+b.Send(user, "text", tb.Silent, tb.NoPreview)
+```
+
+Full list of supported option-flags you can find
+[here](https://github.com/tucnak/telebot/blob/v2/options.go#L9).
+
+## Editable
+If you want to edit some existing message, you don't really need to store the
+original `*Message` object. In fact, upon edit, Telegram only requires `chat_id`
+and `message_id`. So you don't really need the Message as the whole. Also you
+might want to store references to certain messages in the database, so I thought
+it made sense for *any* Go struct to be editable as a Telegram message, to implement
+`Editable`:
+```go
+// Editable is an interface for all objects that
+// provide "message signature", a pair of 32-bit
+// message ID and 64-bit chat ID, both required
+// for edit operations.
+//
+// Use case: DB model struct for messages to-be
+// edited with, say two collums: msg_id,chat_id
+// could easily implement MessageSig() making
+// instances of stored messages editable.
+type Editable interface {
+	// MessageSig is a "message signature".
+	//
+	// For inline messages, return chatID = 0.
+	MessageSig() (messageID int, chatID int64)
+}
+```
+
+For example, `Message` type is Editable. Here is the implementation of `StoredMessage`
+type, provided by telebot:
+```go
+// StoredMessage is an example struct suitable for being
+// stored in the database as-is or being embedded into
+// a larger struct, which is often the case (you might
+// want to store some metadata alongside, or might not.)
+type StoredMessage struct {
+	MessageID int   `sql:"message_id" json:"message_id"`
+	ChatID    int64 `sql:"chat_id" json:"chat_id"`
+}
+
+func (x StoredMessage) MessageSig() (int, int64) {
+	return x.MessageID, x.ChatID
+}
+```
+
+Why bother at all? Well, it allows you to do things like this:
+```go
+// just two integer columns in the database
+var msgs []tb.StoredMessage
+db.Find(&msgs) // gorm syntax
+
+for _, msg := range msgs {
+	bot.Edit(&msg, "Updated text.")
+	// or
+	bot.Delete(&msg)
+}
+```
+
+I find it incredibly neat. Worth noting, at this point of time there exists
+another method in the Edit family, `EditCaption()` which is of a pretty
+rare use, so I didn't bother including it to `Edit()`, just like I did with
+`SendAlbum()` as it would inevitably lead to unnecessary complications.
+```go
+var m *Message
+
+// change caption of a photo, audio, etc.
+bot.EditCaption(m, "new caption")
+```
+
+## Keyboards
+Telebot supports both kinds of keyboards Telegram provides: reply and inline
+keyboards. Any button can also act as an endpoints for `Handle()`:
+
+```go
+func main() {
+	b, _ := tb.NewBot(tb.Settings{...})
+
+	// This button will be displayed in user's
+	// reply keyboard.
+	replyBtn := tb.ReplyButton{Text: "🌕 Button #1"}
+	replyKeys := [][]tb.ReplyButton{
+		[]tb.ReplyButton{replyBtn},
+		// ...
+	}
+
+	// And this one — just under the message itself.
+	// Pressing it will cause the client to send
+	// the bot a callback.
+	//
+	// Make sure Unique stays unique as it has to be
+	// for callback routing to work.
+	inlineBtn := tb.InlineButton{
+		Unique: "sad_moon",
+		Text: "🌚 Button #2",
+	}
+	inlineKeys := [][]tb.InlineButton{
+		[]tb.InlineButton{inlineBtn},
+		// ...
+	}
+
+	b.Handle(&replyBtn, func(m *tb.Message) {
+		// on reply button pressed
+	})
+
+	b.Handle(&inlineBtn, func(c *tb.Callback) {
+		// on inline button pressed (callback!)
+
+		// always respond!
+		b.Respond(c, &tb.CallbackResponse{...})
+	})
+
+	// Command: /start <PAYLOAD>
+	b.Handle("/start", func(m *tb.Message) {
+		if !m.Private() {
+			return
+		}
+
+		b.Send(m.Sender, "Hello!", &tb.ReplyMarkup{
+			ReplyKeyboard:  replyKeys,
+			InlineKeyboard: inlineKeys,
+		})
+	})
+
+	b.Start()
+}
+```
+
+## Inline mode
+So if you want to handle incoming inline queries you better plug the `tb.OnQuery`
+endpoint and then use the `Answer()` method to send a list of inline queries
+back. I think at the time of writing, telebot supports all of the provided result
+types (but not the cached ones). This is how it looks like:
+
+```go
+b.Handle(tb.OnQuery, func(q *tb.Query) {
+	urls := []string{
+		"http://photo.jpg",
+		"http://photo2.jpg",
+	}
+
+	results := make(tb.Results, len(urls)) // []tb.Result
+	for i, url := range urls {
+		result := &tb.PhotoResult{
+			URL: url,
+
+			// required for photos
+			ThumbURL: url,
+		}
+
+		results[i] = result
+		results[i].SetResultID(strconv.Itoa(i)) // It's needed to set a unique string ID for each result
+	}
+
+	err := b.Answer(q, &tb.QueryResponse{
+		Results: results,
+		CacheTime: 60, // a minute
+	})
+
+	if err != nil {
+		fmt.Println(err)
+	}
+})
+```
+
+There's not much to talk about really. It also support some form of authentication
+through deep-linking. For that, use fields `SwitchPMText` and `SwitchPMParameter`
+of `QueryResponse`.
+
+# Contributing
+
+1. Fork it
+2. Clone it: `git clone https://github.com/tucnak/telebot`
+3. Create your feature branch: `git checkout -b my-new-feature`
+4. Make changes and add them: `git add .`
+5. Commit: `git commit -m 'Add some feature'`
+6. Push: `git push origin my-new-feature`
+7. Pull request
+
+# Donate
+
+I do coding for fun but I also try to search for interesting solutions and
+optimize them as much as possible.
+If you feel like it's a good piece of software, I wouldn't mind a tip!
+
+Bitcoin: `1DkfrFvSRqgBnBuxv9BzAz83dqur5zrdTH`
+
+# License
+
+Telebot is distributed under MIT.
diff --git a/vendor/gopkg.in/tucnak/telebot.v2/admin.go b/vendor/gopkg.in/tucnak/telebot.v2/admin.go
new file mode 100644
index 00000000..d590d320
--- /dev/null
+++ b/vendor/gopkg.in/tucnak/telebot.v2/admin.go
@@ -0,0 +1,205 @@
+package telebot
+
+import (
+	"encoding/json"
+	"strconv"
+	"time"
+
+	"github.com/pkg/errors"
+)
+
+// Rights is a list of privileges available to chat members.
+type Rights struct {
+	CanBeEdited        bool `json:"can_be_edited,omitempty"`             // 1
+	CanChangeInfo      bool `json:"can_change_info,omitempty"`           // 2
+	CanPostMessages    bool `json:"can_post_messages,omitempty"`         // 3
+	CanEditMessages    bool `json:"can_edit_messages,omitempty"`         // 4
+	CanDeleteMessages  bool `json:"can_delete_messages,omitempty"`       // 5
+	CanInviteUsers     bool `json:"can_invite_users,omitempty"`          // 6
+	CanRestrictMembers bool `json:"can_restrict_members,omitempty"`      // 7
+	CanPinMessages     bool `json:"can_pin_messages,omitempty"`          // 8
+	CanPromoteMembers  bool `json:"can_promote_members,omitempty"`       // 9
+	CanSendMessages    bool `json:"can_send_messages,omitempty"`         // 10
+	CanSendMedia       bool `json:"can_send_media_messages,omitempty"`   // 11
+	CanSendOther       bool `json:"can_send_other_messages,omitempty"`   // 12
+	CanAddPreviews     bool `json:"can_add_web_page_previews,omitempty"` // 13
+}
+
+// NoRights is the default Rights{}
+func NoRights() Rights { return Rights{} }
+
+// NoRestrictions should be used when un-restricting or
+// un-promoting user.
+//
+//	   member.Rights = NoRestrictions()
+//     bot.Restrict(chat, member)
+//
+func NoRestrictions() Rights {
+	return Rights{
+		true, false, false, false, false, // 1-5
+		false, false, false, false, true, // 6-10
+		true, true, true}
+}
+
+// AdminRights could be used to promote user to admin.
+func AdminRights() Rights {
+	return Rights{
+		true, true, true, true, true, // 1-5
+		true, true, true, true, true, // 6-10
+		true, true, true} // 11-13
+}
+
+// Forever is a Unixtime of "forever" banning.
+func Forever() int64 {
+	return time.Now().Add(367 * 24 * time.Hour).Unix()
+}
+
+// Ban will ban user from chat until `member.RestrictedUntil`.
+func (b *Bot) Ban(chat *Chat, member *ChatMember) error {
+	params := map[string]string{
+		"chat_id":    chat.Recipient(),
+		"user_id":    member.User.Recipient(),
+		"until_date": strconv.FormatInt(member.RestrictedUntil, 10),
+	}
+
+	respJSON, err := b.Raw("kickChatMember", params)
+	if err != nil {
+		return err
+	}
+
+	return extractOkResponse(respJSON)
+}
+
+// Unban will unban user from chat, who would have thought eh?
+func (b *Bot) Unban(chat *Chat, user *User) error {
+	params := map[string]string{
+		"chat_id": chat.Recipient(),
+		"user_id": user.Recipient(),
+	}
+
+	respJSON, err := b.Raw("unbanChatMember", params)
+	if err != nil {
+		return err
+	}
+
+	return extractOkResponse(respJSON)
+}
+
+// Restrict let's you restrict a subset of member's rights until
+// member.RestrictedUntil, such as:
+//
+//     * can send messages
+//     * can send media
+//     * can send other
+//     * can add web page previews
+//
+func (b *Bot) Restrict(chat *Chat, member *ChatMember) error {
+	prv, until := member.Rights, member.RestrictedUntil
+
+	params := map[string]string{
+		"chat_id":    chat.Recipient(),
+		"user_id":    member.User.Recipient(),
+		"until_date": strconv.FormatInt(until, 10),
+	}
+
+	embedRights(params, prv)
+
+	respJSON, err := b.Raw("restrictChatMember", params)
+	if err != nil {
+		return err
+	}
+
+	return extractOkResponse(respJSON)
+}
+
+// Promote lets you update member's admin rights, such as:
+//
+//     * can change info
+//     * can post messages
+//     * can edit messages
+//     * can delete messages
+//     * can invite users
+//     * can restrict members
+//     * can pin messages
+//     * can promote members
+//
+func (b *Bot) Promote(chat *Chat, member *ChatMember) error {
+	prv := member.Rights
+
+	params := map[string]string{
+		"chat_id": chat.Recipient(),
+		"user_id": member.User.Recipient(),
+	}
+
+	embedRights(params, prv)
+
+	respJSON, err := b.Raw("promoteChatMember", params)
+	if err != nil {
+		return err
+	}
+
+	return extractOkResponse(respJSON)
+}
+
+// AdminsOf return a member list of chat admins.
+//
+// On success, returns an Array of ChatMember objects that
+// contains information about all chat administrators except other bots.
+// If the chat is a group or a supergroup and
+// no administrators were appointed, only the creator will be returned.
+func (b *Bot) AdminsOf(chat *Chat) ([]ChatMember, error) {
+	params := map[string]string{
+		"chat_id": chat.Recipient(),
+	}
+
+	respJSON, err := b.Raw("getChatAdministrators", params)
+	if err != nil {
+		return nil, err
+	}
+
+	var resp struct {
+		Ok          bool
+		Result      []ChatMember
+		Description string `json:"description"`
+	}
+
+	err = json.Unmarshal(respJSON, &resp)
+	if err != nil {
+		return nil, errors.Wrap(err, "bad response json")
+	}
+
+	if !resp.Ok {
+		return nil, errors.Errorf("api error: %s", resp.Description)
+	}
+
+	return resp.Result, nil
+}
+
+// Len return the number of members in a chat.
+func (b *Bot) Len(chat *Chat) (int, error) {
+	params := map[string]string{
+		"chat_id": chat.Recipient(),
+	}
+
+	respJSON, err := b.Raw("getChatMembersCount", params)
+	if err != nil {
+		return 0, err
+	}
+
+	var resp struct {
+		Ok          bool
+		Result      int
+		Description string `json:"description"`
+	}
+
+	err = json.Unmarshal(respJSON, &resp)
+	if err != nil {
+		return 0, errors.Wrap(err, "bad response json")
+	}
+
+	if !resp.Ok {
+		return 0, errors.Errorf("api error: %s", resp.Description)
+	}
+
+	return resp.Result, nil
+}
diff --git a/vendor/gopkg.in/tucnak/telebot.v2/api.go b/vendor/gopkg.in/tucnak/telebot.v2/api.go
new file mode 100644
index 00000000..c0c3a81d
--- /dev/null
+++ b/vendor/gopkg.in/tucnak/telebot.v2/api.go
@@ -0,0 +1,210 @@
+package telebot
+
+import (
+	"bytes"
+	"encoding/json"
+	"io"
+	"io/ioutil"
+	"mime/multipart"
+	"net/http"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/pkg/errors"
+)
+
+// Raw lets you call any method of Bot API manually.
+func (b *Bot) Raw(method string, payload interface{}) ([]byte, error) {
+	url := b.URL + "/bot" + b.Token + "/" + method
+
+	var buf bytes.Buffer
+	if err := json.NewEncoder(&buf).Encode(payload); err != nil {
+		return []byte{}, wrapSystem(err)
+	}
+
+	resp, err := b.client.Post(url, "application/json", &buf)
+	if err != nil {
+		return []byte{}, errors.Wrap(err, "http.Post failed")
+	}
+	resp.Close = true
+	defer resp.Body.Close()
+
+	json, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return []byte{}, wrapSystem(err)
+	}
+
+	return json, nil
+}
+
+func addFileToWriter(writer *multipart.Writer,
+	filename, field string, file interface{}) error {
+
+	var reader io.Reader
+	if r, ok := file.(io.Reader); ok {
+		reader = r
+	} else if path, ok := file.(string); ok {
+		f, err := os.Open(path)
+		if err != nil {
+			return err
+		}
+		defer f.Close()
+		reader = f
+	} else {
+		return errors.Errorf("File for field `%v` should be an io.ReadCloser or string", field)
+	}
+
+	part, err := writer.CreateFormFile(field, filename)
+	if err != nil {
+		return err
+	}
+
+	_, err = io.Copy(part, reader)
+	return err
+}
+
+func (b *Bot) sendFiles(method string, files map[string]File,
+	params map[string]string) ([]byte, error) {
+
+	body := &bytes.Buffer{}
+	rawFiles := map[string]interface{}{}
+
+	for name, f := range files {
+		switch {
+		case f.InCloud():
+			params[name] = f.FileID
+		case f.FileURL != "":
+			params[name] = f.FileURL
+		case f.OnDisk():
+			rawFiles[name] = f.FileLocal
+		case f.FileReader != nil:
+			rawFiles[name] = f.FileReader
+		default:
+			return nil, errors.Errorf("sendFiles: File for field %s doesn't exist", name)
+		}
+	}
+
+	if len(rawFiles) == 0 {
+		return b.Raw(method, params)
+	}
+
+	writer := multipart.NewWriter(body)
+
+	for field, file := range rawFiles {
+		if err := addFileToWriter(writer, params["file_name"], field, file); err != nil {
+			return nil, wrapSystem(err)
+		}
+	}
+
+	for field, value := range params {
+		if err := writer.WriteField(field, value); err != nil {
+			return nil, wrapSystem(err)
+		}
+	}
+
+	if err := writer.Close(); err != nil {
+		return nil, wrapSystem(err)
+	}
+
+	url := b.URL + "/bot" + b.Token + "/" + method
+	req, err := http.NewRequest("POST", url, body)
+	if err != nil {
+		return nil, wrapSystem(err)
+	}
+
+	req.Header.Add("Content-Type", writer.FormDataContentType())
+
+	resp, err := b.client.Do(req)
+	if err != nil {
+		return nil, errors.Wrap(err, "http.Post failed")
+	}
+
+	if resp.StatusCode == http.StatusInternalServerError {
+		return nil, errors.New("api error: internal server error")
+	}
+
+	json, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return nil, wrapSystem(err)
+	}
+
+	return json, nil
+}
+
+func (b *Bot) sendObject(f *File, what string, params map[string]string, files map[string]File) (*Message, error) {
+	sendWhat := "send" + strings.Title(what)
+
+	if what == "videoNote" {
+		what = "video_note"
+	}
+
+	sendFiles := map[string]File{what: *f}
+	for k, v := range files {
+		sendFiles[k] = v
+	}
+
+	respJSON, err := b.sendFiles(sendWhat, sendFiles, params)
+	if err != nil {
+		return nil, err
+	}
+
+	return extractMsgResponse(respJSON)
+}
+
+func (b *Bot) getMe() (*User, error) {
+	meJSON, err := b.Raw("getMe", nil)
+	if err != nil {
+		return nil, err
+	}
+
+	var botInfo struct {
+		Ok          bool
+		Result      *User
+		Description string
+	}
+
+	err = json.Unmarshal(meJSON, &botInfo)
+	if err != nil {
+		return nil, errors.Wrap(err, "bad response json")
+	}
+
+	if !botInfo.Ok {
+		return nil, errors.Errorf("api error: %s", botInfo.Description)
+	}
+
+	return botInfo.Result, nil
+
+}
+
+func (b *Bot) getUpdates(offset int, timeout time.Duration) (upd []Update, err error) {
+	params := map[string]string{
+		"offset":  strconv.Itoa(offset),
+		"timeout": strconv.Itoa(int(timeout / time.Second)),
+	}
+	updatesJSON, errCommand := b.Raw("getUpdates", params)
+	if errCommand != nil {
+		err = errCommand
+		return
+
+	}
+	var updatesReceived struct {
+		Ok          bool
+		Result      []Update
+		Description string
+	}
+
+	err = json.Unmarshal(updatesJSON, &updatesReceived)
+	if err != nil {
+		err = errors.Wrap(err, "bad response json")
+		return
+	}
+
+	if !updatesReceived.Ok {
+		err = errors.Errorf("api error: %s", updatesReceived.Description)
+		return
+	}
+
+	return updatesReceived.Result, nil
+}
diff --git a/vendor/gopkg.in/tucnak/telebot.v2/bot.go b/vendor/gopkg.in/tucnak/telebot.v2/bot.go
new file mode 100644
index 00000000..67790bce
--- /dev/null
+++ b/vendor/gopkg.in/tucnak/telebot.v2/bot.go
@@ -0,0 +1,1522 @@
+package telebot
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"github.com/pkg/errors"
+)
+
+// NewBot does try to build a Bot with token `token`, which
+// is a secret API key assigned to particular bot.
+func NewBot(pref Settings) (*Bot, error) {
+	if pref.Updates == 0 {
+		pref.Updates = 100
+	}
+
+	client := pref.Client
+	if client == nil {
+		client = http.DefaultClient
+	}
+
+	if pref.URL == "" {
+		pref.URL = DefaultApiURL
+	}
+
+	bot := &Bot{
+		Token:   pref.Token,
+		URL:     pref.URL,
+		Updates: make(chan Update, pref.Updates),
+		Poller:  pref.Poller,
+
+		handlers: make(map[string]interface{}),
+		stop:     make(chan struct{}),
+		reporter: pref.Reporter,
+		client:   client,
+	}
+
+	user, err := bot.getMe()
+	if err != nil {
+		return nil, err
+	}
+
+	bot.Me = user
+	return bot, nil
+}
+
+// Bot represents a separate Telegram bot instance.
+type Bot struct {
+	Me      *User
+	Token   string
+	URL     string
+	Updates chan Update
+	Poller  Poller
+
+	handlers map[string]interface{}
+	reporter func(error)
+	stop     chan struct{}
+	client   *http.Client
+}
+
+// Settings represents a utility struct for passing certain
+// properties of a bot around and is required to make bots.
+type Settings struct {
+	// Telegram API Url
+	URL string
+
+	// Telegram token
+	Token string
+
+	// Updates channel capacity
+	Updates int // Default: 100
+
+	// Poller is the provider of Updates.
+	Poller Poller
+
+	// Reporter is a callback function that will get called
+	// on any panics recovered from endpoint handlers.
+	Reporter func(error)
+
+	// HTTP Client used to make requests to telegram api
+	Client *http.Client
+}
+
+// Update object represents an incoming update.
+type Update struct {
+	ID int `json:"update_id"`
+
+	Message            *Message            `json:"message,omitempty"`
+	EditedMessage      *Message            `json:"edited_message,omitempty"`
+	ChannelPost        *Message            `json:"channel_post,omitempty"`
+	EditedChannelPost  *Message            `json:"edited_channel_post,omitempty"`
+	Callback           *Callback           `json:"callback_query,omitempty"`
+	Query              *Query              `json:"inline_query,omitempty"`
+	ChosenInlineResult *ChosenInlineResult `json:"chosen_inline_result,omitempty"`
+	PreCheckoutQuery   *PreCheckoutQuery   `json:"pre_checkout_query,omitempty"`
+}
+
+// ChosenInlineResult represents a result of an inline query that was chosen
+// by the user and sent to their chat partner.
+type ChosenInlineResult struct {
+	From     User      `json:"from"`
+	Location *Location `json:"location,omitempty"`
+	ResultID string    `json:"result_id"`
+	Query    string    `json:"query"`
+	// Inline messages only!
+	MessageID string `json:"inline_message_id"`
+}
+
+type PreCheckoutQuery struct {
+	Sender   *User  `json:"from"`
+	ID       string `json:"id"`
+	Currency string `json:"currency"`
+	Payload  string `json:"invoice_payload"`
+	Total    int    `json:"total_amount"`
+}
+
+// Handle lets you set the handler for some command name or
+// one of the supported endpoints.
+//
+// Example:
+//
+//     b.handle("/help", func (m *tb.Message) {})
+//     b.handle(tb.OnEdited, func (m *tb.Message) {})
+//     b.handle(tb.OnQuery, func (q *tb.Query) {})
+//
+//     // make a hook for one of your preserved (by-pointer)
+//     // inline buttons.
+//     b.handle(&inlineButton, func (c *tb.Callback) {})
+//
+func (b *Bot) Handle(endpoint interface{}, handler interface{}) {
+	switch end := endpoint.(type) {
+	case string:
+		b.handlers[end] = handler
+	case CallbackEndpoint:
+		b.handlers[end.CallbackUnique()] = handler
+	default:
+		panic("telebot: unsupported endpoint")
+	}
+}
+
+var (
+	cmdRx   = regexp.MustCompile(`^(\/\w+)(@(\w+))?(\s|$)(.+)?`)
+	cbackRx = regexp.MustCompile(`^\f(\w+)(\|(.+))?$`)
+)
+
+func (b *Bot) handleCommand(m *Message, cmdName, cmdBot string) bool {
+
+	return false
+}
+
+// Start brings bot into motion by consuming incoming
+// updates (see Bot.Updates channel).
+func (b *Bot) Start() {
+	if b.Poller == nil {
+		panic("telebot: can't start without a poller")
+	}
+
+	stopPoller := make(chan struct{})
+
+	go b.Poller.Poll(b, b.Updates, stopPoller)
+
+	for {
+		select {
+		// handle incoming updates
+		case upd := <-b.Updates:
+			b.incomingUpdate(&upd)
+
+		// call to stop polling
+		case <-b.stop:
+			stopPoller <- struct{}{}
+
+		// polling has stopped
+		case <-stopPoller:
+			return
+		}
+	}
+}
+
+func (b *Bot) incomingUpdate(upd *Update) {
+	if upd.Message != nil {
+		m := upd.Message
+
+		if m.PinnedMessage != nil {
+			b.handle(OnPinned, m)
+			return
+		}
+
+		// Commands
+		if m.Text != "" {
+			// Filtering malicious messsages
+			if m.Text[0] == '\a' {
+				return
+			}
+
+			match := cmdRx.FindAllStringSubmatch(m.Text, -1)
+
+			// Command found - handle and return
+			if match != nil {
+				// Syntax: "</command>@<bot> <payload>"
+				command, botName := match[0][1], match[0][3]
+				m.Payload = match[0][5]
+
+				if botName != "" && !strings.EqualFold(b.Me.Username, botName) {
+					return
+				}
+
+				if b.handle(command, m) {
+					return
+				}
+			}
+
+			// 1:1 satisfaction
+			if b.handle(m.Text, m) {
+				return
+			}
+
+			// OnText
+			b.handle(OnText, m)
+			return
+		}
+
+		// on media
+		if b.handleMedia(m) {
+			return
+		}
+
+		// OnAddedToGroup
+		wasAdded := (m.UserJoined != nil && m.UserJoined.ID == b.Me.ID) ||
+			(m.UsersJoined != nil && isUserInList(b.Me, m.UsersJoined))
+		if m.GroupCreated || m.SuperGroupCreated || wasAdded {
+			b.handle(OnAddedToGroup, m)
+			return
+		}
+
+		if m.UserJoined != nil {
+			b.handle(OnUserJoined, m)
+			return
+		}
+
+		if m.UsersJoined != nil {
+			for _, user := range m.UsersJoined {
+				m.UserJoined = &user
+				b.handle(OnUserJoined, m)
+			}
+
+			return
+		}
+
+		if m.UserLeft != nil {
+			b.handle(OnUserLeft, m)
+			return
+		}
+
+		if m.NewGroupTitle != "" {
+			b.handle(OnNewGroupTitle, m)
+			return
+		}
+
+		if m.NewGroupPhoto != nil {
+			b.handle(OnNewGroupPhoto, m)
+			return
+		}
+
+		if m.GroupPhotoDeleted {
+			b.handle(OnGroupPhotoDeleted, m)
+			return
+		}
+
+		if m.MigrateTo != 0 {
+			if handler, ok := b.handlers[OnMigration]; ok {
+				if handler, ok := handler.(func(int64, int64)); ok {
+					// i'm not 100% sure that any of the values
+					// won't be cached, so I pass them all in:
+					go func(b *Bot, handler func(int64, int64), from, to int64) {
+						if b.reporter == nil {
+							defer b.deferDebug()
+						}
+						handler(from, to)
+					}(b, handler, m.MigrateFrom, m.MigrateTo)
+
+				} else {
+					panic("telebot: migration handler is bad")
+				}
+			}
+
+			return
+		}
+
+		return
+	}
+
+	if upd.EditedMessage != nil {
+		b.handle(OnEdited, upd.EditedMessage)
+		return
+	}
+
+	if upd.ChannelPost != nil {
+		b.handle(OnChannelPost, upd.ChannelPost)
+		return
+	}
+
+	if upd.EditedChannelPost != nil {
+		b.handle(OnEditedChannelPost, upd.EditedChannelPost)
+		return
+	}
+
+	if upd.Callback != nil {
+		if upd.Callback.Data != "" {
+			data := upd.Callback.Data
+
+			if data[0] == '\f' {
+				match := cbackRx.FindAllStringSubmatch(data, -1)
+
+				if match != nil {
+					unique, payload := match[0][1], match[0][3]
+
+					if handler, ok := b.handlers["\f"+unique]; ok {
+						if handler, ok := handler.(func(*Callback)); ok {
+							upd.Callback.Data = payload
+							// i'm not 100% sure that any of the values
+							// won't be cached, so I pass them all in:
+							go func(b *Bot, handler func(*Callback), c *Callback) {
+								if b.reporter == nil {
+									defer b.deferDebug()
+								}
+								handler(c)
+							}(b, handler, upd.Callback)
+
+							return
+						}
+					}
+
+				}
+			}
+		}
+
+		if handler, ok := b.handlers[OnCallback]; ok {
+			if handler, ok := handler.(func(*Callback)); ok {
+				// i'm not 100% sure that any of the values
+				// won't be cached, so I pass them all in:
+				go func(b *Bot, handler func(*Callback), c *Callback) {
+					if b.reporter == nil {
+						defer b.deferDebug()
+					}
+					handler(c)
+				}(b, handler, upd.Callback)
+
+			} else {
+				panic("telebot: callback handler is bad")
+			}
+		}
+		return
+	}
+
+	if upd.Query != nil {
+		if handler, ok := b.handlers[OnQuery]; ok {
+			if handler, ok := handler.(func(*Query)); ok {
+				// i'm not 100% sure that any of the values
+				// won't be cached, so I pass them all in:
+				go func(b *Bot, handler func(*Query), q *Query) {
+					if b.reporter == nil {
+						defer b.deferDebug()
+					}
+					handler(q)
+				}(b, handler, upd.Query)
+
+			} else {
+				panic("telebot: query handler is bad")
+			}
+		}
+		return
+	}
+
+	if upd.ChosenInlineResult != nil {
+		if handler, ok := b.handlers[OnChosenInlineResult]; ok {
+			if handler, ok := handler.(func(*ChosenInlineResult)); ok {
+				// i'm not 100% sure that any of the values
+				// won't be cached, so I pass them all in:
+				go func(b *Bot, handler func(*ChosenInlineResult),
+					r *ChosenInlineResult) {
+					if b.reporter == nil {
+						defer b.deferDebug()
+					}
+					handler(r)
+				}(b, handler, upd.ChosenInlineResult)
+
+			} else {
+				panic("telebot: chosen inline result handler is bad")
+			}
+		}
+		return
+	}
+
+	if upd.PreCheckoutQuery != nil {
+		if handler, ok := b.handlers[OnCheckout]; ok {
+			if handler, ok := handler.(func(*PreCheckoutQuery)); ok {
+				// i'm not 100% sure that any of the values
+				// won't be cached, so I pass them all in:
+				go func(b *Bot, handler func(*PreCheckoutQuery),
+					r *PreCheckoutQuery) {
+					if b.reporter == nil {
+						defer b.deferDebug()
+					}
+					handler(r)
+				}(b, handler, upd.PreCheckoutQuery)
+
+			} else {
+				panic("telebot: checkout handler is bad")
+			}
+		}
+		return
+	}
+}
+
+func (b *Bot) handle(end string, m *Message) bool {
+	handler, ok := b.handlers[end]
+	if !ok {
+		return false
+	}
+
+	if handler, ok := handler.(func(*Message)); ok {
+		// i'm not 100% sure that any of the values
+		// won't be cached, so I pass them all in:
+		go func(b *Bot, handler func(*Message), m *Message) {
+			if b.reporter == nil {
+				defer b.deferDebug()
+			}
+			handler(m)
+		}(b, handler, m)
+
+		return true
+	}
+
+	return false
+}
+
+func (b *Bot) handleMedia(m *Message) bool {
+	if m.Photo != nil {
+		b.handle(OnPhoto, m)
+		return true
+	}
+
+	if m.Voice != nil {
+		b.handle(OnVoice, m)
+		return true
+	}
+
+	if m.Audio != nil {
+		b.handle(OnAudio, m)
+		return true
+	}
+
+	if m.Document != nil {
+		b.handle(OnDocument, m)
+		return true
+	}
+
+	if m.Sticker != nil {
+		b.handle(OnSticker, m)
+		return true
+	}
+
+	if m.Video != nil {
+		b.handle(OnVideo, m)
+		return true
+	}
+
+	if m.VideoNote != nil {
+		b.handle(OnVideoNote, m)
+		return true
+	}
+
+	if m.Contact != nil {
+		b.handle(OnContact, m)
+		return true
+	}
+
+	if m.Location != nil {
+		b.handle(OnLocation, m)
+		return true
+	}
+
+	if m.Venue != nil {
+		b.handle(OnVenue, m)
+		return true
+	}
+
+	return false
+}
+
+// Stop gracefully shuts the poller down.
+func (b *Bot) Stop() {
+	b.stop <- struct{}{}
+}
+
+// Send accepts 2+ arguments, starting with destination chat, followed by
+// some Sendable (or string!) and optional send options.
+//
+// Note: since most arguments are of type interface{}, but have pointer
+// 		method recievers, make sure to pass them by-pointer, NOT by-value.
+//
+// What is a send option exactly? It can be one of the following types:
+//
+//     - *SendOptions (the actual object accepted by Telegram API)
+//     - *ReplyMarkup (a component of SendOptions)
+//     - Option (a shorcut flag for popular options)
+//     - ParseMode (HTML, Markdown, etc)
+//
+// This function will panic upon unsupported payloads and options!
+func (b *Bot) Send(to Recipient, what interface{}, options ...interface{}) (*Message, error) {
+	sendOpts := extractOptions(options)
+
+	switch object := what.(type) {
+	case string:
+		return b.sendText(to, object, sendOpts)
+	case Sendable:
+		return object.Send(b, to, sendOpts)
+	default:
+		return nil, errors.New("telebot: unsupported sendable")
+	}
+}
+
+// SendAlbum is used when sending multiple instances of media as a single
+// message (so-called album).
+//
+// From all existing options, it only supports telebot.Silent.
+func (b *Bot) SendAlbum(to Recipient, a Album, options ...interface{}) ([]Message, error) {
+	media := make([]string, len(a))
+	files := make(map[string]File)
+
+	for i, x := range a {
+		var mediaRepr string
+		var jsonRepr []byte
+
+		f := x.MediaFile()
+
+		if f.InCloud() {
+			mediaRepr = f.FileID
+		} else if f.FileURL != "" {
+			mediaRepr = f.FileURL
+		} else if f.OnDisk() || f.FileReader != nil {
+			mediaRepr = "attach://" + strconv.Itoa(i)
+			files[strconv.Itoa(i)] = *f
+		} else {
+			return nil, errors.Errorf(
+				"telebot: album entry #%d doesn't exist anywhere", i)
+		}
+
+		switch y := x.(type) {
+		case *Photo:
+			jsonRepr, _ = json.Marshal(struct {
+				Type    string `json:"type"`
+				Caption string `json:"caption"`
+				Media   string `json:"media"`
+			}{
+				"photo",
+				y.Caption,
+				mediaRepr,
+			})
+		case *Video:
+			jsonRepr, _ = json.Marshal(struct {
+				Type              string `json:"type"`
+				Caption           string `json:"caption"`
+				Media             string `json:"media"`
+				Width             int    `json:"width,omitempty"`
+				Height            int    `json:"height,omitempty"`
+				Duration          int    `json:"duration,omitempty"`
+				SupportsStreaming bool   `json:"supports_streaming,omitempty"`
+			}{
+				"video",
+				y.Caption,
+				mediaRepr,
+				y.Width,
+				y.Height,
+				y.Duration,
+				y.SupportsStreaming,
+			})
+		default:
+			return nil, errors.Errorf("telebot: album entry #%d is not valid", i)
+		}
+
+		media[i] = string(jsonRepr)
+	}
+
+	params := map[string]string{
+		"chat_id": to.Recipient(),
+		"media":   "[" + strings.Join(media, ",") + "]",
+	}
+
+	sendOpts := extractOptions(options)
+	embedSendOptions(params, sendOpts)
+
+	respJSON, err := b.sendFiles("sendMediaGroup", files, params)
+	if err != nil {
+		return nil, err
+	}
+
+	var resp struct {
+		Ok          bool
+		Result      []Message
+		Description string
+	}
+
+	err = json.Unmarshal(respJSON, &resp)
+	if err != nil {
+		return nil, errors.Wrap(err, "bad response json")
+	}
+
+	if !resp.Ok {
+		return nil, errors.Errorf("api error: %s", resp.Description)
+	}
+
+	for attachName, _ := range files {
+		i, _ := strconv.Atoi(attachName)
+
+		var newID string
+		if resp.Result[i].Photo != nil {
+			newID = resp.Result[i].Photo.FileID
+		} else {
+			newID = resp.Result[i].Video.FileID
+		}
+
+		a[i].MediaFile().FileID = newID
+	}
+
+	return resp.Result, nil
+}
+
+// Reply behaves just like Send() with an exception of "reply-to" indicator.
+func (b *Bot) Reply(to *Message, what interface{}, options ...interface{}) (*Message, error) {
+	// This function will panic upon unsupported payloads and options!
+	sendOpts := extractOptions(options)
+	if sendOpts == nil {
+		sendOpts = &SendOptions{}
+	}
+
+	sendOpts.ReplyTo = to
+
+	return b.Send(to.Chat, what, sendOpts)
+}
+
+// Forward behaves just like Send() but of all options it
+// only supports Silent (see Bots API).
+//
+// This function will panic upon unsupported payloads and options!
+func (b *Bot) Forward(to Recipient, what *Message, options ...interface{}) (*Message, error) {
+	params := map[string]string{
+		"chat_id":      to.Recipient(),
+		"from_chat_id": what.Chat.Recipient(),
+		"message_id":   strconv.Itoa(what.ID),
+	}
+
+	sendOpts := extractOptions(options)
+	embedSendOptions(params, sendOpts)
+
+	respJSON, err := b.Raw("forwardMessage", params)
+	if err != nil {
+		return nil, err
+	}
+
+	return extractMsgResponse(respJSON)
+}
+
+// Edit is magic, it lets you change already sent message.
+//
+// Use cases:
+//
+//     b.Edit(msg, msg.Text, newMarkup)
+//     b.Edit(msg, "new <b>text</b>", tb.ModeHTML)
+//
+//     // Edit live location:
+//     b.Edit(liveMsg, tb.Location{42.1337, 69.4242})
+//
+func (b *Bot) Edit(message Editable, what interface{}, options ...interface{}) (*Message, error) {
+	messageID, chatID := message.MessageSig()
+
+	params := map[string]string{}
+
+	switch v := what.(type) {
+	case string:
+		params["text"] = v
+	case Location:
+		params["latitude"] = fmt.Sprintf("%f", v.Lat)
+		params["longitude"] = fmt.Sprintf("%f", v.Lng)
+	default:
+		panic("telebot: unsupported what argument")
+	}
+
+	// if inline message
+	if chatID == 0 {
+		params["inline_message_id"] = messageID
+	} else {
+		params["chat_id"] = strconv.FormatInt(chatID, 10)
+		params["message_id"] = messageID
+	}
+
+	sendOpts := extractOptions(options)
+	embedSendOptions(params, sendOpts)
+
+	respJSON, err := b.Raw("editMessageText", params)
+	if err != nil {
+		return nil, err
+	}
+
+	return extractMsgResponse(respJSON)
+}
+
+// EditReplyMarkup used to edit reply markup of already sent message.
+//
+// On success, returns edited message object
+func (b *Bot) EditReplyMarkup(message Editable, markup *ReplyMarkup) (*Message, error) {
+	messageID, chatID := message.MessageSig()
+
+	params := map[string]string{}
+
+	// if inline message
+	if chatID == 0 {
+		params["inline_message_id"] = messageID
+	} else {
+		params["chat_id"] = strconv.FormatInt(chatID, 10)
+		params["message_id"] = messageID
+	}
+
+	processButtons(markup.InlineKeyboard)
+	jsonMarkup, _ := json.Marshal(markup)
+	params["reply_markup"] = string(jsonMarkup)
+
+	respJSON, err := b.Raw("editMessageReplyMarkup", params)
+	if err != nil {
+		return nil, err
+	}
+
+	return extractMsgResponse(respJSON)
+}
+
+// EditCaption used to edit already sent photo caption with known recepient and message id.
+//
+// On success, returns edited message object
+func (b *Bot) EditCaption(message Editable, caption string) (*Message, error) {
+	messageID, chatID := message.MessageSig()
+
+	params := map[string]string{"caption": caption}
+
+	// if inline message
+	if chatID == 0 {
+		params["inline_message_id"] = messageID
+	} else {
+		params["chat_id"] = strconv.FormatInt(chatID, 10)
+		params["message_id"] = messageID
+	}
+
+	respJSON, err := b.Raw("editMessageCaption", params)
+	if err != nil {
+		return nil, err
+	}
+
+	return extractMsgResponse(respJSON)
+}
+
+// EditMedia used to edit already sent media with known recepient and message id.
+//
+// Use cases:
+//
+//     bot.EditMedia(msg, &tb.Photo{File: tb.FromDisk("chicken.jpg")});
+//     bot.EditMedia(msg, &tb.Video{File: tb.FromURL("http://video.mp4")});
+//
+func (b *Bot) EditMedia(message Editable, inputMedia InputMedia, options ...interface{}) (*Message, error) {
+	var mediaRepr string
+	var jsonRepr []byte
+	var thumb *Photo
+
+	file := make(map[string]File)
+
+	f := inputMedia.MediaFile()
+
+	if f.InCloud() {
+		mediaRepr = f.FileID
+	} else if f.FileURL != "" {
+		mediaRepr = f.FileURL
+	} else if f.OnDisk() || f.FileReader != nil {
+		s := f.FileLocal
+		if f.FileReader != nil {
+			s = "0"
+		}
+		mediaRepr = "attach://" + s
+		file[s] = *f
+	} else {
+		return nil, errors.Errorf(
+			"telebot: can't edit media, it doesn't exist anywhere")
+	}
+
+	type FileJson struct {
+		// All types.
+		Type    string `json:"type"`
+		Caption string `json:"caption"`
+		Media   string `json:"media"`
+
+		// Video.
+		Width             int  `json:"width,omitempty"`
+		Height            int  `json:"height,omitempty"`
+		SupportsStreaming bool `json:"supports_streaming,omitempty"`
+
+		// Video and audio.
+		Duration int `json:"duration,omitempty"`
+
+		// Document.
+		FileName string `json:"file_name"`
+
+		// Document, video and audio.
+		Thumbnail string `json:"thumb,omitempty"`
+		MIME      string `json:"mime_type,omitempty"`
+
+		// Audio.
+		Title     string `json:"title,omitempty"`
+		Performer string `json:"performer,omitempty"`
+	}
+
+	resultMedia := &FileJson{Media: mediaRepr}
+
+	switch y := inputMedia.(type) {
+	case *Photo:
+		resultMedia.Type = "photo"
+		resultMedia.Caption = y.Caption
+	case *Video:
+		resultMedia.Type = "video"
+		resultMedia.Caption = y.Caption
+		resultMedia.Width = y.Width
+		resultMedia.Height = y.Height
+		resultMedia.Duration = y.Duration
+		resultMedia.SupportsStreaming = y.SupportsStreaming
+		resultMedia.MIME = y.MIME
+		thumb = y.Thumbnail
+		if thumb != nil {
+			resultMedia.Thumbnail = "attach://thumb"
+		}
+	case *Document:
+		resultMedia.Type = "document"
+		resultMedia.Caption = y.Caption
+		resultMedia.FileName = y.FileName
+		resultMedia.MIME = y.MIME
+		thumb = y.Thumbnail
+		if thumb != nil {
+			resultMedia.Thumbnail = "attach://thumb"
+		}
+	case *Audio:
+		resultMedia.Type = "audio"
+		resultMedia.Caption = y.Caption
+		resultMedia.Duration = y.Duration
+		resultMedia.MIME = y.MIME
+		resultMedia.Title = y.Title
+		resultMedia.Performer = y.Performer
+	default:
+		return nil, errors.Errorf("telebot: inputMedia entry is not valid")
+	}
+
+	messageID, chatID := message.MessageSig()
+
+	jsonRepr, _ = json.Marshal(resultMedia)
+	params := map[string]string{}
+	params["media"] = string(jsonRepr)
+
+	// If inline message.
+	if chatID == 0 {
+		params["inline_message_id"] = messageID
+	} else {
+		params["chat_id"] = strconv.FormatInt(chatID, 10)
+		params["message_id"] = messageID
+	}
+
+	if thumb != nil {
+		file["thumb"] = *thumb.MediaFile()
+	}
+
+	sendOpts := extractOptions(options)
+	embedSendOptions(params, sendOpts)
+
+	respJSON, err := b.sendFiles("editMessageMedia", file, params)
+	if err != nil {
+		return nil, err
+	}
+
+	return extractMsgResponse(respJSON)
+}
+
+// Delete removes the message, including service messages,
+// with the following limitations:
+//
+//     * A message can only be deleted if it was sent less than 48 hours ago.
+//     * Bots can delete outgoing messages in groups and supergroups.
+//     * Bots granted can_post_messages permissions can delete outgoing
+//       messages in channels.
+//     * If the bot is an administrator of a group, it can delete any message there.
+//     * If the bot has can_delete_messages permission in a supergroup or a
+//       channel, it can delete any message there.
+//
+func (b *Bot) Delete(message Editable) error {
+	messageID, chatID := message.MessageSig()
+
+	params := map[string]string{
+		"chat_id":    strconv.FormatInt(chatID, 10),
+		"message_id": messageID,
+	}
+
+	respJSON, err := b.Raw("deleteMessage", params)
+	if err != nil {
+		return err
+	}
+
+	return extractOkResponse(respJSON)
+}
+
+// Notify updates the chat action for recipient.
+//
+// Chat action is a status message that recipient would see where
+// you typically see "Harry is typing" status message. The only
+// difference is that bots' chat actions live only for 5 seconds
+// and die just once the client recieves a message from the bot.
+//
+// Currently, Telegram supports only a narrow range of possible
+// actions, these are aligned as constants of this package.
+func (b *Bot) Notify(recipient Recipient, action ChatAction) error {
+	params := map[string]string{
+		"chat_id": recipient.Recipient(),
+		"action":  string(action),
+	}
+
+	respJSON, err := b.Raw("sendChatAction", params)
+	if err != nil {
+		return err
+	}
+
+	return extractOkResponse(respJSON)
+}
+
+// Accept finalizes the deal.
+func (b *Bot) Accept(query *PreCheckoutQuery, errorMessage ...string) error {
+	params := map[string]string{
+		"pre_checkout_query_id": query.ID,
+	}
+
+	if len(errorMessage) == 0 {
+		params["ok"] = "True"
+	} else {
+		params["ok"] = "False"
+		params["error_message"] = errorMessage[0]
+	}
+
+	respJSON, err := b.Raw("answerPreCheckoutQuery", params)
+	if err != nil {
+		return err
+	}
+
+	return extractOkResponse(respJSON)
+}
+
+// Answer sends a response for a given inline query. A query can only
+// be responded to once, subsequent attempts to respond to the same query
+// will result in an error.
+func (b *Bot) Answer(query *Query, response *QueryResponse) error {
+	response.QueryID = query.ID
+
+	for _, result := range response.Results {
+		result.Process()
+	}
+
+	respJSON, err := b.Raw("answerInlineQuery", response)
+	if err != nil {
+		return err
+	}
+
+	return extractOkResponse(respJSON)
+}
+
+// Respond sends a response for a given callback query. A callback can
+// only be responded to once, subsequent attempts to respond to the same callback
+// will result in an error.
+//
+// Example:
+//
+//		bot.Respond(c)
+//		bot.Respond(c, response)
+//
+func (b *Bot) Respond(callback *Callback, responseOptional ...*CallbackResponse) error {
+	var response *CallbackResponse
+	if responseOptional == nil {
+		response = &CallbackResponse{}
+	} else {
+		response = responseOptional[0]
+	}
+
+	response.CallbackID = callback.ID
+	respJSON, err := b.Raw("answerCallbackQuery", response)
+	if err != nil {
+		return err
+	}
+
+	return extractOkResponse(respJSON)
+}
+
+// FileByID returns full file object including File.FilePath, allowing you to
+// download the file from the server.
+//
+// Usually, Telegram-provided File objects miss FilePath so you might need to
+// perform an additional request to fetch them.
+func (b *Bot) FileByID(fileID string) (File, error) {
+	params := map[string]string{
+		"file_id": fileID,
+	}
+
+	respJSON, err := b.Raw("getFile", params)
+	if err != nil {
+		return File{}, err
+	}
+
+	var resp struct {
+		Ok          bool
+		Description string
+		Result      File
+	}
+
+	err = json.Unmarshal(respJSON, &resp)
+	if err != nil {
+		return File{}, errors.Wrap(err, "bad response json")
+	}
+
+	if !resp.Ok {
+		return File{}, errors.Errorf("api error: %s", resp.Description)
+
+	}
+
+	return resp.Result, nil
+}
+
+// Download saves the file from Telegram servers locally.
+//
+// Maximum file size to download is 20 MB.
+func (b *Bot) Download(file *File, localFilename string) error {
+	reader, err := b.GetFile(file)
+	if err != nil {
+		return wrapSystem(err)
+	}
+	defer reader.Close()
+
+	out, err := os.Create(localFilename)
+	if err != nil {
+		return wrapSystem(err)
+	}
+	defer out.Close()
+
+	_, err = io.Copy(out, reader)
+	if err != nil {
+		return wrapSystem(err)
+	}
+	file.FileLocal = localFilename
+
+	return nil
+}
+
+// GetFile from Telegram servers
+func (b *Bot) GetFile(file *File) (io.ReadCloser, error) {
+	f, err := b.FileByID(file.FileID)
+	if err != nil {
+		return nil, err
+	}
+
+	url := b.URL + "/file/bot" + b.Token + "/" + f.FilePath
+
+	resp, err := http.Get(url)
+	if err != nil {
+		return nil, err
+	}
+	// set FilePath
+	*file = f
+
+	return resp.Body, nil
+}
+
+// StopLiveLocation should be called to stop broadcasting live message location
+// before Location.LivePeriod expires.
+//
+// It supports telebot.ReplyMarkup.
+func (b *Bot) StopLiveLocation(message Editable, options ...interface{}) (*Message, error) {
+	messageID, chatID := message.MessageSig()
+
+	params := map[string]string{
+		"chat_id":    strconv.FormatInt(chatID, 10),
+		"message_id": messageID,
+	}
+
+	sendOpts := extractOptions(options)
+	embedSendOptions(params, sendOpts)
+
+	respJSON, err := b.Raw("stopMessageLiveLocation", params)
+	if err != nil {
+		return nil, err
+	}
+
+	return extractMsgResponse(respJSON)
+}
+
+// GetInviteLink should be used to export chat's invite link.
+func (b *Bot) GetInviteLink(chat *Chat) (string, error) {
+	params := map[string]string{
+		"chat_id": chat.Recipient(),
+	}
+
+	respJSON, err := b.Raw("exportChatInviteLink", params)
+	if err != nil {
+		return "", err
+	}
+
+	var resp struct {
+		Ok          bool
+		Description string
+		Result      string
+	}
+
+	err = json.Unmarshal(respJSON, &resp)
+	if err != nil {
+		return "", errors.Wrap(err, "bad response json")
+	}
+
+	if !resp.Ok {
+		return "", errors.Errorf("api error: %s", resp.Description)
+	}
+
+	return resp.Result, nil
+}
+
+// SetChatTitle should be used to update group title.
+func (b *Bot) SetGroupTitle(chat *Chat, newTitle string) error {
+	params := map[string]string{
+		"chat_id": chat.Recipient(),
+		"title":   newTitle,
+	}
+
+	respJSON, err := b.Raw("setChatTitle", params)
+	if err != nil {
+		return err
+	}
+
+	return extractOkResponse(respJSON)
+}
+
+// SetGroupDescription should be used to update group title.
+func (b *Bot) SetGroupDescription(chat *Chat, description string) error {
+	params := map[string]string{
+		"chat_id":     chat.Recipient(),
+		"description": description,
+	}
+
+	respJSON, err := b.Raw("setChatDescription", params)
+	if err != nil {
+		return err
+	}
+
+	return extractOkResponse(respJSON)
+}
+
+// SetGroupPhoto should be used to update group photo.
+func (b *Bot) SetGroupPhoto(chat *Chat, p *Photo) error {
+	params := map[string]string{
+		"chat_id": chat.Recipient(),
+	}
+
+	respJSON, err := b.sendFiles("setChatPhoto", map[string]File{"photo": p.File}, params)
+	if err != nil {
+		return err
+	}
+
+	return extractOkResponse(respJSON)
+}
+
+// SetGroupStickerSet should be used to update group's group sticker set.
+func (b *Bot) SetGroupStickerSet(chat *Chat, setName string) error {
+	params := map[string]string{
+		"chat_id":          chat.Recipient(),
+		"sticker_set_name": setName,
+	}
+
+	respJSON, err := b.Raw("setChatStickerSet", params)
+	if err != nil {
+		return err
+	}
+
+	return extractOkResponse(respJSON)
+}
+
+// DeleteGroupPhoto should be used to just remove group photo.
+func (b *Bot) DeleteGroupPhoto(chat *Chat) error {
+	params := map[string]string{
+		"chat_id": chat.Recipient(),
+	}
+
+	respJSON, err := b.Raw("deleteGroupPhoto", params)
+	if err != nil {
+		return err
+	}
+
+	return extractOkResponse(respJSON)
+}
+
+// DeleteGroupStickerSet should be used to just remove group sticker set.
+func (b *Bot) DeleteGroupStickerSet(chat *Chat) error {
+	params := map[string]string{
+		"chat_id": chat.Recipient(),
+	}
+
+	respJSON, err := b.Raw("deleteChatStickerSet", params)
+	if err != nil {
+		return err
+	}
+
+	return extractOkResponse(respJSON)
+}
+
+// Leave makes bot leave a group, supergroup or channel.
+func (b *Bot) Leave(chat *Chat) error {
+	params := map[string]string{
+		"chat_id": chat.Recipient(),
+	}
+
+	respJSON, err := b.Raw("leaveChat", params)
+	if err != nil {
+		return err
+	}
+
+	return extractOkResponse(respJSON)
+}
+
+// Use this method to pin a message in a supergroup or a channel.
+//
+// It supports telebot.Silent option.
+func (b *Bot) Pin(message Editable, options ...interface{}) error {
+	messageID, chatID := message.MessageSig()
+
+	params := map[string]string{
+		"chat_id":    strconv.FormatInt(chatID, 10),
+		"message_id": messageID,
+	}
+
+	sendOpts := extractOptions(options)
+	embedSendOptions(params, sendOpts)
+
+	respJSON, err := b.Raw("pinChatMessage", params)
+	if err != nil {
+		return err
+	}
+
+	return extractOkResponse(respJSON)
+}
+
+// Use this method to unpin a message in a supergroup or a channel.
+//
+// It supports telebot.Silent option.
+func (b *Bot) Unpin(chat *Chat) error {
+	params := map[string]string{
+		"chat_id": chat.Recipient(),
+	}
+
+	respJSON, err := b.Raw("unpinChatMessage", params)
+	if err != nil {
+		return err
+	}
+
+	return extractOkResponse(respJSON)
+}
+
+// ChatByID fetches chat info of its ID.
+//
+// Including current name of the user for one-on-one conversations,
+// current username of a user, group or channel, etc.
+//
+// Returns a Chat object on success.
+func (b *Bot) ChatByID(id string) (*Chat, error) {
+	params := map[string]string{
+		"chat_id": id,
+	}
+
+	respJSON, err := b.Raw("getChat", params)
+	if err != nil {
+		return nil, err
+	}
+
+	var resp struct {
+		Ok          bool
+		Description string
+		Result      *Chat
+	}
+
+	err = json.Unmarshal(respJSON, &resp)
+	if err != nil {
+		return nil, errors.Wrap(err, "bad response json")
+	}
+
+	if !resp.Ok {
+		return nil, errors.Errorf("api error: %s", resp.Description)
+	}
+
+	if resp.Result.Type == ChatChannel && resp.Result.Username == "" {
+		//Channel is Private
+		resp.Result.Type = ChatChannelPrivate
+	}
+
+	return resp.Result, nil
+}
+
+// ProfilePhotosOf return list of profile pictures for a user.
+func (b *Bot) ProfilePhotosOf(user *User) ([]Photo, error) {
+	params := map[string]string{
+		"user_id": user.Recipient(),
+	}
+
+	respJSON, err := b.Raw("getUserProfilePhotos", params)
+	if err != nil {
+		return nil, err
+	}
+
+	var resp struct {
+		Ok     bool
+		Result struct {
+			Count  int     `json:"total_count"`
+			Photos []Photo `json:"photos"`
+		}
+
+		Description string `json:"description"`
+	}
+
+	err = json.Unmarshal(respJSON, &resp)
+	if err != nil {
+		return nil, errors.Wrap(err, "bad response json")
+	}
+
+	if !resp.Ok {
+		return nil, errors.Errorf("api error: %s", resp.Description)
+	}
+
+	return resp.Result.Photos, nil
+}
+
+// ChatMemberOf return information about a member of a chat.
+//
+// Returns a ChatMember object on success.
+func (b *Bot) ChatMemberOf(chat *Chat, user *User) (*ChatMember, error) {
+	params := map[string]string{
+		"chat_id": chat.Recipient(),
+		"user_id": user.Recipient(),
+	}
+
+	respJSON, err := b.Raw("getChatMember", params)
+	if err != nil {
+		return nil, err
+	}
+
+	var resp struct {
+		Ok          bool
+		Result      *ChatMember
+		Description string `json:"description"`
+	}
+
+	err = json.Unmarshal(respJSON, &resp)
+	if err != nil {
+		return nil, errors.Wrap(err, "bad response json")
+	}
+
+	if !resp.Ok {
+		return nil, errors.Errorf("api error: %s", resp.Description)
+	}
+
+	return resp.Result, nil
+}
+
+// FileURLByID returns direct url for files using FileId which you can get from File object
+func (b *Bot) FileURLByID(fileID string) (string, error) {
+	f, err := b.FileByID(fileID)
+	if err != nil {
+		return "", err
+	}
+	return b.URL + "/file/bot" + b.Token + "/" + f.FilePath, nil
+}
+
+// UploadStickerFile returns uploaded File on success.
+func (b *Bot) UploadStickerFile(userID int, pngSticker *File) (*File, error) {
+	files := map[string]File{
+		"png_sticker": *pngSticker,
+	}
+	params := map[string]string{
+		"user_id": strconv.Itoa(userID),
+	}
+
+	respJSON, err := b.sendFiles("uploadStickerFile", files, params)
+	if err != nil {
+		return nil, err
+	}
+
+	var resp struct {
+		Ok          bool
+		Result      File
+		Description string
+	}
+
+	err = json.Unmarshal(respJSON, &resp)
+	if err != nil {
+		return nil, err
+	}
+
+	if !resp.Ok {
+		return nil, errors.Errorf("api error: %s", resp.Description)
+	}
+
+	return &resp.Result, nil
+}
+
+// GetStickerSet returns StickerSet on success.
+func (b *Bot) GetStickerSet(name string) (*StickerSet, error) {
+	respJSON, err := b.Raw("getStickerSet", map[string]string{"name": name})
+	if err != nil {
+		return nil, err
+	}
+
+	var resp struct {
+		Ok          bool
+		Description string
+		Result      *StickerSet
+	}
+	err = json.Unmarshal(respJSON, &resp)
+	if err != nil {
+		return nil, err
+	}
+
+	if !resp.Ok {
+		return nil, errors.Errorf("api error: %s", resp.Description)
+	}
+
+	return resp.Result, nil
+}
+
+// CreateNewStickerSet creates new sticker set.
+func (b *Bot) CreateNewStickerSet(sp StickerSetParams, containsMasks bool, maskPosition MaskPosition) error {
+	files := map[string]File{
+		"png_sticker": *sp.PngSticker,
+	}
+	params := map[string]string{
+		"user_id": strconv.Itoa(sp.UserID),
+		"name":    sp.Name,
+		"title":   sp.Title,
+		"emojis":  sp.Emojis,
+	}
+
+	if containsMasks {
+		mp, err := json.Marshal(&maskPosition)
+		if err != nil {
+			return err
+		}
+		params["mask_position"] = string(mp)
+	}
+
+	respJSON, err := b.sendFiles("createNewStickerSet", files, params)
+	if err != nil {
+		return err
+	}
+
+	return extractOkResponse(respJSON)
+}
+
+// AddStickerToSet adds new sticker to existing sticker set.
+func (b *Bot) AddStickerToSet(sp StickerSetParams, maskPosition MaskPosition) error {
+	files := map[string]File{
+		"png_sticker": *sp.PngSticker,
+	}
+	params := map[string]string{
+		"user_id": strconv.Itoa(sp.UserID),
+		"name":    sp.Name,
+		"title":   sp.Title,
+		"emojis":  sp.Emojis,
+	}
+
+	if maskPosition != (MaskPosition{}) {
+		mp, err := json.Marshal(&maskPosition)
+		if err != nil {
+			return err
+		}
+		params["mask_position"] = string(mp)
+	}
+
+	respJSON, err := b.sendFiles("addStickerToSet", files, params)
+	if err != nil {
+		return err
+	}
+
+	return extractOkResponse(respJSON)
+}
+
+// SetStickerPositionInSet moves a sticker in set to a specific position.
+func (b *Bot) SetStickerPositionInSet(sticker string, position int) error {
+	params := map[string]string{
+		"sticker":  sticker,
+		"position": strconv.Itoa(position),
+	}
+	respJSON, err := b.Raw("setStickerPositionInSet", params)
+	if err != nil {
+		return err
+	}
+
+	return extractOkResponse(respJSON)
+}
+
+// DeleteStickerFromSet deletes sticker from set created by the bot.
+func (b *Bot) DeleteStickerFromSet(sticker string) error {
+	respJSON, err := b.Raw("deleteStickerFromSet", map[string]string{"sticker": sticker})
+	if err != nil {
+		return err
+	}
+
+	return extractOkResponse(respJSON)
+}
diff --git a/vendor/gopkg.in/tucnak/telebot.v2/callbacks.go b/vendor/gopkg.in/tucnak/telebot.v2/callbacks.go
new file mode 100644
index 00000000..fb7778bf
--- /dev/null
+++ b/vendor/gopkg.in/tucnak/telebot.v2/callbacks.go
@@ -0,0 +1,82 @@
+package telebot
+
+// CallbackEndpoint is an interface any element capable
+// of responding to a callback `\f<unique>`.
+type CallbackEndpoint interface {
+	CallbackUnique() string
+}
+
+// Callback object represents a query from a callback button in an
+// inline keyboard.
+type Callback struct {
+	ID string `json:"id"`
+
+	// For message sent to channels, Sender may be empty
+	Sender *User `json:"from"`
+
+	// Message will be set if the button that originated the query
+	// was attached to a message sent by a bot.
+	Message *Message `json:"message"`
+
+	// MessageID will be set if the button was attached to a message
+	// sent via the bot in inline mode.
+	MessageID string `json:"inline_message_id"`
+
+	// Data associated with the callback button. Be aware that
+	// a bad client can send arbitrary data in this field.
+	Data string `json:"data"`
+}
+
+// CallbackResponse builds a response to a Callback query.
+//
+// See also: https://core.telegram.org/bots/api#answerCallbackQuery
+type CallbackResponse struct {
+	// The ID of the callback to which this is a response.
+	//
+	// Note: Telebot sets this field automatically!
+	CallbackID string `json:"callback_query_id"`
+
+	// Text of the notification. If not specified, nothing will be
+	// shown to the user.
+	Text string `json:"text,omitempty"`
+
+	// (Optional) If true, an alert will be shown by the client instead
+	// of a notification at the top of the chat screen. Defaults to false.
+	ShowAlert bool `json:"show_alert,omitempty"`
+
+	// (Optional) URL that will be opened by the user's client.
+	// If you have created a Game and accepted the conditions via
+	// @BotFather, specify the URL that opens your game.
+	//
+	// Note: this will only work if the query comes from a game
+	// callback button. Otherwise, you may use deep-linking:
+	// https://telegram.me/your_bot?start=XXXX
+	URL string `json:"url,omitempty"`
+}
+
+// InlineButton represents a button displayed in the message.
+type InlineButton struct {
+	// Unique slagish name for this kind of button,
+	// try to be as specific as possible.
+	//
+	// It will be used as a callback endpoint.
+	Unique string `json:"unique,omitempty"`
+
+	Text            string `json:"text"`
+	URL             string `json:"url,omitempty"`
+	Data            string `json:"callback_data,omitempty"`
+	InlineQuery     string `json:"switch_inline_query,omitempty"`
+	InlineQueryChat string `json:"switch_inline_query_current_chat"`
+
+	Action func(*Callback) `json:"-"`
+}
+
+// CallbackUnique returns InlineButto.Unique.
+func (t *InlineButton) CallbackUnique() string {
+	return "\f" + t.Unique
+}
+
+// CallbackUnique returns KeyboardButton.Text.
+func (t *ReplyButton) CallbackUnique() string {
+	return t.Text
+}
diff --git a/vendor/gopkg.in/tucnak/telebot.v2/chat.go b/vendor/gopkg.in/tucnak/telebot.v2/chat.go
new file mode 100644
index 00000000..f59273fe
--- /dev/null
+++ b/vendor/gopkg.in/tucnak/telebot.v2/chat.go
@@ -0,0 +1,57 @@
+package telebot
+
+import "strconv"
+
+// User object represents a Telegram user, bot
+type User struct {
+	ID int `json:"id"`
+
+	FirstName    string `json:"first_name"`
+	LastName     string `json:"last_name"`
+	Username     string `json:"username"`
+	LanguageCode string `json:"language_code"`
+	IsBot        bool   `json:"is_bot"`
+}
+
+// Recipient returns user ID (see Recipient interface).
+func (u *User) Recipient() string {
+	return strconv.Itoa(u.ID)
+}
+
+// Chat object represents a Telegram user, bot, group or a channel.
+type Chat struct {
+	ID int64 `json:"id"`
+
+	// See telebot.ChatType and consts.
+	Type ChatType `json:"type"`
+
+	// Won't be there for ChatPrivate.
+	Title string `json:"title"`
+
+	FirstName string `json:"first_name"`
+	LastName  string `json:"last_name"`
+	Username  string `json:"username"`
+}
+
+// Recipient returns chat ID (see Recipient interface).
+func (c *Chat) Recipient() string {
+	return strconv.FormatInt(c.ID, 10)
+}
+
+// ChatMember object represents information about a single chat member.
+type ChatMember struct {
+	Rights
+
+	User *User        `json:"user"`
+	Role MemberStatus `json:"status"`
+
+	// Date when restrictions will be lifted for the user, unix time.
+	//
+	// If user is restricted for more than 366 days or less than
+	// 30 seconds from the current time, they are considered to be
+	// restricted forever.
+	//
+	// Use tb.Forever().
+	//
+	RestrictedUntil int64 `json:"until_date,omitempty"`
+}
diff --git a/vendor/gopkg.in/tucnak/telebot.v2/data_payments.go b/vendor/gopkg.in/tucnak/telebot.v2/data_payments.go
new file mode 100644
index 00000000..2b0c4aea
--- /dev/null
+++ b/vendor/gopkg.in/tucnak/telebot.v2/data_payments.go
@@ -0,0 +1,3 @@
+package telebot
+
+const dataSupportedCurrenciesJSON = `{"AED":{"code":"AED","title":"United Arab Emirates Dirham","symbol":"AED","native":"\u062f.\u0625.\u200f","thousands_sep":",","decimal_sep":".","symbol_left":true,"space_between":true,"exp":2,"min_amount":"367","max_amount":"3673200"},"AFN":{"code":"AFN","title":"Afghan Afghani","symbol":"AFN","native":"\u060b","thousands_sep":",","decimal_sep":".","symbol_left":true,"space_between":false,"exp":2,"min_amount":"7554","max_amount":"75540495"},"ALL":{"code":"ALL","title":"Albanian Lek","symbol":"ALL","native":"Lek","thousands_sep":".","decimal_sep":",","symbol_left":false,"space_between":false,"exp":2,"min_amount":"10908","max_amount":"109085036"},"AMD":{"code":"AMD","title":"Armenian Dram","symbol":"AMD","native":"\u0564\u0580.","thousands_sep":",","decimal_sep":".","symbol_left":false,"space_between":true,"exp":2,"min_amount":"48398","max_amount":"483984962"},"ARS":{"code":"ARS","title":"Argentine Peso","symbol":"ARS","native":"$","thousands_sep":".","decimal_sep":",","symbol_left":true,"space_between":true,"exp":2,"min_amount":"3720","max_amount":"37202998"},"AUD":{"code":"AUD","title":"Australian Dollar","symbol":"AU$","native":"$","thousands_sep":",","decimal_sep":".","symbol_left":true,"space_between":false,"exp":2,"min_amount":"139","max_amount":"1392750"},"AZN":{"code":"AZN","title":"Azerbaijani Manat","symbol":"AZN","native":"\u043c\u0430\u043d.","thousands_sep":"\u00a0","decimal_sep":",","symbol_left":false,"space_between":true,"exp":2,"min_amount":"170","max_amount":"1702500"},"BAM":{"code":"BAM","title":"Bosnia & Herzegovina Convertible Mark","symbol":"BAM","native":"KM","thousands_sep":".","decimal_sep":",","symbol_left":false,"space_between":true,"exp":2,"min_amount":"171","max_amount":"1715550"},"BDT":{"code":"BDT","title":"Bangladeshi Taka","symbol":"BDT","native":"\u09f3","thousands_sep":",","decimal_sep":".","symbol_left":true,"space_between":true,"exp":2,"min_amount":"8336","max_amount":"83367500"},"BGN":{"code":"BGN","title":"Bulgarian Lev","symbol":"BGN","native":"\u043b\u0432.","thousands_sep":"\u00a0","decimal_sep":",","symbol_left":false,"space_between":true,"exp":2,"min_amount":"171","max_amount":"1716850"},"BND":{"code":"BND","title":"Brunei Dollar","symbol":"BND","native":"$","thousands_sep":".","decimal_sep":",","symbol_left":true,"space_between":false,"exp":2,"min_amount":"134","max_amount":"1349850"},"BOB":{"code":"BOB","title":"Bolivian Boliviano","symbol":"BOB","native":"Bs","thousands_sep":".","decimal_sep":",","symbol_left":true,"space_between":true,"exp":2,"min_amount":"687","max_amount":"6877150"},"BRL":{"code":"BRL","title":"Brazilian Real","symbol":"R$","native":"R$","thousands_sep":".","decimal_sep":",","symbol_left":true,"space_between":true,"exp":2,"min_amount":"377","max_amount":"3775397"},"CAD":{"code":"CAD","title":"Canadian Dollar","symbol":"CA$","native":"$","thousands_sep":",","decimal_sep":".","symbol_left":true,"space_between":false,"exp":2,"min_amount":"132","max_amount":"1321950"},"CHF":{"code":"CHF","title":"Swiss Franc","symbol":"CHF","native":"CHF","thousands_sep":"'","decimal_sep":".","symbol_left":false,"space_between":true,"exp":2,"min_amount":"99","max_amount":"993220"},"CLP":{"code":"CLP","title":"Chilean Peso","symbol":"CLP","native":"$","thousands_sep":".","decimal_sep":",","symbol_left":true,"space_between":true,"exp":0,"min_amount":"666","max_amount":"6665199"},"CNY":{"code":"CNY","title":"Chinese Renminbi Yuan","symbol":"CN\u00a5","native":"CN\u00a5","thousands_sep":",","decimal_sep":".","symbol_left":true,"space_between":false,"exp":2,"min_amount":"674","max_amount":"6747298"},"COP":{"code":"COP","title":"Colombian Peso","symbol":"COP","native":"$","thousands_sep":".","decimal_sep":",","symbol_left":true,"space_between":true,"exp":2,"min_amount":"315595","max_amount":"3155950000"},"CRC":{"code":"CRC","title":"Costa Rican Col\u00f3n","symbol":"CRC","native":"\u20a1","thousands_sep":".","decimal_sep":",","symbol_left":true,"space_between":false,"exp":2,"min_amount":"60113","max_amount":"601130282"},"CZK":{"code":"CZK","title":"Czech Koruna","symbol":"CZK","native":"K\u010d","thousands_sep":"\u00a0","decimal_sep":",","symbol_left":false,"space_between":true,"exp":2,"min_amount":"2251","max_amount":"22510978"},"DKK":{"code":"DKK","title":"Danish Krone","symbol":"DKK","native":"kr","thousands_sep":"","decimal_sep":",","symbol_left":false,"space_between":true,"exp":2,"min_amount":"654","max_amount":"6545403"},"DOP":{"code":"DOP","title":"Dominican Peso","symbol":"DOP","native":"$","thousands_sep":",","decimal_sep":".","symbol_left":true,"space_between":false,"exp":2,"min_amount":"5032","max_amount":"50329504"},"DZD":{"code":"DZD","title":"Algerian Dinar","symbol":"DZD","native":"\u062f.\u062c.\u200f","thousands_sep":",","decimal_sep":".","symbol_left":true,"space_between":true,"exp":2,"min_amount":"11872","max_amount":"118729869"},"EGP":{"code":"EGP","title":"Egyptian Pound","symbol":"EGP","native":"\u062c.\u0645.\u200f","thousands_sep":",","decimal_sep":".","symbol_left":true,"space_between":true,"exp":2,"min_amount":"1791","max_amount":"17912012"},"EUR":{"code":"EUR","title":"Euro","symbol":"\u20ac","native":"\u20ac","thousands_sep":"\u00a0","decimal_sep":",","symbol_left":false,"space_between":true,"exp":2,"min_amount":"87","max_amount":"877155"},"GBP":{"code":"GBP","title":"British Pound","symbol":"\u00a3","native":"\u00a3","thousands_sep":",","decimal_sep":".","symbol_left":true,"space_between":false,"exp":2,"min_amount":"75","max_amount":"757605"},"GEL":{"code":"GEL","title":"Georgian Lari","symbol":"GEL","native":"GEL","thousands_sep":"\u00a0","decimal_sep":",","symbol_left":false,"space_between":true,"exp":2,"min_amount":"266","max_amount":"2663750"},"GTQ":{"code":"GTQ","title":"Guatemalan Quetzal","symbol":"GTQ","native":"Q","thousands_sep":",","decimal_sep":".","symbol_left":true,"space_between":false,"exp":2,"min_amount":"768","max_amount":"7689850"},"HKD":{"code":"HKD","title":"Hong Kong Dollar","symbol":"HK$","native":"$","thousands_sep":",","decimal_sep":".","symbol_left":true,"space_between":false,"exp":2,"min_amount":"784","max_amount":"7845505"},"HNL":{"code":"HNL","title":"Honduran Lempira","symbol":"HNL","native":"L","thousands_sep":",","decimal_sep":".","symbol_left":true,"space_between":true,"exp":2,"min_amount":"2427","max_amount":"24277502"},"HRK":{"code":"HRK","title":"Croatian Kuna","symbol":"HRK","native":"kn","thousands_sep":".","decimal_sep":",","symbol_left":false,"space_between":true,"exp":2,"min_amount":"650","max_amount":"6506302"},"HUF":{"code":"HUF","title":"Hungarian Forint","symbol":"HUF","native":"Ft","thousands_sep":"\u00a0","decimal_sep":",","symbol_left":false,"space_between":true,"exp":2,"min_amount":"27844","max_amount":"278440341"},"IDR":{"code":"IDR","title":"Indonesian Rupiah","symbol":"IDR","native":"Rp","thousands_sep":".","decimal_sep":",","symbol_left":true,"space_between":false,"exp":2,"min_amount":"1406555","max_amount":"14065550000"},"ILS":{"code":"ILS","title":"Israeli New Sheqel","symbol":"\u20aa","native":"\u20aa","thousands_sep":",","decimal_sep":".","symbol_left":true,"space_between":true,"exp":2,"min_amount":"366","max_amount":"3668230"},"INR":{"code":"INR","title":"Indian Rupee","symbol":"\u20b9","native":"\u20b9","thousands_sep":",","decimal_sep":".","symbol_left":true,"space_between":false,"exp":2,"min_amount":"7090","max_amount":"70900503"},"ISK":{"code":"ISK","title":"Icelandic Kr\u00f3na","symbol":"ISK","native":"kr","thousands_sep":".","decimal_sep":",","symbol_left":false,"space_between":true,"exp":0,"min_amount":"119","max_amount":"1195599"},"JMD":{"code":"JMD","title":"Jamaican Dollar","symbol":"JMD","native":"$","thousands_sep":",","decimal_sep":".","symbol_left":true,"space_between":false,"exp":2,"min_amount":"13153","max_amount":"131539958"},"JPY":{"code":"JPY","title":"Japanese Yen","symbol":"\u00a5","native":"\uffe5","thousands_sep":",","decimal_sep":".","symbol_left":true,"space_between":false,"exp":0,"min_amount":"109","max_amount":"1095549"},"KES":{"code":"KES","title":"Kenyan Shilling","symbol":"KES","native":"Ksh","thousands_sep":",","decimal_sep":".","symbol_left":true,"space_between":false,"exp":2,"min_amount":"10032","max_amount":"100322011"},"KGS":{"code":"KGS","title":"Kyrgyzstani Som","symbol":"KGS","native":"KGS","thousands_sep":"\u00a0","decimal_sep":"-","symbol_left":false,"space_between":true,"exp":2,"min_amount":"6982","max_amount":"69820300"},"KRW":{"code":"KRW","title":"South Korean Won","symbol":"\u20a9","native":"\u20a9","thousands_sep":",","decimal_sep":".","symbol_left":true,"space_between":false,"exp":0,"min_amount":"1119","max_amount":"11190001"},"KZT":{"code":"KZT","title":"Kazakhstani Tenge","symbol":"KZT","native":"\u20b8","thousands_sep":"\u00a0","decimal_sep":"-","symbol_left":true,"space_between":false,"exp":2,"min_amount":"37767","max_amount":"377674954"},"LBP":{"code":"LBP","title":"Lebanese Pound","symbol":"LBP","native":"\u0644.\u0644.\u200f","thousands_sep":",","decimal_sep":".","symbol_left":true,"space_between":true,"exp":2,"min_amount":"150080","max_amount":"1500802255"},"LKR":{"code":"LKR","title":"Sri Lankan Rupee","symbol":"LKR","native":"\u0dbb\u0dd4.","thousands_sep":",","decimal_sep":".","symbol_left":true,"space_between":true,"exp":2,"min_amount":"18078","max_amount":"180789638"},"MAD":{"code":"MAD","title":"Moroccan Dirham","symbol":"MAD","native":"\u062f.\u0645.\u200f","thousands_sep":",","decimal_sep":".","symbol_left":true,"space_between":true,"exp":2,"min_amount":"955","max_amount":"9554850"},"MDL":{"code":"MDL","title":"Moldovan Leu","symbol":"MDL","native":"MDL","thousands_sep":",","decimal_sep":".","symbol_left":false,"space_between":true,"exp":2,"min_amount":"1703","max_amount":"17038967"},"MNT":{"code":"MNT","title":"Mongolian T\u00f6gr\u00f6g","symbol":"MNT","native":"MNT","thousands_sep":"\u00a0","decimal_sep":",","symbol_left":true,"space_between":false,"exp":2,"min_amount":"261750","max_amount":"2617500000"},"MUR":{"code":"MUR","title":"Mauritian Rupee","symbol":"MUR","native":"MUR","thousands_sep":",","decimal_sep":".","symbol_left":true,"space_between":false,"exp":2,"min_amount":"3438","max_amount":"34384499"},"MVR":{"code":"MVR","title":"Maldivian Rufiyaa","symbol":"MVR","native":"MVR","thousands_sep":",","decimal_sep":".","symbol_left":false,"space_between":true,"exp":2,"min_amount":"1550","max_amount":"15501063"},"MXN":{"code":"MXN","title":"Mexican Peso","symbol":"MX$","native":"$","thousands_sep":",","decimal_sep":".","symbol_left":true,"space_between":false,"exp":2,"min_amount":"1898","max_amount":"18988704"},"MYR":{"code":"MYR","title":"Malaysian Ringgit","symbol":"MYR","native":"RM","thousands_sep":",","decimal_sep":".","symbol_left":true,"space_between":false,"exp":2,"min_amount":"412","max_amount":"4124501"},"MZN":{"code":"MZN","title":"Mozambican Metical","symbol":"MZN","native":"MTn","thousands_sep":",","decimal_sep":".","symbol_left":true,"space_between":false,"exp":2,"min_amount":"6188","max_amount":"61889913"},"NGN":{"code":"NGN","title":"Nigerian Naira","symbol":"NGN","native":"\u20a6","thousands_sep":",","decimal_sep":".","symbol_left":true,"space_between":false,"exp":2,"min_amount":"36174","max_amount":"361749532"},"NIO":{"code":"NIO","title":"Nicaraguan C\u00f3rdoba","symbol":"NIO","native":"C$","thousands_sep":",","decimal_sep":".","symbol_left":true,"space_between":true,"exp":2,"min_amount":"3241","max_amount":"32415503"},"NOK":{"code":"NOK","title":"Norwegian Krone","symbol":"NOK","native":"kr","thousands_sep":"\u00a0","decimal_sep":",","symbol_left":true,"space_between":true,"exp":2,"min_amount":"851","max_amount":"8510100"},"NPR":{"code":"NPR","title":"Nepalese Rupee","symbol":"NPR","native":"\u0928\u0947\u0930\u0942","thousands_sep":",","decimal_sep":".","symbol_left":true,"space_between":false,"exp":2,"min_amount":"11299","max_amount":"112995016"},"NZD":{"code":"NZD","title":"New Zealand Dollar","symbol":"NZ$","native":"$","thousands_sep":",","decimal_sep":".","symbol_left":true,"space_between":false,"exp":2,"min_amount":"146","max_amount":"1461850"},"PAB":{"code":"PAB","title":"Panamanian Balboa","symbol":"PAB","native":"B\/.","thousands_sep":",","decimal_sep":".","symbol_left":true,"space_between":true,"exp":2,"min_amount":"99","max_amount":"995290"},"PEN":{"code":"PEN","title":"Peruvian Nuevo Sol","symbol":"PEN","native":"S\/.","thousands_sep":",","decimal_sep":".","symbol_left":true,"space_between":true,"exp":2,"min_amount":"333","max_amount":"3331250"},"PHP":{"code":"PHP","title":"Philippine Peso","symbol":"PHP","native":"\u20b1","thousands_sep":",","decimal_sep":".","symbol_left":true,"space_between":false,"exp":2,"min_amount":"5260","max_amount":"52602981"},"PKR":{"code":"PKR","title":"Pakistani Rupee","symbol":"PKR","native":"\u20a8","thousands_sep":",","decimal_sep":".","symbol_left":true,"space_between":false,"exp":2,"min_amount":"13921","max_amount":"139214990"},"PLN":{"code":"PLN","title":"Polish Z\u0142oty","symbol":"PLN","native":"z\u0142","thousands_sep":"\u00a0","decimal_sep":",","symbol_left":false,"space_between":true,"exp":2,"min_amount":"376","max_amount":"3764026"},"PYG":{"code":"PYG","title":"Paraguayan Guaran\u00ed","symbol":"PYG","native":"\u20b2","thousands_sep":".","decimal_sep":",","symbol_left":true,"space_between":true,"exp":0,"min_amount":"6013","max_amount":"60134502"},"QAR":{"code":"QAR","title":"Qatari Riyal","symbol":"QAR","native":"\u0631.\u0642.\u200f","thousands_sep":",","decimal_sep":".","symbol_left":true,"space_between":true,"exp":2,"min_amount":"364","max_amount":"3641101"},"RON":{"code":"RON","title":"Romanian Leu","symbol":"RON","native":"RON","thousands_sep":".","decimal_sep":",","symbol_left":false,"space_between":true,"exp":2,"min_amount":"417","max_amount":"4172003"},"RSD":{"code":"RSD","title":"Serbian Dinar","symbol":"RSD","native":"\u0434\u0438\u043d.","thousands_sep":".","decimal_sep":",","symbol_left":false,"space_between":true,"exp":2,"min_amount":"10391","max_amount":"103910127"},"RUB":{"code":"RUB","title":"Russian Ruble","symbol":"RUB","native":"\u0440\u0443\u0431.","thousands_sep":"\u00a0","decimal_sep":",","symbol_left":false,"space_between":true,"exp":2,"min_amount":"6598","max_amount":"65986027"},"SAR":{"code":"SAR","title":"Saudi Riyal","symbol":"SAR","native":"\u0631.\u0633.\u200f","thousands_sep":",","decimal_sep":".","symbol_left":true,"space_between":true,"exp":2,"min_amount":"373","max_amount":"3732650"},"SEK":{"code":"SEK","title":"Swedish Krona","symbol":"SEK","native":"kr","thousands_sep":".","decimal_sep":",","symbol_left":false,"space_between":true,"exp":2,"min_amount":"904","max_amount":"9047896"},"SGD":{"code":"SGD","title":"Singapore Dollar","symbol":"SGD","native":"$","thousands_sep":",","decimal_sep":".","symbol_left":true,"space_between":false,"exp":2,"min_amount":"135","max_amount":"1353897"},"THB":{"code":"THB","title":"Thai Baht","symbol":"\u0e3f","native":"\u0e3f","thousands_sep":",","decimal_sep":".","symbol_left":true,"space_between":false,"exp":2,"min_amount":"3156","max_amount":"31563499"},"TJS":{"code":"TJS","title":"Tajikistani Somoni","symbol":"TJS","native":"TJS","thousands_sep":"\u00a0","decimal_sep":";","symbol_left":false,"space_between":true,"exp":2,"min_amount":"938","max_amount":"9389950"},"TRY":{"code":"TRY","title":"Turkish Lira","symbol":"TRY","native":"TL","thousands_sep":".","decimal_sep":",","symbol_left":false,"space_between":true,"exp":2,"min_amount":"526","max_amount":"5267200"},"TTD":{"code":"TTD","title":"Trinidad and Tobago Dollar","symbol":"TTD","native":"$","thousands_sep":",","decimal_sep":".","symbol_left":true,"space_between":false,"exp":2,"min_amount":"675","max_amount":"6757850"},"TWD":{"code":"TWD","title":"New Taiwan Dollar","symbol":"NT$","native":"NT$","thousands_sep":",","decimal_sep":".","symbol_left":true,"space_between":false,"exp":2,"min_amount":"3072","max_amount":"30722993"},"TZS":{"code":"TZS","title":"Tanzanian Shilling","symbol":"TZS","native":"TSh","thousands_sep":",","decimal_sep":".","symbol_left":true,"space_between":false,"exp":2,"min_amount":"230200","max_amount":"2302000188"},"UAH":{"code":"UAH","title":"Ukrainian Hryvnia","symbol":"UAH","native":"\u20b4","thousands_sep":"\u00a0","decimal_sep":",","symbol_left":false,"space_between":false,"exp":2,"min_amount":"2764","max_amount":"27648991"},"UGX":{"code":"UGX","title":"Ugandan Shilling","symbol":"UGX","native":"USh","thousands_sep":",","decimal_sep":".","symbol_left":true,"space_between":false,"exp":0,"min_amount":"3657","max_amount":"36575502"},"USD":{"code":"USD","title":"United States Dollar","symbol":"$","native":"$","thousands_sep":",","decimal_sep":".","symbol_left":true,"space_between":false,"exp":2,"min_amount":"100","max_amount":1000000},"UYU":{"code":"UYU","title":"Uruguayan Peso","symbol":"UYU","native":"$","thousands_sep":".","decimal_sep":",","symbol_left":true,"space_between":true,"exp":2,"min_amount":"3246","max_amount":"32469503"},"UZS":{"code":"UZS","title":"Uzbekistani Som","symbol":"UZS","native":"UZS","thousands_sep":"\u00a0","decimal_sep":",","symbol_left":false,"space_between":true,"exp":2,"min_amount":"832759","max_amount":"8327599915"},"VND":{"code":"VND","title":"Vietnamese \u0110\u1ed3ng","symbol":"\u20ab","native":"\u20ab","thousands_sep":".","decimal_sep":",","symbol_left":false,"space_between":true,"exp":0,"min_amount":"23084","max_amount":"230840500"},"YER":{"code":"YER","title":"Yemeni Rial","symbol":"YER","native":"\u0631.\u064a.\u200f","thousands_sep":",","decimal_sep":".","symbol_left":true,"space_between":true,"exp":2,"min_amount":"25030","max_amount":"250301249"},"ZAR":{"code":"ZAR","title":"South African Rand","symbol":"ZAR","native":"R","thousands_sep":",","decimal_sep":".","symbol_left":true,"space_between":true,"exp":2,"min_amount":"1362","max_amount":"13620106"}}`
diff --git a/vendor/gopkg.in/tucnak/telebot.v2/editable.go b/vendor/gopkg.in/tucnak/telebot.v2/editable.go
new file mode 100644
index 00000000..f00a95f7
--- /dev/null
+++ b/vendor/gopkg.in/tucnak/telebot.v2/editable.go
@@ -0,0 +1,30 @@
+package telebot
+
+// Editable is an interface for all objects that
+// provide "message signature", a pair of 32-bit
+// message ID and 64-bit chat ID, both required
+// for edit operations.
+//
+// Use case: DB model struct for messages to-be
+// edited with, say two collums: msg_id,chat_id
+// could easily implement MessageSig() making
+// instances of stored messages editable.
+type Editable interface {
+	// MessageSig is a "message signature".
+	//
+	// For inline messages, return chatID = 0.
+	MessageSig() (messageID string, chatID int64)
+}
+
+// StoredMessage is an example struct suitable for being
+// stored in the database as-is or being embedded into
+// a larger struct, which is often the case (you might
+// want to store some metadata alongside, or might not.)
+type StoredMessage struct {
+	MessageID string `sql:"message_id" json:"message_id"`
+	ChatID    int64  `sql:"chat_id" json:"chat_id"`
+}
+
+func (x StoredMessage) MessageSig() (string, int64) {
+	return x.MessageID, x.ChatID
+}
diff --git a/vendor/gopkg.in/tucnak/telebot.v2/file.go b/vendor/gopkg.in/tucnak/telebot.v2/file.go
new file mode 100644
index 00000000..a6ffe49c
--- /dev/null
+++ b/vendor/gopkg.in/tucnak/telebot.v2/file.go
@@ -0,0 +1,87 @@
+package telebot
+
+import (
+	"io"
+	"os"
+)
+
+// File object represents any sort of file.
+type File struct {
+	FileID   string `json:"file_id"`
+	FileSize int    `json:"file_size"`
+
+	// file on telegram server https://core.telegram.org/bots/api#file
+	FilePath string `json:"file_path"`
+
+	// file on local file system.
+	FileLocal string `json:"file_local"`
+
+	// file on the internet
+	FileURL string `json:"file_url"`
+
+	// file backed with io.Reader
+	FileReader io.Reader `json:"-"`
+}
+
+// FromDisk constructs a new local (on-disk) file object.
+//
+// Note, it returns File, not *File for a very good reason:
+// in telebot, File is pretty much an embeddable struct,
+// so upon uploading media you'll need to set embedded File
+// with something. NewFile() returning File makes it a one-liner.
+//
+//     photo := &tb.Photo{File: tb.FromDisk("chicken.jpg")}
+//
+func FromDisk(filename string) File {
+	return File{FileLocal: filename}
+}
+
+// FromURL constructs a new file on provided HTTP URL.
+//
+// Note, it returns File, not *File for a very good reason:
+// in telebot, File is pretty much an embeddable struct,
+// so upon uploading media you'll need to set embedded File
+// with something. NewFile() returning File makes it a one-liner.
+//
+//     photo := &tb.Photo{File: tb.FromURL("https://site.com/picture.jpg")}
+//
+func FromURL(url string) File {
+	return File{FileURL: url}
+}
+
+// FromReader constructs a new file from io.Reader.
+//
+// Note, it returns File, not *File for a very good reason:
+// in telebot, File is pretty much an embeddable struct,
+// so upon uploading media you'll need to set embedded File
+// with something. NewFile() returning File makes it a one-liner.
+//
+//     photo := &tb.Photo{File: tb.FromReader(bytes.NewReader(...))}
+//
+func FromReader(reader io.Reader) File {
+	return File{FileReader: reader}
+}
+
+func (f *File) stealRef(g *File) {
+	if g.OnDisk() {
+		f.FileLocal = g.FileLocal
+	}
+
+	if g.FileURL != "" {
+		f.FileURL = g.FileURL
+	}
+}
+
+// InCloud tells whether the file is present on Telegram servers.
+func (f *File) InCloud() bool {
+	return f.FileID != ""
+}
+
+// OnDisk will return true if file is present on disk.
+func (f *File) OnDisk() bool {
+	if _, err := os.Stat(f.FileLocal); err != nil {
+		return false
+	}
+
+	return true
+}
diff --git a/vendor/gopkg.in/tucnak/telebot.v2/filters.go b/vendor/gopkg.in/tucnak/telebot.v2/filters.go
new file mode 100644
index 00000000..7384fffa
--- /dev/null
+++ b/vendor/gopkg.in/tucnak/telebot.v2/filters.go
@@ -0,0 +1,66 @@
+package telebot
+
+// Filter is some thing that does filtering for
+// incoming updates.
+//
+// Return false if you wish to sieve the update out.
+type Filter interface {
+	Filter(*Update) bool
+}
+
+// FilterFunc is basically a lightweight version of Filter.
+type FilterFunc func(*Update) bool
+
+func NewChain(parent Poller) *Chain {
+	c := &Chain{}
+	c.Poller = parent
+	c.Filter = func(upd *Update) bool {
+		for _, filter := range c.Filters {
+			switch f := filter.(type) {
+			case Filter:
+				if !f.Filter(upd) {
+					return false
+				}
+
+			case FilterFunc:
+				if !f(upd) {
+					return false
+				}
+
+			case func(*Update) bool:
+				if !f(upd) {
+					return false
+				}
+			}
+
+		}
+
+		return true
+	}
+
+	return c
+}
+
+// Chain is a chain of middle
+type Chain struct {
+	MiddlewarePoller
+
+	// (Filter | FilterFunc | func(*Update) bool)
+	Filters []interface{}
+}
+
+// Add accepts either Filter interface or FilterFunc
+func (c *Chain) Add(filter interface{}) {
+	switch filter.(type) {
+	case Filter:
+		break
+	case FilterFunc:
+		break
+	case func(*Update) bool:
+		break
+	default:
+		panic("telebot: unsupported filter type")
+	}
+
+	c.Filters = append(c.Filters, filter)
+}
diff --git a/vendor/gopkg.in/tucnak/telebot.v2/go.mod b/vendor/gopkg.in/tucnak/telebot.v2/go.mod
new file mode 100644
index 00000000..4f243d97
--- /dev/null
+++ b/vendor/gopkg.in/tucnak/telebot.v2/go.mod
@@ -0,0 +1,5 @@
+module gopkg.in/tucnak/telebot.v2
+
+go 1.11
+
+require github.com/pkg/errors v0.8.1
diff --git a/vendor/gopkg.in/tucnak/telebot.v2/go.sum b/vendor/gopkg.in/tucnak/telebot.v2/go.sum
new file mode 100644
index 00000000..f29ab350
--- /dev/null
+++ b/vendor/gopkg.in/tucnak/telebot.v2/go.sum
@@ -0,0 +1,2 @@
+github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I=
+github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
diff --git a/vendor/gopkg.in/tucnak/telebot.v2/inline.go b/vendor/gopkg.in/tucnak/telebot.v2/inline.go
new file mode 100644
index 00000000..b076d1a5
--- /dev/null
+++ b/vendor/gopkg.in/tucnak/telebot.v2/inline.go
@@ -0,0 +1,122 @@
+package telebot
+
+import (
+	"encoding/json"
+	"fmt"
+)
+
+// Query is an incoming inline query. When the user sends
+// an empty query, your bot could return some default or
+// trending results.
+type Query struct {
+	// Unique identifier for this query. 1-64 bytes.
+	ID string `json:"id"`
+
+	// Sender.
+	From User `json:"from"`
+
+	// Sender location, only for bots that request user location.
+	Location *Location `json:"location"`
+
+	// Text of the query (up to 512 characters).
+	Text string `json:"query"`
+
+	// Offset of the results to be returned, can be controlled by the bot.
+	Offset string `json:"offset"`
+}
+
+// QueryResponse builds a response to an inline Query.
+// See also: https://core.telegram.org/bots/api#answerinlinequery
+type QueryResponse struct {
+	// The ID of the query to which this is a response.
+	//
+	// Note: Telebot sets this field automatically!
+	QueryID string `json:"inline_query_id"`
+
+	// The results for the inline query.
+	Results Results `json:"results"`
+
+	// (Optional) The maximum amount of time in seconds that the result
+	// of the inline query may be cached on the server.
+	CacheTime int `json:"cache_time,omitempty"`
+
+	// (Optional) Pass True, if results may be cached on the server side
+	// only for the user that sent the query. By default, results may
+	// be returned to any user who sends the same query.
+	IsPersonal bool `json:"is_personal"`
+
+	// (Optional) Pass the offset that a client should send in the next
+	// query with the same text to receive more results. Pass an empty
+	// string if there are no more results or if you don‘t support
+	// pagination. Offset length can’t exceed 64 bytes.
+	NextOffset string `json:"next_offset"`
+
+	// (Optional) If passed, clients will display a button with specified
+	// text that switches the user to a private chat with the bot and sends
+	// the bot a start message with the parameter switch_pm_parameter.
+	SwitchPMText string `json:"switch_pm_text,omitempty"`
+
+	// (Optional) Parameter for the start message sent to the bot when user
+	// presses the switch button.
+	SwitchPMParameter string `json:"switch_pm_parameter,omitempty"`
+}
+
+// Result represents one result of an inline query.
+type Result interface {
+	ResultID() string
+	SetResultID(string)
+	SetContent(InputMessageContent)
+	SetReplyMarkup([][]InlineButton)
+	Process()
+}
+
+// Results is a slice wrapper for convenient marshalling.
+type Results []Result
+
+// MarshalJSON makes sure IQRs have proper IDs and Type variables set.
+func (results Results) MarshalJSON() ([]byte, error) {
+	for _, result := range results {
+		if result.ResultID() == "" {
+			result.SetResultID(fmt.Sprintf("%d", &result))
+		}
+
+		if err := inferIQR(result); err != nil {
+			return nil, err
+		}
+	}
+
+	return json.Marshal([]Result(results))
+}
+
+func inferIQR(result Result) error {
+	switch r := result.(type) {
+	case *ArticleResult:
+		r.Type = "article"
+	case *AudioResult:
+		r.Type = "audio"
+	case *ContactResult:
+		r.Type = "contact"
+	case *DocumentResult:
+		r.Type = "document"
+	case *GifResult:
+		r.Type = "gif"
+	case *LocationResult:
+		r.Type = "location"
+	case *Mpeg4GifResult:
+		r.Type = "mpeg4_gif"
+	case *PhotoResult:
+		r.Type = "photo"
+	case *VenueResult:
+		r.Type = "venue"
+	case *VideoResult:
+		r.Type = "video"
+	case *VoiceResult:
+		r.Type = "voice"
+	case *StickerResult:
+		r.Type = "sticker"
+	default:
+		return fmt.Errorf("result %v is not supported", result)
+	}
+
+	return nil
+}
diff --git a/vendor/gopkg.in/tucnak/telebot.v2/inline_types.go b/vendor/gopkg.in/tucnak/telebot.v2/inline_types.go
new file mode 100644
index 00000000..c959d427
--- /dev/null
+++ b/vendor/gopkg.in/tucnak/telebot.v2/inline_types.go
@@ -0,0 +1,319 @@
+package telebot
+
+// ResultBase must be embedded into all IQRs.
+type ResultBase struct {
+	// Unique identifier for this result, 1-64 Bytes.
+	// If left unspecified, a 64-bit FNV-1 hash will be calculated
+	ID string `json:"id"`
+
+	// Ignore. This field gets set automatically.
+	Type string `json:"type"`
+
+	// Optional. Content of the message to be sent.
+	Content *InputMessageContent `json:"input_message_content,omitempty"`
+
+	// Optional. Inline keyboard attached to the message.
+	ReplyMarkup *InlineKeyboardMarkup `json:"reply_markup,omitempty"`
+}
+
+// ResultID returns ResultBase.ID.
+func (r *ResultBase) ResultID() string {
+	return r.ID
+}
+
+// SetResultID sets ResultBase.ID.
+func (r *ResultBase) SetResultID(id string) {
+	r.ID = id
+}
+
+// SetContent sets ResultBase.Content.
+func (r *ResultBase) SetContent(content InputMessageContent) {
+	r.Content = &content
+}
+
+// SetReplyMarkup sets ResultBase.ReplyMarkup.
+func (r *ResultBase) SetReplyMarkup(keyboard [][]InlineButton) {
+	r.ReplyMarkup = &InlineKeyboardMarkup{InlineKeyboard: keyboard}
+}
+
+func (r *ResultBase) Process() {
+	if r.ReplyMarkup != nil {
+		processButtons(r.ReplyMarkup.InlineKeyboard)
+	}
+}
+
+// ArticleResult represents a link to an article or web page.
+// See also: https://core.telegram.org/bots/api#inlinequeryresultarticle
+type ArticleResult struct {
+	ResultBase
+
+	// Title of the result.
+	Title string `json:"title"`
+
+	// Message text. Shortcut (and mutually exclusive to) specifying
+	// InputMessageContent.
+	Text string `json:"message_text,omitempty"`
+
+	// Optional. URL of the result.
+	URL string `json:"url,omitempty"`
+
+	// Optional. Pass True, if you don't want the URL to be shown in the message.
+	HideURL bool `json:"hide_url,omitempty"`
+
+	// Optional. Short description of the result.
+	Description string `json:"description,omitempty"`
+
+	// Optional. URL of the thumbnail for the result.
+	ThumbURL string `json:"thumb_url,omitempty"`
+}
+
+// AudioResult represents a link to an mp3 audio file.
+type AudioResult struct {
+	ResultBase
+
+	// Title.
+	Title string `json:"title"`
+
+	// A valid URL for the audio file.
+	URL string `json:"audio_url"`
+
+	// Optional. Performer.
+	Performer string `json:"performer,omitempty"`
+
+	// Optional. Audio duration in seconds.
+	Duration int `json:"audio_duration,omitempty"`
+
+	// If Cache != "", it'll be used instead
+	Cache string `json:"audio_file_id,omitempty"`
+}
+
+// ContentResult represents a contact with a phone number.
+// See also: https://core.telegram.org/bots/api#inlinequeryresultcontact
+type ContactResult struct {
+	ResultBase
+
+	// Contact's phone number.
+	PhoneNumber string `json:"phone_number"`
+
+	// Contact's first name.
+	FirstName string `json:"first_name"`
+
+	// Optional. Contact's last name.
+	LastName string `json:"last_name,omitempty"`
+
+	// Optional. URL of the thumbnail for the result.
+	ThumbURL string `json:"thumb_url,omitempty"`
+}
+
+// DocumentResult represents a link to a file.
+// See also: https://core.telegram.org/bots/api#inlinequeryresultdocument
+type DocumentResult struct {
+	ResultBase
+
+	// Title for the result.
+	Title string `json:"title"`
+
+	// A valid URL for the file
+	URL string `json:"document_url"`
+
+	// Mime type of the content of the file, either “application/pdf” or
+	// “application/zip”.
+	MIME string `json:"mime_type"`
+
+	// Optional. Caption of the document to be sent, 0-200 characters.
+	Caption string `json:"caption,omitempty"`
+
+	// Optional. Short description of the result.
+	Description string `json:"description,omitempty"`
+
+	// Optional. URL of the thumbnail (jpeg only) for the file.
+	ThumbURL string `json:"thumb_url,omitempty"`
+
+	// If Cache != "", it'll be used instead
+	Cache string `json:"document_file_id,omitempty"`
+}
+
+// GifResult represents a link to an animated GIF file.
+// See also: https://core.telegram.org/bots/api#inlinequeryresultgif
+type GifResult struct {
+	ResultBase
+
+	// A valid URL for the GIF file. File size must not exceed 1MB.
+	URL string `json:"gif_url"`
+
+	// Optional. Width of the GIF.
+	Width int `json:"gif_width,omitempty"`
+
+	// Optional. Height of the GIF.
+	Height int `json:"gif_height,omitempty"`
+
+	// Optional. Title for the result.
+	Title string `json:"title,omitempty"`
+
+	// Optional. Caption of the GIF file to be sent, 0-200 characters.
+	Caption string `json:"caption,omitempty"`
+
+	// URL of the static thumbnail for the result (jpeg or gif).
+	ThumbURL string `json:"thumb_url"`
+
+	// If Cache != "", it'll be used instead
+	Cache string `json:"gif_file_id,omitempty"`
+}
+
+// LocationResult represents a location on a map.
+// See also: https://core.telegram.org/bots/api#inlinequeryresultlocation
+type LocationResult struct {
+	ResultBase
+
+	Location
+
+	// Location title.
+	Title string `json:"title"`
+
+	// Optional. Url of the thumbnail for the result.
+	ThumbURL string `json:"thumb_url,omitempty"`
+}
+
+// ResultMpeg4Gif represents a link to a video animation
+// (H.264/MPEG-4 AVC video without sound).
+// See also: https://core.telegram.org/bots/api#inlinequeryresultmpeg4gif
+type Mpeg4GifResult struct {
+	ResultBase
+
+	// A valid URL for the MP4 file.
+	URL string `json:"mpeg4_url"`
+
+	// Optional. Video width.
+	Width int `json:"mpeg4_width,omitempty"`
+
+	// Optional. Video height.
+	Height int `json:"mpeg4_height,omitempty"`
+
+	// URL of the static thumbnail (jpeg or gif) for the result.
+	ThumbURL string `json:"thumb_url,omitempty"`
+
+	// Optional. Title for the result.
+	Title string `json:"title,omitempty"`
+
+	// Optional. Caption of the MPEG-4 file to be sent, 0-200 characters.
+	Caption string `json:"caption,omitempty"`
+
+	// If Cache != "", it'll be used instead
+	Cache string `json:"mpeg4_file_id,omitempty"`
+}
+
+// ResultResult represents a link to a photo.
+// See also: https://core.telegram.org/bots/api#inlinequeryresultphoto
+type PhotoResult struct {
+	ResultBase
+
+	// A valid URL of the photo. Photo must be in jpeg format.
+	// Photo size must not exceed 5MB.
+	URL string `json:"photo_url"`
+
+	// Optional. Width of the photo.
+	Width int `json:"photo_width,omitempty"`
+
+	// Optional. Height of the photo.
+	Height int `json:"photo_height,omitempty"`
+
+	// Optional. Title for the result.
+	Title string `json:"title,omitempty"`
+
+	// Optional. Short description of the result.
+	Description string `json:"description,omitempty"`
+
+	// Optional. Caption of the photo to be sent, 0-200 characters.
+	Caption string `json:"caption,omitempty"`
+
+	// URL of the thumbnail for the photo.
+	ThumbURL string `json:"thumb_url"`
+
+	// If Cache != "", it'll be used instead
+	Cache string `json:"photo_file_id,omitempty"`
+}
+
+// VenueResult represents a venue.
+// See also: https://core.telegram.org/bots/api#inlinequeryresultvenue
+type VenueResult struct {
+	ResultBase
+
+	Location
+
+	// Title of the venue.
+	Title string `json:"title"`
+
+	// Address of the venue.
+	Address string `json:"address"`
+
+	// Optional. Foursquare identifier of the venue if known.
+	FoursquareID string `json:"foursquare_id,omitempty"`
+
+	// Optional. URL of the thumbnail for the result.
+	ThumbURL string `json:"thumb_url,omitempty"`
+}
+
+// VideoResult represents a link to a page containing an embedded
+// video player or a video file.
+// See also: https://core.telegram.org/bots/api#inlinequeryresultvideo
+type VideoResult struct {
+	ResultBase
+
+	// A valid URL for the embedded video player or video file.
+	URL string `json:"video_url"`
+
+	// Mime type of the content of video url, “text/html” or “video/mp4”.
+	MIME string `json:"mime_type"`
+
+	// URL of the thumbnail (jpeg only) for the video.
+	ThumbURL string `json:"thumb_url"`
+
+	// Title for the result.
+	Title string `json:"title"`
+
+	// Optional. Caption of the video to be sent, 0-200 characters.
+	Caption string `json:"caption,omitempty"`
+
+	// Optional. Video width.
+	Width int `json:"video_width,omitempty"`
+
+	// Optional. Video height.
+	Height int `json:"video_height,omitempty"`
+
+	// Optional. Video duration in seconds.
+	Duration int `json:"video_duration,omitempty"`
+
+	// Optional. Short description of the result.
+	Description string `json:"description,omitempty"`
+
+	// If Cache != "", it'll be used instead
+	Cache string `json:"video_file_id,omitempty"`
+}
+
+// VoiceResult represents a link to a voice recording in an .ogg
+// container encoded with OPUS.
+//
+// See also: https://core.telegram.org/bots/api#inlinequeryresultvoice
+type VoiceResult struct {
+	ResultBase
+
+	// A valid URL for the voice recording.
+	URL string `json:"voice_url"`
+
+	// Recording title.
+	Title string `json:"title"`
+
+	// Optional. Recording duration in seconds.
+	Duration int `json:"voice_duration"`
+
+	// If Cache != "", it'll be used instead
+	Cache string `json:"voice_file_id,omitempty"`
+}
+
+// StickerResult represents an inline cached sticker response.
+type StickerResult struct {
+	ResultBase
+
+	// If Cache != "", it'll be used instead
+	Cache string `json:"sticker_file_id,omitempty"`
+}
diff --git a/vendor/gopkg.in/tucnak/telebot.v2/input_types.go b/vendor/gopkg.in/tucnak/telebot.v2/input_types.go
new file mode 100644
index 00000000..3bf85bff
--- /dev/null
+++ b/vendor/gopkg.in/tucnak/telebot.v2/input_types.go
@@ -0,0 +1,78 @@
+package telebot
+
+// InputMessageContent objects represent the content of a message to be sent
+// as a result of an inline query.
+// See also: https://core.telegram.org/bots/api#inputmessagecontent
+type InputMessageContent interface {
+	IsInputMessageContent() bool
+}
+
+// InputTextMessageContent represents the content of a text message to be
+// sent as the result of an inline query.
+// See also: https://core.telegram.org/bots/api#inputtextmessagecontent
+type InputTextMessageContent struct {
+	// Text of the message to be sent, 1-4096 characters.
+	Text string `json:"message_text"`
+
+	// Optional. Send Markdown or HTML, if you want Telegram apps to show
+	// bold, italic, fixed-width text or inline URLs in your bot's message.
+	ParseMode string `json:"parse_mode,omitempty"`
+
+	// Optional. Disables link previews for links in the sent message.
+	DisablePreview bool `json:"disable_web_page_preview"`
+}
+
+func (input *InputTextMessageContent) IsInputMessageContent() bool {
+	return true
+}
+
+// InputLocationMessageContent represents the content of a location message
+// to be sent as the result of an inline query.
+// See also: https://core.telegram.org/bots/api#inputlocationmessagecontent
+type InputLocationMessageContent struct {
+	Lat float32 `json:"latitude"`
+	Lng float32 `json:"longitude"`
+}
+
+func (input *InputLocationMessageContent) IsInputMessageContent() bool {
+	return true
+}
+
+// InputVenueMessageContent represents the content of a venue message to
+// be sent as the result of an inline query.
+// See also: https://core.telegram.org/bots/api#inputvenuemessagecontent
+type InputVenueMessageContent struct {
+	Lat float32 `json:"latitude"`
+	Lng float32 `json:"longitude"`
+
+	// Name of the venue.
+	Title string `json:"title"`
+
+	// Address of the venue.
+	Address string `json:"address"`
+
+	// Optional. Foursquare identifier of the venue, if known.
+	FoursquareID string `json:"foursquare_id,omitempty"`
+}
+
+func (input *InputVenueMessageContent) IsInputMessageContent() bool {
+	return true
+}
+
+// InputContactMessageContent represents the content of a contact
+// message to be sent as the result of an inline query.
+// See also: https://core.telegram.org/bots/api#inputcontactmessagecontent
+type InputContactMessageContent struct {
+	// Contact's phone number.
+	PhoneNumber string `json:"phone_number"`
+
+	// Contact's first name.
+	FirstName string `json:"first_name"`
+
+	// Optional. Contact's last name.
+	LastName string `json:"last_name,omitempty"`
+}
+
+func (input *InputContactMessageContent) IsInputMessageContent() bool {
+	return true
+}
diff --git a/vendor/gopkg.in/tucnak/telebot.v2/media.go b/vendor/gopkg.in/tucnak/telebot.v2/media.go
new file mode 100644
index 00000000..e3366871
--- /dev/null
+++ b/vendor/gopkg.in/tucnak/telebot.v2/media.go
@@ -0,0 +1,189 @@
+package telebot
+
+import (
+	"encoding/json"
+)
+
+// Album lets you group multiple media (so-called InputMedia)
+// into a single messsage.
+//
+// On older clients albums look like N regular messages.
+type Album []InputMedia
+
+// InputMedia is a generic type for all kinds of media you
+// can put into an album.
+type InputMedia interface {
+	// As some files must be uploaded (instead of referencing)
+	// outer layers of Telebot require it.
+	MediaFile() *File
+}
+
+// Photo object represents a single photo file.
+type Photo struct {
+	File
+
+	Width  int `json:"width"`
+	Height int `json:"height"`
+
+	// (Optional)
+	Caption string `json:"caption,omitempty"`
+}
+
+type photoSize struct {
+	File
+	Width   int    `json:"width"`
+	Height  int    `json:"height"`
+	Caption string `json:"caption,omitempty"`
+}
+
+// MediaFile returns &Photo.File
+func (p *Photo) MediaFile() *File {
+	return &p.File
+}
+
+// UnmarshalJSON is custom unmarshaller required to abstract
+// away the hassle of treating different thumbnail sizes.
+// Instead, Telebot chooses the hi-res one and just sticks to
+// it.
+//
+// I really do find it a beautiful solution.
+func (p *Photo) UnmarshalJSON(jsonStr []byte) error {
+	var hq photoSize
+
+	if jsonStr[0] == '{' {
+		if err := json.Unmarshal(jsonStr, &hq); err != nil {
+			return err
+		}
+	} else {
+		var sizes []photoSize
+
+		if err := json.Unmarshal(jsonStr, &sizes); err != nil {
+			return err
+		}
+
+		hq = sizes[len(sizes)-1]
+	}
+
+	p.File = hq.File
+	p.Width = hq.Width
+	p.Height = hq.Height
+
+	return nil
+}
+
+// Audio object represents an audio file.
+type Audio struct {
+	File
+
+	// Duration of the recording in seconds as defined by sender.
+	Duration int `json:"duration,omitempty"`
+
+	// (Optional)
+	Caption   string `json:"caption,omitempty"`
+	Title     string `json:"title,omitempty"`
+	Performer string `json:"performer,omitempty"`
+	MIME      string `json:"mime_type,omitempty"`
+	FileName  string `json:"file_name,omitempty"`
+}
+
+// MediaFile returns &Audio.File
+func (a *Audio) MediaFile() *File {
+	return &a.File
+}
+
+// Document object represents a general file (as opposed to Photo or Audio).
+// Telegram users can send files of any type of up to 1.5 GB in size.
+type Document struct {
+	File
+
+	// (Optional)
+	Thumbnail *Photo `json:"thumb,omitempty"`
+	Caption   string `json:"caption,omitempty"`
+	MIME      string `json:"mime_type"`
+	FileName  string `json:"file_name,omitempty"`
+}
+
+// MediaFile returns &Document.File
+func (d *Document) MediaFile() *File {
+	return &d.File
+}
+
+// Video object represents a video file.
+type Video struct {
+	File
+
+	Width  int `json:"width"`
+	Height int `json:"height"`
+
+	Duration int `json:"duration,omitempty"`
+
+	// (Optional)
+	Caption           string `json:"caption,omitempty"`
+	Thumbnail         *Photo `json:"thumb,omitempty"`
+	SupportsStreaming bool   `json:"supports_streaming,omitempty"`
+	MIME              string `json:"mime_type,omitempty"`
+	FileName          string `json:"file_name,omitempty"`
+}
+
+// MediaFile returns &Video.File
+func (v *Video) MediaFile() *File {
+	return &v.File
+}
+
+// Voice object represents a voice note.
+type Voice struct {
+	File
+
+	// Duration of the recording in seconds as defined by sender.
+	Duration int `json:"duration"`
+
+	// (Optional)
+	MIME string `json:"mime_type,omitempty"`
+}
+
+// VideoNote represents a video message (available in Telegram apps
+// as of v.4.0).
+type VideoNote struct {
+	File
+
+	// Duration of the recording in seconds as defined by sender.
+	Duration int `json:"duration"`
+
+	// (Optional)
+	Thumbnail *Photo `json:"thumb,omitempty"`
+	Length    int    `json:"length,omitempty"`
+}
+
+// Contact object represents a contact to Telegram user
+type Contact struct {
+	PhoneNumber string `json:"phone_number"`
+	FirstName   string `json:"first_name"`
+
+	// (Optional)
+	LastName string `json:"last_name"`
+	UserID   int    `json:"user_id,omitempty"`
+}
+
+// Location object represents geographic position.
+type Location struct {
+	// Latitude
+	Lat float32 `json:"latitude"`
+	// Longitude
+	Lng float32 `json:"longitude"`
+
+	// Period in seconds for which the location will be updated
+	// (see Live Locations, should be between 60 and 86400.)
+	LivePeriod int `json:"live_period,omitempty"`
+}
+
+// Venue object represents a venue location with name, address and
+// optional foursquare ID.
+type Venue struct {
+	Location Location `json:"location"`
+	Title    string   `json:"title"`
+	Address  string   `json:"address"`
+
+	// (Optional)
+	FoursquareID   string `json:"foursquare_id,omitempty"`
+	FoursquareType string `json:"foursquare_type,omitempty"`
+}
diff --git a/vendor/gopkg.in/tucnak/telebot.v2/message.go b/vendor/gopkg.in/tucnak/telebot.v2/message.go
new file mode 100644
index 00000000..4b87d50a
--- /dev/null
+++ b/vendor/gopkg.in/tucnak/telebot.v2/message.go
@@ -0,0 +1,267 @@
+package telebot
+
+import (
+	"strconv"
+	"time"
+)
+
+// Message object represents a message.
+type Message struct {
+	ID int `json:"message_id"`
+
+	// For message sent to channels, Sender will be nil
+	Sender *User `json:"from"`
+
+	// Unixtime, use Message.Time() to get time.Time
+	Unixtime int64 `json:"date"`
+
+	// Conversation the message belongs to.
+	Chat *Chat `json:"chat"`
+
+	// For forwarded messages, sender of the original message.
+	OriginalSender *User `json:"forward_from"`
+
+	// For forwarded messages, chat of the original message when
+	// forwarded from a channel.
+	OriginalChat *Chat `json:"forward_from_chat"`
+
+	// For forwarded messages, unixtime of the original message.
+	OriginalUnixtime int `json:"forward_date"`
+
+	// For replies, ReplyTo represents the original message.
+	//
+	// Note that the Message object in this field will not
+	// contain further ReplyTo fields even if it
+	// itself is a reply.
+	ReplyTo *Message `json:"reply_to_message"`
+
+	// (Optional) Time of last edit in Unix
+	LastEdit int64 `json:"edit_date"`
+
+	// AlbumID is the unique identifier of a media message group
+	// this message belongs to.
+	AlbumID string `json:"media_group_id"`
+
+	// Author signature (in channels).
+	Signature string `json:"author_signature"`
+
+	// For a text message, the actual UTF-8 text of the message.
+	Text string `json:"text"`
+
+	// For registered commands, will contain the string payload:
+	//
+	// Ex: `/command <payload>` or `/command@botname <payload>`
+	Payload string `json:"-"`
+
+	// For text messages, special entities like usernames, URLs, bot commands,
+	// etc. that appear in the text.
+	Entities []MessageEntity `json:"entities,omitempty"`
+
+	// Some messages containing media, may as well have a caption.
+	Caption string `json:"caption,omitempty"`
+
+	// For messages with a caption, special entities like usernames, URLs,
+	// bot commands, etc. that appear in the caption.
+	CaptionEntities []MessageEntity `json:"caption_entities,omitempty"`
+
+	// For an audio recording, information about it.
+	Audio *Audio `json:"audio"`
+
+	// For a gneral file, information about it.
+	Document *Document `json:"document"`
+
+	// For a photo, all available sizes (thumbnails).
+	Photo *Photo `json:"photo"`
+
+	// For a sticker, information about it.
+	Sticker *Sticker `json:"sticker"`
+
+	// For a voice message, information about it.
+	Voice *Voice `json:"voice"`
+
+	// For a video note, information about it.
+	VideoNote *VideoNote `json:"video_note"`
+
+	// For a video, information about it.
+	Video *Video `json:"video"`
+
+	// For a contact, contact information itself.
+	Contact *Contact `json:"contact"`
+
+	// For a location, its longitude and latitude.
+	Location *Location `json:"location"`
+
+	// For a venue, information about it.
+	Venue *Venue `json:"venue"`
+
+	// For a service message, represents a user,
+	// that just got added to chat, this message came from.
+	//
+	// Sender leads to User, capable of invite.
+	//
+	// UserJoined might be the Bot itself.
+	UserJoined *User `json:"new_chat_member"`
+
+	// For a service message, represents a user,
+	// that just left chat, this message came from.
+	//
+	// If user was kicked, Sender leads to a User,
+	// capable of this kick.
+	//
+	// UserLeft might be the Bot itself.
+	UserLeft *User `json:"left_chat_member"`
+
+	// For a service message, represents a new title
+	// for chat this message came from.
+	//
+	// Sender would lead to a User, capable of change.
+	NewGroupTitle string `json:"new_chat_title"`
+
+	// For a service message, represents all available
+	// thumbnails of the new chat photo.
+	//
+	// Sender would lead to a User, capable of change.
+	NewGroupPhoto *Photo `json:"new_chat_photo"`
+
+	// For a service message, new members that were added to
+	// the group or supergroup and information about them
+	// (the bot itself may be one of these members).
+	UsersJoined []User `json:"new_chat_members"`
+
+	// For a service message, true if chat photo just
+	// got removed.
+	//
+	// Sender would lead to a User, capable of change.
+	GroupPhotoDeleted bool `json:"delete_chat_photo"`
+
+	// For a service message, true if group has been created.
+	//
+	// You would recieve such a message if you are one of
+	// initial group chat members.
+	//
+	// Sender would lead to creator of the chat.
+	GroupCreated bool `json:"group_chat_created"`
+
+	// For a service message, true if super group has been created.
+	//
+	// You would recieve such a message if you are one of
+	// initial group chat members.
+	//
+	// Sender would lead to creator of the chat.
+	SuperGroupCreated bool `json:"supergroup_chat_created"`
+
+	// For a service message, true if channel has been created.
+	//
+	// You would recieve such a message if you are one of
+	// initial channel administrators.
+	//
+	// Sender would lead to creator of the chat.
+	ChannelCreated bool `json:"channel_chat_created"`
+
+	// For a service message, the destination (super group) you
+	// migrated to.
+	//
+	// You would recieve such a message when your chat has migrated
+	// to a super group.
+	//
+	// Sender would lead to creator of the migration.
+	MigrateTo int64 `json:"migrate_to_chat_id"`
+
+	// For a service message, the Origin (normal group) you migrated
+	// from.
+	//
+	// You would recieve such a message when your chat has migrated
+	// to a super group.
+	//
+	// Sender would lead to creator of the migration.
+	MigrateFrom int64 `json:"migrate_from_chat_id"`
+
+	// Specified message was pinned. Note that the Message object
+	// in this field will not contain further ReplyTo fields even
+	// if it is itself a reply.
+	PinnedMessage *Message `json:"pinned_message"`
+}
+
+// MessageEntity object represents "special" parts of text messages,
+// including hashtags, usernames, URLs, etc.
+type MessageEntity struct {
+	// Specifies entity type.
+	Type EntityType `json:"type"`
+
+	// Offset in UTF-16 code units to the start of the entity.
+	Offset int `json:"offset"`
+
+	// Length of the entity in UTF-16 code units.
+	Length int `json:"length"`
+
+	// (Optional) For EntityTextLink entity type only.
+	//
+	// URL will be opened after user taps on the text.
+	URL string `json:"url,omitempty"`
+
+	// (Optional) For EntityTMention entity type only.
+	User *User `json:"user,omitempty"`
+}
+
+// MessageSig satisfies Editable interface (see Editable.)
+func (m *Message) MessageSig() (string, int64) {
+	return strconv.Itoa(m.ID), m.Chat.ID
+}
+
+// Time returns the moment of message creation in local time.
+func (m *Message) Time() time.Time {
+	return time.Unix(m.Unixtime, 0)
+}
+
+// LastEdited returns time.Time of last edit.
+func (m *Message) LastEdited() time.Time {
+	return time.Unix(m.LastEdit, 0)
+}
+
+// IsForwarded says whether message is forwarded copy of another
+// message or not.
+func (m *Message) IsForwarded() bool {
+	return m.OriginalSender != nil || m.OriginalChat != nil
+}
+
+// IsReply says whether message is a reply to another message.
+func (m *Message) IsReply() bool {
+	return m.ReplyTo != nil
+}
+
+// Private returns true, if it's a personal message.
+func (m *Message) Private() bool {
+	return m.Chat.Type == ChatPrivate
+}
+
+// FromGroup returns true, if message came from a group OR
+// a super group.
+func (m *Message) FromGroup() bool {
+	return m.Chat.Type == ChatGroup || m.Chat.Type == ChatSuperGroup
+}
+
+// FromChannel returns true, if message came from a channel.
+func (m *Message) FromChannel() bool {
+	return m.Chat.Type == ChatChannel
+}
+
+// IsService returns true, if message is a service message,
+// returns false otherwise.
+//
+// Service messages are automatically sent messages, which
+// typically occur on some global action. For instance, when
+// anyone leaves the chat or chat title changes.
+func (m *Message) IsService() bool {
+	fact := false
+
+	fact = fact || m.UserJoined != nil
+	fact = fact || len(m.UsersJoined) > 0
+	fact = fact || m.UserLeft != nil
+	fact = fact || m.NewGroupTitle != ""
+	fact = fact || m.NewGroupPhoto != nil
+	fact = fact || m.GroupPhotoDeleted
+	fact = fact || m.GroupCreated || m.SuperGroupCreated
+	fact = fact || (m.MigrateTo != m.MigrateFrom)
+
+	return fact
+}
diff --git a/vendor/gopkg.in/tucnak/telebot.v2/options.go b/vendor/gopkg.in/tucnak/telebot.v2/options.go
new file mode 100644
index 00000000..bacd66fe
--- /dev/null
+++ b/vendor/gopkg.in/tucnak/telebot.v2/options.go
@@ -0,0 +1,146 @@
+package telebot
+
+// Option is a shorcut flag type for certain message features
+// (so-called options). It means that instead of passing
+// fully-fledged SendOptions* to Send(), you can use these
+// flags instead.
+//
+// Supported options are defined as iota-constants.
+type Option int
+
+const (
+	// NoPreview = SendOptions.DisableWebPagePreview
+	NoPreview Option = iota
+
+	// Silent = SendOptions.DisableNotification
+	Silent
+
+	// ForceReply = ReplyMarkup.ForceReply
+	ForceReply
+
+	// OneTimeKeyboard = ReplyMarkup.OneTimeKeyboard
+	OneTimeKeyboard
+)
+
+// SendOptions has most complete control over in what way the message
+// must be sent, providing an API-complete set of custom properties
+// and options.
+//
+// Despite its power, SendOptions is rather inconvenient to use all
+// the way through bot logic, so you might want to consider storing
+// and re-using it somewhere or be using Option flags instead.
+type SendOptions struct {
+	// If the message is a reply, original message.
+	ReplyTo *Message
+
+	// See ReplyMarkup struct definition.
+	ReplyMarkup *ReplyMarkup
+
+	// For text messages, disables previews for links in this message.
+	DisableWebPagePreview bool
+
+	// Sends the message silently. iOS users will not receive a notification, Android users will receive a notification with no sound.
+	DisableNotification bool
+
+	// ParseMode controls how client apps render your message.
+	ParseMode ParseMode
+}
+
+func (og *SendOptions) copy() *SendOptions {
+	cp := *og
+	if cp.ReplyMarkup != nil {
+		cp.ReplyMarkup = cp.ReplyMarkup.copy()
+	}
+
+	return &cp
+}
+
+// ReplyMarkup controls two convenient options for bot-user communications
+// such as reply keyboard and inline "keyboard" (a grid of buttons as a part
+// of the message).
+type ReplyMarkup struct {
+	// InlineKeyboard is a grid of InlineButtons displayed in the message.
+	//
+	// Note: DO NOT confuse with ReplyKeyboard and other keyboard properties!
+	InlineKeyboard [][]InlineButton `json:"inline_keyboard,omitempty"`
+
+	// ReplyKeyboard is a grid, consisting of keyboard buttons.
+	//
+	// Note: you don't need to set HideCustomKeyboard field to show custom keyboard.
+	ReplyKeyboard [][]ReplyButton `json:"keyboard,omitempty"`
+
+	// ForceReply forces Telegram clients to display
+	// a reply interface to the user (act as if the user
+	// has selected the bot‘s message and tapped "Reply").
+	ForceReply bool `json:"force_reply,omitempty"`
+
+	// Requests clients to resize the keyboard vertically for optimal fit
+	// (e.g. make the keyboard smaller if there are just two rows of buttons).
+	//
+	// Defaults to false, in which case the custom keyboard is always of the
+	// same height as the app's standard keyboard.
+	ResizeReplyKeyboard bool `json:"resize_keyboard,omitempty"`
+
+	// Requests clients to hide the reply keyboard as soon as it's been used.
+	//
+	// Defaults to false.
+	OneTimeKeyboard bool `json:"one_time_keyboard,omitempty"`
+
+	// Requests clients to remove the reply keyboard.
+	//
+	// Dafaults to false.
+	ReplyKeyboardRemove bool `json:"remove_keyboard,omitempty"`
+
+	// Use this param if you want to force reply from
+	// specific users only.
+	//
+	// Targets:
+	// 1) Users that are @mentioned in the text of the Message object;
+	// 2) If the bot's message is a reply (has SendOptions.ReplyTo),
+	//       sender of the original message.
+	Selective bool `json:"selective,omitempty"`
+}
+
+func (og *ReplyMarkup) copy() *ReplyMarkup {
+	cp := *og
+
+	cp.ReplyKeyboard = make([][]ReplyButton, len(og.ReplyKeyboard))
+	for i, row := range og.ReplyKeyboard {
+		cp.ReplyKeyboard[i] = make([]ReplyButton, len(row))
+		for j, btn := range row {
+			cp.ReplyKeyboard[i][j] = btn
+		}
+	}
+
+	cp.InlineKeyboard = make([][]InlineButton, len(og.InlineKeyboard))
+	for i, row := range og.InlineKeyboard {
+		cp.InlineKeyboard[i] = make([]InlineButton, len(row))
+		for j, btn := range row {
+			cp.InlineKeyboard[i][j] = btn
+		}
+	}
+
+	return &cp
+}
+
+// ReplyButton represents a button displayed in reply-keyboard.
+//
+// Set either Contact or Location to true in order to request
+// sensitive info, such as user's phone number or current location.
+// (Available in private chats only.)
+type ReplyButton struct {
+	Text string `json:"text"`
+
+	Contact  bool `json:"request_contact,omitempty"`
+	Location bool `json:"request_location,omitempty"`
+
+	Action func(*Callback) `json:"-"`
+}
+
+// InlineKeyboardMarkup represents an inline keyboard that appears
+// right next to the message it belongs to.
+type InlineKeyboardMarkup struct {
+	// Array of button rows, each represented by
+	// an Array of KeyboardButton objects.
+	InlineKeyboard [][]InlineButton `json:"inline_keyboard,omitempty"`
+}
diff --git a/vendor/gopkg.in/tucnak/telebot.v2/payments.go b/vendor/gopkg.in/tucnak/telebot.v2/payments.go
new file mode 100644
index 00000000..6cd40a42
--- /dev/null
+++ b/vendor/gopkg.in/tucnak/telebot.v2/payments.go
@@ -0,0 +1,64 @@
+package telebot
+
+import (
+	"encoding/json"
+	"math"
+)
+
+type Invoice struct {
+	// Product name, 1-32 characters.
+	Title string `json:"title"`
+
+	// Product description, 1-255 characters.
+	Description string `json:"description"`
+
+	// Custom payload, required, 1-128 bytes.
+	Payload string `json:"payload"`
+
+	// Unique deep-linking parameter that can be used to
+	// generate this invoice when used as a start parameter.
+	Start string `json:"start_parameter"`
+
+	// Provider token to use.
+	Token string `json:"provider_token"`
+
+	Currency string `json:"currency"`
+
+	Prices []Price `json:"prices"`
+}
+
+type Price struct {
+	Label  string `json:"label"`
+	Amount int    `json:"amount"`
+}
+
+type Currency struct {
+	Code         string      `json:"code"`
+	Title        string      `json:"title"`
+	Symbol       string      `json:"symbol"`
+	Native       string      `json:"native"`
+	ThousandsSep string      `json:"thousands_sep"`
+	DecimalSep   string      `json:"decimal_sep"`
+	SymbolLeft   bool        `json:"symbol_left"`
+	SpaceBetween bool        `json:"space_between"`
+	Exp          int         `json:"exp"`
+	MinAmount    interface{} `json:"min_amount"`
+	MaxAmount    interface{} `json:"max_amount"`
+}
+
+func (c Currency) FromTotal(total int) float64 {
+	return float64(total) / math.Pow(10, float64(c.Exp))
+}
+
+func (c Currency) ToTotal(total float64) int {
+	return int(total) * int(math.Pow(10, float64(c.Exp)))
+}
+
+var SupportedCurrencies = map[string]Currency{}
+
+func init() {
+	err := json.Unmarshal([]byte(dataSupportedCurrenciesJSON), &SupportedCurrencies)
+	if err != nil {
+		panic(err)
+	}
+}
diff --git a/vendor/gopkg.in/tucnak/telebot.v2/poller.go b/vendor/gopkg.in/tucnak/telebot.v2/poller.go
new file mode 100644
index 00000000..82d8fa93
--- /dev/null
+++ b/vendor/gopkg.in/tucnak/telebot.v2/poller.go
@@ -0,0 +1,106 @@
+package telebot
+
+import (
+	"time"
+
+	"github.com/pkg/errors"
+)
+
+var (
+	ErrCouldNotUpdate = errors.New("telebot: could not fetch new updates")
+)
+
+// Poller is a provider of Updates.
+//
+// All pollers must implement Poll(), which accepts bot
+// pointer and subscription channel and start polling
+// synchronously straight away.
+type Poller interface {
+	// Poll is supposed to take the bot object
+	// subscription channel and start polling
+	// for Updates immediately.
+	//
+	// Poller must listen for stop constantly and close
+	// it as soon as it's done polling.
+	Poll(b *Bot, updates chan Update, stop chan struct{})
+}
+
+// MiddlewarePoller is a special kind of poller that acts
+// like a filter for updates. It could be used for spam
+// handling, banning or whatever.
+//
+// For heavy middleware, use increased capacity.
+//
+type MiddlewarePoller struct {
+	Capacity int // Default: 1
+	Poller   Poller
+	Filter   func(*Update) bool
+}
+
+// NewMiddlewarePoller wait for it... constructs a new middleware poller.
+func NewMiddlewarePoller(original Poller, filter func(*Update) bool) *MiddlewarePoller {
+	return &MiddlewarePoller{
+		Poller: original,
+		Filter: filter,
+	}
+}
+
+// Poll sieves updates through middleware filter.
+func (p *MiddlewarePoller) Poll(b *Bot, dest chan Update, stop chan struct{}) {
+	cap := 1
+	if p.Capacity > 1 {
+		cap = p.Capacity
+	}
+
+	middle := make(chan Update, cap)
+	stopPoller := make(chan struct{})
+
+	go p.Poller.Poll(b, middle, stopPoller)
+
+	for {
+		select {
+		// call to stop
+		case <-stop:
+			stopPoller <- struct{}{}
+
+		// poller is done
+		case <-stopPoller:
+			close(stop)
+			return
+
+		case upd := <-middle:
+			if p.Filter(&upd) {
+				dest <- upd
+			}
+		}
+	}
+}
+
+// LongPoller is a classic LongPoller with timeout.
+type LongPoller struct {
+	Timeout time.Duration
+
+	LastUpdateID int
+}
+
+// Poll does long polling.
+func (p *LongPoller) Poll(b *Bot, dest chan Update, stop chan struct{}) {
+	go func(stop chan struct{}) {
+		<-stop
+		close(stop)
+	}(stop)
+
+	for {
+		updates, err := b.getUpdates(p.LastUpdateID+1, p.Timeout)
+
+		if err != nil {
+			b.debug(ErrCouldNotUpdate)
+			continue
+		}
+
+		for _, update := range updates {
+			p.LastUpdateID = update.ID
+			dest <- update
+		}
+	}
+}
diff --git a/vendor/gopkg.in/tucnak/telebot.v2/sendable.go b/vendor/gopkg.in/tucnak/telebot.v2/sendable.go
new file mode 100644
index 00000000..df6f3b41
--- /dev/null
+++ b/vendor/gopkg.in/tucnak/telebot.v2/sendable.go
@@ -0,0 +1,279 @@
+package telebot
+
+import (
+	"encoding/json"
+	"fmt"
+	"strconv"
+)
+
+// Recipient is any possible endpoint you can send
+// messages to: either user, group or a channel.
+type Recipient interface {
+	// Must return legit Telegram chat_id or username
+	Recipient() string
+}
+
+// Sendable is any object that can send itself.
+//
+// This is pretty cool, since it lets bots implement
+// custom Sendables for complex kind of media or
+// chat objects spanning across multiple messages.
+type Sendable interface {
+	Send(*Bot, Recipient, *SendOptions) (*Message, error)
+}
+
+// Send delivers media through bot b to recipient.
+func (p *Photo) Send(b *Bot, to Recipient, opt *SendOptions) (*Message, error) {
+	params := map[string]string{
+		"chat_id": to.Recipient(),
+		"caption": p.Caption,
+	}
+
+	embedSendOptions(params, opt)
+
+	msg, err := b.sendObject(&p.File, "photo", params, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	msg.Photo.File.stealRef(&p.File)
+	*p = *msg.Photo
+	p.Caption = msg.Caption
+
+	return msg, nil
+}
+
+// Send delivers media through bot b to recipient.
+func (a *Audio) Send(b *Bot, to Recipient, opt *SendOptions) (*Message, error) {
+	params := map[string]string{
+		"chat_id":   to.Recipient(),
+		"caption":   a.Caption,
+		"performer": a.Performer,
+		"title":     a.Title,
+		"file_name": a.FileName,
+	}
+
+	if a.Duration != 0 {
+		params["duration"] = strconv.Itoa(a.Duration)
+	}
+
+	embedSendOptions(params, opt)
+
+	msg, err := b.sendObject(&a.File, "audio", params, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	if msg.Audio != nil {
+		msg.Audio.File.stealRef(&a.File)
+		*a = *msg.Audio
+		a.Caption = msg.Caption
+	}
+
+	if msg.Document != nil {
+		msg.Document.File.stealRef(&a.File)
+		a.File = msg.Document.File
+	}
+
+	return msg, nil
+}
+
+// Send delivers media through bot b to recipient.
+func (d *Document) Send(b *Bot, to Recipient, opt *SendOptions) (*Message, error) {
+	params := map[string]string{
+		"chat_id":   to.Recipient(),
+		"caption":   d.Caption,
+		"file_name": d.FileName,
+	}
+
+	if d.FileSize != 0 {
+		params["file_size"] = strconv.Itoa(d.FileSize)
+	}
+
+	embedSendOptions(params, opt)
+
+	msg, err := b.sendObject(&d.File, "document", params, thumbnailToFilemap(d.Thumbnail))
+	if err != nil {
+		return nil, err
+	}
+
+	msg.Document.File.stealRef(&d.File)
+	*d = *msg.Document
+	d.Caption = msg.Caption
+
+	return msg, nil
+}
+
+// Send delivers media through bot b to recipient.
+func (s *Sticker) Send(b *Bot, to Recipient, opt *SendOptions) (*Message, error) {
+	params := map[string]string{
+		"chat_id": to.Recipient(),
+	}
+	embedSendOptions(params, opt)
+
+	msg, err := b.sendObject(&s.File, "sticker", params, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	msg.Sticker.File.stealRef(&s.File)
+	*s = *msg.Sticker
+
+	return msg, nil
+}
+
+// Send delivers media through bot b to recipient.
+func (v *Video) Send(b *Bot, to Recipient, opt *SendOptions) (*Message, error) {
+	params := map[string]string{
+		"chat_id":   to.Recipient(),
+		"caption":   v.Caption,
+		"file_name": v.FileName,
+	}
+
+	if v.Duration != 0 {
+		params["duration"] = strconv.Itoa(v.Duration)
+	}
+	if v.Width != 0 {
+		params["width"] = strconv.Itoa(v.Width)
+	}
+	if v.Height != 0 {
+		params["height"] = strconv.Itoa(v.Height)
+	}
+	if v.SupportsStreaming {
+		params["supports_streaming"] = "true"
+	}
+
+	embedSendOptions(params, opt)
+
+	msg, err := b.sendObject(&v.File, "video", params, thumbnailToFilemap(v.Thumbnail))
+	if err != nil {
+		return nil, err
+	}
+
+	if vid := msg.Video; vid != nil {
+		vid.File.stealRef(&v.File)
+		*v = *vid
+		v.Caption = msg.Caption
+	} else if doc := msg.Document; doc != nil {
+		// If video has no sound, Telegram can turn it into Document (GIF)
+		doc.File.stealRef(&v.File)
+
+		v.Caption = doc.Caption
+		v.MIME = doc.MIME
+		v.Thumbnail = doc.Thumbnail
+	}
+
+	return msg, nil
+}
+
+// Send delivers media through bot b to recipient.
+func (v *Voice) Send(b *Bot, to Recipient, opt *SendOptions) (*Message, error) {
+	params := map[string]string{
+		"chat_id": to.Recipient(),
+	}
+
+	if v.Duration != 0 {
+		params["duration"] = strconv.Itoa(v.Duration)
+	}
+
+	embedSendOptions(params, opt)
+
+	msg, err := b.sendObject(&v.File, "voice", params, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	msg.Voice.File.stealRef(&v.File)
+	*v = *msg.Voice
+
+	return msg, nil
+}
+
+// Send delivers media through bot b to recipient.
+func (v *VideoNote) Send(b *Bot, to Recipient, opt *SendOptions) (*Message, error) {
+	params := map[string]string{
+		"chat_id": to.Recipient(),
+	}
+
+	if v.Duration != 0 {
+		params["duration"] = strconv.Itoa(v.Duration)
+	}
+	if v.Length != 0 {
+		params["length"] = strconv.Itoa(v.Length)
+	}
+
+	embedSendOptions(params, opt)
+
+	msg, err := b.sendObject(&v.File, "videoNote", params, thumbnailToFilemap(v.Thumbnail))
+	if err != nil {
+		return nil, err
+	}
+
+	msg.VideoNote.File.stealRef(&v.File)
+	*v = *msg.VideoNote
+
+	return msg, nil
+}
+
+// Send delivers media through bot b to recipient.
+func (x *Location) Send(b *Bot, to Recipient, opt *SendOptions) (*Message, error) {
+	params := map[string]string{
+		"chat_id":     to.Recipient(),
+		"latitude":    fmt.Sprintf("%f", x.Lat),
+		"longitude":   fmt.Sprintf("%f", x.Lng),
+		"live_period": strconv.Itoa(x.LivePeriod),
+	}
+	embedSendOptions(params, opt)
+
+	respJSON, err := b.Raw("sendLocation", params)
+	if err != nil {
+		return nil, err
+	}
+
+	return extractMsgResponse(respJSON)
+}
+
+// Send delivers media through bot b to recipient.
+func (v *Venue) Send(b *Bot, to Recipient, opt *SendOptions) (*Message, error) {
+	params := map[string]string{
+		"chat_id":         to.Recipient(),
+		"latitude":        fmt.Sprintf("%f", v.Location.Lat),
+		"longitude":       fmt.Sprintf("%f", v.Location.Lng),
+		"title":           v.Title,
+		"address":         v.Address,
+		"foursquare_id":   v.FoursquareID,
+		"foursquare_type": v.FoursquareType,
+	}
+	embedSendOptions(params, opt)
+
+	respJSON, err := b.Raw("sendVenue", params)
+	if err != nil {
+		return nil, err
+	}
+
+	return extractMsgResponse(respJSON)
+}
+
+// Send delivers media through bot b to recipient.
+func (i *Invoice) Send(b *Bot, to Recipient, opt *SendOptions) (*Message, error) {
+	prices, _ := json.Marshal(i.Prices)
+
+	params := map[string]string{
+		"chat_id":         to.Recipient(),
+		"title":           i.Title,
+		"description":     i.Description,
+		"start_parameter": i.Start,
+		"payload":         i.Payload,
+		"provider_token":  i.Token,
+		"currency":        i.Currency,
+		"prices":          string(prices),
+	}
+	embedSendOptions(params, opt)
+
+	respJSON, err := b.Raw("sendInvoice", params)
+	if err != nil {
+		return nil, err
+	}
+
+	return extractMsgResponse(respJSON)
+}
diff --git a/vendor/gopkg.in/tucnak/telebot.v2/stickers.go b/vendor/gopkg.in/tucnak/telebot.v2/stickers.go
new file mode 100644
index 00000000..7c5caff5
--- /dev/null
+++ b/vendor/gopkg.in/tucnak/telebot.v2/stickers.go
@@ -0,0 +1,40 @@
+package telebot
+
+// Sticker object represents a WebP image, so-called sticker.
+type Sticker struct {
+	File
+
+	Width  int `json:"width"`
+	Height int `json:"height"`
+
+	Thumbnail    *Photo        `json:"thumb,omitempty"`
+	Emoji        string        `json:"emoji,omitempty"`
+	SetName      string        `json:"set_name,omitempty"`
+	MaskPosition *MaskPosition `json:"mask_position,omitempty"`
+}
+
+// StickerSet represents a sticker set
+type StickerSet struct {
+	Name          string    `json:"name"`
+	Title         string    `json:"title"`
+	ContainsMasks bool      `json:"contains_masks"`
+	Stickers      []Sticker `json:"stickers"`
+}
+
+// MaskPosition describes the position on faces where
+// a mask should be placed by default.
+type MaskPosition struct {
+	Feature MaskFeature `json:"point"`
+	XShift  float32     `json:"x_shift"`
+	YShift  float32     `json:"y_shift"`
+	Scale   float32     `json:"scale"`
+}
+
+// StickerSetParams describes the payload in creating new sticker set api-method.
+type StickerSetParams struct {
+	UserID     int
+	Name       string
+	Title      string
+	PngSticker *File
+	Emojis     string
+}
diff --git a/vendor/gopkg.in/tucnak/telebot.v2/telebot.go b/vendor/gopkg.in/tucnak/telebot.v2/telebot.go
new file mode 100644
index 00000000..ae9f59d4
--- /dev/null
+++ b/vendor/gopkg.in/tucnak/telebot.v2/telebot.go
@@ -0,0 +1,167 @@
+// Package telebot is a framework for Telegram bots.
+//
+// Example:
+//
+//		package main
+//
+//		import (
+//			"time"
+//			tb "gopkg.in/tucnak/telebot.v2"
+//		)
+//
+//		func main() {
+//			b, err := tb.NewBot(tb.Settings{
+//				Token: "TOKEN_HERE",
+//				Poller: &tb.LongPoller{Timeout: 10 * time.Second},
+//			})
+//
+//			if err != nil {
+//				return
+//			}
+//
+//			b.Handle(tb.OnText, func(m *tb.Message) {
+//				b.Send(m.Sender, "hello world")
+//			})
+//
+//			b.Start()
+//		}
+//
+package telebot
+
+// These are one of the possible events Handle() can deal with.
+//
+// For convenience, all Telebot-provided endpoints start with
+// an "alert" character \a.
+const (
+	// Basic message handlers.
+	//
+	// Handler: func(*Message)
+	OnText              = "\atext"
+	OnPhoto             = "\aphoto"
+	OnAudio             = "\aaudio"
+	OnDocument          = "\adocument"
+	OnSticker           = "\asticker"
+	OnVideo             = "\avideo"
+	OnVoice             = "\avoice"
+	OnVideoNote         = "\avideo_note"
+	OnContact           = "\acontact"
+	OnLocation          = "\alocation"
+	OnVenue             = "\avenue"
+	OnEdited            = "\aedited"
+	OnPinned            = "\apinned"
+	OnChannelPost       = "\achan_post"
+	OnEditedChannelPost = "\achan_edited_post"
+
+	// Will fire when bot is added to a group.
+	OnAddedToGroup = "\aadded_to_group"
+	// Group events:
+	OnUserJoined        = "\auser_joined"
+	OnUserLeft          = "\auser_left"
+	OnNewGroupTitle     = "\anew_chat_title"
+	OnNewGroupPhoto     = "\anew_chat_photo"
+	OnGroupPhotoDeleted = "\achat_photo_del"
+
+	// Migration happens when group switches to
+	// a super group. You might want to update
+	// your internal references to this chat
+	// upon switching as its ID will change.
+	//
+	// Handler: func(from, to int64)
+	OnMigration = "\amigration"
+
+	// Will fire on callback requests.
+	//
+	// Handler: func(*Callback)
+	OnCallback = "\acallback"
+
+	// Will fire on incoming inline queries.
+	//
+	// Handler: func(*Query)
+	OnQuery = "\aquery"
+
+	// Will fire on chosen inline results.
+	//
+	// Handler: func(*ChosenInlineResult)
+	OnChosenInlineResult = "\achosen_inline_result"
+
+	// Will fire on PreCheckoutQuery.
+	//
+	// Handler: func(*PreCheckoutQuery)
+	OnCheckout = "\apre_checkout_query"
+)
+
+// ChatAction is a client-side status indicating bot activity.
+type ChatAction string
+
+const (
+	Typing            ChatAction = "typing"
+	UploadingPhoto    ChatAction = "upload_photo"
+	UploadingVideo    ChatAction = "upload_video"
+	UploadingAudio    ChatAction = "upload_audio"
+	UploadingDocument ChatAction = "upload_document"
+	UploadingVNote    ChatAction = "upload_video_note"
+	RecordingVideo    ChatAction = "record_video"
+	RecordingAudio    ChatAction = "record_audio"
+	FindingLocation   ChatAction = "find_location"
+)
+
+// ParseMode determines the way client applications treat the text of the message
+type ParseMode string
+
+const (
+	ModeDefault  ParseMode = ""
+	ModeMarkdown ParseMode = "Markdown"
+	ModeHTML     ParseMode = "HTML"
+)
+
+// EntityType is a MessageEntity type.
+type EntityType string
+
+const (
+	EntityMention   EntityType = "mention"
+	EntityTMention  EntityType = "text_mention"
+	EntityHashtag   EntityType = "hashtag"
+	EntityCommand   EntityType = "bot_command"
+	EntityURL       EntityType = "url"
+	EntityEmail     EntityType = "email"
+	EntityBold      EntityType = "bold"
+	EntityItalic    EntityType = "italic"
+	EntityCode      EntityType = "code"
+	EntityCodeBlock EntityType = "pre"
+	EntityTextLink  EntityType = "text_link"
+)
+
+// ChatType represents one of the possible chat types.
+type ChatType string
+
+const (
+	ChatPrivate        ChatType = "private"
+	ChatGroup          ChatType = "group"
+	ChatSuperGroup     ChatType = "supergroup"
+	ChatChannel        ChatType = "channel"
+	ChatChannelPrivate ChatType = "privatechannel"
+)
+
+// MemberStatus is one's chat status
+type MemberStatus string
+
+const (
+	Creator       MemberStatus = "creator"
+	Administrator MemberStatus = "administrator"
+	Member        MemberStatus = "member"
+	Restricted    MemberStatus = "restricted"
+	Left          MemberStatus = "left"
+	Kicked        MemberStatus = "kicked"
+)
+
+// MaskFeature defines sticker mask position.
+type MaskFeature string
+
+const (
+	FeatureForehead MaskFeature = "forehead"
+	FeatureEyes     MaskFeature = "eyes"
+	FeatureMouth    MaskFeature = "mouth"
+	FeatureChin     MaskFeature = "chin"
+)
+
+const DefaultApiURL = "https://api.telegram.org"
diff --git a/vendor/gopkg.in/tucnak/telebot.v2/util.go b/vendor/gopkg.in/tucnak/telebot.v2/util.go
new file mode 100644
index 00000000..6c2c1b50
--- /dev/null
+++ b/vendor/gopkg.in/tucnak/telebot.v2/util.go
@@ -0,0 +1,221 @@
+package telebot
+
+import (
+	"encoding/json"
+	"log"
+	"strconv"
+
+	"github.com/pkg/errors"
+)
+
+func (b *Bot) debug(err error) {
+	err = errors.WithStack(err)
+
+	if b.reporter != nil {
+		b.reporter(err)
+	} else {
+		log.Printf("%+v\n", err)
+	}
+}
+
+func (b *Bot) deferDebug() {
+	if r := recover(); r != nil {
+		if err, ok := r.(error); ok {
+			b.debug(err)
+		} else if str, ok := r.(string); ok {
+			b.debug(errors.Errorf("%s", str))
+		}
+	}
+}
+
+func (b *Bot) sendText(to Recipient, text string, opt *SendOptions) (*Message, error) {
+	params := map[string]string{
+		"chat_id": to.Recipient(),
+		"text":    text,
+	}
+	embedSendOptions(params, opt)
+
+	respJSON, err := b.Raw("sendMessage", params)
+	if err != nil {
+		return nil, err
+	}
+
+	return extractMsgResponse(respJSON)
+}
+
+func wrapSystem(err error) error {
+	return errors.Wrap(err, "system error")
+}
+
+func isUserInList(user *User, list []User) bool {
+	for _, user2 := range list {
+		if user.ID == user2.ID {
+			return true
+		}
+	}
+
+	return false
+}
+
+func extractMsgResponse(respJSON []byte) (*Message, error) {
+	var resp struct {
+		Ok          bool
+		Result      *Message
+		Description string
+	}
+
+	err := json.Unmarshal(respJSON, &resp)
+	if err != nil {
+		var resp struct {
+			Ok          bool
+			Result      bool
+			Description string
+		}
+
+		err := json.Unmarshal(respJSON, &resp)
+		if err != nil {
+			return nil, errors.Wrap(err, "bad response json")
+		}
+
+		if !resp.Ok {
+			return nil, errors.Errorf("api error: %s", resp.Description)
+		}
+	}
+
+	if !resp.Ok {
+		return nil, errors.Errorf("api error: %s", resp.Description)
+	}
+
+	return resp.Result, nil
+}
+
+func extractOkResponse(respJSON []byte) error {
+	var resp struct {
+		Ok          bool
+		Description string
+	}
+
+	err := json.Unmarshal(respJSON, &resp)
+	if err != nil {
+		return errors.Wrap(err, "bad response json")
+	}
+
+	if !resp.Ok {
+		return errors.Errorf("api error: %s", resp.Description)
+	}
+
+	return nil
+}
+
+func extractOptions(how []interface{}) *SendOptions {
+	var opts *SendOptions
+
+	for _, prop := range how {
+		switch opt := prop.(type) {
+		case *SendOptions:
+			opts = opt.copy()
+
+		case *ReplyMarkup:
+			if opts == nil {
+				opts = &SendOptions{}
+			}
+			opts.ReplyMarkup = opt.copy()
+
+		case Option:
+			if opts == nil {
+				opts = &SendOptions{}
+			}
+
+			switch opt {
+			case NoPreview:
+				opts.DisableWebPagePreview = true
+			case Silent:
+				opts.DisableNotification = true
+			case ForceReply:
+				if opts.ReplyMarkup == nil {
+					opts.ReplyMarkup = &ReplyMarkup{}
+				}
+				opts.ReplyMarkup.ForceReply = true
+			case OneTimeKeyboard:
+				if opts.ReplyMarkup == nil {
+					opts.ReplyMarkup = &ReplyMarkup{}
+				}
+				opts.ReplyMarkup.OneTimeKeyboard = true
+			default:
+				panic("telebot: unsupported flag-option")
+			}
+
+		case ParseMode:
+			if opts == nil {
+				opts = &SendOptions{}
+			}
+			opts.ParseMode = opt
+
+		default:
+			panic("telebot: unsupported send-option")
+		}
+	}
+
+	return opts
+}
+
+func embedSendOptions(params map[string]string, opt *SendOptions) {
+	if opt == nil {
+		return
+	}
+
+	if opt.ReplyTo != nil && opt.ReplyTo.ID != 0 {
+		params["reply_to_message_id"] = strconv.Itoa(opt.ReplyTo.ID)
+	}
+
+	if opt.DisableWebPagePreview {
+		params["disable_web_page_preview"] = "true"
+	}
+
+	if opt.DisableNotification {
+		params["disable_notification"] = "true"
+	}
+
+	if opt.ParseMode != ModeDefault {
+		params["parse_mode"] = string(opt.ParseMode)
+	}
+
+	if opt.ReplyMarkup != nil {
+		processButtons(opt.ReplyMarkup.InlineKeyboard)
+		replyMarkup, _ := json.Marshal(opt.ReplyMarkup)
+		params["reply_markup"] = string(replyMarkup)
+	}
+}
+
+func processButtons(keys [][]InlineButton) {
+	if keys == nil || len(keys) < 1 || len(keys[0]) < 1 {
+		return
+	}
+
+	for i, _ := range keys {
+		for j, _ := range keys[i] {
+			key := &keys[i][j]
+			if key.Unique != "" {
+				// Format: "\f<callback_name>|<data>"
+				data := key.Data
+				if data == "" {
+					key.Data = "\f" + key.Unique
+				} else {
+					key.Data = "\f" + key.Unique + "|" + data
+				}
+			}
+		}
+	}
+}
+
+func embedRights(p map[string]string, prv Rights) {
+	jsonRepr, _ := json.Marshal(prv)
+	json.Unmarshal(jsonRepr, &p)
+}
+
+func thumbnailToFilemap(thumb *Photo) map[string]File {
+	if thumb != nil {
+		return map[string]File{"thumb": thumb.File}
+	}
+	return nil
+}
diff --git a/vendor/gopkg.in/tucnak/telebot.v2/webhook.go b/vendor/gopkg.in/tucnak/telebot.v2/webhook.go
new file mode 100644
index 00000000..60e96e27
--- /dev/null
+++ b/vendor/gopkg.in/tucnak/telebot.v2/webhook.go
@@ -0,0 +1,150 @@
+package telebot
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+)
+
+// A WebhookTLS specifies the path to a key and a cert so the poller can open
+// a TLS listener
+type WebhookTLS struct {
+	Key  string
+	Cert string
+}
+
+// A WebhookEndpoint describes the endpoint to which telegram will send its requests.
+// This must be a public URL and can be a loadbalancer or something similar. If the
+// endpoint uses TLS and the certificate is selfsigned you have to add the certificate
+// path of this certificate so telegram will trust it. This field can be ignored if you
+// have a trusted certifcate (letsencrypt, ...).
+type WebhookEndpoint struct {
+	PublicURL string
+	Cert      string
+}
+
+// A Webhook configures the poller for webhooks. It opens a port on the given
+// listen adress. If TLS is filled, the listener will use the key and cert to open
+// a secure port. Otherwise it will use plain HTTP.
+// If you have a loadbalancer ore other infrastructure in front of your service, you
+// must fill the Endpoint structure so this poller will send this data to telegram. If
+// you leave these values empty, your local adress will be sent to telegram which is mostly
+// not what you want (at least while developing). If you have a single instance of your
+// bot you should consider to use the LongPoller instead of a WebHook.
+// You can also leave the Listen field empty. In this case it is up to the caller to
+// add the Webhook to a http-mux.
+type Webhook struct {
+	Listen   string
+	TLS      *WebhookTLS
+	Endpoint *WebhookEndpoint
+	dest     chan<- Update
+	bot      *Bot
+}
+
+type registerResult struct {
+	Ok          bool   `json:"ok"`
+	ErrorCode   int    `json:"error_code"`
+	Description string `json:"description"`
+}
+
+func (h *Webhook) getFiles() map[string]File {
+	m := make(map[string]File)
+
+	if h.TLS != nil {
+		m["certificate"] = FromDisk(h.TLS.Cert)
+	}
+	// check if it is overwritten by an endpoint
+	if h.Endpoint != nil {
+		if h.Endpoint.Cert == "" {
+			// this can be the case if there is a loadbalancer or reverseproxy in
+			// front with a public cert. in this case we do not need to upload it
+			// to telegram. we delete the certificate from the map, because someone
+			// can have an internal TLS listener with a private cert
+			delete(m, "certificate")
+		} else {
+			// someone configured a certificate
+			m["certificate"] = FromDisk(h.Endpoint.Cert)
+		}
+	}
+	return m
+}
+
+func (h *Webhook) getParams() map[string]string {
+	param := make(map[string]string)
+	if h.TLS != nil {
+		param["url"] = "https://" + h.Listen
+	} else {
+		// this will not work with telegram, they want TLS
+		// but i allow this because telegram will send an error
+		// when you register this hook. in their docs they write
+		// that port 80/http is allowed ...
+		param["url"] = "http://" + h.Listen
+	}
+	if h.Endpoint != nil {
+		param["url"] = h.Endpoint.PublicURL
+	}
+	return param
+}
+
+func (h *Webhook) Poll(b *Bot, dest chan Update, stop chan struct{}) {
+	res, err := b.sendFiles("setWebhook", h.getFiles(), h.getParams())
+	if err != nil {
+		b.debug(fmt.Errorf("setWebhook failed %q: %v", string(res), err))
+		close(stop)
+		return
+	}
+	var result registerResult
+	err = json.Unmarshal(res, &result)
+	if err != nil {
+		b.debug(fmt.Errorf("bad json data %q: %v", string(res), err))
+		close(stop)
+		return
+	}
+	if !result.Ok {
+		b.debug(fmt.Errorf("cannot register webhook: %s", result.Description))
+		close(stop)
+		return
+	}
+	// store the variables so the HTTP-handler can use 'em
+	h.dest = dest
+	h.bot = b
+
+	if h.Listen == "" {
+		h.waitForStop(stop)
+		return
+	}
+
+	s := &http.Server{
+		Addr:    h.Listen,
+		Handler: h,
+	}
+
+	go func(stop chan struct{}) {
+		h.waitForStop(stop)
+		s.Shutdown(context.Background())
+	}(stop)
+
+	if h.TLS != nil {
+		s.ListenAndServeTLS(h.TLS.Cert, h.TLS.Key)
+	} else {
+		s.ListenAndServe()
+	}
+}
+
+func (h *Webhook) waitForStop(stop chan struct{}) {
+	<-stop
+	close(stop)
+}
+
+// The handler simply reads the update from the body of the requests
+// and writes them to the update channel.
+func (h *Webhook) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	var update Update
+	err := json.NewDecoder(r.Body).Decode(&update)
+	if err != nil {
+		h.bot.debug(fmt.Errorf("cannot decode update: %v", err))
+		return
+	}
+	h.dest <- update
+}
diff --git a/vendor/modules.txt b/vendor/modules.txt
index a681f4a1..7a71db1a 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -28,6 +28,8 @@ github.com/hashicorp/golang-lru
 github.com/hashicorp/golang-lru/simplelru
 # github.com/jessevdk/go-flags v1.4.0
 github.com/jessevdk/go-flags
+# github.com/microcosm-cc/bluemonday v1.0.2
+github.com/microcosm-cc/bluemonday
 # github.com/patrickmn/go-cache v2.1.0+incompatible
 github.com/patrickmn/go-cache
 # github.com/pkg/errors v0.8.1
@@ -36,9 +38,14 @@ github.com/pkg/errors
 github.com/pmezard/go-difflib/difflib
 # github.com/stretchr/testify v1.3.0
 github.com/stretchr/testify/assert
+# golang.org/x/net v0.0.0-20190311183353-d8887717615a
+golang.org/x/net/html
+golang.org/x/net/html/atom
 # golang.org/x/sys v0.0.0-20190312061237-fead79001313
 golang.org/x/sys/unix
 # golang.org/x/time v0.0.0-20190308202827-9d24e82272b4
 golang.org/x/time/rate
+# gopkg.in/tucnak/telebot.v2 v2.0.0-20191005061224-d0707a9d73c4
+gopkg.in/tucnak/telebot.v2
 # gopkg.in/yaml.v2 v2.2.2
 gopkg.in/yaml.v2

From d8fb33189e46ea7ef69814e9958ed3735c6043e1 Mon Sep 17 00:00:00 2001
From: Sergey Gaynetdinov <sergey@gaynetdinov.ru>
Date: Mon, 18 Nov 2019 18:09:43 +0500
Subject: [PATCH 04/25] Not raise error if telegram token empty

---
 app/proc/telegram.go      |  8 ++++++++
 app/proc/telegram_test.go | 28 ++++++++++++++++++++++++++++
 2 files changed, 36 insertions(+)
 create mode 100644 app/proc/telegram_test.go

diff --git a/app/proc/telegram.go b/app/proc/telegram.go
index c14bf7d7..0dbc2a67 100644
--- a/app/proc/telegram.go
+++ b/app/proc/telegram.go
@@ -18,6 +18,10 @@ type TelegramClient struct {
 
 // NewTelegramClient init telegram client
 func NewTelegramClient(token string) (*TelegramClient, error) {
+	if token == "" {
+		return nil, nil
+	}
+
 	bot, err := tb.NewBot(tb.Settings{
 		Token: token,
 	})
@@ -33,6 +37,10 @@ func NewTelegramClient(token string) (*TelegramClient, error) {
 
 // Send message, skip if telegram token empty
 func (client TelegramClient) Send(channelID string, item feed.Item) error {
+	if client.Bot == nil {
+		return nil
+	}
+
 	if channelID == "" {
 		return nil
 	}
diff --git a/app/proc/telegram_test.go b/app/proc/telegram_test.go
new file mode 100644
index 00000000..e09bd11c
--- /dev/null
+++ b/app/proc/telegram_test.go
@@ -0,0 +1,28 @@
+package proc
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/umputun/feed-master/app/feed"
+)
+
+func TestNewTelegramClientIfTokenEmpty(t *testing.T) {
+	token := ""
+	client, err := NewTelegramClient(token)
+
+	assert.Nil(t, err)
+	assert.Nil(t, client)
+}
+
+func TestSendIfBotIsNil(t *testing.T) {
+	client := TelegramClient{
+		Bot: nil,
+	}
+
+	item := feed.Item{}
+	got := client.Send("@channel", item)
+
+	assert.Nil(t, got)
+}

From c741b89b3d6b310936e57ffe6f349fa444116f07 Mon Sep 17 00:00:00 2001
From: Sergey Gaynetdinov <sergey@gaynetdinov.ru>
Date: Mon, 18 Nov 2019 18:17:26 +0500
Subject: [PATCH 05/25] Add 'TestSendIfChannelIDEmpty'

---
 app/proc/telegram_test.go | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/app/proc/telegram_test.go b/app/proc/telegram_test.go
index e09bd11c..f4ad7f92 100644
--- a/app/proc/telegram_test.go
+++ b/app/proc/telegram_test.go
@@ -4,6 +4,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	tb "gopkg.in/tucnak/telebot.v2"
 
 	"github.com/umputun/feed-master/app/feed"
 )
@@ -26,3 +27,13 @@ func TestSendIfBotIsNil(t *testing.T) {
 
 	assert.Nil(t, got)
 }
+
+func TestSendIfChannelIDEmpty(t *testing.T) {
+	client := TelegramClient{
+		Bot: &tb.Bot{},
+	}
+
+	got := client.Send("", feed.Item{})
+
+	assert.Nil(t, got)
+}

From ee439da0d76f50ea41141d9434570fd4e4d9e991 Mon Sep 17 00:00:00 2001
From: Sergey Gaynetdinov <sergey@gaynetdinov.ru>
Date: Mon, 18 Nov 2019 18:43:43 +0500
Subject: [PATCH 06/25] Fix: 'NewTelegramClient' return 'TelegramClient' not
 'nil'

---
 app/proc/telegram.go      | 2 +-
 app/proc/telegram_test.go | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/app/proc/telegram.go b/app/proc/telegram.go
index 0dbc2a67..681e651d 100644
--- a/app/proc/telegram.go
+++ b/app/proc/telegram.go
@@ -19,7 +19,7 @@ type TelegramClient struct {
 // NewTelegramClient init telegram client
 func NewTelegramClient(token string) (*TelegramClient, error) {
 	if token == "" {
-		return nil, nil
+		return &TelegramClient{Bot: nil}, nil
 	}
 
 	bot, err := tb.NewBot(tb.Settings{
diff --git a/app/proc/telegram_test.go b/app/proc/telegram_test.go
index f4ad7f92..8e62c2ab 100644
--- a/app/proc/telegram_test.go
+++ b/app/proc/telegram_test.go
@@ -14,7 +14,7 @@ func TestNewTelegramClientIfTokenEmpty(t *testing.T) {
 	client, err := NewTelegramClient(token)
 
 	assert.Nil(t, err)
-	assert.Nil(t, client)
+	assert.Nil(t, client.Bot)
 }
 
 func TestSendIfBotIsNil(t *testing.T) {

From 635a6741aef3bf93fed562eb55ec938537cb00c1 Mon Sep 17 00:00:00 2001
From: Sergey Gaynetdinov <sergey@gaynetdinov.ru>
Date: Mon, 18 Nov 2019 20:34:50 +0500
Subject: [PATCH 07/25] Add in environment 'TELEGRAM_TOKEN'

---
 docker-compose.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/docker-compose.yml b/docker-compose.yml
index ea642cbc..4d0aa213 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -19,6 +19,7 @@ services:
             - DEBUG=false
             - FM_DB=/srv/var/feed-master.bdb
             - FM_CONF=/srv/etc/fm.yml
+            - TELEGRAM_TOKEN
         volumes:
             - ./var:/srv/var # mapped location to save status
             - ./_example/etc:/srv/etc # mapped location for config

From 80ca1987b3e880e463bda3dd94b353dc545ebf7a Mon Sep 17 00:00:00 2001
From: Sergey Gaynetdinov <sergey@gaynetdinov.ru>
Date: Mon, 18 Nov 2019 20:39:10 +0500
Subject: [PATCH 08/25] Refactoring test

---
 app/proc/telegram_test.go | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/app/proc/telegram_test.go b/app/proc/telegram_test.go
index 8e62c2ab..b34b3bfe 100644
--- a/app/proc/telegram_test.go
+++ b/app/proc/telegram_test.go
@@ -10,21 +10,18 @@ import (
 )
 
 func TestNewTelegramClientIfTokenEmpty(t *testing.T) {
-	token := ""
-	client, err := NewTelegramClient(token)
+	client, err := NewTelegramClient("")
 
 	assert.Nil(t, err)
 	assert.Nil(t, client.Bot)
 }
 
 func TestSendIfBotIsNil(t *testing.T) {
-	client := TelegramClient{
-		Bot: nil,
-	}
+	client, err := NewTelegramClient("")
 
-	item := feed.Item{}
-	got := client.Send("@channel", item)
+	got := client.Send("@channel", feed.Item{})
 
+	assert.Nil(t, err)
 	assert.Nil(t, got)
 }
 

From be4eeb7ef578c0f447827fdce30b5134caf5fd81 Mon Sep 17 00:00:00 2001
From: Sergey Gaynetdinov <sergey@gaynetdinov.ru>
Date: Mon, 18 Nov 2019 20:52:21 +0500
Subject: [PATCH 09/25] Add test for 'TelegramClient.tagLinkOnlySupport'

---
 app/proc/telegram_test.go | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/app/proc/telegram_test.go b/app/proc/telegram_test.go
index b34b3bfe..393182d4 100644
--- a/app/proc/telegram_test.go
+++ b/app/proc/telegram_test.go
@@ -34,3 +34,31 @@ func TestSendIfChannelIDEmpty(t *testing.T) {
 
 	assert.Nil(t, got)
 }
+
+func TestTagLinkOnlySupport(t *testing.T) {
+	html := `
+<li>Особое канадское искусство. </li>
+<li>Результаты нашего странного эксперимента.</li>
+<li>Теперь можно и в <a href="https://t.me/uwp_podcast">телеграмме</a></li>
+<li>Саботаж на местах.</li>
+<li>Их нравы: кумовство и коррупция.</li>
+<li>Вопросы и ответы</li>
+</ul>
+<p><a href="https://podcast.umputun.com/media/ump_podcast437.mp3"><em>аудио</em></a></p>`
+
+	html_expected := `
+Особое канадское искусство. 
+Результаты нашего странного эксперимента.
+Теперь можно и в <a href="https://t.me/uwp_podcast">телеграмме</a>
+Саботаж на местах.
+Их нравы: кумовство и коррупция.
+Вопросы и ответы
+
+<a href="https://podcast.umputun.com/media/ump_podcast437.mp3">аудио</a>`
+
+	client := TelegramClient{}
+
+	got := client.tagLinkOnlySupport(html)
+
+	assert.Equal(t, got, html_expected, "support only html tag a")
+}

From 117ef402f39704760d772c896c580f594724f839 Mon Sep 17 00:00:00 2001
From: Sergey Gaynetdinov <sergey@gaynetdinov.ru>
Date: Mon, 18 Nov 2019 21:01:49 +0500
Subject: [PATCH 10/25] Add test for 'TelegramClient.getMessageHTML'

---
 app/proc/telegram_test.go | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/app/proc/telegram_test.go b/app/proc/telegram_test.go
index 393182d4..ace3e521 100644
--- a/app/proc/telegram_test.go
+++ b/app/proc/telegram_test.go
@@ -62,3 +62,20 @@ func TestTagLinkOnlySupport(t *testing.T) {
 
 	assert.Equal(t, got, html_expected, "support only html tag a")
 }
+
+func TestGetMessageHTML(t *testing.T) {
+	item := feed.Item{
+		Title:       "\tPodcast\n\t",
+		Description: "<p>News <a href='#'>Podcast Link</a></p>\n",
+		Enclosure: feed.Enclosure{
+			URL: "https://example.com",
+		},
+	}
+
+	expected := "Podcast\n\nNews <a href=\"#\">Podcast Link</a>\n\nhttps://example.com"
+
+	client := TelegramClient{}
+	got := client.getMessageHTML(item)
+
+	assert.Equal(t, got, expected)
+}

From bec8544c29ca6073b2ea433680765de113e3f00a Mon Sep 17 00:00:00 2001
From: Sergey Gaynetdinov <sergey@gaynetdinov.ru>
Date: Mon, 18 Nov 2019 21:05:50 +0500
Subject: [PATCH 11/25] Rename 'html_expected' -> 'htmlExpected'

---
 app/proc/telegram_test.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/app/proc/telegram_test.go b/app/proc/telegram_test.go
index ace3e521..ff7e2ee8 100644
--- a/app/proc/telegram_test.go
+++ b/app/proc/telegram_test.go
@@ -46,7 +46,7 @@ func TestTagLinkOnlySupport(t *testing.T) {
 </ul>
 <p><a href="https://podcast.umputun.com/media/ump_podcast437.mp3"><em>аудио</em></a></p>`
 
-	html_expected := `
+	htmlExpected := `
 Особое канадское искусство. 
 Результаты нашего странного эксперимента.
 Теперь можно и в <a href="https://t.me/uwp_podcast">телеграмме</a>
@@ -60,7 +60,7 @@ func TestTagLinkOnlySupport(t *testing.T) {
 
 	got := client.tagLinkOnlySupport(html)
 
-	assert.Equal(t, got, html_expected, "support only html tag a")
+	assert.Equal(t, got, htmlExpected, "support only html tag a")
 }
 
 func TestGetMessageHTML(t *testing.T) {

From 010a33109f4e921513bafa82666900d1d86dedb7 Mon Sep 17 00:00:00 2001
From: Sergey Gaynetdinov <sergey@gaynetdinov.ru>
Date: Tue, 19 Nov 2019 12:01:46 +0500
Subject: [PATCH 12/25] Pretty log, if error send telegram message

---
 app/proc/processor.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/app/proc/processor.go b/app/proc/processor.go
index 12b74833..ba50539b 100644
--- a/app/proc/processor.go
+++ b/app/proc/processor.go
@@ -103,7 +103,7 @@ func (p *Processor) feed(name, url, telegramChannel string, max int) {
 		}
 
 		if err := p.Telegram.Send(telegramChannel, item); err != nil {
-			log.Printf("[WARN] failed send telegram message %s (%s) to %s, %v", item.GUID, item.PubDate, name, err)
+			log.Printf("[WARN] failed send telegram message %s (%s) to channel (%s), %v", item.GUID, item.PubDate, telegramChannel, err)
 		}
 	}
 }

From d3d0adb482d885028cce4136f34ced7241d37cc6 Mon Sep 17 00:00:00 2001
From: Sergey Gaynetdinov <sergey@gaynetdinov.ru>
Date: Tue, 19 Nov 2019 12:07:23 +0500
Subject: [PATCH 13/25] dd prefix "@" for "channel" if not found

---
 app/proc/telegram.go      |  4 ++++
 app/proc/telegram_test.go | 13 +++++++++++++
 2 files changed, 17 insertions(+)

diff --git a/app/proc/telegram.go b/app/proc/telegram.go
index 681e651d..c4dcc7bf 100644
--- a/app/proc/telegram.go
+++ b/app/proc/telegram.go
@@ -82,5 +82,9 @@ type recipient struct {
 }
 
 func (r recipient) Recipient() string {
+	if !strings.HasPrefix(r.chatID, "@") {
+		return "@" + r.chatID
+	}
+
 	return r.chatID
 }
diff --git a/app/proc/telegram_test.go b/app/proc/telegram_test.go
index ff7e2ee8..a3a032fe 100644
--- a/app/proc/telegram_test.go
+++ b/app/proc/telegram_test.go
@@ -79,3 +79,16 @@ func TestGetMessageHTML(t *testing.T) {
 
 	assert.Equal(t, got, expected)
 }
+
+func TestRecipientChannelIDNotStartWithAt(t *testing.T) {
+	cases := []string{"channel", "@channel"}
+	expected := "@channel"
+
+	for _, channelID := range cases {
+		t.Run("", func(t *testing.T) {
+			got := recipient{chatID: channelID} //nolint
+
+			assert.Equal(t, got.Recipient(), expected)
+		})
+	}
+}

From b8312f070018b0dd485031209c64454407bb8c92 Mon Sep 17 00:00:00 2001
From: Sergey Gaynetdinov <sergey@gaynetdinov.ru>
Date: Tue, 19 Nov 2019 16:13:49 +0500
Subject: [PATCH 14/25] Add interface 'Notification'

---
 app/main.go           |  2 +-
 app/proc/processor.go | 13 +++++++++----
 2 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/app/main.go b/app/main.go
index 33994f6a..ed47b44d 100644
--- a/app/main.go
+++ b/app/main.go
@@ -42,7 +42,7 @@ func main() {
 		log.Fatalf("[ERROR] failed initilization telegram client %s, %v", opts.TG, err)
 	}
 
-	p := &proc.Processor{Conf: conf, Store: db, Telegram: tg}
+	p := &proc.Processor{Conf: conf, Store: db, Notification: tg}
 	go p.Do()
 
 	server := api.Server{
diff --git a/app/proc/processor.go b/app/proc/processor.go
index ba50539b..e7d9ac52 100644
--- a/app/proc/processor.go
+++ b/app/proc/processor.go
@@ -12,11 +12,16 @@ import (
 	"github.com/umputun/feed-master/app/feed"
 )
 
+// Notification is interface implemented send message
+type Notification interface {
+	Send(string, feed.Item) error
+}
+
 // Processor is a feed reader and store writer
 type Processor struct {
-	Conf     *Conf
-	Store    *BoltDB
-	Telegram *TelegramClient
+	Conf         *Conf
+	Store        *BoltDB
+	Notification Notification
 }
 
 // Conf for feeds config yml
@@ -102,7 +107,7 @@ func (p *Processor) feed(name, url, telegramChannel string, max int) {
 			return
 		}
 
-		if err := p.Telegram.Send(telegramChannel, item); err != nil {
+		if err := p.Notification.Send(telegramChannel, item); err != nil {
 			log.Printf("[WARN] failed send telegram message %s (%s) to channel (%s), %v", item.GUID, item.PubDate, telegramChannel, err)
 		}
 	}

From 69f08f9d8eff5cff634973b12eeea0b48f28c53c Mon Sep 17 00:00:00 2001
From: Sergey Gaynetdinov <sergey@gaynetdinov.ru>
Date: Wed, 20 Nov 2019 11:01:40 +0500
Subject: [PATCH 15/25] Set timeout for telegram

---
 app/proc/telegram.go | 37 ++++++++++++++++++++++++++++++++-----
 1 file changed, 32 insertions(+), 5 deletions(-)

diff --git a/app/proc/telegram.go b/app/proc/telegram.go
index c4dcc7bf..f9a56ca5 100644
--- a/app/proc/telegram.go
+++ b/app/proc/telegram.go
@@ -1,8 +1,10 @@
 package proc
 
 import (
+	"context"
 	"fmt"
 	"strings"
+	"time"
 
 	log "github.com/go-pkgz/lgr"
 	"github.com/microcosm-cc/bluemonday"
@@ -45,18 +47,38 @@ func (client TelegramClient) Send(channelID string, item feed.Item) error {
 		return nil
 	}
 
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	response := make(chan *responseTelegram)
+	go client.send(channelID, item, response)
+
+	select {
+	case <-ctx.Done():
+		log.Printf("[WARN] timeout send telegram channel: [%s], title: [%s], url: [%s]", channelID, item.Title, item.Enclosure.URL)
+		return nil
+	case got := <-response:
+		if got.err != nil {
+			return got.err
+		}
+
+		log.Printf("[DEBUG] send telegram message: \n%s", got.message.Text)
+		return got.err
+	}
+}
+
+func (client TelegramClient) send(channelID string, item feed.Item, responseCh chan<- *responseTelegram) {
 	message, err := client.Bot.Send(
 		recipient{chatID: channelID},
 		client.getMessageHTML(item),
 		tb.ModeHTML,
 		tb.NoPreview,
 	)
-	if err != nil {
-		return err
-	}
 
-	log.Printf("[DEBUG] send telegram message: \n%s", message.Text)
-	return err
+	responseCh <- &responseTelegram{
+		message: message,
+		err:     err,
+	}
 }
 
 // https://core.telegram.org/bots/api#html-style
@@ -88,3 +110,8 @@ func (r recipient) Recipient() string {
 
 	return r.chatID
 }
+
+type responseTelegram struct {
+	message *tb.Message
+	err     error
+}

From 2b9813025774caa3f91cb2a8c7fde9cfaa94522f Mon Sep 17 00:00:00 2001
From: Sergey Gaynetdinov <sergey@gaynetdinov.ru>
Date: Tue, 26 Nov 2019 16:34:50 +0500
Subject: [PATCH 16/25] Revert "Set timeout for telegram"

This reverts commit 69f08f9d8eff5cff634973b12eeea0b48f28c53c.
---
 app/proc/telegram.go | 37 +++++--------------------------------
 1 file changed, 5 insertions(+), 32 deletions(-)

diff --git a/app/proc/telegram.go b/app/proc/telegram.go
index f9a56ca5..c4dcc7bf 100644
--- a/app/proc/telegram.go
+++ b/app/proc/telegram.go
@@ -1,10 +1,8 @@
 package proc
 
 import (
-	"context"
 	"fmt"
 	"strings"
-	"time"
 
 	log "github.com/go-pkgz/lgr"
 	"github.com/microcosm-cc/bluemonday"
@@ -47,38 +45,18 @@ func (client TelegramClient) Send(channelID string, item feed.Item) error {
 		return nil
 	}
 
-	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
-	defer cancel()
-
-	response := make(chan *responseTelegram)
-	go client.send(channelID, item, response)
-
-	select {
-	case <-ctx.Done():
-		log.Printf("[WARN] timeout send telegram channel: [%s], title: [%s], url: [%s]", channelID, item.Title, item.Enclosure.URL)
-		return nil
-	case got := <-response:
-		if got.err != nil {
-			return got.err
-		}
-
-		log.Printf("[DEBUG] send telegram message: \n%s", got.message.Text)
-		return got.err
-	}
-}
-
-func (client TelegramClient) send(channelID string, item feed.Item, responseCh chan<- *responseTelegram) {
 	message, err := client.Bot.Send(
 		recipient{chatID: channelID},
 		client.getMessageHTML(item),
 		tb.ModeHTML,
 		tb.NoPreview,
 	)
-
-	responseCh <- &responseTelegram{
-		message: message,
-		err:     err,
+	if err != nil {
+		return err
 	}
+
+	log.Printf("[DEBUG] send telegram message: \n%s", message.Text)
+	return err
 }
 
 // https://core.telegram.org/bots/api#html-style
@@ -110,8 +88,3 @@ func (r recipient) Recipient() string {
 
 	return r.chatID
 }
-
-type responseTelegram struct {
-	message *tb.Message
-	err     error
-}

From 336fa152647a382044bce13090929eb02d378d07 Mon Sep 17 00:00:00 2001
From: Sergey Gaynetdinov <sergey@gaynetdinov.ru>
Date: Tue, 26 Nov 2019 17:02:41 +0500
Subject: [PATCH 17/25] Use timeout from http.Client without context timeout

---
 app/proc/telegram.go | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/app/proc/telegram.go b/app/proc/telegram.go
index c4dcc7bf..65d6b49f 100644
--- a/app/proc/telegram.go
+++ b/app/proc/telegram.go
@@ -2,7 +2,9 @@ package proc
 
 import (
 	"fmt"
+	"net/http"
 	"strings"
+	"time"
 
 	log "github.com/go-pkgz/lgr"
 	"github.com/microcosm-cc/bluemonday"
@@ -23,7 +25,8 @@ func NewTelegramClient(token string) (*TelegramClient, error) {
 	}
 
 	bot, err := tb.NewBot(tb.Settings{
-		Token: token,
+		Token:  token,
+		Client: &http.Client{Timeout: 10 * time.Second},
 	})
 	if err != nil {
 		return nil, err

From c5a94a5e589a6707d35750e39191b1316003a700 Mon Sep 17 00:00:00 2001
From: Sergey Gaynetdinov <sergey@gaynetdinov.ru>
Date: Wed, 4 Dec 2019 17:59:27 +0500
Subject: [PATCH 18/25] Pretty log

---
 app/proc/processor.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/app/proc/processor.go b/app/proc/processor.go
index e7d9ac52..395ff697 100644
--- a/app/proc/processor.go
+++ b/app/proc/processor.go
@@ -108,7 +108,7 @@ func (p *Processor) feed(name, url, telegramChannel string, max int) {
 		}
 
 		if err := p.Notification.Send(telegramChannel, item); err != nil {
-			log.Printf("[WARN] failed send telegram message %s (%s) to channel (%s), %v", item.GUID, item.PubDate, telegramChannel, err)
+			log.Printf("[WARN] failed send telegram message, url=%s to channel=%s, %v", item.Enclosure.URL, telegramChannel, err)
 		}
 	}
 }

From c2f5de1ce5e4632552b117973ed4598b5e59a126 Mon Sep 17 00:00:00 2001
From: Sergey Gaynetdinov <sergey@gaynetdinov.ru>
Date: Thu, 5 Dec 2019 01:48:12 +0500
Subject: [PATCH 19/25] Send audio if file size less 50 Mb or send only text

---
 app/proc/telegram.go | 90 ++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 86 insertions(+), 4 deletions(-)

diff --git a/app/proc/telegram.go b/app/proc/telegram.go
index 65d6b49f..a4e3a408 100644
--- a/app/proc/telegram.go
+++ b/app/proc/telegram.go
@@ -1,7 +1,10 @@
 package proc
 
 import (
+	"bytes"
+	"errors"
 	"fmt"
+	"io/ioutil"
 	"net/http"
 	"strings"
 	"time"
@@ -26,7 +29,7 @@ func NewTelegramClient(token string) (*TelegramClient, error) {
 
 	bot, err := tb.NewBot(tb.Settings{
 		Token:  token,
-		Client: &http.Client{Timeout: 10 * time.Second},
+		Client: &http.Client{Timeout: 60 * 10 * time.Second},
 	})
 	if err != nil {
 		return nil, err
@@ -48,18 +51,97 @@ func (client TelegramClient) Send(channelID string, item feed.Item) error {
 		return nil
 	}
 
+	contentLength, err := getContentLength(item.Enclosure.URL)
+	if err != nil {
+		return err
+	}
+
+	var message *tb.Message
+
+	if contentLength < 50_000_000 {
+		message, err = client.sendAudio(channelID, item)
+	} else {
+		message, err = client.sendText(channelID, item)
+	}
+
+	if err != nil {
+		return err
+	}
+
+	log.Printf("[DEBUG] send telegram message: \n%s", message.Text)
+	return err
+}
+
+func getContentLength(url string) (int64, error) {
+	resp, err := http.Head(url) //nolint:gosec
+	if err != nil {
+		return 0, err
+	}
+
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		return 0, errors.New("status code != 200")
+	}
+
+	log.Printf("[DEBUG] Content-Length: %d, url: %s", resp.ContentLength, url)
+	return resp.ContentLength, err
+}
+
+func (client TelegramClient) sendText(channelID string, item feed.Item) (*tb.Message, error) {
 	message, err := client.Bot.Send(
 		recipient{chatID: channelID},
 		client.getMessageHTML(item),
 		tb.ModeHTML,
 		tb.NoPreview,
 	)
+
+	return message, err
+}
+
+func (client TelegramClient) sendAudio(channelID string, item feed.Item) (*tb.Message, error) {
+	file, err := client.downloadAudio(item.Enclosure.URL)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
-	log.Printf("[DEBUG] send telegram message: \n%s", message.Text)
-	return err
+	audio := tb.Audio{
+		File:     tb.FromReader(bytes.NewReader(*file)),
+		FileName: "1.mp3",
+		MIME:     "audio/mpeg",
+		Caption:  client.getMessageHTML(item),
+		Title:    item.Title,
+	}
+
+	message, err := audio.Send(
+		client.Bot,
+		recipient{chatID: channelID},
+		&tb.SendOptions{
+			ParseMode: tb.ModeHTML,
+		},
+	)
+
+	return message, err
+}
+
+func (client TelegramClient) downloadAudio(url string) (*[]byte, error) {
+	clientHTTP := &http.Client{Timeout: 60 * 10 * time.Second}
+
+	resp, err := clientHTTP.Get(url)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	log.Printf("[DEBUG] start download audio: %s", url)
+
+	file, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return nil, err
+	}
+
+	log.Printf("[DEBUG] finish download audio: %s", url)
+	return &file, err
 }
 
 // https://core.telegram.org/bots/api#html-style

From 727df453e8e5e8cfa4f5c1e495a09d08635963f3 Mon Sep 17 00:00:00 2001
From: Sergey Gaynetdinov <sergey@gaynetdinov.ru>
Date: Thu, 5 Dec 2019 11:12:59 +0500
Subject: [PATCH 20/25] Add const 'maxTelegramFileSize'

---
 app/proc/telegram.go | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/app/proc/telegram.go b/app/proc/telegram.go
index a4e3a408..30223c5a 100644
--- a/app/proc/telegram.go
+++ b/app/proc/telegram.go
@@ -16,6 +16,10 @@ import (
 	"github.com/umputun/feed-master/app/feed"
 )
 
+const (
+	maxTelegramFileSize = 50_000_000
+)
+
 // TelegramClient client
 type TelegramClient struct {
 	Bot *tb.Bot
@@ -58,7 +62,7 @@ func (client TelegramClient) Send(channelID string, item feed.Item) error {
 
 	var message *tb.Message
 
-	if contentLength < 50_000_000 {
+	if contentLength < maxTelegramFileSize {
 		message, err = client.sendAudio(channelID, item)
 	} else {
 		message, err = client.sendText(channelID, item)

From 395831a365974d0a5cf76c5531d549c6282370dd Mon Sep 17 00:00:00 2001
From: Sergey Gaynetdinov <sergey@gaynetdinov.ru>
Date: Thu, 5 Dec 2019 11:20:38 +0500
Subject: [PATCH 21/25] Refactoring, message error

---
 app/proc/telegram.go | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/app/proc/telegram.go b/app/proc/telegram.go
index 30223c5a..2d0514d3 100644
--- a/app/proc/telegram.go
+++ b/app/proc/telegram.go
@@ -2,7 +2,6 @@ package proc
 
 import (
 	"bytes"
-	"errors"
 	"fmt"
 	"io/ioutil"
 	"net/http"
@@ -85,7 +84,7 @@ func getContentLength(url string) (int64, error) {
 	defer resp.Body.Close()
 
 	if resp.StatusCode != 200 {
-		return 0, errors.New("status code != 200")
+		return 0, fmt.Errorf("resp.StatusCode: %d, not equal 200", resp.StatusCode)
 	}
 
 	log.Printf("[DEBUG] Content-Length: %d, url: %s", resp.ContentLength, url)

From ec63f0e1c5202553d9e33c15452527fb1a41a4cb Mon Sep 17 00:00:00 2001
From: Sergey Gaynetdinov <sergey@gaynetdinov.ru>
Date: Thu, 5 Dec 2019 11:34:18 +0500
Subject: [PATCH 22/25] Get filename audio file from url

---
 app/proc/telegram.go      |  8 +++++++-
 app/proc/telegram_test.go | 21 +++++++++++++++++++++
 2 files changed, 28 insertions(+), 1 deletion(-)

diff --git a/app/proc/telegram.go b/app/proc/telegram.go
index 2d0514d3..b648745b 100644
--- a/app/proc/telegram.go
+++ b/app/proc/telegram.go
@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"io/ioutil"
 	"net/http"
+	"path"
 	"strings"
 	"time"
 
@@ -110,7 +111,7 @@ func (client TelegramClient) sendAudio(channelID string, item feed.Item) (*tb.Me
 
 	audio := tb.Audio{
 		File:     tb.FromReader(bytes.NewReader(*file)),
-		FileName: "1.mp3",
+		FileName: client.getFilenameByURL(item.Enclosure.URL),
 		MIME:     "audio/mpeg",
 		Caption:  client.getMessageHTML(item),
 		Title:    item.Title,
@@ -165,6 +166,11 @@ func (client TelegramClient) getMessageHTML(item feed.Item) string {
 	return messageHTML
 }
 
+func (client TelegramClient) getFilenameByURL(url string) string {
+	_, filename := path.Split(url)
+	return filename
+}
+
 type recipient struct {
 	chatID string
 }
diff --git a/app/proc/telegram_test.go b/app/proc/telegram_test.go
index a3a032fe..1d2f5975 100644
--- a/app/proc/telegram_test.go
+++ b/app/proc/telegram_test.go
@@ -92,3 +92,24 @@ func TestRecipientChannelIDNotStartWithAt(t *testing.T) {
 		})
 	}
 }
+
+func TestGetFilenameByURL(t *testing.T) {
+	cases := []struct {
+		url, expected string
+	}{
+		{"https://example.com/100500/song.mp3", "song.mp3"},
+		{"https://example.com//song.mp3", "song.mp3"},
+		{"https://example.com/song.mp3", "song.mp3"},
+		{"https://example.com/song.mp3/", ""},
+		{"https://example.com/", ""},
+	}
+
+	for _, tc := range cases {
+		t.Run("", func(t *testing.T) {
+			client := TelegramClient{}
+			got := client.getFilenameByURL(tc.url)
+
+			assert.Equal(t, got, tc.expected)
+		})
+	}
+}

From 588a63f4c436c0287435d8ef4e8ce58c9e32acad Mon Sep 17 00:00:00 2001
From: Sergey Gaynetdinov <sergey@gaynetdinov.ru>
Date: Thu, 5 Dec 2019 11:37:39 +0500
Subject: [PATCH 23/25] Fix: []byte is a slice backed by pointer already

---
 app/proc/telegram.go      | 6 +++---
 app/proc/telegram_test.go | 1 +
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/app/proc/telegram.go b/app/proc/telegram.go
index b648745b..0688649e 100644
--- a/app/proc/telegram.go
+++ b/app/proc/telegram.go
@@ -110,7 +110,7 @@ func (client TelegramClient) sendAudio(channelID string, item feed.Item) (*tb.Me
 	}
 
 	audio := tb.Audio{
-		File:     tb.FromReader(bytes.NewReader(*file)),
+		File:     tb.FromReader(bytes.NewReader(file)),
 		FileName: client.getFilenameByURL(item.Enclosure.URL),
 		MIME:     "audio/mpeg",
 		Caption:  client.getMessageHTML(item),
@@ -128,7 +128,7 @@ func (client TelegramClient) sendAudio(channelID string, item feed.Item) (*tb.Me
 	return message, err
 }
 
-func (client TelegramClient) downloadAudio(url string) (*[]byte, error) {
+func (client TelegramClient) downloadAudio(url string) ([]byte, error) {
 	clientHTTP := &http.Client{Timeout: 60 * 10 * time.Second}
 
 	resp, err := clientHTTP.Get(url)
@@ -145,7 +145,7 @@ func (client TelegramClient) downloadAudio(url string) (*[]byte, error) {
 	}
 
 	log.Printf("[DEBUG] finish download audio: %s", url)
-	return &file, err
+	return file, err
 }
 
 // https://core.telegram.org/bots/api#html-style
diff --git a/app/proc/telegram_test.go b/app/proc/telegram_test.go
index 1d2f5975..7c35f851 100644
--- a/app/proc/telegram_test.go
+++ b/app/proc/telegram_test.go
@@ -104,6 +104,7 @@ func TestGetFilenameByURL(t *testing.T) {
 		{"https://example.com/", ""},
 	}
 
+	//nolint:scopelint
 	for _, tc := range cases {
 		t.Run("", func(t *testing.T) {
 			client := TelegramClient{}

From e27a0454cb3e926e965a5855665b3853726f38e7 Mon Sep 17 00:00:00 2001
From: Sergey Gaynetdinov <sergey@gaynetdinov.ru>
Date: Thu, 5 Dec 2019 22:25:13 +0500
Subject: [PATCH 24/25] Telegram timeout moved to opts

---
 app/main.go               | 12 +++++++-----
 app/proc/telegram.go      | 21 +++++++++++++++------
 app/proc/telegram_test.go | 25 +++++++++++++++++++++++--
 3 files changed, 45 insertions(+), 13 deletions(-)

diff --git a/app/main.go b/app/main.go
index ed47b44d..9fc0eaef 100644
--- a/app/main.go
+++ b/app/main.go
@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"io/ioutil"
 	"os"
+	"time"
 
 	log "github.com/go-pkgz/lgr"
 	"github.com/jessevdk/go-flags"
@@ -14,10 +15,11 @@ import (
 )
 
 var opts struct {
-	DB   string `short:"c" long:"db" env:"FM_DB" default:"var/feed-master.bdb" description:"bolt db file"`
-	Conf string `short:"f" long:"conf" env:"FM_CONF" default:"feed-master.yml" description:"config file (yml)"`
-	Dbg  bool   `long:"dbg" env:"DEBUG" description:"debug mode"`
-	TG   string `long:"telegram_token" env:"TELEGRAM_TOKEN" description:"Telegram token"`
+	DB              string `short:"c" long:"db" env:"FM_DB" default:"var/feed-master.bdb" description:"bolt db file"`
+	Conf            string `short:"f" long:"conf" env:"FM_CONF" default:"feed-master.yml" description:"config file (yml)"`
+	Dbg             bool   `long:"dbg" env:"DEBUG" description:"debug mode"`
+	TG              string `long:"telegram_token" env:"TELEGRAM_TOKEN" description:"Telegram token"`
+	TelegramTimeout int64  `long:"telegram_timeout" env:"TELEGRAM_TIMEOUT" description:"Telegram timeout"`
 }
 
 var revision = "local"
@@ -37,7 +39,7 @@ func main() {
 	if err != nil {
 		log.Fatalf("[ERROR] can't open db %s, %v", opts.DB, err)
 	}
-	tg, err := proc.NewTelegramClient(opts.TG)
+	tg, err := proc.NewTelegramClient(opts.TG, time.Duration(opts.TelegramTimeout))
 	if err != nil {
 		log.Fatalf("[ERROR] failed initilization telegram client %s, %v", opts.TG, err)
 	}
diff --git a/app/proc/telegram.go b/app/proc/telegram.go
index 0688649e..9a02851d 100644
--- a/app/proc/telegram.go
+++ b/app/proc/telegram.go
@@ -22,25 +22,34 @@ const (
 
 // TelegramClient client
 type TelegramClient struct {
-	Bot *tb.Bot
+	Bot     *tb.Bot
+	Timeout time.Duration
 }
 
 // NewTelegramClient init telegram client
-func NewTelegramClient(token string) (*TelegramClient, error) {
+func NewTelegramClient(token string, timeout time.Duration) (*TelegramClient, error) {
+	if timeout == 0 {
+		timeout = time.Duration(60 * 10)
+	}
+
 	if token == "" {
-		return &TelegramClient{Bot: nil}, nil
+		return &TelegramClient{
+			Bot:     nil,
+			Timeout: timeout,
+		}, nil
 	}
 
 	bot, err := tb.NewBot(tb.Settings{
 		Token:  token,
-		Client: &http.Client{Timeout: 60 * 10 * time.Second},
+		Client: &http.Client{Timeout: timeout * time.Second},
 	})
 	if err != nil {
 		return nil, err
 	}
 
 	result := TelegramClient{
-		Bot: bot,
+		Bot:     bot,
+		Timeout: timeout,
 	}
 	return &result, err
 }
@@ -129,7 +138,7 @@ func (client TelegramClient) sendAudio(channelID string, item feed.Item) (*tb.Me
 }
 
 func (client TelegramClient) downloadAudio(url string) ([]byte, error) {
-	clientHTTP := &http.Client{Timeout: 60 * 10 * time.Second}
+	clientHTTP := &http.Client{Timeout: client.Timeout * time.Second}
 
 	resp, err := clientHTTP.Get(url)
 	if err != nil {
diff --git a/app/proc/telegram_test.go b/app/proc/telegram_test.go
index 7c35f851..2c6f8b0d 100644
--- a/app/proc/telegram_test.go
+++ b/app/proc/telegram_test.go
@@ -2,6 +2,7 @@ package proc
 
 import (
 	"testing"
+	"time"
 
 	"github.com/stretchr/testify/assert"
 	tb "gopkg.in/tucnak/telebot.v2"
@@ -10,14 +11,34 @@ import (
 )
 
 func TestNewTelegramClientIfTokenEmpty(t *testing.T) {
-	client, err := NewTelegramClient("")
+	client, err := NewTelegramClient("", 0)
 
 	assert.Nil(t, err)
 	assert.Nil(t, client.Bot)
 }
 
+func TestNewTelegramClientCheckTimeout(t *testing.T) {
+	cases := []struct {
+		timeout, expected time.Duration
+	}{
+		{0, 600},
+		{300, 300},
+		{100500, 100500},
+	}
+
+	//nolint:scopelint
+	for _, tc := range cases {
+		t.Run("", func(t *testing.T) {
+			client, err := NewTelegramClient("", tc.timeout)
+
+			assert.Nil(t, err)
+			assert.Equal(t, tc.expected, client.Timeout)
+		})
+	}
+}
+
 func TestSendIfBotIsNil(t *testing.T) {
-	client, err := NewTelegramClient("")
+	client, err := NewTelegramClient("", 0)
 
 	got := client.Send("@channel", feed.Item{})
 

From 7193518df4b6ae9535032d42e1d052dc481d67b2 Mon Sep 17 00:00:00 2001
From: Sergey Gaynetdinov <sergey@gaynetdinov.ru>
Date: Thu, 5 Dec 2019 23:37:05 +0500
Subject: [PATCH 25/25] Not reads file content to memory

---
 app/proc/telegram.go | 19 ++++++-------------
 1 file changed, 6 insertions(+), 13 deletions(-)

diff --git a/app/proc/telegram.go b/app/proc/telegram.go
index 9a02851d..4a9cd686 100644
--- a/app/proc/telegram.go
+++ b/app/proc/telegram.go
@@ -1,9 +1,8 @@
 package proc
 
 import (
-	"bytes"
 	"fmt"
-	"io/ioutil"
+	"io"
 	"net/http"
 	"path"
 	"strings"
@@ -113,13 +112,14 @@ func (client TelegramClient) sendText(channelID string, item feed.Item) (*tb.Mes
 }
 
 func (client TelegramClient) sendAudio(channelID string, item feed.Item) (*tb.Message, error) {
-	file, err := client.downloadAudio(item.Enclosure.URL)
+	httpBody, err := client.downloadAudio(item.Enclosure.URL)
+	defer httpBody.Close() //nolint:staticcheck
 	if err != nil {
 		return nil, err
 	}
 
 	audio := tb.Audio{
-		File:     tb.FromReader(bytes.NewReader(file)),
+		File:     tb.FromReader(httpBody),
 		FileName: client.getFilenameByURL(item.Enclosure.URL),
 		MIME:     "audio/mpeg",
 		Caption:  client.getMessageHTML(item),
@@ -137,24 +137,17 @@ func (client TelegramClient) sendAudio(channelID string, item feed.Item) (*tb.Me
 	return message, err
 }
 
-func (client TelegramClient) downloadAudio(url string) ([]byte, error) {
+func (client TelegramClient) downloadAudio(url string) (io.ReadCloser, error) {
 	clientHTTP := &http.Client{Timeout: client.Timeout * time.Second}
 
 	resp, err := clientHTTP.Get(url)
 	if err != nil {
 		return nil, err
 	}
-	defer resp.Body.Close()
 
 	log.Printf("[DEBUG] start download audio: %s", url)
 
-	file, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		return nil, err
-	}
-
-	log.Printf("[DEBUG] finish download audio: %s", url)
-	return file, err
+	return resp.Body, err
 }
 
 // https://core.telegram.org/bots/api#html-style