Removed vendoring

Use vendor when building (#201 )
* Use vendor code for all go calls * Add missing vendor dependencies * Add travis_retry to yarn install * Fix go test call
2026-06-11 07:41:08 -05:00 · 2019-11-16 08:35:01 -08:00 · 2019-11-16 08:03:28 -08:00
1318 changed files with 60 additions and 643644 deletions
--- a/.travis.yml
+++ b/.travis.yml
@@ -9,7 +9,7 @@ env:
  - GO111MODULE=on
 before_install:
 - echo -e "machine github.com\n  login $CI_USER_TOKEN" > ~/.netrc
- yarn --cwd ui/v2 install
+- travis_retry yarn --cwd ui/v2 install
 - make generate
 - CI=false yarn --cwd ui/v2 build # TODO: Fix warnings
 #- go get -v github.com/mgechev/revive
--- a/4
+++ b/4
@@ -6,7 +6,7 @@ endif
 build:
 	$(eval DATE := $(shell go run scripts/getDate.go))
 	$(eval GITHASH := $(shell git rev-parse --short HEAD))
-	$(SET) CGO_ENABLED=1 $(SEPARATOR) go build -mod=vendor -v -ldflags "-X 'github.com/stashapp/stash/pkg/api.buildstamp=$(DATE)' -X 'github.com/stashapp/stash/pkg/api.githash=$(GITHASH)'"
+	$(SET) CGO_ENABLED=1 $(SEPARATOR) go build -v -ldflags "-X 'github.com/stashapp/stash/pkg/api.buildstamp=$(DATE)' -X 'github.com/stashapp/stash/pkg/api.githash=$(GITHASH)'"

 install:
 	packr2 install
@@ -32,7 +32,7 @@ vet:

 .PHONY: lint
 lint:
-	revive -config revive.toml -exclude ./vendor/...  ./...
+	revive -config revive.toml -exclude ./...

 .PHONY: ui
 ui:
--- a/go.mod
+++ b/go.mod
@@ -1,27 +1,26 @@
 module github.com/stashapp/stash

 require (
-	github.com/99designs/gqlgen v0.9.0
+	github.com/99designs/gqlgen v0.10.1
 	github.com/PuerkitoBio/goquery v1.5.0
 	github.com/bmatcuk/doublestar v1.1.5
-	github.com/disintegration/imaging v1.6.0
-	github.com/fsnotify/fsnotify v1.4.7
+	github.com/disintegration/imaging v1.6.1
 	github.com/go-chi/chi v4.0.2+incompatible
 	github.com/gobuffalo/packr/v2 v2.0.2
-	github.com/golang-migrate/migrate/v4 v4.3.1
-	github.com/gorilla/websocket v1.4.0
-	github.com/h2non/filetype v1.0.8
-	github.com/inconshreveable/mousetrap v1.0.0 // indirect
+	github.com/golang-migrate/migrate/v4 v4.7.0
+	github.com/gorilla/websocket v1.4.1
+	github.com/h2non/filetype v1.0.10
 	github.com/jmoiron/sqlx v1.2.0
 	github.com/mattn/go-sqlite3 v1.10.0
-	github.com/microcosm-cc/bluemonday v1.0.2 // indirect
-	github.com/rs/cors v1.6.0
+	github.com/rs/cors v1.7.0
 	github.com/sirupsen/logrus v1.4.2
-	github.com/spf13/pflag v1.0.3
-	github.com/spf13/viper v1.4.0
-	github.com/vektah/gqlparser v1.1.2
+	github.com/spf13/pflag v1.0.5
+	github.com/spf13/viper v1.5.0
+	github.com/vektah/gqlparser v1.2.0
 	golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4
 	golang.org/x/image v0.0.0-20190118043309-183bebdce1b2 // indirect
 )

 replace git.apache.org/thrift.git => github.com/apache/thrift v0.0.0-20180902110319-2566ecd5d999
+
+go 1.13
--- a/go.sum
+++ b/go.sum
@@ -1,20 +1,14 @@
 cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
-cloud.google.com/go v0.28.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
 cloud.google.com/go v0.31.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
 cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
 cloud.google.com/go v0.36.0/go.mod h1:RUoy9p/M4ge0HzT8L+SDZ8jg+Q6fth0CiBuhFJpSV40=
 cloud.google.com/go v0.37.4/go.mod h1:NHPJ89PdicEuT9hdPXMROBD91xc5uRDxsMtSB16k7hw=
-contrib.go.opencensus.io/exporter/stackdriver v0.6.0/go.mod h1:QeFzMJDAw8TXt5+aRaSuE8l5BwaMIOIlaVkBOPRuMuw=
 dmitri.shuralyov.com/app/changes v0.0.0-20180602232624-0a106ad413e3/go.mod h1:Yl+fi1br7+Rr3LqpNJf1/uxUdtRUV+Tnj0o93V2B9MU=
 dmitri.shuralyov.com/html/belt v0.0.0-20180602232347-f7d459c86be0/go.mod h1:JLBrvjyP0v+ecvNYvCpyZgu5/xkfAUhi6wJj28eUfSU=
 dmitri.shuralyov.com/service/change v0.0.0-20181023043359-a85b471d5412/go.mod h1:a1inKt/atXimZ4Mv927x+r7UpyzRUf4emIoiiSC2TN4=
 dmitri.shuralyov.com/state v0.0.0-20180228185332-28bcc343414c/go.mod h1:0PRwlb0D6DFvNNtx+9ybjezNCa8XF0xaYcETyp6rHWU=
-github.com/99designs/gqlgen v0.4.5-0.20190127090136-055fb4bc9a6a h1:oTsAt8YXjEk1fo7uZR7gya1jrH48oPulx5oF6zWTHRw=
-github.com/99designs/gqlgen v0.4.5-0.20190127090136-055fb4bc9a6a/go.mod h1:st7qHA6ssU3uRZkmv+wzrzgX4srvIqEIdE5iuRW8GhE=
-github.com/99designs/gqlgen v0.8.2 h1:xOkDPWn/MZjkQ32pu6Axx15mNah0NAq9WalFqT+RavA=
-github.com/99designs/gqlgen v0.8.2/go.mod h1:aLyJw9xUgdJxZ8EqNQxo2pGFhXXJ/hq8t7J4yn8TgI4=
-github.com/99designs/gqlgen v0.9.0 h1:g1arBPML74Vqv0L3Q+TqIhGXLspV+2MYtRLkBxuZrlE=
-github.com/99designs/gqlgen v0.9.0/go.mod h1:HrrG7ic9EgLPsULxsZh/Ti+p0HNWgR3XRuvnD0pb5KY=
+github.com/99designs/gqlgen v0.10.1 h1:1BgB6XKGTHq7uH4G1/PYyKe2Kz7/vw3AlvMZlD3TEEY=
+github.com/99designs/gqlgen v0.10.1/go.mod h1:IviubpnyI4gbBcj8IcxSSc/Q/+af5riwCmJmwF0uaPE=
 github.com/Azure/go-ansiterm v0.0.0-20170929234023-d6e3b3328b78/go.mod h1:LmzpDX56iTiv29bbRTIsUNlaFfuhWRQBWjQdVyAevI8=
 github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ=
 github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
@@ -39,13 +33,10 @@ github.com/anmitsu/go-shlex v0.0.0-20161002113705-648efa622239/go.mod h1:2FmKhYU
 github.com/apache/thrift v0.0.0-20180902110319-2566ecd5d999/go.mod h1:cp2SuWMxlEZw2r+iP2GNCdIi4C1qmUzdZFSVb+bacwQ=
 github.com/apache/thrift v0.12.0/go.mod h1:cp2SuWMxlEZw2r+iP2GNCdIi4C1qmUzdZFSVb+bacwQ=
 github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8=
-github.com/aws/aws-sdk-go v1.15.54/go.mod h1:mFuSZ37Z9YOHbQEwBWztmVzqXrEkub65tZoCYDt7FT0=
 github.com/aws/aws-sdk-go v1.17.7/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo=
 github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
 github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8=
 github.com/bitly/go-hostpool v0.0.0-20171023180738-a3a6125de932/go.mod h1:NOuUCSz6Q9T7+igc/hlvDOUdtWKryOrtFyIVABv/p7k=
-github.com/bmatcuk/doublestar v1.1.1 h1:YroD6BJCZBYx06yYFEWvUuKVWQn3vLLQAVmDmvTSaiQ=
-github.com/bmatcuk/doublestar v1.1.1/go.mod h1:UD6OnuiIn0yFxxA2le/rnRU1G4RaI4UvFv1sNto9p6w=
 github.com/bmatcuk/doublestar v1.1.5 h1:2bNwBOmhyFEFcoB3tGvTD5xanq+4kyOZlB8wFYbMjkk=
 github.com/bmatcuk/doublestar v1.1.5/go.mod h1:wiQtGV+rzVYxB7WIlirSN++5HPtPlXEo9MEoZQC/PmE=
 github.com/bmizerany/assert v0.0.0-20160611221934-b7ed37b82869/go.mod h1:Ekp36dRnpXw/yCqJaO+ZrUyxD+3VXMFFr56k5XYrpB4=
@@ -55,6 +46,7 @@ github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDk
 github.com/cockroachdb/apd v1.1.0/go.mod h1:8Sl8LxpKi29FqWXR16WEFZRNSz3SoPzUzeMeY4+DwBQ=
 github.com/cockroachdb/cockroach-go v0.0.0-20181001143604-e0a95dfd547c/go.mod h1:XGLbWH/ujMcbPbhZq52Nv6UrCghb1yGn//133kEsvDk=
 github.com/codegangsta/negroni v1.0.0/go.mod h1:v0y3T5G7Y1UlFfyxFn/QLRU4a2EuNau2iZY63YTKWo0=
+github.com/containerd/containerd v1.2.7/go.mod h1:bC6axHOhabU15QhwfG7w5PipXdVtMXFTttgp+kVtyUA=
 github.com/coreos/bbolt v1.3.2/go.mod h1:iRUV2dpdMOn7Bo10OQBFzIJO9kkE559Wcmn+qkEiiKk=
 github.com/coreos/etcd v3.3.10+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE=
 github.com/coreos/go-etcd v2.0.0+incompatible/go.mod h1:Jez6KQU2B/sWsbdaef3ED8NzMklzPG4d5KIOhIy30Tk=
@@ -75,14 +67,15 @@ github.com/cznic/zappy v0.0.0-20160723133515-2533cb5b45cc/go.mod h1:Y1SNZ4dRUOKX
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/denisenkom/go-mssqldb v0.0.0-20190515213511-eb9f6a1743f3/go.mod h1:zAg7JM8CkOJ43xKXIj7eRO9kmWm/TW578qo+oDO6tuM=
 github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
 github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8PWV+bWy6jNmig1y/TA+kYO4g3RSRF0IAv0no=
 github.com/dhui/dktest v0.3.0/go.mod h1:cyzIUfGsBEbZ6BT7tnXqAShHSXCZhSNmFl70sZ7c1yc=
-github.com/disintegration/imaging v1.6.0 h1:nVPXRUUQ36Z7MNf0O77UzgnOb1mkMMor7lmJMJXc/mA=
-github.com/disintegration/imaging v1.6.0/go.mod h1:xuIt+sRxDFrHS0drzXUlCJthkJ8k7lkkUojDSR247MQ=
+github.com/disintegration/imaging v1.6.1 h1:JnBbK6ECIZb1NsWIikP9pd8gIlTIRx7fuDNpU9fsxOE=
+github.com/disintegration/imaging v1.6.1/go.mod h1:xuIt+sRxDFrHS0drzXUlCJthkJ8k7lkkUojDSR247MQ=
 github.com/docker/distribution v2.7.0+incompatible/go.mod h1:J2gT2udsDAN96Uj4KfcMRqY0/ypR+oyYUYmja8H+y+w=
 github.com/docker/docker v0.7.3-0.20190103212154-2b7e084dc98b/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
-github.com/docker/docker v0.7.3-0.20190108045446-77df18c24acf/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
+github.com/docker/docker v0.7.3-0.20190817195342-4760db040282/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
 github.com/docker/go-connections v0.4.0/go.mod h1:Gbd7IOopHjR8Iph03tsViu4nIes5XhDvyHbTtUxmeec=
 github.com/docker/go-units v0.3.3/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk=
 github.com/dustin/go-humanize v0.0.0-20180713052910-9f541cc9db5d/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
@@ -97,17 +90,12 @@ github.com/fatih/structs v1.1.0/go.mod h1:9NiDSp5zOcgEDl+j00MP/WkGVPOlPRLejGD8Ga
 github.com/flynn/go-shlex v0.0.0-20150515145356-3f9db97f8568/go.mod h1:xEzjJPgXI435gkrCt3MPfRiAkVrwSbHsst4LCFVfpJc=
 github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
-github.com/fsouza/fake-gcs-server v1.3.0/go.mod h1:Lq+43m2znsXfDKHnQMfdA0HpYYAEJsfizsbpk5k3TLo=
 github.com/fsouza/fake-gcs-server v1.7.0/go.mod h1:5XIRs4YvwNbNoz+1JF8j6KLAyDh7RHGAyAK3EP2EsNk=
 github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
 github.com/gliderlabs/ssh v0.1.1/go.mod h1:U7qILu1NlMHj9FlMhZLlkCdDnU1DBEAqr0aevW3Awn0=
 github.com/go-chi/chi v3.3.2+incompatible/go.mod h1:eB3wogJHnLi3x/kFX2A+IbTBlXxmMeXJVKy9tTv1XzQ=
-github.com/go-chi/chi v4.0.1+incompatible h1:RSRC5qmFPtO90t7pTL0DBMNpZFsb/sHF3RXVlDgFisA=
-github.com/go-chi/chi v4.0.1+incompatible/go.mod h1:eB3wogJHnLi3x/kFX2A+IbTBlXxmMeXJVKy9tTv1XzQ=
 github.com/go-chi/chi v4.0.2+incompatible h1:maB6vn6FqCxrpz4FqWdh4+lwpyZIQS7YEAUcHlgXVRs=
 github.com/go-chi/chi v4.0.2+incompatible/go.mod h1:eB3wogJHnLi3x/kFX2A+IbTBlXxmMeXJVKy9tTv1XzQ=
-github.com/go-ini/ini v1.25.4/go.mod h1:ByCAeIL28uOIIG0E3PJtZPDL8WnHpFKFOtgjp+3Ies8=
-github.com/go-ini/ini v1.39.0/go.mod h1:ByCAeIL28uOIIG0E3PJtZPDL8WnHpFKFOtgjp+3Ies8=
 github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
 github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
 github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
@@ -268,6 +256,7 @@ github.com/gobuffalo/packr v1.15.0/go.mod h1:t5gXzEhIviQwVlNx/+3SfS07GS+cZ2hn76W
 github.com/gobuffalo/packr v1.15.1/go.mod h1:IeqicJ7jm8182yrVmNbM6PR4g79SjN9tZLH8KduZZwE=
 github.com/gobuffalo/packr v1.19.0/go.mod h1:MstrNkfCQhd5o+Ct4IJ0skWlxN8emOq8DsoT1G98VIU=
 github.com/gobuffalo/packr v1.20.0/go.mod h1:JDytk1t2gP+my1ig7iI4NcVaXr886+N0ecUga6884zw=
+github.com/gobuffalo/packr v1.21.0 h1:p2ujcDJQp2QTiYWcI0ByHbr/gMoCouok6M0vXs/yTYQ=
 github.com/gobuffalo/packr v1.21.0/go.mod h1:H00jGfj1qFKxscFJSw8wcL4hpQtPe1PfU2wa6sg/SR0=
 github.com/gobuffalo/packr/v2 v2.0.0-rc.8/go.mod h1:y60QCdzwuMwO2R49fdQhsjCPv7tLQFR0ayzxxla9zes=
 github.com/gobuffalo/packr/v2 v2.0.0-rc.9/go.mod h1:fQqADRfZpEsgkc7c/K7aMew3n4aF1Kji7+lIZeR98Fc=
@@ -322,7 +311,6 @@ github.com/gobuffalo/uuid v2.0.5+incompatible/go.mod h1:ErhIzkRhm0FtRuiE/PeORqcw
 github.com/gobuffalo/validate v2.0.3+incompatible/go.mod h1:N+EtDe0J8252BgfzQUChBgfd6L93m9weay53EWFVsMM=
 github.com/gobuffalo/x v0.0.0-20181003152136-452098b06085/go.mod h1:WevpGD+5YOreDJznWevcn8NTmQEW5STSBgIkpkjzqXc=
 github.com/gobuffalo/x v0.0.0-20181007152206-913e47c59ca7/go.mod h1:9rDPXaB3kXdKWzMc4odGQQdG2e2DIEmANy5aSJ9yesY=
-github.com/gocql/gocql v0.0.0-20181124151448-70385f88b28b/go.mod h1:4Fw1eo5iaEhDUs8XyuhSVCVy52Jq3L+/3GJgYkwc+/0=
 github.com/gocql/gocql v0.0.0-20190301043612-f6df8288f9b4/go.mod h1:4Fw1eo5iaEhDUs8XyuhSVCVy52Jq3L+/3GJgYkwc+/0=
 github.com/gofrs/uuid v3.1.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM=
 github.com/gofrs/uuid v3.2.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM=
@@ -330,10 +318,8 @@ github.com/gogo/protobuf v1.0.0/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7a
 github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
 github.com/gogo/protobuf v1.2.0/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
 github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zVXpSg4=
-github.com/golang-migrate/migrate/v4 v4.2.2 h1:m9WF3B3yge1mKm5+/q6C3qPETMWqphrod3+osb+sP8A=
-github.com/golang-migrate/migrate/v4 v4.2.2/go.mod h1:JRwdki93/aFawDXMUM4GcRu/FAIfyw+1Kuyd9vkbaeA=
-github.com/golang-migrate/migrate/v4 v4.3.1 h1:3eR1NY+pplX+m6yJ1fQf5dFWX3fBgUtZfDiaS/kJVu4=
-github.com/golang-migrate/migrate/v4 v4.3.1/go.mod h1:mJ89KBgbXmM3P49BqOxRL3riNF/ATlg5kMhm17GA0dE=
+github.com/golang-migrate/migrate/v4 v4.7.0 h1:gONcHxHApDTKXDyLH/H97gEHmpu1zcnnbAaq2zgrPrs=
+github.com/golang-migrate/migrate/v4 v4.7.0/go.mod h1:Qvut3N4xKWjoH3sokBccML6WyHSnggXm/DvMMnTsQIc=
 github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
 github.com/golang/groupcache v0.0.0-20190129154638-5b532d6fd5ef/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
 github.com/golang/lint v0.0.0-20180702182130-06c8688daad7/go.mod h1:tluoj9z5200jBnyusfRPU2LqT6J+DAorxEvtC7LHB+E=
@@ -356,7 +342,6 @@ github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OI
 github.com/googleapis/gax-go v2.0.0+incompatible/go.mod h1:SFVmujtThgffbyetf+mdk2eWhX2bMyUtNHzFKcPA9HY=
 github.com/googleapis/gax-go/v2 v2.0.3/go.mod h1:LLvjysVCY1JZeum8Z6l8qUty8fiNwE08qbEPm1M08qg=
 github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg=
-github.com/gopherjs/gopherjs v0.0.0-20181004151105-1babbf986f6f/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
 github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
 github.com/gorilla/context v0.0.0-20160226214623-1ea25387ff6f/go.mod h1:kBGZzfjB9CEq2AlWe17Uuf7NDRt0dE0s8S51q0aT7Yg=
 github.com/gorilla/context v1.1.1/go.mod h1:kBGZzfjB9CEq2AlWe17Uuf7NDRt0dE0s8S51q0aT7Yg=
@@ -371,15 +356,15 @@ github.com/gorilla/websocket v1.2.0 h1:VJtLvh6VQym50czpZzx07z/kw9EgAxI3x1ZB8taTM
 github.com/gorilla/websocket v1.2.0/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ=
 github.com/gorilla/websocket v1.4.0 h1:WDFjx/TMzVgy9VdMMQi2K2Emtwi2QcUQsztZ/zLaH/Q=
 github.com/gorilla/websocket v1.4.0/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ=
+github.com/gorilla/websocket v1.4.1 h1:q7AeDBpnBk8AogcD4DSag/Ukw/KV+YhzLj2bP5HvKCM=
+github.com/gorilla/websocket v1.4.1/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/gregjones/httpcache v0.0.0-20180305231024-9cad4c3443a7/go.mod h1:FecbI9+v66THATjSRHfNgh1IVFe/9kFxbXtjV0ctIMA=
 github.com/grpc-ecosystem/go-grpc-middleware v1.0.0/go.mod h1:FiyG127CGDf3tlThmgyCl78X/SZQqEOJBCDaAfeWzPs=
 github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0/go.mod h1:8NvIoxWQoOIhqOTXgfV/d3M/q6VIi02HzZEHgUlZvzk=
 github.com/grpc-ecosystem/grpc-gateway v1.5.0/go.mod h1:RSKVYQBd5MCa4OVpNdGskqpgL2+G+NZTnrVHpWWfpdw=
 github.com/grpc-ecosystem/grpc-gateway v1.9.0/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY=
-github.com/h2non/filetype v1.0.6 h1:g84/+gdkAT1hnYO+tHpCLoikm13Ju55OkN4KCb1uGEQ=
-github.com/h2non/filetype v1.0.6/go.mod h1:isekKqOuhMj+s/7r3rIeTErIRy4Rub5uBWHfvMusLMU=
-github.com/h2non/filetype v1.0.8 h1:le8gpf+FQA0/DlDABbtisA1KiTS0Xi+YSC/E8yY3Y14=
-github.com/h2non/filetype v1.0.8/go.mod h1:isekKqOuhMj+s/7r3rIeTErIRy4Rub5uBWHfvMusLMU=
+github.com/h2non/filetype v1.0.10 h1:z+SJfnL6thYJ9kAST+6nPRXp1lMxnOVbMZHNYHMar0s=
+github.com/h2non/filetype v1.0.10/go.mod h1:isekKqOuhMj+s/7r3rIeTErIRy4Rub5uBWHfvMusLMU=
 github.com/hailocab/go-hostpool v0.0.0-20160125115350-e80d13ce29ed/go.mod h1:tMWxXQ9wFIaZeTI9F+hmhFiGpFmhOHzyShyFUhRm0H4=
 github.com/hashicorp/errwrap v1.0.0 h1:hLrqtEDnRye3+sgx6z4qVLNuviH3MR5aQ0ykNJa/UYA=
 github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
@@ -397,7 +382,6 @@ github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANyt
 github.com/jackc/fake v0.0.0-20150926172116-812a484cc733/go.mod h1:WrMFNQdiFJ80sQsxDoMokWK1W5TQtxBFNpzWTD84ibQ=
 github.com/jackc/pgx v3.2.0+incompatible/go.mod h1:0ZGrqGqkRlliWnWB4zKnWtjbSWbGkVEFm4TeybAXq+I=
 github.com/jellevandenhooff/dkim v0.0.0-20150330215556-f50fe3d243e1/go.mod h1:E0B/fFc00Y+Rasa88328GlI/XbtyysCtTHZS8h7IrBU=
-github.com/jmespath/go-jmespath v0.0.0-20160202185014-0b12d6b521d8/go.mod h1:Nht3zPeWKUH0NzdCt2Blrr5ys8VGpn0CEB0cQHVjt7k=
 github.com/jmespath/go-jmespath v0.0.0-20180206201540-c2b33e8439af/go.mod h1:Nht3zPeWKUH0NzdCt2Blrr5ys8VGpn0CEB0cQHVjt7k=
 github.com/jmoiron/sqlx v0.0.0-20180614180643-0dae4fefe7c0/go.mod h1:IiEW3SEiiErVyFdH8NTuWjSifiEQKUoyK3LNqr2kCHU=
 github.com/jmoiron/sqlx v1.2.0 h1:41Ip0zITnmWNR/vHV+S4m+VoUivnWY5E4OJfLZjCJMA=
@@ -407,7 +391,6 @@ github.com/joho/godotenv v1.3.0 h1:Zjp+RcGpHhGlrMbJzXTrZZPrWj+1vfm90La1wgB6Bhc=
 github.com/joho/godotenv v1.3.0/go.mod h1:7hK45KPybAkOC6peb+G5yklZfMxEjkZhHbwpqxOKXbg=
 github.com/jonboulle/clockwork v0.1.0/go.mod h1:Ii8DK3G1RaLaWxj9trq07+26W01tbo22gdxWY5EU2bo=
 github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU=
-github.com/jtolds/gls v4.2.1+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
 github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
 github.com/kardianos/osext v0.0.0-20190222173326-2bc1f35cddc0/go.mod h1:1NbS8ALrpOvjt0rHPNLyCIeMtbizbir8U//inJ+zuB8=
 github.com/karrick/godirwalk v1.7.5/go.mod h1:2c9FRhkDxdIbgkOnCEvnSWs71Bhugbl46shStcFDJ34=
@@ -429,12 +412,13 @@ github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/pty v1.1.3/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/kshvakov/clickhouse v1.3.4/go.mod h1:DMzX7FxRymoNkVgizH0DWAL8Cur7wHLgx3MUnGwJqpE=
 github.com/kshvakov/clickhouse v1.3.5/go.mod h1:DMzX7FxRymoNkVgizH0DWAL8Cur7wHLgx3MUnGwJqpE=
 github.com/lib/pq v1.0.0 h1:X5PMW56eZitiTeO7tKzZxFCSpbFZJtkMMooicw2us9A=
 github.com/lib/pq v1.0.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
 github.com/magiconair/properties v1.8.0 h1:LLgXmsheXeRoUOBOjtwPQCWIYqM/LU1ayDtDePerRcY=
 github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
+github.com/magiconair/properties v1.8.1 h1:ZC2Vc7/ZFkGmsVC9KvOjumD+G5lXy2RtTKyzRKO2BQ4=
+github.com/magiconair/properties v1.8.1/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
 github.com/markbates/deplist v1.0.4/go.mod h1:gRRbPbbuA8TmMiRvaOzUlRfzfjeCCBqX2A6arxN01MM=
 github.com/markbates/deplist v1.0.5/go.mod h1:gRRbPbbuA8TmMiRvaOzUlRfzfjeCCBqX2A6arxN01MM=
 github.com/markbates/going v1.0.2/go.mod h1:UWCk3zm0UKefHZ7l8BNqi26UyiEMniznk8naLdTcy6c=
@@ -470,9 +454,8 @@ github.com/mitchellh/mapstructure v0.0.0-20180203102830-a4e142e9c047/go.mod h1:F
 github.com/mitchellh/mapstructure v1.0.0/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
 github.com/mitchellh/mapstructure v1.1.2 h1:fmNYVwqnSfB9mZU6OS2O6GsXM+wcskZDuKQzvN1EDeE=
 github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
-github.com/mongodb/mongo-go-driver v0.1.0/go.mod h1:NK/HWDIIZkaYsnYa0hmtP443T5ELr0KDecmIioVuuyU=
-github.com/mongodb/mongo-go-driver v0.3.0/go.mod h1:NK/HWDIIZkaYsnYa0hmtP443T5ELr0KDecmIioVuuyU=
 github.com/monoculum/formam v0.0.0-20180901015400-4e68be1d79ba/go.mod h1:RKgILGEJq24YyJ2ban8EO0RUVSJlF1pGsEvoLEACr/Q=
+github.com/morikuni/aec v0.0.0-20170113033406-39771216ff4c/go.mod h1:BbKIizmSmc5MMPqRYbxO4ZU0S0+P200+tUnFx7PXmsc=
 github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
 github.com/nakagami/firebirdsql v0.0.0-20190310045651-3c02a58cfed8/go.mod h1:86wM1zFnC6/uDBfZGNwB65O+pR2OFi5q/YQaEUid1qA=
 github.com/neelance/astrewrite v0.0.0-20160511093645-99348263ae86/go.mod h1:kHJEU3ofeGjhHklVoIGuVj85JJwZ6kWPaJwCIxgnFmo=
@@ -510,7 +493,6 @@ github.com/prometheus/common v0.0.0-20181113130724-41aa239b4cce/go.mod h1:daVV7q
 github.com/prometheus/common v0.2.0/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
 github.com/prometheus/common v0.4.0/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
 github.com/prometheus/procfs v0.0.0-20180725123919-05ee40e3a273/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
-github.com/prometheus/procfs v0.0.0-20180920065004-418d78d0b9a7/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
 github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
 github.com/prometheus/procfs v0.0.0-20190117184657-bf6a532e95b1/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
 github.com/prometheus/procfs v0.0.0-20190507164030-5867b95ac084/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
@@ -524,6 +506,8 @@ github.com/rogpeppe/go-internal v1.2.2 h1:J7U/N7eRtzjhs26d6GqMh2HBuXP8/Z64Densii
 github.com/rogpeppe/go-internal v1.2.2/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
 github.com/rs/cors v1.6.0 h1:G9tHG9lebljV9mfp9SNPDL36nCDxmo3zTlAf1YgvzmI=
 github.com/rs/cors v1.6.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU=
+github.com/rs/cors v1.7.0 h1:+88SsELBHx5r+hZ8TCkggzSstaWNbDvThkVK8H6f9ik=
+github.com/rs/cors v1.7.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU=
 github.com/russross/blackfriday v1.5.2/go.mod h1:JO/DiYxRf+HjHt06OyowR9PTA263kcR/rfWxYHBV53g=
 github.com/satori/go.uuid v1.2.0/go.mod h1:dA0hQrYB0VpLJoorglMZABFdXlWrHn1NEOzdhQKdks0=
 github.com/serenize/snaker v0.0.0-20171204205717-a683aaf2d516/go.mod h1:Yow6lPLSAXx2ifx470yD/nUe22Dv5vBvxK/UK9UUTVs=
@@ -564,8 +548,6 @@ github.com/sirupsen/logrus v1.3.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPx
 github.com/sirupsen/logrus v1.4.1/go.mod h1:ni0Sbl8bgC9z8RoU9G6nDWqqs/fq4eDPysMBDgk/93Q=
 github.com/sirupsen/logrus v1.4.2 h1:SPIRibHv4MatM3XXNO2BJeFLZwZ2LvZgfQ5+UNI2im4=
 github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
-github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
-github.com/smartystreets/goconvey v0.0.0-20180222194500-ef6db91d284a/go.mod h1:XDJAKZRPZ1CvBcN2aX5YOUTYGHki24fSF0Iv48Ibg0s=
 github.com/soheilhy/cmux v0.1.4/go.mod h1:IM3LyeVVIOuxMH7sFAkER9+bJ4dT7Ms6E4xg4kGIyLM=
 github.com/sourcegraph/annotate v0.0.0-20160123013949-f4cad6c6324d/go.mod h1:UdhH50NIW0fCiwBSr0co2m7BnFLdv4fQTgdqdJTHFeE=
 github.com/sourcegraph/syntaxhighlight v0.0.0-20170531221838-bd320f5d308e/go.mod h1:HuIsMU8RRBOtsCgI77wP899iHVBQpCmg4ErYMZB+2IA=
@@ -583,18 +565,20 @@ github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb6
 github.com/spf13/pflag v1.0.2/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
 github.com/spf13/pflag v1.0.3 h1:zPAT6CGy6wXeQ7NtTnaTerfKOsV6V6F8agHXFiazDkg=
 github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
+github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
+github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/spf13/viper v1.2.1/go.mod h1:P4AexN0a+C9tGAnUFNwDMYYZv3pjFuvmeiMyKRaNVlI=
 github.com/spf13/viper v1.3.1/go.mod h1:ZiWeW+zYFKm7srdB9IoDzzZXaJaI5eL9QjNiN/DMA2s=
-github.com/spf13/viper v1.3.2 h1:VUFqw5KcqRf7i70GOzW7N+Q7+gxVBkSSqiXB12+JQ4M=
-github.com/spf13/viper v1.3.2/go.mod h1:ZiWeW+zYFKm7srdB9IoDzzZXaJaI5eL9QjNiN/DMA2s=
-github.com/spf13/viper v1.4.0 h1:yXHLWeravcrgGyFSyCgdYpXQ9dR9c/WED3pg1RhxqEU=
-github.com/spf13/viper v1.4.0/go.mod h1:PTJ7Z/lr49W6bUbkmS1V3by4uWynFiR9p7+dSq/yZzE=
+github.com/spf13/viper v1.5.0 h1:GpsTwfsQ27oS/Aha/6d1oD7tpKIqWnOA6tgOX9HHkt4=
+github.com/spf13/viper v1.5.0/go.mod h1:AkYRkVJF8TkSG/xet6PzXX+l39KhhXa2pdqVSxnTcn4=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.2.1/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/subosito/gotenv v1.2.0 h1:Slr1R9HxAlEKefgq5jn9U+DnETlIUa6HfgEzj0g5d7s=
+github.com/subosito/gotenv v1.2.0/go.mod h1:N0PQaV/YGNqwC0u51sEeR/aUtSLEXKX9iv69rRypqCw=
 github.com/tarm/serial v0.0.0-20180830185346-98f6abe2eb07/go.mod h1:kDXzergiv9cbyO7IOYJZWg1U88JhDg3PB6klq9Hg2pA=
 github.com/tidwall/pretty v0.0.0-20180105212114-65a9db5fad51/go.mod h1:XNkn88O1ChpSDQmQeStsy+sBenx6DDtFZJxhVysOjyk=
 github.com/tmc/grpc-websocket-proxy v0.0.0-20190109142713-0ad062ec5ee5/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U=
@@ -604,12 +588,12 @@ github.com/unrolled/secure v0.0.0-20180918153822-f340ee86eb8b/go.mod h1:mnPT77IA
 github.com/unrolled/secure v0.0.0-20181005190816-ff9db2ff917f/go.mod h1:mnPT77IAdsi/kV7+Es7y+pXALeV3h7G6dQF6mNYjcLA=
 github.com/urfave/cli v1.20.0 h1:fDqGv3UG/4jbVl/QkFwEdddtEDjh/5Ov6X+0B/3bPaw=
 github.com/urfave/cli v1.20.0/go.mod h1:70zkFmudgCuE/ngEzBv17Jvp/497gISqfk5gWijbERA=
-github.com/vektah/dataloaden v0.2.0/go.mod h1:vxM6NuRlgiR0M6wbVTJeKp9vQIs81ZMfCYO+4yq/jbE=
+github.com/vektah/dataloaden v0.2.1-0.20190515034641-a19b9a6e7c9e h1:+w0Zm/9gaWpEAyDlU1eKOuk5twTjAjuevXqcJJw8hrg=
 github.com/vektah/dataloaden v0.2.1-0.20190515034641-a19b9a6e7c9e/go.mod h1:/HUdMve7rvxZma+2ZELQeNh88+003LL7Pf/CZ089j8U=
-github.com/vektah/gqlparser v1.1.0 h1:3668p2gUlO+PiS81x957Rpr3/FPRWG6cxgCXAvTS1hw=
-github.com/vektah/gqlparser v1.1.0/go.mod h1:1ycwN7Ij5njmMkPPAOaRFY4rET2Enx7IkVv3vaXspKw=
 github.com/vektah/gqlparser v1.1.2 h1:ZsyLGn7/7jDNI+y4SEhI4yAxRChlv15pUHMjijT+e68=
 github.com/vektah/gqlparser v1.1.2/go.mod h1:1ycwN7Ij5njmMkPPAOaRFY4rET2Enx7IkVv3vaXspKw=
+github.com/vektah/gqlparser v1.2.0 h1:ntkSCX7F5ZJKl+HIVnmLaO269MruasVpNiMOjX9kgo0=
+github.com/vektah/gqlparser v1.2.0/go.mod h1:bkVf0FX+Stjg/MHnm8mEyubuaArhNEqfQhF+OTiAL74=
 github.com/xanzy/go-gitlab v0.15.0/go.mod h1:8zdQa/ri1dfn8eS3Ir1SyfvOKlw7WBJ8DVThkpGiXrs=
 github.com/xdg/scram v0.0.0-20180814205039-7eeb5667e42c/go.mod h1:lB8K/P019DLNhemzwFU4jHLhdvlE6uDZjXFejJXr49I=
 github.com/xdg/stringprep v1.0.0/go.mod h1:Jhud4/sHMO4oL310DaZAKk9ZaJ08SJfe+sJh0HrGL1Y=
@@ -617,7 +601,7 @@ github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q
 github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q=
 gitlab.com/nyarla/go-crypt v0.0.0-20160106005555-d9a5dc2b789b/go.mod h1:T3BPAOm2cqquPa0MKWeNkmOM5RQsRhkrwMWonFMN7fE=
 go.etcd.io/bbolt v1.3.2/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU=
-go.opencensus.io v0.17.0/go.mod h1:mp1VrMQxhlqqDpKvH4UcQUa4YwlzNmymAjPrDdfxNpI=
+go.mongodb.org/mongo-driver v1.1.0/go.mod h1:u7ryQJ+DOzQmeO7zB6MHyr8jkEQvC8vH7qLUO4lqsUM=
 go.opencensus.io v0.18.0/go.mod h1:vKdFvxhtzZ9onBp9VKHK8z/sRpBMnKAsufL7wlDrCOA=
 go.opencensus.io v0.20.1/go.mod h1:6WKK9ahsWS3RSO+PY9ZHZUfv2irvY6gN279GOPZjmmk=
 go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=
@@ -644,6 +628,7 @@ golang.org/x/crypto v0.0.0-20190103213133-ff983b9c42bc h1:F5tKCVGp+MUAHhKp5MZtGq
 golang.org/x/crypto v0.0.0-20190103213133-ff983b9c42bc/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20190211182817-74369b46fc67/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20190325154230-a5d413f7728c/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20190426145343-a29dc8fdc734 h1:p/H982KKEjUnLJkM3tt/LemDnOc1GiZL5FCVlORJ5zo=
 golang.org/x/crypto v0.0.0-20190426145343-a29dc8fdc734/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4 h1:HuIa8hRrWRSrqYzx1qI49NNxhdi2PrY7gxVSq1JjLDc=
@@ -658,13 +643,11 @@ golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvx
 golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
 golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
 golang.org/x/net v0.0.0-20180218175443-cbe0f9307d01/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20180404174746-b3c676e531a6/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180816102801-aaf60122140d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180921000356-2f5d2388922f/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20180925072008-f04abc6bdfa7/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180926154720-4dfa2610cdf3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20181005035420-146acd28ed58/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20181011144130-49bb7cea24b1/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
@@ -698,6 +681,7 @@ golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJ
 golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4 h1:YUO/7uOKsKeq9UokNS62b8FYywz3ker1l1vDZRCRefw=
 golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58 h1:8gQV6CLnAEikrhgkHFbMAEhagSSnXWGV915qUMm9mrU=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20180816055513-1c9583448a9c/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
@@ -705,7 +689,6 @@ golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5h
 golang.org/x/sys v0.0.0-20180906133057-8cf3aee42992/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20180921163948-d47a0f339242/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20180925112736-b09afc3d579e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20180927150500-dad3d9fb7b6e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20181005133103-4497e2df6f9e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20181011152604-fa43e7bc11ba/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
@@ -722,7 +705,6 @@ golang.org/x/sys v0.0.0-20181122145206-62eef0e2fa9b/go.mod h1:STP8DvDyc/dI5b8T5h
 golang.org/x/sys v0.0.0-20181205085412-a5c9d58dba9a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20181206074257-70b957f3b65e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190102155601-82a175fd1598/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190108104531-7fbe1cd0fcc2/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190116161447-11f53e031339 h1:g/Jesu8+QLnA0CPzF3E1pURg0Byr7i6jLoX5sqjcAh0=
 golang.org/x/sys v0.0.0-20190116161447-11f53e031339/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
@@ -741,7 +723,6 @@ golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxb
 golang.org/x/tools v0.0.0-20180221164845-07fd8470d635/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20180828015842-6cd1fcedba52/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20180924175601-e93be7f42f9f/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20181003024731-2f84ea8ef872/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20181006002542-f60d9635b16a/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20181008205924-a2b3f7f249e9/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
@@ -763,7 +744,6 @@ golang.org/x/tools v0.0.0-20181207183836-8bc39b988060/go.mod h1:n7NCudcB/nEzxVGm
 golang.org/x/tools v0.0.0-20181212172921-837e80568c09/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190102213336-ca9055ed7d04/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190104182027-498d95493402/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20190108222858-421f03a57a64/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190111214448-fc1d57b08d7b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190118193359-16909d206f00 h1:6OmoTtlNJlHuWNIjTEyUtMBHrryp8NRuf/XtnC7MmXM=
@@ -782,8 +762,6 @@ golang.org/x/tools v0.0.0-20190425222832-ad9eeb80039a/go.mod h1:RgjU9mgBXZiqYHBn
 golang.org/x/tools v0.0.0-20190515012406-7d7faa4812bd h1:oMEQDWVXVNpceQoVd1JN3CQ7LYJJzs5qWqZIUcxXHHw=
 golang.org/x/tools v0.0.0-20190515012406-7d7faa4812bd/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
 google.golang.org/api v0.0.0-20180910000450-7ca32eb868bf/go.mod h1:4mhQ8q/RsB7i+udVvVy5NUi08OU8ZlA0gRVgrF7VFY0=
-google.golang.org/api v0.0.0-20180921000521-920bb1beccf7/go.mod h1:4mhQ8q/RsB7i+udVvVy5NUi08OU8ZlA0gRVgrF7VFY0=
-google.golang.org/api v0.0.0-20181015145326-625cd1887957/go.mod h1:4mhQ8q/RsB7i+udVvVy5NUi08OU8ZlA0gRVgrF7VFY0=
 google.golang.org/api v0.0.0-20181030000543-1d582fd0359e/go.mod h1:4mhQ8q/RsB7i+udVvVy5NUi08OU8ZlA0gRVgrF7VFY0=
 google.golang.org/api v0.1.0/go.mod h1:UGEZY7KEX120AnNLIHFMKIo4obdJhkp2tPbaPlQx13Y=
 google.golang.org/api v0.3.1/go.mod h1:6wY9I6uQWHQ8EM57III9mq/AjF+i8G65rmVagqKMtkk=
@@ -794,19 +772,17 @@ google.golang.org/appengine v1.2.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7
 google.golang.org/appengine v1.3.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
 google.golang.org/appengine v1.4.0 h1:/wp5JvzpHIxhs/dumFmF7BXTf3Z+dd4uXta4kVyO508=
 google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+google.golang.org/appengine v1.5.0 h1:KxkO13IPW4Lslp2bz+KHP2E3gtFlrIGNThxkZQ3g+4c=
 google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
 google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
 google.golang.org/genproto v0.0.0-20180831171423-11092d34479b/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
-google.golang.org/genproto v0.0.0-20180924164928-221a8d4f7494/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
 google.golang.org/genproto v0.0.0-20181029155118-b69ba1387ce2/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
 google.golang.org/genproto v0.0.0-20181202183823-bd91e49a0898/go.mod h1:7Ep/1NZk928CDR8SjdVbjWNpdIf6nzjE3BTgJDr2Atg=
-google.golang.org/genproto v0.0.0-20190108161440-ae2f86662275/go.mod h1:7Ep/1NZk928CDR8SjdVbjWNpdIf6nzjE3BTgJDr2Atg=
 google.golang.org/genproto v0.0.0-20190201180003-4b09977fb922/go.mod h1:L3J43x8/uS+qIUoksaLKe6OS3nUKxOKuIFz1sl2/jx4=
 google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
 google.golang.org/genproto v0.0.0-20190404172233-64821d5d2107/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
 google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
 google.golang.org/grpc v1.14.0/go.mod h1:yo6s7OP7yaDglbqo1J04qKzAhqBH6lvTonzMVmEdcZw=
-google.golang.org/grpc v1.15.0/go.mod h1:0JHn/cJsOMiMfNA9+DeHDlAU7KAAB5GDlYFpa9MZMio=
 google.golang.org/grpc v1.16.0/go.mod h1:0JHn/cJsOMiMfNA9+DeHDlAU7KAAB5GDlYFpa9MZMio=
 google.golang.org/grpc v1.17.0/go.mod h1:6QZJwpn2B+Zp71q/5VxRsJ6NXXVCE5NRUHRo+f3cWCs=
 google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
@@ -823,7 +799,6 @@ gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMy
 gopkg.in/gemnasium/logrus-airbrake-hook.v2 v2.1.2/go.mod h1:Xk6kEKp8OKb+X14hQBKWaSkCsqBpgog8nAV2xsGOxlo=
 gopkg.in/gomail.v2 v2.0.0-20160411212932-81ebce5c23df/go.mod h1:LRQQ+SO6ZHR7tOkpBDuZnXENFzX8qRjMDMyPD6BRkCw=
 gopkg.in/inf.v0 v0.9.1/go.mod h1:cWUDdTG/fYaXco+Dcufb5Vnc6Gp2YChqWtbxRZE0mXw=
-gopkg.in/ini.v1 v1.39.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
 gopkg.in/mail.v2 v2.0.0-20180731213649-a0242b2233b4/go.mod h1:htwXN1Qh09vZJ1NVKxQqHPBaCBbzKhp5GzuJEA4VJWw=
 gopkg.in/resty.v1 v1.12.0/go.mod h1:mDo4pnntr5jdWRML875a/NmxYqAlA73dVijT2AXvQQo=
 gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
@@ -831,10 +806,11 @@ gopkg.in/yaml.v2 v2.0.0-20170812160011-eb3733d160e7/go.mod h1:JAlM8MvJe8wmxCU4Bl
 gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 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=
+gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gotest.tools v2.2.0+incompatible/go.mod h1:DsYFclhRJ6vuDpmuTbkuFWG+y2sxOXAzmJt81HFBacw=
 grpc.go4.org v0.0.0-20170609214715-11d0a25b4919/go.mod h1:77eQGdRu53HpSqPFJFmuJdjuHRquDANNeA4x7B8WQ9o=
 honnef.co/go/tools v0.0.0-20180728063816-88497007e858/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
-honnef.co/go/tools v0.0.0-20180920025451-e3ad64cb4ed3/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 sourcegraph.com/sourcegraph/appdash v0.0.0-20180110180208-2cc67fd64755/go.mod h1:hI742Nqp5OhwiqlzhgfbWU4mW4yO10fP+LoT9WOswdU=
--- a/scripts/cross-compile.sh
+++ b/scripts/cross-compile.sh
@@ -1,14 +1,14 @@
 #!/bin/sh

-DATE=`go run scripts/getDate.go`
+DATE=`go run -mod=vendor scripts/getDate.go`
 GITHASH=`git rev-parse --short HEAD`
 VERSION_FLAGS="-X 'github.com/stashapp/stash/pkg/api.buildstamp=$DATE' -X 'github.com/stashapp/stash/pkg/api.githash=$GITHASH'"

 SETUP="export GO111MODULE=on; export CGO_ENABLED=1;"
-WINDOWS="GOOS=windows GOARCH=amd64 CC=x86_64-w64-mingw32-gcc CXX=x86_64-w64-mingw32-g++ packr2 build -o dist/stash-win.exe -ldflags \"-extldflags '-static' $VERSION_FLAGS\" -tags extended -v -mod=vendor;"
-DARWIN="GOOS=darwin GOARCH=amd64 CC=o64-clang CXX=o64-clang++ packr2 build -o dist/stash-osx -ldflags \"$VERSION_FLAGS\" -tags extended -v -mod=vendor;"
-LINUX="packr2 build -o dist/stash-linux -ldflags \"$VERSION_FLAGS\" -v -mod=vendor;"
-RASPPI="GOOS=linux GOARCH=arm GOARM=5 CC=arm-linux-gnueabi-gcc packr2 build -o dist/stash-pi -ldflags \"$VERSION_FLAGS\" -v -mod=vendor;"
+WINDOWS="GOOS=windows GOARCH=amd64 CC=x86_64-w64-mingw32-gcc CXX=x86_64-w64-mingw32-g++ packr2 build -o dist/stash-win.exe -ldflags \"-extldflags '-static' $VERSION_FLAGS\" -tags extended -v;"
+DARWIN="GOOS=darwin GOARCH=amd64 CC=o64-clang CXX=o64-clang++ packr2 build -o dist/stash-osx -ldflags \"$VERSION_FLAGS\" -tags extended -v;"
+LINUX="packr2 build -o dist/stash-linux -ldflags \"$VERSION_FLAGS\" -v;"
+RASPPI="GOOS=linux GOARCH=arm GOARM=5 CC=arm-linux-gnueabi-gcc packr2 build -o dist/stash-pi -ldflags \"$VERSION_FLAGS\" -v;"

 COMMAND="$SETUP $WINDOWS $DARWIN $LINUX $RASPPI"

--- a/tools.go
+++ b/tools.go
@@ -0,0 +1,7 @@
+// +build tools
+
+package main
+
+import (
+	_ "github.com/99designs/gqlgen"
+)
--- a/vendor/github.com/99designs/gqlgen/LICENSE
+++ b/vendor/github.com/99designs/gqlgen/LICENSE
@@ -1,19 +0,0 @@
-Copyright (c) 2018 Adam Scarr
-
-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.
--- a/vendor/github.com/99designs/gqlgen/complexity/complexity.go
+++ b/vendor/github.com/99designs/gqlgen/complexity/complexity.go
@@ -1,104 +0,0 @@
-package complexity
-
-import (
-	"github.com/99designs/gqlgen/graphql"
-	"github.com/vektah/gqlparser/ast"
-)
-
-func Calculate(es graphql.ExecutableSchema, op *ast.OperationDefinition, vars map[string]interface{}) int {
-	walker := complexityWalker{
-		es:     es,
-		schema: es.Schema(),
-		vars:   vars,
-	}
-	return walker.selectionSetComplexity(op.SelectionSet)
-}
-
-type complexityWalker struct {
-	es     graphql.ExecutableSchema
-	schema *ast.Schema
-	vars   map[string]interface{}
-}
-
-func (cw complexityWalker) selectionSetComplexity(selectionSet ast.SelectionSet) int {
-	var complexity int
-	for _, selection := range selectionSet {
-		switch s := selection.(type) {
-		case *ast.Field:
-			fieldDefinition := cw.schema.Types[s.Definition.Type.Name()]
-			var childComplexity int
-			switch fieldDefinition.Kind {
-			case ast.Object, ast.Interface, ast.Union:
-				childComplexity = cw.selectionSetComplexity(s.SelectionSet)
-			}
-
-			args := s.ArgumentMap(cw.vars)
-			var fieldComplexity int
-			if s.ObjectDefinition.Kind == ast.Interface {
-				fieldComplexity = cw.interfaceFieldComplexity(s.ObjectDefinition, s.Name, childComplexity, args)
-			} else {
-				fieldComplexity = cw.fieldComplexity(s.ObjectDefinition.Name, s.Name, childComplexity, args)
-			}
-			complexity = safeAdd(complexity, fieldComplexity)
-
-		case *ast.FragmentSpread:
-			complexity = safeAdd(complexity, cw.selectionSetComplexity(s.Definition.SelectionSet))
-
-		case *ast.InlineFragment:
-			complexity = safeAdd(complexity, cw.selectionSetComplexity(s.SelectionSet))
-		}
-	}
-	return complexity
-}
-
-func (cw complexityWalker) interfaceFieldComplexity(def *ast.Definition, field string, childComplexity int, args map[string]interface{}) int {
-	// Interfaces don't have their own separate field costs, so they have to assume the worst case.
-	// We iterate over all implementors and choose the most expensive one.
-	maxComplexity := 0
-	implementors := cw.schema.GetPossibleTypes(def)
-	for _, t := range implementors {
-		fieldComplexity := cw.fieldComplexity(t.Name, field, childComplexity, args)
-		if fieldComplexity > maxComplexity {
-			maxComplexity = fieldComplexity
-		}
-	}
-	return maxComplexity
-}
-
-func (cw complexityWalker) fieldComplexity(object, field string, childComplexity int, args map[string]interface{}) int {
-	if customComplexity, ok := cw.es.Complexity(object, field, childComplexity, args); ok && customComplexity >= childComplexity {
-		return customComplexity
-	}
-	// default complexity calculation
-	return safeAdd(1, childComplexity)
-}
-
-const maxInt = int(^uint(0) >> 1)
-
-// safeAdd is a saturating add of a and b that ignores negative operands.
-// If a + b would overflow through normal Go addition,
-// it returns the maximum integer value instead.
-//
-// Adding complexities with this function prevents attackers from intentionally
-// overflowing the complexity calculation to allow overly-complex queries.
-//
-// It also helps mitigate the impact of custom complexities that accidentally
-// return negative values.
-func safeAdd(a, b int) int {
-	// Ignore negative operands.
-	if a < 0 {
-		if b < 0 {
-			return 1
-		}
-		return b
-	} else if b < 0 {
-		return a
-	}
-
-	c := a + b
-	if c < a {
-		// Set c to maximum integer instead of overflowing.
-		c = maxInt
-	}
-	return c
-}
--- a/vendor/github.com/99designs/gqlgen/graphql/any.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/any.go
@@ -1,19 +0,0 @@
-package graphql
-
-import (
-	"encoding/json"
-	"io"
-)
-
-func MarshalAny(v interface{}) Marshaler {
-	return WriterFunc(func(w io.Writer) {
-		err := json.NewEncoder(w).Encode(v)
-		if err != nil {
-			panic(err)
-		}
-	})
-}
-
-func UnmarshalAny(v interface{}) (interface{}, error) {
-	return v, nil
-}
--- a/vendor/github.com/99designs/gqlgen/graphql/bool.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/bool.go
@@ -1,30 +0,0 @@
-package graphql
-
-import (
-	"fmt"
-	"io"
-	"strings"
-)
-
-func MarshalBoolean(b bool) Marshaler {
-	return WriterFunc(func(w io.Writer) {
-		if b {
-			w.Write(trueLit)
-		} else {
-			w.Write(falseLit)
-		}
-	})
-}
-
-func UnmarshalBoolean(v interface{}) (bool, error) {
-	switch v := v.(type) {
-	case string:
-		return strings.ToLower(v) == "true", nil
-	case int:
-		return v != 0, nil
-	case bool:
-		return v, nil
-	default:
-		return false, fmt.Errorf("%T is not a bool", v)
-	}
-}
--- a/vendor/github.com/99designs/gqlgen/graphql/context.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/context.go
@@ -1,274 +0,0 @@
-package graphql
-
-import (
-	"context"
-	"fmt"
-	"sync"
-
-	"github.com/vektah/gqlparser/ast"
-	"github.com/vektah/gqlparser/gqlerror"
-)
-
-type Resolver func(ctx context.Context) (res interface{}, err error)
-type FieldMiddleware func(ctx context.Context, next Resolver) (res interface{}, err error)
-type RequestMiddleware func(ctx context.Context, next func(ctx context.Context) []byte) []byte
-type ComplexityLimitFunc func(ctx context.Context) int
-
-type RequestContext struct {
-	RawQuery  string
-	Variables map[string]interface{}
-	Doc       *ast.QueryDocument
-
-	ComplexityLimit      int
-	OperationComplexity  int
-	DisableIntrospection bool
-
-	// ErrorPresenter will be used to generate the error
-	// message from errors given to Error().
-	ErrorPresenter      ErrorPresenterFunc
-	Recover             RecoverFunc
-	ResolverMiddleware  FieldMiddleware
-	DirectiveMiddleware FieldMiddleware
-	RequestMiddleware   RequestMiddleware
-	Tracer              Tracer
-
-	errorsMu     sync.Mutex
-	Errors       gqlerror.List
-	extensionsMu sync.Mutex
-	Extensions   map[string]interface{}
-}
-
-func DefaultResolverMiddleware(ctx context.Context, next Resolver) (res interface{}, err error) {
-	return next(ctx)
-}
-
-func DefaultDirectiveMiddleware(ctx context.Context, next Resolver) (res interface{}, err error) {
-	return next(ctx)
-}
-
-func DefaultRequestMiddleware(ctx context.Context, next func(ctx context.Context) []byte) []byte {
-	return next(ctx)
-}
-
-func NewRequestContext(doc *ast.QueryDocument, query string, variables map[string]interface{}) *RequestContext {
-	return &RequestContext{
-		Doc:                 doc,
-		RawQuery:            query,
-		Variables:           variables,
-		ResolverMiddleware:  DefaultResolverMiddleware,
-		DirectiveMiddleware: DefaultDirectiveMiddleware,
-		RequestMiddleware:   DefaultRequestMiddleware,
-		Recover:             DefaultRecover,
-		ErrorPresenter:      DefaultErrorPresenter,
-		Tracer:              &NopTracer{},
-	}
-}
-
-type key string
-
-const (
-	request  key = "request_context"
-	resolver key = "resolver_context"
-)
-
-func GetRequestContext(ctx context.Context) *RequestContext {
-	if val, ok := ctx.Value(request).(*RequestContext); ok {
-		return val
-	}
-	return nil
-}
-
-func WithRequestContext(ctx context.Context, rc *RequestContext) context.Context {
-	return context.WithValue(ctx, request, rc)
-}
-
-type ResolverContext struct {
-	Parent *ResolverContext
-	// The name of the type this field belongs to
-	Object string
-	// These are the args after processing, they can be mutated in middleware to change what the resolver will get.
-	Args map[string]interface{}
-	// The raw field
-	Field CollectedField
-	// The index of array in path.
-	Index *int
-	// The result object of resolver
-	Result interface{}
-	// IsMethod indicates if the resolver is a method
-	IsMethod bool
-}
-
-func (r *ResolverContext) Path() []interface{} {
-	var path []interface{}
-	for it := r; it != nil; it = it.Parent {
-		if it.Index != nil {
-			path = append(path, *it.Index)
-		} else if it.Field.Field != nil {
-			path = append(path, it.Field.Alias)
-		}
-	}
-
-	// because we are walking up the chain, all the elements are backwards, do an inplace flip.
-	for i := len(path)/2 - 1; i >= 0; i-- {
-		opp := len(path) - 1 - i
-		path[i], path[opp] = path[opp], path[i]
-	}
-
-	return path
-}
-
-func GetResolverContext(ctx context.Context) *ResolverContext {
-	if val, ok := ctx.Value(resolver).(*ResolverContext); ok {
-		return val
-	}
-	return nil
-}
-
-func WithResolverContext(ctx context.Context, rc *ResolverContext) context.Context {
-	rc.Parent = GetResolverContext(ctx)
-	return context.WithValue(ctx, resolver, rc)
-}
-
-// This is just a convenient wrapper method for CollectFields
-func CollectFieldsCtx(ctx context.Context, satisfies []string) []CollectedField {
-	resctx := GetResolverContext(ctx)
-	return CollectFields(GetRequestContext(ctx), resctx.Field.Selections, satisfies)
-}
-
-// CollectAllFields returns a slice of all GraphQL field names that were selected for the current resolver context.
-// The slice will contain the unique set of all field names requested regardless of fragment type conditions.
-func CollectAllFields(ctx context.Context) []string {
-	resctx := GetResolverContext(ctx)
-	collected := CollectFields(GetRequestContext(ctx), resctx.Field.Selections, nil)
-	uniq := make([]string, 0, len(collected))
-Next:
-	for _, f := range collected {
-		for _, name := range uniq {
-			if name == f.Name {
-				continue Next
-			}
-		}
-		uniq = append(uniq, f.Name)
-	}
-	return uniq
-}
-
-// Errorf sends an error string to the client, passing it through the formatter.
-func (c *RequestContext) Errorf(ctx context.Context, format string, args ...interface{}) {
-	c.errorsMu.Lock()
-	defer c.errorsMu.Unlock()
-
-	c.Errors = append(c.Errors, c.ErrorPresenter(ctx, fmt.Errorf(format, args...)))
-}
-
-// Error sends an error to the client, passing it through the formatter.
-func (c *RequestContext) Error(ctx context.Context, err error) {
-	c.errorsMu.Lock()
-	defer c.errorsMu.Unlock()
-
-	c.Errors = append(c.Errors, c.ErrorPresenter(ctx, err))
-}
-
-// HasError returns true if the current field has already errored
-func (c *RequestContext) HasError(rctx *ResolverContext) bool {
-	c.errorsMu.Lock()
-	defer c.errorsMu.Unlock()
-	path := rctx.Path()
-
-	for _, err := range c.Errors {
-		if equalPath(err.Path, path) {
-			return true
-		}
-	}
-	return false
-}
-
-// GetErrors returns a list of errors that occurred in the current field
-func (c *RequestContext) GetErrors(rctx *ResolverContext) gqlerror.List {
-	c.errorsMu.Lock()
-	defer c.errorsMu.Unlock()
-	path := rctx.Path()
-
-	var errs gqlerror.List
-	for _, err := range c.Errors {
-		if equalPath(err.Path, path) {
-			errs = append(errs, err)
-		}
-	}
-	return errs
-}
-
-func equalPath(a []interface{}, b []interface{}) bool {
-	if len(a) != len(b) {
-		return false
-	}
-
-	for i := 0; i < len(a); i++ {
-		if a[i] != b[i] {
-			return false
-		}
-	}
-
-	return true
-}
-
-// AddError is a convenience method for adding an error to the current response
-func AddError(ctx context.Context, err error) {
-	GetRequestContext(ctx).Error(ctx, err)
-}
-
-// AddErrorf is a convenience method for adding an error to the current response
-func AddErrorf(ctx context.Context, format string, args ...interface{}) {
-	GetRequestContext(ctx).Errorf(ctx, format, args...)
-}
-
-// RegisterExtension registers an extension, returns error if extension has already been registered
-func (c *RequestContext) RegisterExtension(key string, value interface{}) error {
-	c.extensionsMu.Lock()
-	defer c.extensionsMu.Unlock()
-
-	if c.Extensions == nil {
-		c.Extensions = make(map[string]interface{})
-	}
-
-	if _, ok := c.Extensions[key]; ok {
-		return fmt.Errorf("extension already registered for key %s", key)
-	}
-
-	c.Extensions[key] = value
-	return nil
-}
-
-// ChainFieldMiddleware add chain by FieldMiddleware
-func ChainFieldMiddleware(handleFunc ...FieldMiddleware) FieldMiddleware {
-	n := len(handleFunc)
-
-	if n > 1 {
-		lastI := n - 1
-		return func(ctx context.Context, next Resolver) (interface{}, error) {
-			var (
-				chainHandler Resolver
-				curI         int
-			)
-			chainHandler = func(currentCtx context.Context) (interface{}, error) {
-				if curI == lastI {
-					return next(currentCtx)
-				}
-				curI++
-				res, err := handleFunc[curI](currentCtx, chainHandler)
-				curI--
-				return res, err
-
-			}
-			return handleFunc[0](ctx, chainHandler)
-		}
-	}
-
-	if n == 1 {
-		return handleFunc[0]
-	}
-
-	return func(ctx context.Context, next Resolver) (interface{}, error) {
-		return next(ctx)
-	}
-}
--- a/vendor/github.com/99designs/gqlgen/graphql/error.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/error.go
@@ -1,33 +0,0 @@
-package graphql
-
-import (
-	"context"
-
-	"github.com/vektah/gqlparser/gqlerror"
-)
-
-type ErrorPresenterFunc func(context.Context, error) *gqlerror.Error
-
-type ExtendedError interface {
-	Extensions() map[string]interface{}
-}
-
-func DefaultErrorPresenter(ctx context.Context, err error) *gqlerror.Error {
-	if gqlerr, ok := err.(*gqlerror.Error); ok {
-		if gqlerr.Path == nil {
-			gqlerr.Path = GetResolverContext(ctx).Path()
-		}
-		return gqlerr
-	}
-
-	var extensions map[string]interface{}
-	if ee, ok := err.(ExtendedError); ok {
-		extensions = ee.Extensions()
-	}
-
-	return &gqlerror.Error{
-		Message:    err.Error(),
-		Path:       GetResolverContext(ctx).Path(),
-		Extensions: extensions,
-	}
-}
--- a/vendor/github.com/99designs/gqlgen/graphql/exec.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/exec.go
@@ -1,144 +0,0 @@
-package graphql
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/vektah/gqlparser/ast"
-)
-
-type ExecutableSchema interface {
-	Schema() *ast.Schema
-
-	Complexity(typeName, fieldName string, childComplexity int, args map[string]interface{}) (int, bool)
-	Query(ctx context.Context, op *ast.OperationDefinition) *Response
-	Mutation(ctx context.Context, op *ast.OperationDefinition) *Response
-	Subscription(ctx context.Context, op *ast.OperationDefinition) func() *Response
-}
-
-// CollectFields returns the set of fields from an ast.SelectionSet where all collected fields satisfy at least one of the GraphQL types
-// passed through satisfies. Providing an empty or nil slice for satisfies will return collect all fields regardless of fragment
-// type conditions.
-func CollectFields(reqCtx *RequestContext, selSet ast.SelectionSet, satisfies []string) []CollectedField {
-	return collectFields(reqCtx, selSet, satisfies, map[string]bool{})
-}
-
-func collectFields(reqCtx *RequestContext, selSet ast.SelectionSet, satisfies []string, visited map[string]bool) []CollectedField {
-	groupedFields := make([]CollectedField, 0, len(selSet))
-
-	for _, sel := range selSet {
-		switch sel := sel.(type) {
-		case *ast.Field:
-			if !shouldIncludeNode(sel.Directives, reqCtx.Variables) {
-				continue
-			}
-			f := getOrCreateAndAppendField(&groupedFields, sel.Alias, func() CollectedField {
-				return CollectedField{Field: sel}
-			})
-
-			f.Selections = append(f.Selections, sel.SelectionSet...)
-		case *ast.InlineFragment:
-			if !shouldIncludeNode(sel.Directives, reqCtx.Variables) {
-				continue
-			}
-			if len(satisfies) > 0 && !instanceOf(sel.TypeCondition, satisfies) {
-				continue
-			}
-			for _, childField := range collectFields(reqCtx, sel.SelectionSet, satisfies, visited) {
-				f := getOrCreateAndAppendField(&groupedFields, childField.Name, func() CollectedField { return childField })
-				f.Selections = append(f.Selections, childField.Selections...)
-			}
-
-		case *ast.FragmentSpread:
-			if !shouldIncludeNode(sel.Directives, reqCtx.Variables) {
-				continue
-			}
-			fragmentName := sel.Name
-			if _, seen := visited[fragmentName]; seen {
-				continue
-			}
-			visited[fragmentName] = true
-
-			fragment := reqCtx.Doc.Fragments.ForName(fragmentName)
-			if fragment == nil {
-				// should never happen, validator has already run
-				panic(fmt.Errorf("missing fragment %s", fragmentName))
-			}
-
-			if len(satisfies) > 0 && !instanceOf(fragment.TypeCondition, satisfies) {
-				continue
-			}
-
-			for _, childField := range collectFields(reqCtx, fragment.SelectionSet, satisfies, visited) {
-				f := getOrCreateAndAppendField(&groupedFields, childField.Name, func() CollectedField { return childField })
-				f.Selections = append(f.Selections, childField.Selections...)
-			}
-		default:
-			panic(fmt.Errorf("unsupported %T", sel))
-		}
-	}
-
-	return groupedFields
-}
-
-type CollectedField struct {
-	*ast.Field
-
-	Selections ast.SelectionSet
-}
-
-func instanceOf(val string, satisfies []string) bool {
-	for _, s := range satisfies {
-		if val == s {
-			return true
-		}
-	}
-	return false
-}
-
-func getOrCreateAndAppendField(c *[]CollectedField, name string, creator func() CollectedField) *CollectedField {
-	for i, cf := range *c {
-		if cf.Alias == name {
-			return &(*c)[i]
-		}
-	}
-
-	f := creator()
-
-	*c = append(*c, f)
-	return &(*c)[len(*c)-1]
-}
-
-func shouldIncludeNode(directives ast.DirectiveList, variables map[string]interface{}) bool {
-	if len(directives) == 0 {
-		return true
-	}
-
-	skip, include := false, true
-
-	if d := directives.ForName("skip"); d != nil {
-		skip = resolveIfArgument(d, variables)
-	}
-
-	if d := directives.ForName("include"); d != nil {
-		include = resolveIfArgument(d, variables)
-	}
-
-	return !skip && include
-}
-
-func resolveIfArgument(d *ast.Directive, variables map[string]interface{}) bool {
-	arg := d.Arguments.ForName("if")
-	if arg == nil {
-		panic(fmt.Sprintf("%s: argument 'if' not defined", d.Name))
-	}
-	value, err := arg.Value.Value(variables)
-	if err != nil {
-		panic(err)
-	}
-	ret, ok := value.(bool)
-	if !ok {
-		panic(fmt.Sprintf("%s: argument 'if' is not a boolean", d.Name))
-	}
-	return ret
-}
--- a/vendor/github.com/99designs/gqlgen/graphql/fieldset.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/fieldset.go
@@ -1,63 +0,0 @@
-package graphql
-
-import (
-	"io"
-	"sync"
-)
-
-type FieldSet struct {
-	fields  []CollectedField
-	Values  []Marshaler
-	delayed []delayedResult
-}
-
-type delayedResult struct {
-	i int
-	f func() Marshaler
-}
-
-func NewFieldSet(fields []CollectedField) *FieldSet {
-	return &FieldSet{
-		fields: fields,
-		Values: make([]Marshaler, len(fields)),
-	}
-}
-
-func (m *FieldSet) Concurrently(i int, f func() Marshaler) {
-	m.delayed = append(m.delayed, delayedResult{i: i, f: f})
-}
-
-func (m *FieldSet) Dispatch() {
-	if len(m.delayed) == 1 {
-		// only one concurrent task, no need to spawn a goroutine or deal create waitgroups
-		d := m.delayed[0]
-		m.Values[d.i] = d.f()
-	} else if len(m.delayed) > 1 {
-		// more than one concurrent task, use the main goroutine to do one, only spawn goroutines for the others
-
-		var wg sync.WaitGroup
-		for _, d := range m.delayed[1:] {
-			wg.Add(1)
-			go func(d delayedResult) {
-				m.Values[d.i] = d.f()
-				wg.Done()
-			}(d)
-		}
-
-		m.Values[m.delayed[0].i] = m.delayed[0].f()
-		wg.Wait()
-	}
-}
-
-func (m *FieldSet) MarshalGQL(writer io.Writer) {
-	writer.Write(openBrace)
-	for i, field := range m.fields {
-		if i != 0 {
-			writer.Write(comma)
-		}
-		writeQuotedString(writer, field.Alias)
-		writer.Write(colon)
-		m.Values[i].MarshalGQL(writer)
-	}
-	writer.Write(closeBrace)
-}
--- a/vendor/github.com/99designs/gqlgen/graphql/float.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/float.go
@@ -1,31 +0,0 @@
-package graphql
-
-import (
-	"encoding/json"
-	"fmt"
-	"io"
-	"strconv"
-)
-
-func MarshalFloat(f float64) Marshaler {
-	return WriterFunc(func(w io.Writer) {
-		io.WriteString(w, fmt.Sprintf("%g", f))
-	})
-}
-
-func UnmarshalFloat(v interface{}) (float64, error) {
-	switch v := v.(type) {
-	case string:
-		return strconv.ParseFloat(v, 64)
-	case int:
-		return float64(v), nil
-	case int64:
-		return float64(v), nil
-	case float64:
-		return v, nil
-	case json.Number:
-		return strconv.ParseFloat(string(v), 64)
-	default:
-		return 0, fmt.Errorf("%T is not an float", v)
-	}
-}
--- a/vendor/github.com/99designs/gqlgen/graphql/id.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/id.go
@@ -1,57 +0,0 @@
-package graphql
-
-import (
-	"encoding/json"
-	"fmt"
-	"io"
-	"strconv"
-)
-
-func MarshalID(s string) Marshaler {
-	return WriterFunc(func(w io.Writer) {
-		io.WriteString(w, strconv.Quote(s))
-	})
-}
-func UnmarshalID(v interface{}) (string, error) {
-	switch v := v.(type) {
-	case string:
-		return v, nil
-	case json.Number:
-		return string(v), nil
-	case int:
-		return strconv.Itoa(v), nil
-	case float64:
-		return fmt.Sprintf("%f", v), nil
-	case bool:
-		if v {
-			return "true", nil
-		} else {
-			return "false", nil
-		}
-	case nil:
-		return "null", nil
-	default:
-		return "", fmt.Errorf("%T is not a string", v)
-	}
-}
-
-func MarshalIntID(i int) Marshaler {
-	return WriterFunc(func(w io.Writer) {
-		writeQuotedString(w, strconv.Itoa(i))
-	})
-}
-
-func UnmarshalIntID(v interface{}) (int, error) {
-	switch v := v.(type) {
-	case string:
-		return strconv.Atoi(v)
-	case int:
-		return v, nil
-	case int64:
-		return int(v), nil
-	case json.Number:
-		return strconv.Atoi(string(v))
-	default:
-		return 0, fmt.Errorf("%T is not an int", v)
-	}
-}
--- a/vendor/github.com/99designs/gqlgen/graphql/int.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/int.go
@@ -1,79 +0,0 @@
-package graphql
-
-import (
-	"encoding/json"
-	"fmt"
-	"io"
-	"strconv"
-)
-
-func MarshalInt(i int) Marshaler {
-	return WriterFunc(func(w io.Writer) {
-		io.WriteString(w, strconv.Itoa(i))
-	})
-}
-
-func UnmarshalInt(v interface{}) (int, error) {
-	switch v := v.(type) {
-	case string:
-		return strconv.Atoi(v)
-	case int:
-		return v, nil
-	case int64:
-		return int(v), nil
-	case json.Number:
-		return strconv.Atoi(string(v))
-	default:
-		return 0, fmt.Errorf("%T is not an int", v)
-	}
-}
-
-func MarshalInt64(i int64) Marshaler {
-	return WriterFunc(func(w io.Writer) {
-		io.WriteString(w, strconv.FormatInt(i, 10))
-	})
-}
-
-func UnmarshalInt64(v interface{}) (int64, error) {
-	switch v := v.(type) {
-	case string:
-		return strconv.ParseInt(v, 10, 64)
-	case int:
-		return int64(v), nil
-	case int64:
-		return v, nil
-	case json.Number:
-		return strconv.ParseInt(string(v), 10, 64)
-	default:
-		return 0, fmt.Errorf("%T is not an int", v)
-	}
-}
-
-func MarshalInt32(i int32) Marshaler {
-	return WriterFunc(func(w io.Writer) {
-		io.WriteString(w, strconv.FormatInt(int64(i), 10))
-	})
-}
-
-func UnmarshalInt32(v interface{}) (int32, error) {
-	switch v := v.(type) {
-	case string:
-		iv, err := strconv.ParseInt(v, 10, 32)
-		if err != nil {
-			return 0, err
-		}
-		return int32(iv), nil
-	case int:
-		return int32(v), nil
-	case int64:
-		return int32(v), nil
-	case json.Number:
-		iv, err := strconv.ParseInt(string(v), 10, 32)
-		if err != nil {
-			return 0, err
-		}
-		return int32(iv), nil
-	default:
-		return 0, fmt.Errorf("%T is not an int", v)
-	}
-}
--- a/vendor/github.com/99designs/gqlgen/graphql/introspection/introspection.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/introspection/introspection.go
@@ -1,72 +0,0 @@
-// introspection implements the spec defined in https://github.com/facebook/graphql/blob/master/spec/Section%204%20--%20Introspection.md#schema-introspection
-package introspection
-
-import "github.com/vektah/gqlparser/ast"
-
-type (
-	Directive struct {
-		Name        string
-		Description string
-		Locations   []string
-		Args        []InputValue
-	}
-
-	EnumValue struct {
-		Name        string
-		Description string
-		deprecation *ast.Directive
-	}
-
-	Field struct {
-		Name        string
-		Description string
-		Type        *Type
-		Args        []InputValue
-		deprecation *ast.Directive
-	}
-
-	InputValue struct {
-		Name         string
-		Description  string
-		DefaultValue *string
-		Type         *Type
-	}
-)
-
-func WrapSchema(schema *ast.Schema) *Schema {
-	return &Schema{schema: schema}
-}
-
-func (f *EnumValue) IsDeprecated() bool {
-	return f.deprecation != nil
-}
-
-func (f *EnumValue) DeprecationReason() *string {
-	if f.deprecation == nil {
-		return nil
-	}
-
-	reason := f.deprecation.Arguments.ForName("reason")
-	if reason == nil {
-		return nil
-	}
-
-	return &reason.Value.Raw
-}
-
-func (f *Field) IsDeprecated() bool {
-	return f.deprecation != nil
-}
-
-func (f *Field) DeprecationReason() *string {
-	if f.deprecation == nil {
-		return nil
-	}
-
-	reason := f.deprecation.Arguments.ForName("reason")
-	if reason == nil {
-		return nil
-	}
-
-	return &reason.Value.Raw
-}
--- a/vendor/github.com/99designs/gqlgen/graphql/introspection/query.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/introspection/query.go
@@ -1,104 +0,0 @@
-package introspection
-
-// Query is the query generated by graphiql to determine type information
-const Query = `
-query IntrospectionQuery {
-  __schema {
-    queryType {
-      name
-    }
-    mutationType {
-      name
-    }
-    subscriptionType {
-      name
-    }
-    types {
-      ...FullType
-    }
-    directives {
-      name
-      description
-      locations
-      args {
-        ...InputValue
-      }
-    }
-  }
-}
-
-fragment FullType on __Type {
-  kind
-  name
-  description
-  fields(includeDeprecated: true) {
-    name
-    description
-    args {
-      ...InputValue
-    }
-    type {
-      ...TypeRef
-    }
-    isDeprecated
-    deprecationReason
-  }
-  inputFields {
-    ...InputValue
-  }
-  interfaces {
-    ...TypeRef
-  }
-  enumValues(includeDeprecated: true) {
-    name
-    description
-    isDeprecated
-    deprecationReason
-  }
-  possibleTypes {
-    ...TypeRef
-  }
-}
-
-fragment InputValue on __InputValue {
-  name
-  description
-  type {
-    ...TypeRef
-  }
-  defaultValue
-}
-
-fragment TypeRef on __Type {
-  kind
-  name
-  ofType {
-    kind
-    name
-    ofType {
-      kind
-      name
-      ofType {
-        kind
-        name
-        ofType {
-          kind
-          name
-          ofType {
-            kind
-            name
-            ofType {
-              kind
-              name
-              ofType {
-                kind
-                name
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}
-`
--- a/vendor/github.com/99designs/gqlgen/graphql/introspection/schema.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/introspection/schema.go
@@ -1,68 +0,0 @@
-package introspection
-
-import (
-	"strings"
-
-	"github.com/vektah/gqlparser/ast"
-)
-
-type Schema struct {
-	schema *ast.Schema
-}
-
-func (s *Schema) Types() []Type {
-	var types []Type
-	for _, typ := range s.schema.Types {
-		if strings.HasPrefix(typ.Name, "__") {
-			continue
-		}
-		types = append(types, *WrapTypeFromDef(s.schema, typ))
-	}
-	return types
-}
-
-func (s *Schema) QueryType() *Type {
-	return WrapTypeFromDef(s.schema, s.schema.Query)
-}
-
-func (s *Schema) MutationType() *Type {
-	return WrapTypeFromDef(s.schema, s.schema.Mutation)
-}
-
-func (s *Schema) SubscriptionType() *Type {
-	return WrapTypeFromDef(s.schema, s.schema.Subscription)
-}
-
-func (s *Schema) Directives() []Directive {
-	var res []Directive
-
-	for _, d := range s.schema.Directives {
-		res = append(res, s.directiveFromDef(d))
-	}
-
-	return res
-}
-
-func (s *Schema) directiveFromDef(d *ast.DirectiveDefinition) Directive {
-	var locs []string
-	for _, loc := range d.Locations {
-		locs = append(locs, string(loc))
-	}
-
-	var args []InputValue
-	for _, arg := range d.Arguments {
-		args = append(args, InputValue{
-			Name:         arg.Name,
-			Description:  arg.Description,
-			DefaultValue: defaultValue(arg.DefaultValue),
-			Type:         WrapTypeFromType(s.schema, arg.Type),
-		})
-	}
-
-	return Directive{
-		Name:        d.Name,
-		Description: d.Description,
-		Locations:   locs,
-		Args:        args,
-	}
-}
--- a/vendor/github.com/99designs/gqlgen/graphql/introspection/type.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/introspection/type.go
@@ -1,176 +0,0 @@
-package introspection
-
-import (
-	"strings"
-
-	"github.com/vektah/gqlparser/ast"
-)
-
-type Type struct {
-	schema *ast.Schema
-	def    *ast.Definition
-	typ    *ast.Type
-}
-
-func WrapTypeFromDef(s *ast.Schema, def *ast.Definition) *Type {
-	if def == nil {
-		return nil
-	}
-	return &Type{schema: s, def: def}
-}
-
-func WrapTypeFromType(s *ast.Schema, typ *ast.Type) *Type {
-	if typ == nil {
-		return nil
-	}
-
-	if !typ.NonNull && typ.NamedType != "" {
-		return &Type{schema: s, def: s.Types[typ.NamedType]}
-	}
-	return &Type{schema: s, typ: typ}
-}
-
-func (t *Type) Kind() string {
-	if t.typ != nil {
-		if t.typ.NonNull {
-			return "NON_NULL"
-		}
-
-		if t.typ.Elem != nil {
-			return "LIST"
-		}
-	} else {
-		return string(t.def.Kind)
-	}
-
-	panic("UNKNOWN")
-}
-
-func (t *Type) Name() *string {
-	if t.def == nil {
-		return nil
-	}
-	return &t.def.Name
-}
-
-func (t *Type) Description() string {
-	if t.def == nil {
-		return ""
-	}
-	return t.def.Description
-}
-
-func (t *Type) Fields(includeDeprecated bool) []Field {
-	if t.def == nil || (t.def.Kind != ast.Object && t.def.Kind != ast.Interface) {
-		return []Field{}
-	}
-	fields := []Field{}
-	for _, f := range t.def.Fields {
-		if strings.HasPrefix(f.Name, "__") {
-			continue
-		}
-
-		if !includeDeprecated && f.Directives.ForName("deprecated") != nil {
-			continue
-		}
-
-		var args []InputValue
-		for _, arg := range f.Arguments {
-			args = append(args, InputValue{
-				Type:         WrapTypeFromType(t.schema, arg.Type),
-				Name:         arg.Name,
-				Description:  arg.Description,
-				DefaultValue: defaultValue(arg.DefaultValue),
-			})
-		}
-
-		fields = append(fields, Field{
-			Name:        f.Name,
-			Description: f.Description,
-			Args:        args,
-			Type:        WrapTypeFromType(t.schema, f.Type),
-			deprecation: f.Directives.ForName("deprecated"),
-		})
-	}
-	return fields
-}
-
-func (t *Type) InputFields() []InputValue {
-	if t.def == nil || t.def.Kind != ast.InputObject {
-		return []InputValue{}
-	}
-
-	res := []InputValue{}
-	for _, f := range t.def.Fields {
-		res = append(res, InputValue{
-			Name:         f.Name,
-			Description:  f.Description,
-			Type:         WrapTypeFromType(t.schema, f.Type),
-			DefaultValue: defaultValue(f.DefaultValue),
-		})
-	}
-	return res
-}
-
-func defaultValue(value *ast.Value) *string {
-	if value == nil {
-		return nil
-	}
-	val := value.String()
-	return &val
-}
-
-func (t *Type) Interfaces() []Type {
-	if t.def == nil || t.def.Kind != ast.Object {
-		return []Type{}
-	}
-
-	res := []Type{}
-	for _, intf := range t.def.Interfaces {
-		res = append(res, *WrapTypeFromDef(t.schema, t.schema.Types[intf]))
-	}
-
-	return res
-}
-
-func (t *Type) PossibleTypes() []Type {
-	if t.def == nil || (t.def.Kind != ast.Interface && t.def.Kind != ast.Union) {
-		return []Type{}
-	}
-
-	res := []Type{}
-	for _, pt := range t.schema.GetPossibleTypes(t.def) {
-		res = append(res, *WrapTypeFromDef(t.schema, pt))
-	}
-	return res
-}
-
-func (t *Type) EnumValues(includeDeprecated bool) []EnumValue {
-	if t.def == nil || t.def.Kind != ast.Enum {
-		return []EnumValue{}
-	}
-
-	res := []EnumValue{}
-	for _, val := range t.def.EnumValues {
-		res = append(res, EnumValue{
-			Name:        val.Name,
-			Description: val.Description,
-			deprecation: val.Directives.ForName("deprecated"),
-		})
-	}
-	return res
-}
-
-func (t *Type) OfType() *Type {
-	if t.typ == nil {
-		return nil
-	}
-	if t.typ.NonNull {
-		// fake non null nodes
-		cpy := *t.typ
-		cpy.NonNull = false
-
-		return WrapTypeFromType(t.schema, &cpy)
-	}
-	return WrapTypeFromType(t.schema, t.typ.Elem)
-}
--- a/vendor/github.com/99designs/gqlgen/graphql/jsonw.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/jsonw.go
@@ -1,52 +0,0 @@
-package graphql
-
-import (
-	"io"
-)
-
-var nullLit = []byte(`null`)
-var trueLit = []byte(`true`)
-var falseLit = []byte(`false`)
-var openBrace = []byte(`{`)
-var closeBrace = []byte(`}`)
-var openBracket = []byte(`[`)
-var closeBracket = []byte(`]`)
-var colon = []byte(`:`)
-var comma = []byte(`,`)
-
-var Null = &lit{nullLit}
-var True = &lit{trueLit}
-var False = &lit{falseLit}
-
-type Marshaler interface {
-	MarshalGQL(w io.Writer)
-}
-
-type Unmarshaler interface {
-	UnmarshalGQL(v interface{}) error
-}
-
-type WriterFunc func(writer io.Writer)
-
-func (f WriterFunc) MarshalGQL(w io.Writer) {
-	f(w)
-}
-
-type Array []Marshaler
-
-func (a Array) MarshalGQL(writer io.Writer) {
-	writer.Write(openBracket)
-	for i, val := range a {
-		if i != 0 {
-			writer.Write(comma)
-		}
-		val.MarshalGQL(writer)
-	}
-	writer.Write(closeBracket)
-}
-
-type lit struct{ b []byte }
-
-func (l lit) MarshalGQL(w io.Writer) {
-	w.Write(l.b)
-}
--- a/vendor/github.com/99designs/gqlgen/graphql/map.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/map.go
@@ -1,24 +0,0 @@
-package graphql
-
-import (
-	"encoding/json"
-	"fmt"
-	"io"
-)
-
-func MarshalMap(val map[string]interface{}) Marshaler {
-	return WriterFunc(func(w io.Writer) {
-		err := json.NewEncoder(w).Encode(val)
-		if err != nil {
-			panic(err)
-		}
-	})
-}
-
-func UnmarshalMap(v interface{}) (map[string]interface{}, error) {
-	if m, ok := v.(map[string]interface{}); ok {
-		return m, nil
-	}
-
-	return nil, fmt.Errorf("%T is not a map", v)
-}
--- a/vendor/github.com/99designs/gqlgen/graphql/oneshot.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/oneshot.go
@@ -1,14 +0,0 @@
-package graphql
-
-func OneShot(resp *Response) func() *Response {
-	var oneshot bool
-
-	return func() *Response {
-		if oneshot {
-			return nil
-		}
-		oneshot = true
-
-		return resp
-	}
-}
--- a/vendor/github.com/99designs/gqlgen/graphql/recovery.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/recovery.go
@@ -1,19 +0,0 @@
-package graphql
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"os"
-	"runtime/debug"
-)
-
-type RecoverFunc func(ctx context.Context, err interface{}) (userMessage error)
-
-func DefaultRecover(ctx context.Context, err interface{}) error {
-	fmt.Fprintln(os.Stderr, err)
-	fmt.Fprintln(os.Stderr)
-	debug.PrintStack()
-
-	return errors.New("internal system error")
-}
--- a/vendor/github.com/99designs/gqlgen/graphql/response.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/response.go
@@ -1,24 +0,0 @@
-package graphql
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-
-	"github.com/vektah/gqlparser/gqlerror"
-)
-
-// Errors are intentionally serialized first based on the advice in
-// https://github.com/facebook/graphql/commit/7b40390d48680b15cb93e02d46ac5eb249689876#diff-757cea6edf0288677a9eea4cfc801d87R107
-// and https://github.com/facebook/graphql/pull/384
-type Response struct {
-	Errors     gqlerror.List          `json:"errors,omitempty"`
-	Data       json.RawMessage        `json:"data"`
-	Extensions map[string]interface{} `json:"extensions,omitempty"`
-}
-
-func ErrorResponse(ctx context.Context, messagef string, args ...interface{}) *Response {
-	return &Response{
-		Errors: gqlerror.List{{Message: fmt.Sprintf(messagef, args...)}},
-	}
-}
--- a/vendor/github.com/99designs/gqlgen/graphql/root.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/root.go
@@ -1,7 +0,0 @@
-package graphql
-
-type Query struct{}
-
-type Mutation struct{}
-
-type Subscription struct{}
--- a/vendor/github.com/99designs/gqlgen/graphql/string.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/string.go
@@ -1,68 +0,0 @@
-package graphql
-
-import (
-	"fmt"
-	"io"
-	"strconv"
-)
-
-const encodeHex = "0123456789ABCDEF"
-
-func MarshalString(s string) Marshaler {
-	return WriterFunc(func(w io.Writer) {
-		writeQuotedString(w, s)
-	})
-}
-
-func writeQuotedString(w io.Writer, s string) {
-	start := 0
-	io.WriteString(w, `"`)
-
-	for i, c := range s {
-		if c < 0x20 || c == '\\' || c == '"' {
-			io.WriteString(w, s[start:i])
-
-			switch c {
-			case '\t':
-				io.WriteString(w, `\t`)
-			case '\r':
-				io.WriteString(w, `\r`)
-			case '\n':
-				io.WriteString(w, `\n`)
-			case '\\':
-				io.WriteString(w, `\\`)
-			case '"':
-				io.WriteString(w, `\"`)
-			default:
-				io.WriteString(w, `\u00`)
-				w.Write([]byte{encodeHex[c>>4], encodeHex[c&0xf]})
-			}
-
-			start = i + 1
-		}
-	}
-
-	io.WriteString(w, s[start:])
-	io.WriteString(w, `"`)
-}
-
-func UnmarshalString(v interface{}) (string, error) {
-	switch v := v.(type) {
-	case string:
-		return v, nil
-	case int:
-		return strconv.Itoa(v), nil
-	case float64:
-		return fmt.Sprintf("%f", v), nil
-	case bool:
-		if v {
-			return "true", nil
-		} else {
-			return "false", nil
-		}
-	case nil:
-		return "null", nil
-	default:
-		return "", fmt.Errorf("%T is not a string", v)
-	}
-}
--- a/vendor/github.com/99designs/gqlgen/graphql/time.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/time.go
@@ -1,25 +0,0 @@
-package graphql
-
-import (
-	"errors"
-	"io"
-	"strconv"
-	"time"
-)
-
-func MarshalTime(t time.Time) Marshaler {
-	if t.IsZero() {
-		return Null
-	}
-
-	return WriterFunc(func(w io.Writer) {
-		io.WriteString(w, strconv.Quote(t.Format(time.RFC3339)))
-	})
-}
-
-func UnmarshalTime(v interface{}) (time.Time, error) {
-	if tmpStr, ok := v.(string); ok {
-		return time.Parse(time.RFC3339, tmpStr)
-	}
-	return time.Time{}, errors.New("time should be RFC3339 formatted string")
-}
--- a/vendor/github.com/99designs/gqlgen/graphql/tracer.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/tracer.go
@@ -1,58 +0,0 @@
-package graphql
-
-import (
-	"context"
-)
-
-var _ Tracer = (*NopTracer)(nil)
-
-type Tracer interface {
-	StartOperationParsing(ctx context.Context) context.Context
-	EndOperationParsing(ctx context.Context)
-	StartOperationValidation(ctx context.Context) context.Context
-	EndOperationValidation(ctx context.Context)
-	StartOperationExecution(ctx context.Context) context.Context
-	StartFieldExecution(ctx context.Context, field CollectedField) context.Context
-	StartFieldResolverExecution(ctx context.Context, rc *ResolverContext) context.Context
-	StartFieldChildExecution(ctx context.Context) context.Context
-	EndFieldExecution(ctx context.Context)
-	EndOperationExecution(ctx context.Context)
-}
-
-type NopTracer struct{}
-
-func (NopTracer) StartOperationParsing(ctx context.Context) context.Context {
-	return ctx
-}
-
-func (NopTracer) EndOperationParsing(ctx context.Context) {
-}
-
-func (NopTracer) StartOperationValidation(ctx context.Context) context.Context {
-	return ctx
-}
-
-func (NopTracer) EndOperationValidation(ctx context.Context) {
-}
-
-func (NopTracer) StartOperationExecution(ctx context.Context) context.Context {
-	return ctx
-}
-
-func (NopTracer) StartFieldExecution(ctx context.Context, field CollectedField) context.Context {
-	return ctx
-}
-
-func (NopTracer) StartFieldResolverExecution(ctx context.Context, rc *ResolverContext) context.Context {
-	return ctx
-}
-
-func (NopTracer) StartFieldChildExecution(ctx context.Context) context.Context {
-	return ctx
-}
-
-func (NopTracer) EndFieldExecution(ctx context.Context) {
-}
-
-func (NopTracer) EndOperationExecution(ctx context.Context) {
-}
--- a/vendor/github.com/99designs/gqlgen/graphql/upload.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/upload.go
@@ -1,26 +0,0 @@
-package graphql
-
-import (
-	"fmt"
-	"io"
-)
-
-type Upload struct {
-	File     io.Reader
-	Filename string
-	Size     int64
-}
-
-func MarshalUpload(f Upload) Marshaler {
-	return WriterFunc(func(w io.Writer) {
-		io.Copy(w, f.File)
-	})
-}
-
-func UnmarshalUpload(v interface{}) (Upload, error) {
-	upload, ok := v.(Upload)
-	if !ok {
-		return Upload{}, fmt.Errorf("%T is not an Upload", v)
-	}
-	return upload, nil
-}
--- a/vendor/github.com/99designs/gqlgen/graphql/version.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/version.go
@@ -1,3 +0,0 @@
-package graphql
-
-const Version = "v0.9.0"
--- a/vendor/github.com/99designs/gqlgen/handler/context.go
+++ b/vendor/github.com/99designs/gqlgen/handler/context.go
@@ -1,57 +0,0 @@
-package handler
-
-import "context"
-
-type key string
-
-const (
-	initpayload key = "ws_initpayload_context"
-)
-
-// InitPayload is a structure that is parsed from the websocket init message payload. TO use
-// request headers for non-websocket, instead wrap the graphql handler in a middleware.
-type InitPayload map[string]interface{}
-
-// GetString safely gets a string value from the payload. It returns an empty string if the
-// payload is nil or the value isn't set.
-func (payload InitPayload) GetString(key string) string {
-	if payload == nil {
-		return ""
-	}
-
-	if value, ok := payload[key]; ok {
-		res, _ := value.(string)
-		return res
-	}
-
-	return ""
-}
-
-// Authorization is a short hand for getting the Authorization header from the
-// payload.
-func (payload InitPayload) Authorization() string {
-	if value := payload.GetString("Authorization"); value != "" {
-		return value
-	}
-
-	if value := payload.GetString("authorization"); value != "" {
-		return value
-	}
-
-	return ""
-}
-
-func withInitPayload(ctx context.Context, payload InitPayload) context.Context {
-	return context.WithValue(ctx, initpayload, payload)
-}
-
-// GetInitPayload gets a map of the data sent with the connection_init message, which is used by
-// graphql clients as a stand-in for HTTP headers.
-func GetInitPayload(ctx context.Context) InitPayload {
-	payload, ok := ctx.Value(initpayload).(InitPayload)
-	if !ok {
-		return nil
-	}
-
-	return payload
-}
--- a/vendor/github.com/99designs/gqlgen/handler/graphql.go
+++ b/vendor/github.com/99designs/gqlgen/handler/graphql.go
@@ -1,709 +0,0 @@
-package handler
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"mime"
-	"net/http"
-	"os"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/99designs/gqlgen/complexity"
-	"github.com/99designs/gqlgen/graphql"
-	"github.com/gorilla/websocket"
-	lru "github.com/hashicorp/golang-lru"
-	"github.com/vektah/gqlparser/ast"
-	"github.com/vektah/gqlparser/gqlerror"
-	"github.com/vektah/gqlparser/parser"
-	"github.com/vektah/gqlparser/validator"
-)
-
-type params struct {
-	Query         string                 `json:"query"`
-	OperationName string                 `json:"operationName"`
-	Variables     map[string]interface{} `json:"variables"`
-}
-
-type Config struct {
-	cacheSize                       int
-	upgrader                        websocket.Upgrader
-	recover                         graphql.RecoverFunc
-	errorPresenter                  graphql.ErrorPresenterFunc
-	resolverHook                    graphql.FieldMiddleware
-	requestHook                     graphql.RequestMiddleware
-	tracer                          graphql.Tracer
-	complexityLimit                 int
-	complexityLimitFunc             graphql.ComplexityLimitFunc
-	disableIntrospection            bool
-	connectionKeepAlivePingInterval time.Duration
-	uploadMaxMemory                 int64
-	uploadMaxSize                   int64
-}
-
-func (c *Config) newRequestContext(es graphql.ExecutableSchema, doc *ast.QueryDocument, op *ast.OperationDefinition, query string, variables map[string]interface{}) *graphql.RequestContext {
-	reqCtx := graphql.NewRequestContext(doc, query, variables)
-	reqCtx.DisableIntrospection = c.disableIntrospection
-
-	if hook := c.recover; hook != nil {
-		reqCtx.Recover = hook
-	}
-
-	if hook := c.errorPresenter; hook != nil {
-		reqCtx.ErrorPresenter = hook
-	}
-
-	if hook := c.resolverHook; hook != nil {
-		reqCtx.ResolverMiddleware = hook
-	}
-
-	if hook := c.requestHook; hook != nil {
-		reqCtx.RequestMiddleware = hook
-	}
-
-	if hook := c.tracer; hook != nil {
-		reqCtx.Tracer = hook
-	}
-
-	if c.complexityLimit > 0 || c.complexityLimitFunc != nil {
-		reqCtx.ComplexityLimit = c.complexityLimit
-		operationComplexity := complexity.Calculate(es, op, variables)
-		reqCtx.OperationComplexity = operationComplexity
-	}
-
-	return reqCtx
-}
-
-type Option func(cfg *Config)
-
-func WebsocketUpgrader(upgrader websocket.Upgrader) Option {
-	return func(cfg *Config) {
-		cfg.upgrader = upgrader
-	}
-}
-
-func RecoverFunc(recover graphql.RecoverFunc) Option {
-	return func(cfg *Config) {
-		cfg.recover = recover
-	}
-}
-
-// ErrorPresenter transforms errors found while resolving into errors that will be returned to the user. It provides
-// a good place to add any extra fields, like error.type, that might be desired by your frontend. Check the default
-// implementation in graphql.DefaultErrorPresenter for an example.
-func ErrorPresenter(f graphql.ErrorPresenterFunc) Option {
-	return func(cfg *Config) {
-		cfg.errorPresenter = f
-	}
-}
-
-// IntrospectionEnabled = false will forbid clients from calling introspection endpoints. Can be useful in prod when you dont
-// want clients introspecting the full schema.
-func IntrospectionEnabled(enabled bool) Option {
-	return func(cfg *Config) {
-		cfg.disableIntrospection = !enabled
-	}
-}
-
-// ComplexityLimit sets a maximum query complexity that is allowed to be executed.
-// If a query is submitted that exceeds the limit, a 422 status code will be returned.
-func ComplexityLimit(limit int) Option {
-	return func(cfg *Config) {
-		cfg.complexityLimit = limit
-	}
-}
-
-// ComplexityLimitFunc allows you to define a function to dynamically set the maximum query complexity that is allowed
-// to be executed.
-// If a query is submitted that exceeds the limit, a 422 status code will be returned.
-func ComplexityLimitFunc(complexityLimitFunc graphql.ComplexityLimitFunc) Option {
-	return func(cfg *Config) {
-		cfg.complexityLimitFunc = complexityLimitFunc
-	}
-}
-
-// ResolverMiddleware allows you to define a function that will be called around every resolver,
-// useful for logging.
-func ResolverMiddleware(middleware graphql.FieldMiddleware) Option {
-	return func(cfg *Config) {
-		if cfg.resolverHook == nil {
-			cfg.resolverHook = middleware
-			return
-		}
-
-		lastResolve := cfg.resolverHook
-		cfg.resolverHook = func(ctx context.Context, next graphql.Resolver) (res interface{}, err error) {
-			return lastResolve(ctx, func(ctx context.Context) (res interface{}, err error) {
-				return middleware(ctx, next)
-			})
-		}
-	}
-}
-
-// RequestMiddleware allows you to define a function that will be called around the root request,
-// after the query has been parsed. This is useful for logging
-func RequestMiddleware(middleware graphql.RequestMiddleware) Option {
-	return func(cfg *Config) {
-		if cfg.requestHook == nil {
-			cfg.requestHook = middleware
-			return
-		}
-
-		lastResolve := cfg.requestHook
-		cfg.requestHook = func(ctx context.Context, next func(ctx context.Context) []byte) []byte {
-			return lastResolve(ctx, func(ctx context.Context) []byte {
-				return middleware(ctx, next)
-			})
-		}
-	}
-}
-
-// Tracer allows you to add a request/resolver tracer that will be called around the root request,
-// calling resolver. This is useful for tracing
-func Tracer(tracer graphql.Tracer) Option {
-	return func(cfg *Config) {
-		if cfg.tracer == nil {
-			cfg.tracer = tracer
-
-		} else {
-			lastResolve := cfg.tracer
-			cfg.tracer = &tracerWrapper{
-				tracer1: lastResolve,
-				tracer2: tracer,
-			}
-		}
-
-		opt := RequestMiddleware(func(ctx context.Context, next func(ctx context.Context) []byte) []byte {
-			ctx = tracer.StartOperationExecution(ctx)
-			resp := next(ctx)
-			tracer.EndOperationExecution(ctx)
-
-			return resp
-		})
-		opt(cfg)
-	}
-}
-
-type tracerWrapper struct {
-	tracer1 graphql.Tracer
-	tracer2 graphql.Tracer
-}
-
-func (tw *tracerWrapper) StartOperationParsing(ctx context.Context) context.Context {
-	ctx = tw.tracer1.StartOperationParsing(ctx)
-	ctx = tw.tracer2.StartOperationParsing(ctx)
-	return ctx
-}
-
-func (tw *tracerWrapper) EndOperationParsing(ctx context.Context) {
-	tw.tracer2.EndOperationParsing(ctx)
-	tw.tracer1.EndOperationParsing(ctx)
-}
-
-func (tw *tracerWrapper) StartOperationValidation(ctx context.Context) context.Context {
-	ctx = tw.tracer1.StartOperationValidation(ctx)
-	ctx = tw.tracer2.StartOperationValidation(ctx)
-	return ctx
-}
-
-func (tw *tracerWrapper) EndOperationValidation(ctx context.Context) {
-	tw.tracer2.EndOperationValidation(ctx)
-	tw.tracer1.EndOperationValidation(ctx)
-}
-
-func (tw *tracerWrapper) StartOperationExecution(ctx context.Context) context.Context {
-	ctx = tw.tracer1.StartOperationExecution(ctx)
-	ctx = tw.tracer2.StartOperationExecution(ctx)
-	return ctx
-}
-
-func (tw *tracerWrapper) StartFieldExecution(ctx context.Context, field graphql.CollectedField) context.Context {
-	ctx = tw.tracer1.StartFieldExecution(ctx, field)
-	ctx = tw.tracer2.StartFieldExecution(ctx, field)
-	return ctx
-}
-
-func (tw *tracerWrapper) StartFieldResolverExecution(ctx context.Context, rc *graphql.ResolverContext) context.Context {
-	ctx = tw.tracer1.StartFieldResolverExecution(ctx, rc)
-	ctx = tw.tracer2.StartFieldResolverExecution(ctx, rc)
-	return ctx
-}
-
-func (tw *tracerWrapper) StartFieldChildExecution(ctx context.Context) context.Context {
-	ctx = tw.tracer1.StartFieldChildExecution(ctx)
-	ctx = tw.tracer2.StartFieldChildExecution(ctx)
-	return ctx
-}
-
-func (tw *tracerWrapper) EndFieldExecution(ctx context.Context) {
-	tw.tracer2.EndFieldExecution(ctx)
-	tw.tracer1.EndFieldExecution(ctx)
-}
-
-func (tw *tracerWrapper) EndOperationExecution(ctx context.Context) {
-	tw.tracer2.EndOperationExecution(ctx)
-	tw.tracer1.EndOperationExecution(ctx)
-}
-
-// CacheSize sets the maximum size of the query cache.
-// If size is less than or equal to 0, the cache is disabled.
-func CacheSize(size int) Option {
-	return func(cfg *Config) {
-		cfg.cacheSize = size
-	}
-}
-
-// UploadMaxSize sets the maximum number of bytes used to parse a request body
-// as multipart/form-data.
-func UploadMaxSize(size int64) Option {
-	return func(cfg *Config) {
-		cfg.uploadMaxSize = size
-	}
-}
-
-// UploadMaxMemory sets the maximum number of bytes used to parse a request body
-// as multipart/form-data in memory, with the remainder stored on disk in
-// temporary files.
-func UploadMaxMemory(size int64) Option {
-	return func(cfg *Config) {
-		cfg.uploadMaxMemory = size
-	}
-}
-
-// WebsocketKeepAliveDuration allows you to reconfigure the keepalive behavior.
-// By default, keepalive is enabled with a DefaultConnectionKeepAlivePingInterval
-// duration. Set handler.connectionKeepAlivePingInterval = 0 to disable keepalive
-// altogether.
-func WebsocketKeepAliveDuration(duration time.Duration) Option {
-	return func(cfg *Config) {
-		cfg.connectionKeepAlivePingInterval = duration
-	}
-}
-
-const DefaultCacheSize = 1000
-const DefaultConnectionKeepAlivePingInterval = 25 * time.Second
-
-// DefaultUploadMaxMemory is the maximum number of bytes used to parse a request body
-// as multipart/form-data in memory, with the remainder stored on disk in
-// temporary files.
-const DefaultUploadMaxMemory = 32 << 20
-
-// DefaultUploadMaxSize is maximum number of bytes used to parse a request body
-// as multipart/form-data.
-const DefaultUploadMaxSize = 32 << 20
-
-func GraphQL(exec graphql.ExecutableSchema, options ...Option) http.HandlerFunc {
-	cfg := &Config{
-		cacheSize:                       DefaultCacheSize,
-		uploadMaxMemory:                 DefaultUploadMaxMemory,
-		uploadMaxSize:                   DefaultUploadMaxSize,
-		connectionKeepAlivePingInterval: DefaultConnectionKeepAlivePingInterval,
-		upgrader: websocket.Upgrader{
-			ReadBufferSize:  1024,
-			WriteBufferSize: 1024,
-		},
-	}
-
-	for _, option := range options {
-		option(cfg)
-	}
-
-	var cache *lru.Cache
-	if cfg.cacheSize > 0 {
-		var err error
-		cache, err = lru.New(cfg.cacheSize)
-		if err != nil {
-			// An error is only returned for non-positive cache size
-			// and we already checked for that.
-			panic("unexpected error creating cache: " + err.Error())
-		}
-	}
-	if cfg.tracer == nil {
-		cfg.tracer = &graphql.NopTracer{}
-	}
-
-	handler := &graphqlHandler{
-		cfg:   cfg,
-		cache: cache,
-		exec:  exec,
-	}
-
-	return handler.ServeHTTP
-}
-
-var _ http.Handler = (*graphqlHandler)(nil)
-
-type graphqlHandler struct {
-	cfg   *Config
-	cache *lru.Cache
-	exec  graphql.ExecutableSchema
-}
-
-func (gh *graphqlHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	if r.Method == http.MethodOptions {
-		w.Header().Set("Allow", "OPTIONS, GET, POST")
-		w.WriteHeader(http.StatusOK)
-		return
-	}
-
-	if strings.Contains(r.Header.Get("Upgrade"), "websocket") {
-		connectWs(gh.exec, w, r, gh.cfg, gh.cache)
-		return
-	}
-
-	w.Header().Set("Content-Type", "application/json")
-	var reqParams params
-	switch r.Method {
-	case http.MethodGet:
-		reqParams.Query = r.URL.Query().Get("query")
-		reqParams.OperationName = r.URL.Query().Get("operationName")
-
-		if variables := r.URL.Query().Get("variables"); variables != "" {
-			if err := jsonDecode(strings.NewReader(variables), &reqParams.Variables); err != nil {
-				sendErrorf(w, http.StatusBadRequest, "variables could not be decoded")
-				return
-			}
-		}
-	case http.MethodPost:
-		mediaType, _, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
-		if err != nil {
-			sendErrorf(w, http.StatusBadRequest, "error parsing request Content-Type")
-			return
-		}
-
-		switch mediaType {
-		case "application/json":
-			if err := jsonDecode(r.Body, &reqParams); err != nil {
-				sendErrorf(w, http.StatusBadRequest, "json body could not be decoded: "+err.Error())
-				return
-			}
-
-		case "multipart/form-data":
-			var closers []io.Closer
-			var tmpFiles []string
-			defer func() {
-				for i := len(closers) - 1; 0 <= i; i-- {
-					_ = closers[i].Close()
-				}
-				for _, tmpFile := range tmpFiles {
-					_ = os.Remove(tmpFile)
-				}
-			}()
-			if err := processMultipart(w, r, &reqParams, &closers, &tmpFiles, gh.cfg.uploadMaxSize, gh.cfg.uploadMaxMemory); err != nil {
-				sendErrorf(w, http.StatusBadRequest, "multipart body could not be decoded: "+err.Error())
-				return
-			}
-		default:
-			sendErrorf(w, http.StatusBadRequest, "unsupported Content-Type: "+mediaType)
-			return
-		}
-	default:
-		w.WriteHeader(http.StatusMethodNotAllowed)
-		return
-	}
-
-	ctx := r.Context()
-
-	var doc *ast.QueryDocument
-	var cacheHit bool
-	if gh.cache != nil {
-		val, ok := gh.cache.Get(reqParams.Query)
-		if ok {
-			doc = val.(*ast.QueryDocument)
-			cacheHit = true
-		}
-	}
-
-	ctx, doc, gqlErr := gh.parseOperation(ctx, &parseOperationArgs{
-		Query:     reqParams.Query,
-		CachedDoc: doc,
-	})
-	if gqlErr != nil {
-		sendError(w, http.StatusUnprocessableEntity, gqlErr)
-		return
-	}
-
-	ctx, op, vars, listErr := gh.validateOperation(ctx, &validateOperationArgs{
-		Doc:           doc,
-		OperationName: reqParams.OperationName,
-		CacheHit:      cacheHit,
-		R:             r,
-		Variables:     reqParams.Variables,
-	})
-	if len(listErr) != 0 {
-		sendError(w, http.StatusUnprocessableEntity, listErr...)
-		return
-	}
-
-	if gh.cache != nil && !cacheHit {
-		gh.cache.Add(reqParams.Query, doc)
-	}
-
-	reqCtx := gh.cfg.newRequestContext(gh.exec, doc, op, reqParams.Query, vars)
-	ctx = graphql.WithRequestContext(ctx, reqCtx)
-
-	defer func() {
-		if err := recover(); err != nil {
-			userErr := reqCtx.Recover(ctx, err)
-			sendErrorf(w, http.StatusUnprocessableEntity, userErr.Error())
-		}
-	}()
-
-	if gh.cfg.complexityLimitFunc != nil {
-		reqCtx.ComplexityLimit = gh.cfg.complexityLimitFunc(ctx)
-	}
-
-	if reqCtx.ComplexityLimit > 0 && reqCtx.OperationComplexity > reqCtx.ComplexityLimit {
-		sendErrorf(w, http.StatusUnprocessableEntity, "operation has complexity %d, which exceeds the limit of %d", reqCtx.OperationComplexity, reqCtx.ComplexityLimit)
-		return
-	}
-
-	switch op.Operation {
-	case ast.Query:
-		b, err := json.Marshal(gh.exec.Query(ctx, op))
-		if err != nil {
-			panic(err)
-		}
-		w.Write(b)
-	case ast.Mutation:
-		b, err := json.Marshal(gh.exec.Mutation(ctx, op))
-		if err != nil {
-			panic(err)
-		}
-		w.Write(b)
-	default:
-		sendErrorf(w, http.StatusBadRequest, "unsupported operation type")
-	}
-}
-
-type parseOperationArgs struct {
-	Query     string
-	CachedDoc *ast.QueryDocument
-}
-
-func (gh *graphqlHandler) parseOperation(ctx context.Context, args *parseOperationArgs) (context.Context, *ast.QueryDocument, *gqlerror.Error) {
-	ctx = gh.cfg.tracer.StartOperationParsing(ctx)
-	defer func() { gh.cfg.tracer.EndOperationParsing(ctx) }()
-
-	if args.CachedDoc != nil {
-		return ctx, args.CachedDoc, nil
-	}
-
-	doc, gqlErr := parser.ParseQuery(&ast.Source{Input: args.Query})
-	if gqlErr != nil {
-		return ctx, nil, gqlErr
-	}
-
-	return ctx, doc, nil
-}
-
-type validateOperationArgs struct {
-	Doc           *ast.QueryDocument
-	OperationName string
-	CacheHit      bool
-	R             *http.Request
-	Variables     map[string]interface{}
-}
-
-func (gh *graphqlHandler) validateOperation(ctx context.Context, args *validateOperationArgs) (context.Context, *ast.OperationDefinition, map[string]interface{}, gqlerror.List) {
-	ctx = gh.cfg.tracer.StartOperationValidation(ctx)
-	defer func() { gh.cfg.tracer.EndOperationValidation(ctx) }()
-
-	if !args.CacheHit {
-		listErr := validator.Validate(gh.exec.Schema(), args.Doc)
-		if len(listErr) != 0 {
-			return ctx, nil, nil, listErr
-		}
-	}
-
-	op := args.Doc.Operations.ForName(args.OperationName)
-	if op == nil {
-		return ctx, nil, nil, gqlerror.List{gqlerror.Errorf("operation %s not found", args.OperationName)}
-	}
-
-	if op.Operation != ast.Query && args.R.Method == http.MethodGet {
-		return ctx, nil, nil, gqlerror.List{gqlerror.Errorf("GET requests only allow query operations")}
-	}
-
-	vars, err := validator.VariableValues(gh.exec.Schema(), op, args.Variables)
-	if err != nil {
-		return ctx, nil, nil, gqlerror.List{err}
-	}
-
-	return ctx, op, vars, nil
-}
-
-func jsonDecode(r io.Reader, val interface{}) error {
-	dec := json.NewDecoder(r)
-	dec.UseNumber()
-	return dec.Decode(val)
-}
-
-func sendError(w http.ResponseWriter, code int, errors ...*gqlerror.Error) {
-	w.WriteHeader(code)
-	b, err := json.Marshal(&graphql.Response{Errors: errors})
-	if err != nil {
-		panic(err)
-	}
-	w.Write(b)
-}
-
-func sendErrorf(w http.ResponseWriter, code int, format string, args ...interface{}) {
-	sendError(w, code, &gqlerror.Error{Message: fmt.Sprintf(format, args...)})
-}
-
-type bytesReader struct {
-	s        *[]byte
-	i        int64 // current reading index
-	prevRune int   // index of previous rune; or < 0
-}
-
-func (r *bytesReader) Read(b []byte) (n int, err error) {
-	if r.s == nil {
-		return 0, errors.New("byte slice pointer is nil")
-	}
-	if r.i >= int64(len(*r.s)) {
-		return 0, io.EOF
-	}
-	r.prevRune = -1
-	n = copy(b, (*r.s)[r.i:])
-	r.i += int64(n)
-	return
-}
-
-func processMultipart(w http.ResponseWriter, r *http.Request, request *params, closers *[]io.Closer, tmpFiles *[]string, uploadMaxSize, uploadMaxMemory int64) error {
-	var err error
-	if r.ContentLength > uploadMaxSize {
-		return errors.New("failed to parse multipart form, request body too large")
-	}
-	r.Body = http.MaxBytesReader(w, r.Body, uploadMaxSize)
-	if err = r.ParseMultipartForm(uploadMaxMemory); err != nil {
-		if strings.Contains(err.Error(), "request body too large") {
-			return errors.New("failed to parse multipart form, request body too large")
-		}
-		return errors.New("failed to parse multipart form")
-	}
-	*closers = append(*closers, r.Body)
-
-	if err = jsonDecode(strings.NewReader(r.Form.Get("operations")), &request); err != nil {
-		return errors.New("operations form field could not be decoded")
-	}
-
-	var uploadsMap = map[string][]string{}
-	if err = json.Unmarshal([]byte(r.Form.Get("map")), &uploadsMap); err != nil {
-		return errors.New("map form field could not be decoded")
-	}
-
-	var upload graphql.Upload
-	for key, paths := range uploadsMap {
-		if len(paths) == 0 {
-			return fmt.Errorf("invalid empty operations paths list for key %s", key)
-		}
-		file, header, err := r.FormFile(key)
-		if err != nil {
-			return fmt.Errorf("failed to get key %s from form", key)
-		}
-		*closers = append(*closers, file)
-
-		if len(paths) == 1 {
-			upload = graphql.Upload{
-				File:     file,
-				Size:     header.Size,
-				Filename: header.Filename,
-			}
-			err = addUploadToOperations(request, upload, key, paths[0])
-			if err != nil {
-				return err
-			}
-		} else {
-			if r.ContentLength < uploadMaxMemory {
-				fileBytes, err := ioutil.ReadAll(file)
-				if err != nil {
-					return fmt.Errorf("failed to read file for key %s", key)
-				}
-				for _, path := range paths {
-					upload = graphql.Upload{
-						File:     &bytesReader{s: &fileBytes, i: 0, prevRune: -1},
-						Size:     header.Size,
-						Filename: header.Filename,
-					}
-					err = addUploadToOperations(request, upload, key, path)
-					if err != nil {
-						return err
-					}
-				}
-			} else {
-				tmpFile, err := ioutil.TempFile(os.TempDir(), "gqlgen-")
-				if err != nil {
-					return fmt.Errorf("failed to create temp file for key %s", key)
-				}
-				tmpName := tmpFile.Name()
-				*tmpFiles = append(*tmpFiles, tmpName)
-				_, err = io.Copy(tmpFile, file)
-				if err != nil {
-					if err := tmpFile.Close(); err != nil {
-						return fmt.Errorf("failed to copy to temp file and close temp file for key %s", key)
-					}
-					return fmt.Errorf("failed to copy to temp file for key %s", key)
-				}
-				if err := tmpFile.Close(); err != nil {
-					return fmt.Errorf("failed to close temp file for key %s", key)
-				}
-				for _, path := range paths {
-					pathTmpFile, err := os.Open(tmpName)
-					if err != nil {
-						return fmt.Errorf("failed to open temp file for key %s", key)
-					}
-					*closers = append(*closers, pathTmpFile)
-					upload = graphql.Upload{
-						File:     pathTmpFile,
-						Size:     header.Size,
-						Filename: header.Filename,
-					}
-					err = addUploadToOperations(request, upload, key, path)
-					if err != nil {
-						return err
-					}
-				}
-			}
-		}
-	}
-	return nil
-}
-
-func addUploadToOperations(request *params, upload graphql.Upload, key, path string) error {
-	if !strings.HasPrefix(path, "variables.") {
-		return fmt.Errorf("invalid operations paths for key %s", key)
-	}
-
-	var ptr interface{} = request.Variables
-	parts := strings.Split(path, ".")
-
-	// skip the first part (variables) because we started there
-	for i, p := range parts[1:] {
-		last := i == len(parts)-2
-		if ptr == nil {
-			return fmt.Errorf("path is missing \"variables.\" prefix, key: %s, path: %s", key, path)
-		}
-		if index, parseNbrErr := strconv.Atoi(p); parseNbrErr == nil {
-			if last {
-				ptr.([]interface{})[index] = upload
-			} else {
-				ptr = ptr.([]interface{})[index]
-			}
-		} else {
-			if last {
-				ptr.(map[string]interface{})[p] = upload
-			} else {
-				ptr = ptr.(map[string]interface{})[p]
-			}
-		}
-	}
-
-	return nil
-}
--- a/vendor/github.com/99designs/gqlgen/handler/mock.go
+++ b/vendor/github.com/99designs/gqlgen/handler/mock.go
@@ -1,57 +0,0 @@
-package handler
-
-import (
-	"context"
-
-	"github.com/99designs/gqlgen/graphql"
-	"github.com/vektah/gqlparser"
-	"github.com/vektah/gqlparser/ast"
-)
-
-type executableSchemaMock struct {
-	MutationFunc func(ctx context.Context, op *ast.OperationDefinition) *graphql.Response
-}
-
-var _ graphql.ExecutableSchema = &executableSchemaMock{}
-
-func (e *executableSchemaMock) Schema() *ast.Schema {
-	return gqlparser.MustLoadSchema(&ast.Source{Input: `
-		schema { query: Query, mutation: Mutation }
-		type Query {
-			empty: String!
-		}
-		scalar Upload
-        type File {
-            id: Int!
-        }
-        input UploadFile {
-            id: Int!
-            file: Upload!
-        }
-        type Mutation {
-            singleUpload(file: Upload!): File!
-            singleUploadWithPayload(req: UploadFile!): File!
-            multipleUpload(files: [Upload!]!): [File!]!
-            multipleUploadWithPayload(req: [UploadFile!]!): [File!]!
-        }
-	`})
-}
-
-func (e *executableSchemaMock) Complexity(typeName, field string, childComplexity int, args map[string]interface{}) (int, bool) {
-	return 0, false
-}
-
-func (e *executableSchemaMock) Query(ctx context.Context, op *ast.OperationDefinition) *graphql.Response {
-	return graphql.ErrorResponse(ctx, "queries are not supported")
-}
-
-func (e *executableSchemaMock) Mutation(ctx context.Context, op *ast.OperationDefinition) *graphql.Response {
-	return e.MutationFunc(ctx, op)
-}
-
-func (e *executableSchemaMock) Subscription(ctx context.Context, op *ast.OperationDefinition) func() *graphql.Response {
-	return func() *graphql.Response {
-		<-ctx.Done()
-		return nil
-	}
-}
--- a/vendor/github.com/99designs/gqlgen/handler/playground.go
+++ b/vendor/github.com/99designs/gqlgen/handler/playground.go
@@ -1,61 +0,0 @@
-package handler
-
-import (
-	"html/template"
-	"net/http"
-)
-
-var page = template.Must(template.New("graphiql").Parse(`<!DOCTYPE html>
-<html>
-<head>
-	<meta charset=utf-8/>
-	<meta name="viewport" content="user-scalable=no, initial-scale=1.0, minimum-scale=1.0, maximum-scale=1.0, minimal-ui">
-	<link rel="shortcut icon" href="https://graphcool-playground.netlify.com/favicon.png">
-	<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/graphql-playground-react@{{ .version }}/build/static/css/index.css" 
-		integrity="{{ .cssSRI }}" crossorigin="anonymous"/>
-	<link rel="shortcut icon" href="https://cdn.jsdelivr.net/npm/graphql-playground-react@{{ .version }}/build/favicon.png"
-		integrity="{{ .faviconSRI }}" crossorigin="anonymous"/>
-	<script src="https://cdn.jsdelivr.net/npm/graphql-playground-react@{{ .version }}/build/static/js/middleware.js"
-		integrity="{{ .jsSRI }}" crossorigin="anonymous"></script>
-	<title>{{.title}}</title>
-</head>
-<body>
-<style type="text/css">
-	html { font-family: "Open Sans", sans-serif; overflow: hidden; }
-	body { margin: 0; background: #172a3a; }
-</style>
-<div id="root"/>
-<script type="text/javascript">
-	window.addEventListener('load', function (event) {
-		const root = document.getElementById('root');
-		root.classList.add('playgroundIn');
-		const wsProto = location.protocol == 'https:' ? 'wss:' : 'ws:'
-		GraphQLPlayground.init(root, {
-			endpoint: location.protocol + '//' + location.host + '{{.endpoint}}',
-			subscriptionsEndpoint: wsProto + '//' + location.host + '{{.endpoint }}',
-			settings: {
-				'request.credentials': 'same-origin'
-			}
-		})
-	})
-</script>
-</body>
-</html>
-`))
-
-func Playground(title string, endpoint string) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Add("Content-Type", "text/html")
-		err := page.Execute(w, map[string]string{
-			"title":      title,
-			"endpoint":   endpoint,
-			"version":    "1.7.20",
-			"cssSRI":     "sha256-cS9Vc2OBt9eUf4sykRWukeFYaInL29+myBmFDSa7F/U=",
-			"faviconSRI": "sha256-GhTyE+McTU79R4+pRO6ih+4TfsTOrpPwD8ReKFzb3PM=",
-			"jsSRI":      "sha256-4QG1Uza2GgGdlBL3RCBCGtGeZB6bDbsw8OltCMGeJsA=",
-		})
-		if err != nil {
-			panic(err)
-		}
-	}
-}
--- a/vendor/github.com/99designs/gqlgen/handler/stub.go
+++ b/vendor/github.com/99designs/gqlgen/handler/stub.go
@@ -1,51 +0,0 @@
-package handler
-
-import (
-	"context"
-
-	"github.com/99designs/gqlgen/graphql"
-	"github.com/vektah/gqlparser"
-	"github.com/vektah/gqlparser/ast"
-)
-
-type executableSchemaStub struct {
-	NextResp chan struct{}
-}
-
-var _ graphql.ExecutableSchema = &executableSchemaStub{}
-
-func (e *executableSchemaStub) Schema() *ast.Schema {
-	return gqlparser.MustLoadSchema(&ast.Source{Input: `
-		schema { query: Query }
-		type Query {
-			me: User!
-			user(id: Int): User!
-		}
-		type User { name: String! }
-	`})
-}
-
-func (e *executableSchemaStub) Complexity(typeName, field string, childComplexity int, args map[string]interface{}) (int, bool) {
-	return 0, false
-}
-
-func (e *executableSchemaStub) Query(ctx context.Context, op *ast.OperationDefinition) *graphql.Response {
-	return &graphql.Response{Data: []byte(`{"name":"test"}`)}
-}
-
-func (e *executableSchemaStub) Mutation(ctx context.Context, op *ast.OperationDefinition) *graphql.Response {
-	return graphql.ErrorResponse(ctx, "mutations are not supported")
-}
-
-func (e *executableSchemaStub) Subscription(ctx context.Context, op *ast.OperationDefinition) func() *graphql.Response {
-	return func() *graphql.Response {
-		select {
-		case <-ctx.Done():
-			return nil
-		case <-e.NextResp:
-			return &graphql.Response{
-				Data: []byte(`{"name":"test"}`),
-			}
-		}
-	}
-}
--- a/vendor/github.com/99designs/gqlgen/handler/websocket.go
+++ b/vendor/github.com/99designs/gqlgen/handler/websocket.go
@@ -1,314 +0,0 @@
-package handler
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"fmt"
-	"log"
-	"net/http"
-	"sync"
-	"time"
-
-	"github.com/99designs/gqlgen/graphql"
-	"github.com/gorilla/websocket"
-	"github.com/hashicorp/golang-lru"
-	"github.com/vektah/gqlparser"
-	"github.com/vektah/gqlparser/ast"
-	"github.com/vektah/gqlparser/gqlerror"
-	"github.com/vektah/gqlparser/validator"
-)
-
-const (
-	connectionInitMsg      = "connection_init"      // Client -> Server
-	connectionTerminateMsg = "connection_terminate" // Client -> Server
-	startMsg               = "start"                // Client -> Server
-	stopMsg                = "stop"                 // Client -> Server
-	connectionAckMsg       = "connection_ack"       // Server -> Client
-	connectionErrorMsg     = "connection_error"     // Server -> Client
-	dataMsg                = "data"                 // Server -> Client
-	errorMsg               = "error"                // Server -> Client
-	completeMsg            = "complete"             // Server -> Client
-	connectionKeepAliveMsg = "ka"                   // Server -> Client
-)
-
-type operationMessage struct {
-	Payload json.RawMessage `json:"payload,omitempty"`
-	ID      string          `json:"id,omitempty"`
-	Type    string          `json:"type"`
-}
-
-type wsConnection struct {
-	ctx             context.Context
-	conn            *websocket.Conn
-	exec            graphql.ExecutableSchema
-	active          map[string]context.CancelFunc
-	mu              sync.Mutex
-	cfg             *Config
-	cache           *lru.Cache
-	keepAliveTicker *time.Ticker
-
-	initPayload InitPayload
-}
-
-func connectWs(exec graphql.ExecutableSchema, w http.ResponseWriter, r *http.Request, cfg *Config, cache *lru.Cache) {
-	ws, err := cfg.upgrader.Upgrade(w, r, http.Header{
-		"Sec-Websocket-Protocol": []string{"graphql-ws"},
-	})
-	if err != nil {
-		log.Printf("unable to upgrade %T to websocket %s: ", w, err.Error())
-		sendErrorf(w, http.StatusBadRequest, "unable to upgrade")
-		return
-	}
-
-	conn := wsConnection{
-		active: map[string]context.CancelFunc{},
-		exec:   exec,
-		conn:   ws,
-		ctx:    r.Context(),
-		cfg:    cfg,
-		cache:  cache,
-	}
-
-	if !conn.init() {
-		return
-	}
-
-	conn.run()
-}
-
-func (c *wsConnection) init() bool {
-	message := c.readOp()
-	if message == nil {
-		c.close(websocket.CloseProtocolError, "decoding error")
-		return false
-	}
-
-	switch message.Type {
-	case connectionInitMsg:
-		if len(message.Payload) > 0 {
-			c.initPayload = make(InitPayload)
-			err := json.Unmarshal(message.Payload, &c.initPayload)
-			if err != nil {
-				return false
-			}
-		}
-
-		c.write(&operationMessage{Type: connectionAckMsg})
-	case connectionTerminateMsg:
-		c.close(websocket.CloseNormalClosure, "terminated")
-		return false
-	default:
-		c.sendConnectionError("unexpected message %s", message.Type)
-		c.close(websocket.CloseProtocolError, "unexpected message")
-		return false
-	}
-
-	return true
-}
-
-func (c *wsConnection) write(msg *operationMessage) {
-	c.mu.Lock()
-	c.conn.WriteJSON(msg)
-	c.mu.Unlock()
-}
-
-func (c *wsConnection) run() {
-	// We create a cancellation that will shutdown the keep-alive when we leave
-	// this function.
-	ctx, cancel := context.WithCancel(c.ctx)
-	defer cancel()
-
-	// Create a timer that will fire every interval to keep the connection alive.
-	if c.cfg.connectionKeepAlivePingInterval != 0 {
-		c.mu.Lock()
-		c.keepAliveTicker = time.NewTicker(c.cfg.connectionKeepAlivePingInterval)
-		c.mu.Unlock()
-
-		go c.keepAlive(ctx)
-	}
-
-	for {
-		message := c.readOp()
-		if message == nil {
-			return
-		}
-
-		switch message.Type {
-		case startMsg:
-			if !c.subscribe(message) {
-				return
-			}
-		case stopMsg:
-			c.mu.Lock()
-			closer := c.active[message.ID]
-			c.mu.Unlock()
-			if closer == nil {
-				c.sendError(message.ID, gqlerror.Errorf("%s is not running, cannot stop", message.ID))
-				continue
-			}
-
-			closer()
-		case connectionTerminateMsg:
-			c.close(websocket.CloseNormalClosure, "terminated")
-			return
-		default:
-			c.sendConnectionError("unexpected message %s", message.Type)
-			c.close(websocket.CloseProtocolError, "unexpected message")
-			return
-		}
-	}
-}
-
-func (c *wsConnection) keepAlive(ctx context.Context) {
-	for {
-		select {
-		case <-ctx.Done():
-			c.keepAliveTicker.Stop()
-			return
-		case <-c.keepAliveTicker.C:
-			c.write(&operationMessage{Type: connectionKeepAliveMsg})
-		}
-	}
-}
-
-func (c *wsConnection) subscribe(message *operationMessage) bool {
-	var reqParams params
-	if err := jsonDecode(bytes.NewReader(message.Payload), &reqParams); err != nil {
-		c.sendConnectionError("invalid json")
-		return false
-	}
-
-	var (
-		doc      *ast.QueryDocument
-		cacheHit bool
-	)
-	if c.cache != nil {
-		val, ok := c.cache.Get(reqParams.Query)
-		if ok {
-			doc = val.(*ast.QueryDocument)
-			cacheHit = true
-		}
-	}
-	if !cacheHit {
-		var qErr gqlerror.List
-		doc, qErr = gqlparser.LoadQuery(c.exec.Schema(), reqParams.Query)
-		if qErr != nil {
-			c.sendError(message.ID, qErr...)
-			return true
-		}
-		if c.cache != nil {
-			c.cache.Add(reqParams.Query, doc)
-		}
-	}
-
-	op := doc.Operations.ForName(reqParams.OperationName)
-	if op == nil {
-		c.sendError(message.ID, gqlerror.Errorf("operation %s not found", reqParams.OperationName))
-		return true
-	}
-
-	vars, err := validator.VariableValues(c.exec.Schema(), op, reqParams.Variables)
-	if err != nil {
-		c.sendError(message.ID, err)
-		return true
-	}
-	reqCtx := c.cfg.newRequestContext(c.exec, doc, op, reqParams.Query, vars)
-	ctx := graphql.WithRequestContext(c.ctx, reqCtx)
-
-	if c.initPayload != nil {
-		ctx = withInitPayload(ctx, c.initPayload)
-	}
-
-	if op.Operation != ast.Subscription {
-		var result *graphql.Response
-		if op.Operation == ast.Query {
-			result = c.exec.Query(ctx, op)
-		} else {
-			result = c.exec.Mutation(ctx, op)
-		}
-
-		c.sendData(message.ID, result)
-		c.write(&operationMessage{ID: message.ID, Type: completeMsg})
-		return true
-	}
-
-	ctx, cancel := context.WithCancel(ctx)
-	c.mu.Lock()
-	c.active[message.ID] = cancel
-	c.mu.Unlock()
-	go func() {
-		defer func() {
-			if r := recover(); r != nil {
-				userErr := reqCtx.Recover(ctx, r)
-				c.sendError(message.ID, &gqlerror.Error{Message: userErr.Error()})
-			}
-		}()
-		next := c.exec.Subscription(ctx, op)
-		for result := next(); result != nil; result = next() {
-			c.sendData(message.ID, result)
-		}
-
-		c.write(&operationMessage{ID: message.ID, Type: completeMsg})
-
-		c.mu.Lock()
-		delete(c.active, message.ID)
-		c.mu.Unlock()
-		cancel()
-	}()
-
-	return true
-}
-
-func (c *wsConnection) sendData(id string, response *graphql.Response) {
-	b, err := json.Marshal(response)
-	if err != nil {
-		c.sendError(id, gqlerror.Errorf("unable to encode json response: %s", err.Error()))
-		return
-	}
-
-	c.write(&operationMessage{Type: dataMsg, ID: id, Payload: b})
-}
-
-func (c *wsConnection) sendError(id string, errors ...*gqlerror.Error) {
-	var errs []error
-	for _, err := range errors {
-		errs = append(errs, err)
-	}
-	b, err := json.Marshal(errs)
-	if err != nil {
-		panic(err)
-	}
-	c.write(&operationMessage{Type: errorMsg, ID: id, Payload: b})
-}
-
-func (c *wsConnection) sendConnectionError(format string, args ...interface{}) {
-	b, err := json.Marshal(&gqlerror.Error{Message: fmt.Sprintf(format, args...)})
-	if err != nil {
-		panic(err)
-	}
-
-	c.write(&operationMessage{Type: connectionErrorMsg, Payload: b})
-}
-
-func (c *wsConnection) readOp() *operationMessage {
-	_, r, err := c.conn.NextReader()
-	if err != nil {
-		c.sendConnectionError("invalid json")
-		return nil
-	}
-	message := operationMessage{}
-	if err := jsonDecode(r, &message); err != nil {
-		c.sendConnectionError("invalid json")
-		return nil
-	}
-
-	return &message
-}
-
-func (c *wsConnection) close(closeCode int, message string) {
-	c.mu.Lock()
-	_ = c.conn.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(closeCode, message))
-	c.mu.Unlock()
-	_ = c.conn.Close()
-}
--- a/vendor/github.com/BurntSushi/toml/.gitignore
+++ b/vendor/github.com/BurntSushi/toml/.gitignore
@@ -1,5 +0,0 @@
-TAGS
-tags
-.*.swp
-tomlcheck/tomlcheck
-toml.test
--- a/vendor/github.com/BurntSushi/toml/.travis.yml
+++ b/vendor/github.com/BurntSushi/toml/.travis.yml
@@ -1,15 +0,0 @@
-language: go
-go:
-  - 1.1
-  - 1.2
-  - 1.3
-  - 1.4
-  - 1.5
-  - 1.6
-  - tip
-install:
-  - go install ./...
-  - go get github.com/BurntSushi/toml-test
-script:
-  - export PATH="$PATH:$HOME/gopath/bin"
-  - make test
--- a/vendor/github.com/BurntSushi/toml/COMPATIBLE
+++ b/vendor/github.com/BurntSushi/toml/COMPATIBLE
@@ -1,3 +0,0 @@
-Compatible with TOML version
-[v0.4.0](https://github.com/toml-lang/toml/blob/v0.4.0/versions/en/toml-v0.4.0.md)
-
--- a/vendor/github.com/BurntSushi/toml/COPYING
+++ b/vendor/github.com/BurntSushi/toml/COPYING
@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2013 TOML authors
-
-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.
--- a/vendor/github.com/BurntSushi/toml/Makefile
+++ b/vendor/github.com/BurntSushi/toml/Makefile
@@ -1,19 +0,0 @@
-install:
-	go install ./...
-
-test: install
-	go test -v
-	toml-test toml-test-decoder
-	toml-test -encoder toml-test-encoder
-
-fmt:
-	gofmt -w *.go */*.go
-	colcheck *.go */*.go
-
-tags:
-	find ./ -name '*.go' -print0 | xargs -0 gotags > TAGS
-
-push:
-	git push origin master
-	git push github master
-
--- a/vendor/github.com/BurntSushi/toml/README.md
+++ b/vendor/github.com/BurntSushi/toml/README.md
@@ -1,218 +0,0 @@
-## TOML parser and encoder for Go with reflection
-
-TOML stands for Tom's Obvious, Minimal Language. This Go package provides a
-reflection interface similar to Go's standard library `json` and `xml`
-packages. This package also supports the `encoding.TextUnmarshaler` and
-`encoding.TextMarshaler` interfaces so that you can define custom data
-representations. (There is an example of this below.)
-
-Spec: https://github.com/toml-lang/toml
-
-Compatible with TOML version
-[v0.4.0](https://github.com/toml-lang/toml/blob/master/versions/en/toml-v0.4.0.md)
-
-Documentation: https://godoc.org/github.com/BurntSushi/toml
-
-Installation:
-
-```bash
-go get github.com/BurntSushi/toml
-```
-
-Try the toml validator:
-
-```bash
-go get github.com/BurntSushi/toml/cmd/tomlv
-tomlv some-toml-file.toml
-```
-
-[![Build Status](https://travis-ci.org/BurntSushi/toml.svg?branch=master)](https://travis-ci.org/BurntSushi/toml) [![GoDoc](https://godoc.org/github.com/BurntSushi/toml?status.svg)](https://godoc.org/github.com/BurntSushi/toml)
-
-### Testing
-
-This package passes all tests in
-[toml-test](https://github.com/BurntSushi/toml-test) for both the decoder
-and the encoder.
-
-### Examples
-
-This package works similarly to how the Go standard library handles `XML`
-and `JSON`. Namely, data is loaded into Go values via reflection.
-
-For the simplest example, consider some TOML file as just a list of keys
-and values:
-
-```toml
-Age = 25
-Cats = [ "Cauchy", "Plato" ]
-Pi = 3.14
-Perfection = [ 6, 28, 496, 8128 ]
-DOB = 1987-07-05T05:45:00Z
-```
-
-Which could be defined in Go as:
-
-```go
-type Config struct {
-  Age int
-  Cats []string
-  Pi float64
-  Perfection []int
-  DOB time.Time // requires `import time`
-}
-```
-
-And then decoded with:
-
-```go
-var conf Config
-if _, err := toml.Decode(tomlData, &conf); err != nil {
-  // handle error
-}
-```
-
-You can also use struct tags if your struct field name doesn't map to a TOML
-key value directly:
-
-```toml
-some_key_NAME = "wat"
-```
-
-```go
-type TOML struct {
-  ObscureKey string `toml:"some_key_NAME"`
-}
-```
-
-### Using the `encoding.TextUnmarshaler` interface
-
-Here's an example that automatically parses duration strings into
-`time.Duration` values:
-
-```toml
-[[song]]
-name = "Thunder Road"
-duration = "4m49s"
-
-[[song]]
-name = "Stairway to Heaven"
-duration = "8m03s"
-```
-
-Which can be decoded with:
-
-```go
-type song struct {
-  Name     string
-  Duration duration
-}
-type songs struct {
-  Song []song
-}
-var favorites songs
-if _, err := toml.Decode(blob, &favorites); err != nil {
-  log.Fatal(err)
-}
-
-for _, s := range favorites.Song {
-  fmt.Printf("%s (%s)\n", s.Name, s.Duration)
-}
-```
-
-And you'll also need a `duration` type that satisfies the
-`encoding.TextUnmarshaler` interface:
-
-```go
-type duration struct {
-	time.Duration
-}
-
-func (d *duration) UnmarshalText(text []byte) error {
-	var err error
-	d.Duration, err = time.ParseDuration(string(text))
-	return err
-}
-```
-
-### More complex usage
-
-Here's an example of how to load the example from the official spec page:
-
-```toml
-# This is a TOML document. Boom.
-
-title = "TOML Example"
-
-[owner]
-name = "Tom Preston-Werner"
-organization = "GitHub"
-bio = "GitHub Cofounder & CEO\nLikes tater tots and beer."
-dob = 1979-05-27T07:32:00Z # First class dates? Why not?
-
-[database]
-server = "192.168.1.1"
-ports = [ 8001, 8001, 8002 ]
-connection_max = 5000
-enabled = true
-
-[servers]
-
-  # You can indent as you please. Tabs or spaces. TOML don't care.
-  [servers.alpha]
-  ip = "10.0.0.1"
-  dc = "eqdc10"
-
-  [servers.beta]
-  ip = "10.0.0.2"
-  dc = "eqdc10"
-
-[clients]
-data = [ ["gamma", "delta"], [1, 2] ] # just an update to make sure parsers support it
-
-# Line breaks are OK when inside arrays
-hosts = [
-  "alpha",
-  "omega"
-]
-```
-
-And the corresponding Go types are:
-
-```go
-type tomlConfig struct {
-	Title string
-	Owner ownerInfo
-	DB database `toml:"database"`
-	Servers map[string]server
-	Clients clients
-}
-
-type ownerInfo struct {
-	Name string
-	Org string `toml:"organization"`
-	Bio string
-	DOB time.Time
-}
-
-type database struct {
-	Server string
-	Ports []int
-	ConnMax int `toml:"connection_max"`
-	Enabled bool
-}
-
-type server struct {
-	IP string
-	DC string
-}
-
-type clients struct {
-	Data [][]interface{}
-	Hosts []string
-}
-```
-
-Note that a case insensitive match will be tried if an exact match can't be
-found.
-
-A working example of the above can be found in `_examples/example.{go,toml}`.
--- a/vendor/github.com/BurntSushi/toml/decode.go
+++ b/vendor/github.com/BurntSushi/toml/decode.go
@@ -1,509 +0,0 @@
-package toml
-
-import (
-	"fmt"
-	"io"
-	"io/ioutil"
-	"math"
-	"reflect"
-	"strings"
-	"time"
-)
-
-func e(format string, args ...interface{}) error {
-	return fmt.Errorf("toml: "+format, args...)
-}
-
-// Unmarshaler is the interface implemented by objects that can unmarshal a
-// TOML description of themselves.
-type Unmarshaler interface {
-	UnmarshalTOML(interface{}) error
-}
-
-// Unmarshal decodes the contents of `p` in TOML format into a pointer `v`.
-func Unmarshal(p []byte, v interface{}) error {
-	_, err := Decode(string(p), v)
-	return err
-}
-
-// Primitive is a TOML value that hasn't been decoded into a Go value.
-// When using the various `Decode*` functions, the type `Primitive` may
-// be given to any value, and its decoding will be delayed.
-//
-// A `Primitive` value can be decoded using the `PrimitiveDecode` function.
-//
-// The underlying representation of a `Primitive` value is subject to change.
-// Do not rely on it.
-//
-// N.B. Primitive values are still parsed, so using them will only avoid
-// the overhead of reflection. They can be useful when you don't know the
-// exact type of TOML data until run time.
-type Primitive struct {
-	undecoded interface{}
-	context   Key
-}
-
-// DEPRECATED!
-//
-// Use MetaData.PrimitiveDecode instead.
-func PrimitiveDecode(primValue Primitive, v interface{}) error {
-	md := MetaData{decoded: make(map[string]bool)}
-	return md.unify(primValue.undecoded, rvalue(v))
-}
-
-// PrimitiveDecode is just like the other `Decode*` functions, except it
-// decodes a TOML value that has already been parsed. Valid primitive values
-// can *only* be obtained from values filled by the decoder functions,
-// including this method. (i.e., `v` may contain more `Primitive`
-// values.)
-//
-// Meta data for primitive values is included in the meta data returned by
-// the `Decode*` functions with one exception: keys returned by the Undecoded
-// method will only reflect keys that were decoded. Namely, any keys hidden
-// behind a Primitive will be considered undecoded. Executing this method will
-// update the undecoded keys in the meta data. (See the example.)
-func (md *MetaData) PrimitiveDecode(primValue Primitive, v interface{}) error {
-	md.context = primValue.context
-	defer func() { md.context = nil }()
-	return md.unify(primValue.undecoded, rvalue(v))
-}
-
-// Decode will decode the contents of `data` in TOML format into a pointer
-// `v`.
-//
-// TOML hashes correspond to Go structs or maps. (Dealer's choice. They can be
-// used interchangeably.)
-//
-// TOML arrays of tables correspond to either a slice of structs or a slice
-// of maps.
-//
-// TOML datetimes correspond to Go `time.Time` values.
-//
-// All other TOML types (float, string, int, bool and array) correspond
-// to the obvious Go types.
-//
-// An exception to the above rules is if a type implements the
-// encoding.TextUnmarshaler interface. In this case, any primitive TOML value
-// (floats, strings, integers, booleans and datetimes) will be converted to
-// a byte string and given to the value's UnmarshalText method. See the
-// Unmarshaler example for a demonstration with time duration strings.
-//
-// Key mapping
-//
-// TOML keys can map to either keys in a Go map or field names in a Go
-// struct. The special `toml` struct tag may be used to map TOML keys to
-// struct fields that don't match the key name exactly. (See the example.)
-// A case insensitive match to struct names will be tried if an exact match
-// can't be found.
-//
-// The mapping between TOML values and Go values is loose. That is, there
-// may exist TOML values that cannot be placed into your representation, and
-// there may be parts of your representation that do not correspond to
-// TOML values. This loose mapping can be made stricter by using the IsDefined
-// and/or Undecoded methods on the MetaData returned.
-//
-// This decoder will not handle cyclic types. If a cyclic type is passed,
-// `Decode` will not terminate.
-func Decode(data string, v interface{}) (MetaData, error) {
-	rv := reflect.ValueOf(v)
-	if rv.Kind() != reflect.Ptr {
-		return MetaData{}, e("Decode of non-pointer %s", reflect.TypeOf(v))
-	}
-	if rv.IsNil() {
-		return MetaData{}, e("Decode of nil %s", reflect.TypeOf(v))
-	}
-	p, err := parse(data)
-	if err != nil {
-		return MetaData{}, err
-	}
-	md := MetaData{
-		p.mapping, p.types, p.ordered,
-		make(map[string]bool, len(p.ordered)), nil,
-	}
-	return md, md.unify(p.mapping, indirect(rv))
-}
-
-// DecodeFile is just like Decode, except it will automatically read the
-// contents of the file at `fpath` and decode it for you.
-func DecodeFile(fpath string, v interface{}) (MetaData, error) {
-	bs, err := ioutil.ReadFile(fpath)
-	if err != nil {
-		return MetaData{}, err
-	}
-	return Decode(string(bs), v)
-}
-
-// DecodeReader is just like Decode, except it will consume all bytes
-// from the reader and decode it for you.
-func DecodeReader(r io.Reader, v interface{}) (MetaData, error) {
-	bs, err := ioutil.ReadAll(r)
-	if err != nil {
-		return MetaData{}, err
-	}
-	return Decode(string(bs), v)
-}
-
-// unify performs a sort of type unification based on the structure of `rv`,
-// which is the client representation.
-//
-// Any type mismatch produces an error. Finding a type that we don't know
-// how to handle produces an unsupported type error.
-func (md *MetaData) unify(data interface{}, rv reflect.Value) error {
-
-	// Special case. Look for a `Primitive` value.
-	if rv.Type() == reflect.TypeOf((*Primitive)(nil)).Elem() {
-		// Save the undecoded data and the key context into the primitive
-		// value.
-		context := make(Key, len(md.context))
-		copy(context, md.context)
-		rv.Set(reflect.ValueOf(Primitive{
-			undecoded: data,
-			context:   context,
-		}))
-		return nil
-	}
-
-	// Special case. Unmarshaler Interface support.
-	if rv.CanAddr() {
-		if v, ok := rv.Addr().Interface().(Unmarshaler); ok {
-			return v.UnmarshalTOML(data)
-		}
-	}
-
-	// Special case. Handle time.Time values specifically.
-	// TODO: Remove this code when we decide to drop support for Go 1.1.
-	// This isn't necessary in Go 1.2 because time.Time satisfies the encoding
-	// interfaces.
-	if rv.Type().AssignableTo(rvalue(time.Time{}).Type()) {
-		return md.unifyDatetime(data, rv)
-	}
-
-	// Special case. Look for a value satisfying the TextUnmarshaler interface.
-	if v, ok := rv.Interface().(TextUnmarshaler); ok {
-		return md.unifyText(data, v)
-	}
-	// BUG(burntsushi)
-	// The behavior here is incorrect whenever a Go type satisfies the
-	// encoding.TextUnmarshaler interface but also corresponds to a TOML
-	// hash or array. In particular, the unmarshaler should only be applied
-	// to primitive TOML values. But at this point, it will be applied to
-	// all kinds of values and produce an incorrect error whenever those values
-	// are hashes or arrays (including arrays of tables).
-
-	k := rv.Kind()
-
-	// laziness
-	if k >= reflect.Int && k <= reflect.Uint64 {
-		return md.unifyInt(data, rv)
-	}
-	switch k {
-	case reflect.Ptr:
-		elem := reflect.New(rv.Type().Elem())
-		err := md.unify(data, reflect.Indirect(elem))
-		if err != nil {
-			return err
-		}
-		rv.Set(elem)
-		return nil
-	case reflect.Struct:
-		return md.unifyStruct(data, rv)
-	case reflect.Map:
-		return md.unifyMap(data, rv)
-	case reflect.Array:
-		return md.unifyArray(data, rv)
-	case reflect.Slice:
-		return md.unifySlice(data, rv)
-	case reflect.String:
-		return md.unifyString(data, rv)
-	case reflect.Bool:
-		return md.unifyBool(data, rv)
-	case reflect.Interface:
-		// we only support empty interfaces.
-		if rv.NumMethod() > 0 {
-			return e("unsupported type %s", rv.Type())
-		}
-		return md.unifyAnything(data, rv)
-	case reflect.Float32:
-		fallthrough
-	case reflect.Float64:
-		return md.unifyFloat64(data, rv)
-	}
-	return e("unsupported type %s", rv.Kind())
-}
-
-func (md *MetaData) unifyStruct(mapping interface{}, rv reflect.Value) error {
-	tmap, ok := mapping.(map[string]interface{})
-	if !ok {
-		if mapping == nil {
-			return nil
-		}
-		return e("type mismatch for %s: expected table but found %T",
-			rv.Type().String(), mapping)
-	}
-
-	for key, datum := range tmap {
-		var f *field
-		fields := cachedTypeFields(rv.Type())
-		for i := range fields {
-			ff := &fields[i]
-			if ff.name == key {
-				f = ff
-				break
-			}
-			if f == nil && strings.EqualFold(ff.name, key) {
-				f = ff
-			}
-		}
-		if f != nil {
-			subv := rv
-			for _, i := range f.index {
-				subv = indirect(subv.Field(i))
-			}
-			if isUnifiable(subv) {
-				md.decoded[md.context.add(key).String()] = true
-				md.context = append(md.context, key)
-				if err := md.unify(datum, subv); err != nil {
-					return err
-				}
-				md.context = md.context[0 : len(md.context)-1]
-			} else if f.name != "" {
-				// Bad user! No soup for you!
-				return e("cannot write unexported field %s.%s",
-					rv.Type().String(), f.name)
-			}
-		}
-	}
-	return nil
-}
-
-func (md *MetaData) unifyMap(mapping interface{}, rv reflect.Value) error {
-	tmap, ok := mapping.(map[string]interface{})
-	if !ok {
-		if tmap == nil {
-			return nil
-		}
-		return badtype("map", mapping)
-	}
-	if rv.IsNil() {
-		rv.Set(reflect.MakeMap(rv.Type()))
-	}
-	for k, v := range tmap {
-		md.decoded[md.context.add(k).String()] = true
-		md.context = append(md.context, k)
-
-		rvkey := indirect(reflect.New(rv.Type().Key()))
-		rvval := reflect.Indirect(reflect.New(rv.Type().Elem()))
-		if err := md.unify(v, rvval); err != nil {
-			return err
-		}
-		md.context = md.context[0 : len(md.context)-1]
-
-		rvkey.SetString(k)
-		rv.SetMapIndex(rvkey, rvval)
-	}
-	return nil
-}
-
-func (md *MetaData) unifyArray(data interface{}, rv reflect.Value) error {
-	datav := reflect.ValueOf(data)
-	if datav.Kind() != reflect.Slice {
-		if !datav.IsValid() {
-			return nil
-		}
-		return badtype("slice", data)
-	}
-	sliceLen := datav.Len()
-	if sliceLen != rv.Len() {
-		return e("expected array length %d; got TOML array of length %d",
-			rv.Len(), sliceLen)
-	}
-	return md.unifySliceArray(datav, rv)
-}
-
-func (md *MetaData) unifySlice(data interface{}, rv reflect.Value) error {
-	datav := reflect.ValueOf(data)
-	if datav.Kind() != reflect.Slice {
-		if !datav.IsValid() {
-			return nil
-		}
-		return badtype("slice", data)
-	}
-	n := datav.Len()
-	if rv.IsNil() || rv.Cap() < n {
-		rv.Set(reflect.MakeSlice(rv.Type(), n, n))
-	}
-	rv.SetLen(n)
-	return md.unifySliceArray(datav, rv)
-}
-
-func (md *MetaData) unifySliceArray(data, rv reflect.Value) error {
-	sliceLen := data.Len()
-	for i := 0; i < sliceLen; i++ {
-		v := data.Index(i).Interface()
-		sliceval := indirect(rv.Index(i))
-		if err := md.unify(v, sliceval); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (md *MetaData) unifyDatetime(data interface{}, rv reflect.Value) error {
-	if _, ok := data.(time.Time); ok {
-		rv.Set(reflect.ValueOf(data))
-		return nil
-	}
-	return badtype("time.Time", data)
-}
-
-func (md *MetaData) unifyString(data interface{}, rv reflect.Value) error {
-	if s, ok := data.(string); ok {
-		rv.SetString(s)
-		return nil
-	}
-	return badtype("string", data)
-}
-
-func (md *MetaData) unifyFloat64(data interface{}, rv reflect.Value) error {
-	if num, ok := data.(float64); ok {
-		switch rv.Kind() {
-		case reflect.Float32:
-			fallthrough
-		case reflect.Float64:
-			rv.SetFloat(num)
-		default:
-			panic("bug")
-		}
-		return nil
-	}
-	return badtype("float", data)
-}
-
-func (md *MetaData) unifyInt(data interface{}, rv reflect.Value) error {
-	if num, ok := data.(int64); ok {
-		if rv.Kind() >= reflect.Int && rv.Kind() <= reflect.Int64 {
-			switch rv.Kind() {
-			case reflect.Int, reflect.Int64:
-				// No bounds checking necessary.
-			case reflect.Int8:
-				if num < math.MinInt8 || num > math.MaxInt8 {
-					return e("value %d is out of range for int8", num)
-				}
-			case reflect.Int16:
-				if num < math.MinInt16 || num > math.MaxInt16 {
-					return e("value %d is out of range for int16", num)
-				}
-			case reflect.Int32:
-				if num < math.MinInt32 || num > math.MaxInt32 {
-					return e("value %d is out of range for int32", num)
-				}
-			}
-			rv.SetInt(num)
-		} else if rv.Kind() >= reflect.Uint && rv.Kind() <= reflect.Uint64 {
-			unum := uint64(num)
-			switch rv.Kind() {
-			case reflect.Uint, reflect.Uint64:
-				// No bounds checking necessary.
-			case reflect.Uint8:
-				if num < 0 || unum > math.MaxUint8 {
-					return e("value %d is out of range for uint8", num)
-				}
-			case reflect.Uint16:
-				if num < 0 || unum > math.MaxUint16 {
-					return e("value %d is out of range for uint16", num)
-				}
-			case reflect.Uint32:
-				if num < 0 || unum > math.MaxUint32 {
-					return e("value %d is out of range for uint32", num)
-				}
-			}
-			rv.SetUint(unum)
-		} else {
-			panic("unreachable")
-		}
-		return nil
-	}
-	return badtype("integer", data)
-}
-
-func (md *MetaData) unifyBool(data interface{}, rv reflect.Value) error {
-	if b, ok := data.(bool); ok {
-		rv.SetBool(b)
-		return nil
-	}
-	return badtype("boolean", data)
-}
-
-func (md *MetaData) unifyAnything(data interface{}, rv reflect.Value) error {
-	rv.Set(reflect.ValueOf(data))
-	return nil
-}
-
-func (md *MetaData) unifyText(data interface{}, v TextUnmarshaler) error {
-	var s string
-	switch sdata := data.(type) {
-	case TextMarshaler:
-		text, err := sdata.MarshalText()
-		if err != nil {
-			return err
-		}
-		s = string(text)
-	case fmt.Stringer:
-		s = sdata.String()
-	case string:
-		s = sdata
-	case bool:
-		s = fmt.Sprintf("%v", sdata)
-	case int64:
-		s = fmt.Sprintf("%d", sdata)
-	case float64:
-		s = fmt.Sprintf("%f", sdata)
-	default:
-		return badtype("primitive (string-like)", data)
-	}
-	if err := v.UnmarshalText([]byte(s)); err != nil {
-		return err
-	}
-	return nil
-}
-
-// rvalue returns a reflect.Value of `v`. All pointers are resolved.
-func rvalue(v interface{}) reflect.Value {
-	return indirect(reflect.ValueOf(v))
-}
-
-// indirect returns the value pointed to by a pointer.
-// Pointers are followed until the value is not a pointer.
-// New values are allocated for each nil pointer.
-//
-// An exception to this rule is if the value satisfies an interface of
-// interest to us (like encoding.TextUnmarshaler).
-func indirect(v reflect.Value) reflect.Value {
-	if v.Kind() != reflect.Ptr {
-		if v.CanSet() {
-			pv := v.Addr()
-			if _, ok := pv.Interface().(TextUnmarshaler); ok {
-				return pv
-			}
-		}
-		return v
-	}
-	if v.IsNil() {
-		v.Set(reflect.New(v.Type().Elem()))
-	}
-	return indirect(reflect.Indirect(v))
-}
-
-func isUnifiable(rv reflect.Value) bool {
-	if rv.CanSet() {
-		return true
-	}
-	if _, ok := rv.Interface().(TextUnmarshaler); ok {
-		return true
-	}
-	return false
-}
-
-func badtype(expected string, data interface{}) error {
-	return e("cannot load TOML value of type %T into a Go %s", data, expected)
-}
--- a/vendor/github.com/BurntSushi/toml/decode_meta.go
+++ b/vendor/github.com/BurntSushi/toml/decode_meta.go
@@ -1,121 +0,0 @@
-package toml
-
-import "strings"
-
-// MetaData allows access to meta information about TOML data that may not
-// be inferrable via reflection. In particular, whether a key has been defined
-// and the TOML type of a key.
-type MetaData struct {
-	mapping map[string]interface{}
-	types   map[string]tomlType
-	keys    []Key
-	decoded map[string]bool
-	context Key // Used only during decoding.
-}
-
-// IsDefined returns true if the key given exists in the TOML data. The key
-// should be specified hierarchially. e.g.,
-//
-//	// access the TOML key 'a.b.c'
-//	IsDefined("a", "b", "c")
-//
-// IsDefined will return false if an empty key given. Keys are case sensitive.
-func (md *MetaData) IsDefined(key ...string) bool {
-	if len(key) == 0 {
-		return false
-	}
-
-	var hash map[string]interface{}
-	var ok bool
-	var hashOrVal interface{} = md.mapping
-	for _, k := range key {
-		if hash, ok = hashOrVal.(map[string]interface{}); !ok {
-			return false
-		}
-		if hashOrVal, ok = hash[k]; !ok {
-			return false
-		}
-	}
-	return true
-}
-
-// Type returns a string representation of the type of the key specified.
-//
-// Type will return the empty string if given an empty key or a key that
-// does not exist. Keys are case sensitive.
-func (md *MetaData) Type(key ...string) string {
-	fullkey := strings.Join(key, ".")
-	if typ, ok := md.types[fullkey]; ok {
-		return typ.typeString()
-	}
-	return ""
-}
-
-// Key is the type of any TOML key, including key groups. Use (MetaData).Keys
-// to get values of this type.
-type Key []string
-
-func (k Key) String() string {
-	return strings.Join(k, ".")
-}
-
-func (k Key) maybeQuotedAll() string {
-	var ss []string
-	for i := range k {
-		ss = append(ss, k.maybeQuoted(i))
-	}
-	return strings.Join(ss, ".")
-}
-
-func (k Key) maybeQuoted(i int) string {
-	quote := false
-	for _, c := range k[i] {
-		if !isBareKeyChar(c) {
-			quote = true
-			break
-		}
-	}
-	if quote {
-		return "\"" + strings.Replace(k[i], "\"", "\\\"", -1) + "\""
-	}
-	return k[i]
-}
-
-func (k Key) add(piece string) Key {
-	newKey := make(Key, len(k)+1)
-	copy(newKey, k)
-	newKey[len(k)] = piece
-	return newKey
-}
-
-// Keys returns a slice of every key in the TOML data, including key groups.
-// Each key is itself a slice, where the first element is the top of the
-// hierarchy and the last is the most specific.
-//
-// The list will have the same order as the keys appeared in the TOML data.
-//
-// All keys returned are non-empty.
-func (md *MetaData) Keys() []Key {
-	return md.keys
-}
-
-// Undecoded returns all keys that have not been decoded in the order in which
-// they appear in the original TOML document.
-//
-// This includes keys that haven't been decoded because of a Primitive value.
-// Once the Primitive value is decoded, the keys will be considered decoded.
-//
-// Also note that decoding into an empty interface will result in no decoding,
-// and so no keys will be considered decoded.
-//
-// In this sense, the Undecoded keys correspond to keys in the TOML document
-// that do not have a concrete type in your representation.
-func (md *MetaData) Undecoded() []Key {
-	undecoded := make([]Key, 0, len(md.keys))
-	for _, key := range md.keys {
-		if !md.decoded[key.String()] {
-			undecoded = append(undecoded, key)
-		}
-	}
-	return undecoded
-}
--- a/vendor/github.com/BurntSushi/toml/doc.go
+++ b/vendor/github.com/BurntSushi/toml/doc.go
@@ -1,27 +0,0 @@
-/*
-Package toml provides facilities for decoding and encoding TOML configuration
-files via reflection. There is also support for delaying decoding with
-the Primitive type, and querying the set of keys in a TOML document with the
-MetaData type.
-
-The specification implemented: https://github.com/toml-lang/toml
-
-The sub-command github.com/BurntSushi/toml/cmd/tomlv can be used to verify
-whether a file is a valid TOML document. It can also be used to print the
-type of each key in a TOML document.
-
-Testing
-
-There are two important types of tests used for this package. The first is
-contained inside '*_test.go' files and uses the standard Go unit testing
-framework. These tests are primarily devoted to holistically testing the
-decoder and encoder.
-
-The second type of testing is used to verify the implementation's adherence
-to the TOML specification. These tests have been factored into their own
-project: https://github.com/BurntSushi/toml-test
-
-The reason the tests are in a separate project is so that they can be used by
-any implementation of TOML. Namely, it is language agnostic.
-*/
-package toml
--- a/vendor/github.com/BurntSushi/toml/encode.go
+++ b/vendor/github.com/BurntSushi/toml/encode.go
@@ -1,568 +0,0 @@
-package toml
-
-import (
-	"bufio"
-	"errors"
-	"fmt"
-	"io"
-	"reflect"
-	"sort"
-	"strconv"
-	"strings"
-	"time"
-)
-
-type tomlEncodeError struct{ error }
-
-var (
-	errArrayMixedElementTypes = errors.New(
-		"toml: cannot encode array with mixed element types")
-	errArrayNilElement = errors.New(
-		"toml: cannot encode array with nil element")
-	errNonString = errors.New(
-		"toml: cannot encode a map with non-string key type")
-	errAnonNonStruct = errors.New(
-		"toml: cannot encode an anonymous field that is not a struct")
-	errArrayNoTable = errors.New(
-		"toml: TOML array element cannot contain a table")
-	errNoKey = errors.New(
-		"toml: top-level values must be Go maps or structs")
-	errAnything = errors.New("") // used in testing
-)
-
-var quotedReplacer = strings.NewReplacer(
-	"\t", "\\t",
-	"\n", "\\n",
-	"\r", "\\r",
-	"\"", "\\\"",
-	"\\", "\\\\",
-)
-
-// Encoder controls the encoding of Go values to a TOML document to some
-// io.Writer.
-//
-// The indentation level can be controlled with the Indent field.
-type Encoder struct {
-	// A single indentation level. By default it is two spaces.
-	Indent string
-
-	// hasWritten is whether we have written any output to w yet.
-	hasWritten bool
-	w          *bufio.Writer
-}
-
-// NewEncoder returns a TOML encoder that encodes Go values to the io.Writer
-// given. By default, a single indentation level is 2 spaces.
-func NewEncoder(w io.Writer) *Encoder {
-	return &Encoder{
-		w:      bufio.NewWriter(w),
-		Indent: "  ",
-	}
-}
-
-// Encode writes a TOML representation of the Go value to the underlying
-// io.Writer. If the value given cannot be encoded to a valid TOML document,
-// then an error is returned.
-//
-// The mapping between Go values and TOML values should be precisely the same
-// as for the Decode* functions. Similarly, the TextMarshaler interface is
-// supported by encoding the resulting bytes as strings. (If you want to write
-// arbitrary binary data then you will need to use something like base64 since
-// TOML does not have any binary types.)
-//
-// When encoding TOML hashes (i.e., Go maps or structs), keys without any
-// sub-hashes are encoded first.
-//
-// If a Go map is encoded, then its keys are sorted alphabetically for
-// deterministic output. More control over this behavior may be provided if
-// there is demand for it.
-//
-// Encoding Go values without a corresponding TOML representation---like map
-// types with non-string keys---will cause an error to be returned. Similarly
-// for mixed arrays/slices, arrays/slices with nil elements, embedded
-// non-struct types and nested slices containing maps or structs.
-// (e.g., [][]map[string]string is not allowed but []map[string]string is OK
-// and so is []map[string][]string.)
-func (enc *Encoder) Encode(v interface{}) error {
-	rv := eindirect(reflect.ValueOf(v))
-	if err := enc.safeEncode(Key([]string{}), rv); err != nil {
-		return err
-	}
-	return enc.w.Flush()
-}
-
-func (enc *Encoder) safeEncode(key Key, rv reflect.Value) (err error) {
-	defer func() {
-		if r := recover(); r != nil {
-			if terr, ok := r.(tomlEncodeError); ok {
-				err = terr.error
-				return
-			}
-			panic(r)
-		}
-	}()
-	enc.encode(key, rv)
-	return nil
-}
-
-func (enc *Encoder) encode(key Key, rv reflect.Value) {
-	// Special case. Time needs to be in ISO8601 format.
-	// Special case. If we can marshal the type to text, then we used that.
-	// Basically, this prevents the encoder for handling these types as
-	// generic structs (or whatever the underlying type of a TextMarshaler is).
-	switch rv.Interface().(type) {
-	case time.Time, TextMarshaler:
-		enc.keyEqElement(key, rv)
-		return
-	}
-
-	k := rv.Kind()
-	switch k {
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32,
-		reflect.Int64,
-		reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32,
-		reflect.Uint64,
-		reflect.Float32, reflect.Float64, reflect.String, reflect.Bool:
-		enc.keyEqElement(key, rv)
-	case reflect.Array, reflect.Slice:
-		if typeEqual(tomlArrayHash, tomlTypeOfGo(rv)) {
-			enc.eArrayOfTables(key, rv)
-		} else {
-			enc.keyEqElement(key, rv)
-		}
-	case reflect.Interface:
-		if rv.IsNil() {
-			return
-		}
-		enc.encode(key, rv.Elem())
-	case reflect.Map:
-		if rv.IsNil() {
-			return
-		}
-		enc.eTable(key, rv)
-	case reflect.Ptr:
-		if rv.IsNil() {
-			return
-		}
-		enc.encode(key, rv.Elem())
-	case reflect.Struct:
-		enc.eTable(key, rv)
-	default:
-		panic(e("unsupported type for key '%s': %s", key, k))
-	}
-}
-
-// eElement encodes any value that can be an array element (primitives and
-// arrays).
-func (enc *Encoder) eElement(rv reflect.Value) {
-	switch v := rv.Interface().(type) {
-	case time.Time:
-		// Special case time.Time as a primitive. Has to come before
-		// TextMarshaler below because time.Time implements
-		// encoding.TextMarshaler, but we need to always use UTC.
-		enc.wf(v.UTC().Format("2006-01-02T15:04:05Z"))
-		return
-	case TextMarshaler:
-		// Special case. Use text marshaler if it's available for this value.
-		if s, err := v.MarshalText(); err != nil {
-			encPanic(err)
-		} else {
-			enc.writeQuoted(string(s))
-		}
-		return
-	}
-	switch rv.Kind() {
-	case reflect.Bool:
-		enc.wf(strconv.FormatBool(rv.Bool()))
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32,
-		reflect.Int64:
-		enc.wf(strconv.FormatInt(rv.Int(), 10))
-	case reflect.Uint, reflect.Uint8, reflect.Uint16,
-		reflect.Uint32, reflect.Uint64:
-		enc.wf(strconv.FormatUint(rv.Uint(), 10))
-	case reflect.Float32:
-		enc.wf(floatAddDecimal(strconv.FormatFloat(rv.Float(), 'f', -1, 32)))
-	case reflect.Float64:
-		enc.wf(floatAddDecimal(strconv.FormatFloat(rv.Float(), 'f', -1, 64)))
-	case reflect.Array, reflect.Slice:
-		enc.eArrayOrSliceElement(rv)
-	case reflect.Interface:
-		enc.eElement(rv.Elem())
-	case reflect.String:
-		enc.writeQuoted(rv.String())
-	default:
-		panic(e("unexpected primitive type: %s", rv.Kind()))
-	}
-}
-
-// By the TOML spec, all floats must have a decimal with at least one
-// number on either side.
-func floatAddDecimal(fstr string) string {
-	if !strings.Contains(fstr, ".") {
-		return fstr + ".0"
-	}
-	return fstr
-}
-
-func (enc *Encoder) writeQuoted(s string) {
-	enc.wf("\"%s\"", quotedReplacer.Replace(s))
-}
-
-func (enc *Encoder) eArrayOrSliceElement(rv reflect.Value) {
-	length := rv.Len()
-	enc.wf("[")
-	for i := 0; i < length; i++ {
-		elem := rv.Index(i)
-		enc.eElement(elem)
-		if i != length-1 {
-			enc.wf(", ")
-		}
-	}
-	enc.wf("]")
-}
-
-func (enc *Encoder) eArrayOfTables(key Key, rv reflect.Value) {
-	if len(key) == 0 {
-		encPanic(errNoKey)
-	}
-	for i := 0; i < rv.Len(); i++ {
-		trv := rv.Index(i)
-		if isNil(trv) {
-			continue
-		}
-		panicIfInvalidKey(key)
-		enc.newline()
-		enc.wf("%s[[%s]]", enc.indentStr(key), key.maybeQuotedAll())
-		enc.newline()
-		enc.eMapOrStruct(key, trv)
-	}
-}
-
-func (enc *Encoder) eTable(key Key, rv reflect.Value) {
-	panicIfInvalidKey(key)
-	if len(key) == 1 {
-		// Output an extra newline between top-level tables.
-		// (The newline isn't written if nothing else has been written though.)
-		enc.newline()
-	}
-	if len(key) > 0 {
-		enc.wf("%s[%s]", enc.indentStr(key), key.maybeQuotedAll())
-		enc.newline()
-	}
-	enc.eMapOrStruct(key, rv)
-}
-
-func (enc *Encoder) eMapOrStruct(key Key, rv reflect.Value) {
-	switch rv := eindirect(rv); rv.Kind() {
-	case reflect.Map:
-		enc.eMap(key, rv)
-	case reflect.Struct:
-		enc.eStruct(key, rv)
-	default:
-		panic("eTable: unhandled reflect.Value Kind: " + rv.Kind().String())
-	}
-}
-
-func (enc *Encoder) eMap(key Key, rv reflect.Value) {
-	rt := rv.Type()
-	if rt.Key().Kind() != reflect.String {
-		encPanic(errNonString)
-	}
-
-	// Sort keys so that we have deterministic output. And write keys directly
-	// underneath this key first, before writing sub-structs or sub-maps.
-	var mapKeysDirect, mapKeysSub []string
-	for _, mapKey := range rv.MapKeys() {
-		k := mapKey.String()
-		if typeIsHash(tomlTypeOfGo(rv.MapIndex(mapKey))) {
-			mapKeysSub = append(mapKeysSub, k)
-		} else {
-			mapKeysDirect = append(mapKeysDirect, k)
-		}
-	}
-
-	var writeMapKeys = func(mapKeys []string) {
-		sort.Strings(mapKeys)
-		for _, mapKey := range mapKeys {
-			mrv := rv.MapIndex(reflect.ValueOf(mapKey))
-			if isNil(mrv) {
-				// Don't write anything for nil fields.
-				continue
-			}
-			enc.encode(key.add(mapKey), mrv)
-		}
-	}
-	writeMapKeys(mapKeysDirect)
-	writeMapKeys(mapKeysSub)
-}
-
-func (enc *Encoder) eStruct(key Key, rv reflect.Value) {
-	// Write keys for fields directly under this key first, because if we write
-	// a field that creates a new table, then all keys under it will be in that
-	// table (not the one we're writing here).
-	rt := rv.Type()
-	var fieldsDirect, fieldsSub [][]int
-	var addFields func(rt reflect.Type, rv reflect.Value, start []int)
-	addFields = func(rt reflect.Type, rv reflect.Value, start []int) {
-		for i := 0; i < rt.NumField(); i++ {
-			f := rt.Field(i)
-			// skip unexported fields
-			if f.PkgPath != "" && !f.Anonymous {
-				continue
-			}
-			frv := rv.Field(i)
-			if f.Anonymous {
-				t := f.Type
-				switch t.Kind() {
-				case reflect.Struct:
-					// Treat anonymous struct fields with
-					// tag names as though they are not
-					// anonymous, like encoding/json does.
-					if getOptions(f.Tag).name == "" {
-						addFields(t, frv, f.Index)
-						continue
-					}
-				case reflect.Ptr:
-					if t.Elem().Kind() == reflect.Struct &&
-						getOptions(f.Tag).name == "" {
-						if !frv.IsNil() {
-							addFields(t.Elem(), frv.Elem(), f.Index)
-						}
-						continue
-					}
-					// Fall through to the normal field encoding logic below
-					// for non-struct anonymous fields.
-				}
-			}
-
-			if typeIsHash(tomlTypeOfGo(frv)) {
-				fieldsSub = append(fieldsSub, append(start, f.Index...))
-			} else {
-				fieldsDirect = append(fieldsDirect, append(start, f.Index...))
-			}
-		}
-	}
-	addFields(rt, rv, nil)
-
-	var writeFields = func(fields [][]int) {
-		for _, fieldIndex := range fields {
-			sft := rt.FieldByIndex(fieldIndex)
-			sf := rv.FieldByIndex(fieldIndex)
-			if isNil(sf) {
-				// Don't write anything for nil fields.
-				continue
-			}
-
-			opts := getOptions(sft.Tag)
-			if opts.skip {
-				continue
-			}
-			keyName := sft.Name
-			if opts.name != "" {
-				keyName = opts.name
-			}
-			if opts.omitempty && isEmpty(sf) {
-				continue
-			}
-			if opts.omitzero && isZero(sf) {
-				continue
-			}
-
-			enc.encode(key.add(keyName), sf)
-		}
-	}
-	writeFields(fieldsDirect)
-	writeFields(fieldsSub)
-}
-
-// tomlTypeName returns the TOML type name of the Go value's type. It is
-// used to determine whether the types of array elements are mixed (which is
-// forbidden). If the Go value is nil, then it is illegal for it to be an array
-// element, and valueIsNil is returned as true.
-
-// Returns the TOML type of a Go value. The type may be `nil`, which means
-// no concrete TOML type could be found.
-func tomlTypeOfGo(rv reflect.Value) tomlType {
-	if isNil(rv) || !rv.IsValid() {
-		return nil
-	}
-	switch rv.Kind() {
-	case reflect.Bool:
-		return tomlBool
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32,
-		reflect.Int64,
-		reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32,
-		reflect.Uint64:
-		return tomlInteger
-	case reflect.Float32, reflect.Float64:
-		return tomlFloat
-	case reflect.Array, reflect.Slice:
-		if typeEqual(tomlHash, tomlArrayType(rv)) {
-			return tomlArrayHash
-		}
-		return tomlArray
-	case reflect.Ptr, reflect.Interface:
-		return tomlTypeOfGo(rv.Elem())
-	case reflect.String:
-		return tomlString
-	case reflect.Map:
-		return tomlHash
-	case reflect.Struct:
-		switch rv.Interface().(type) {
-		case time.Time:
-			return tomlDatetime
-		case TextMarshaler:
-			return tomlString
-		default:
-			return tomlHash
-		}
-	default:
-		panic("unexpected reflect.Kind: " + rv.Kind().String())
-	}
-}
-
-// tomlArrayType returns the element type of a TOML array. The type returned
-// may be nil if it cannot be determined (e.g., a nil slice or a zero length
-// slize). This function may also panic if it finds a type that cannot be
-// expressed in TOML (such as nil elements, heterogeneous arrays or directly
-// nested arrays of tables).
-func tomlArrayType(rv reflect.Value) tomlType {
-	if isNil(rv) || !rv.IsValid() || rv.Len() == 0 {
-		return nil
-	}
-	firstType := tomlTypeOfGo(rv.Index(0))
-	if firstType == nil {
-		encPanic(errArrayNilElement)
-	}
-
-	rvlen := rv.Len()
-	for i := 1; i < rvlen; i++ {
-		elem := rv.Index(i)
-		switch elemType := tomlTypeOfGo(elem); {
-		case elemType == nil:
-			encPanic(errArrayNilElement)
-		case !typeEqual(firstType, elemType):
-			encPanic(errArrayMixedElementTypes)
-		}
-	}
-	// If we have a nested array, then we must make sure that the nested
-	// array contains ONLY primitives.
-	// This checks arbitrarily nested arrays.
-	if typeEqual(firstType, tomlArray) || typeEqual(firstType, tomlArrayHash) {
-		nest := tomlArrayType(eindirect(rv.Index(0)))
-		if typeEqual(nest, tomlHash) || typeEqual(nest, tomlArrayHash) {
-			encPanic(errArrayNoTable)
-		}
-	}
-	return firstType
-}
-
-type tagOptions struct {
-	skip      bool // "-"
-	name      string
-	omitempty bool
-	omitzero  bool
-}
-
-func getOptions(tag reflect.StructTag) tagOptions {
-	t := tag.Get("toml")
-	if t == "-" {
-		return tagOptions{skip: true}
-	}
-	var opts tagOptions
-	parts := strings.Split(t, ",")
-	opts.name = parts[0]
-	for _, s := range parts[1:] {
-		switch s {
-		case "omitempty":
-			opts.omitempty = true
-		case "omitzero":
-			opts.omitzero = true
-		}
-	}
-	return opts
-}
-
-func isZero(rv reflect.Value) bool {
-	switch rv.Kind() {
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		return rv.Int() == 0
-	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-		return rv.Uint() == 0
-	case reflect.Float32, reflect.Float64:
-		return rv.Float() == 0.0
-	}
-	return false
-}
-
-func isEmpty(rv reflect.Value) bool {
-	switch rv.Kind() {
-	case reflect.Array, reflect.Slice, reflect.Map, reflect.String:
-		return rv.Len() == 0
-	case reflect.Bool:
-		return !rv.Bool()
-	}
-	return false
-}
-
-func (enc *Encoder) newline() {
-	if enc.hasWritten {
-		enc.wf("\n")
-	}
-}
-
-func (enc *Encoder) keyEqElement(key Key, val reflect.Value) {
-	if len(key) == 0 {
-		encPanic(errNoKey)
-	}
-	panicIfInvalidKey(key)
-	enc.wf("%s%s = ", enc.indentStr(key), key.maybeQuoted(len(key)-1))
-	enc.eElement(val)
-	enc.newline()
-}
-
-func (enc *Encoder) wf(format string, v ...interface{}) {
-	if _, err := fmt.Fprintf(enc.w, format, v...); err != nil {
-		encPanic(err)
-	}
-	enc.hasWritten = true
-}
-
-func (enc *Encoder) indentStr(key Key) string {
-	return strings.Repeat(enc.Indent, len(key)-1)
-}
-
-func encPanic(err error) {
-	panic(tomlEncodeError{err})
-}
-
-func eindirect(v reflect.Value) reflect.Value {
-	switch v.Kind() {
-	case reflect.Ptr, reflect.Interface:
-		return eindirect(v.Elem())
-	default:
-		return v
-	}
-}
-
-func isNil(rv reflect.Value) bool {
-	switch rv.Kind() {
-	case reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
-		return rv.IsNil()
-	default:
-		return false
-	}
-}
-
-func panicIfInvalidKey(key Key) {
-	for _, k := range key {
-		if len(k) == 0 {
-			encPanic(e("Key '%s' is not a valid table name. Key names "+
-				"cannot be empty.", key.maybeQuotedAll()))
-		}
-	}
-}
-
-func isValidKeyName(s string) bool {
-	return len(s) != 0
-}
--- a/vendor/github.com/BurntSushi/toml/encoding_types.go
+++ b/vendor/github.com/BurntSushi/toml/encoding_types.go
@@ -1,19 +0,0 @@
-// +build go1.2
-
-package toml
-
-// In order to support Go 1.1, we define our own TextMarshaler and
-// TextUnmarshaler types. For Go 1.2+, we just alias them with the
-// standard library interfaces.
-
-import (
-	"encoding"
-)
-
-// TextMarshaler is a synonym for encoding.TextMarshaler. It is defined here
-// so that Go 1.1 can be supported.
-type TextMarshaler encoding.TextMarshaler
-
-// TextUnmarshaler is a synonym for encoding.TextUnmarshaler. It is defined
-// here so that Go 1.1 can be supported.
-type TextUnmarshaler encoding.TextUnmarshaler
--- a/vendor/github.com/BurntSushi/toml/encoding_types_1.1.go
+++ b/vendor/github.com/BurntSushi/toml/encoding_types_1.1.go
@@ -1,18 +0,0 @@
-// +build !go1.2
-
-package toml
-
-// These interfaces were introduced in Go 1.2, so we add them manually when
-// compiling for Go 1.1.
-
-// TextMarshaler is a synonym for encoding.TextMarshaler. It is defined here
-// so that Go 1.1 can be supported.
-type TextMarshaler interface {
-	MarshalText() (text []byte, err error)
-}
-
-// TextUnmarshaler is a synonym for encoding.TextUnmarshaler. It is defined
-// here so that Go 1.1 can be supported.
-type TextUnmarshaler interface {
-	UnmarshalText(text []byte) error
-}
--- a/vendor/github.com/BurntSushi/toml/lex.go
+++ b/vendor/github.com/BurntSushi/toml/lex.go
@@ -1,953 +0,0 @@
-package toml
-
-import (
-	"fmt"
-	"strings"
-	"unicode"
-	"unicode/utf8"
-)
-
-type itemType int
-
-const (
-	itemError itemType = iota
-	itemNIL            // used in the parser to indicate no type
-	itemEOF
-	itemText
-	itemString
-	itemRawString
-	itemMultilineString
-	itemRawMultilineString
-	itemBool
-	itemInteger
-	itemFloat
-	itemDatetime
-	itemArray // the start of an array
-	itemArrayEnd
-	itemTableStart
-	itemTableEnd
-	itemArrayTableStart
-	itemArrayTableEnd
-	itemKeyStart
-	itemCommentStart
-	itemInlineTableStart
-	itemInlineTableEnd
-)
-
-const (
-	eof              = 0
-	comma            = ','
-	tableStart       = '['
-	tableEnd         = ']'
-	arrayTableStart  = '['
-	arrayTableEnd    = ']'
-	tableSep         = '.'
-	keySep           = '='
-	arrayStart       = '['
-	arrayEnd         = ']'
-	commentStart     = '#'
-	stringStart      = '"'
-	stringEnd        = '"'
-	rawStringStart   = '\''
-	rawStringEnd     = '\''
-	inlineTableStart = '{'
-	inlineTableEnd   = '}'
-)
-
-type stateFn func(lx *lexer) stateFn
-
-type lexer struct {
-	input string
-	start int
-	pos   int
-	line  int
-	state stateFn
-	items chan item
-
-	// Allow for backing up up to three runes.
-	// This is necessary because TOML contains 3-rune tokens (""" and ''').
-	prevWidths [3]int
-	nprev      int // how many of prevWidths are in use
-	// If we emit an eof, we can still back up, but it is not OK to call
-	// next again.
-	atEOF bool
-
-	// A stack of state functions used to maintain context.
-	// The idea is to reuse parts of the state machine in various places.
-	// For example, values can appear at the top level or within arbitrarily
-	// nested arrays. The last state on the stack is used after a value has
-	// been lexed. Similarly for comments.
-	stack []stateFn
-}
-
-type item struct {
-	typ  itemType
-	val  string
-	line int
-}
-
-func (lx *lexer) nextItem() item {
-	for {
-		select {
-		case item := <-lx.items:
-			return item
-		default:
-			lx.state = lx.state(lx)
-		}
-	}
-}
-
-func lex(input string) *lexer {
-	lx := &lexer{
-		input: input,
-		state: lexTop,
-		line:  1,
-		items: make(chan item, 10),
-		stack: make([]stateFn, 0, 10),
-	}
-	return lx
-}
-
-func (lx *lexer) push(state stateFn) {
-	lx.stack = append(lx.stack, state)
-}
-
-func (lx *lexer) pop() stateFn {
-	if len(lx.stack) == 0 {
-		return lx.errorf("BUG in lexer: no states to pop")
-	}
-	last := lx.stack[len(lx.stack)-1]
-	lx.stack = lx.stack[0 : len(lx.stack)-1]
-	return last
-}
-
-func (lx *lexer) current() string {
-	return lx.input[lx.start:lx.pos]
-}
-
-func (lx *lexer) emit(typ itemType) {
-	lx.items <- item{typ, lx.current(), lx.line}
-	lx.start = lx.pos
-}
-
-func (lx *lexer) emitTrim(typ itemType) {
-	lx.items <- item{typ, strings.TrimSpace(lx.current()), lx.line}
-	lx.start = lx.pos
-}
-
-func (lx *lexer) next() (r rune) {
-	if lx.atEOF {
-		panic("next called after EOF")
-	}
-	if lx.pos >= len(lx.input) {
-		lx.atEOF = true
-		return eof
-	}
-
-	if lx.input[lx.pos] == '\n' {
-		lx.line++
-	}
-	lx.prevWidths[2] = lx.prevWidths[1]
-	lx.prevWidths[1] = lx.prevWidths[0]
-	if lx.nprev < 3 {
-		lx.nprev++
-	}
-	r, w := utf8.DecodeRuneInString(lx.input[lx.pos:])
-	lx.prevWidths[0] = w
-	lx.pos += w
-	return r
-}
-
-// ignore skips over the pending input before this point.
-func (lx *lexer) ignore() {
-	lx.start = lx.pos
-}
-
-// backup steps back one rune. Can be called only twice between calls to next.
-func (lx *lexer) backup() {
-	if lx.atEOF {
-		lx.atEOF = false
-		return
-	}
-	if lx.nprev < 1 {
-		panic("backed up too far")
-	}
-	w := lx.prevWidths[0]
-	lx.prevWidths[0] = lx.prevWidths[1]
-	lx.prevWidths[1] = lx.prevWidths[2]
-	lx.nprev--
-	lx.pos -= w
-	if lx.pos < len(lx.input) && lx.input[lx.pos] == '\n' {
-		lx.line--
-	}
-}
-
-// accept consumes the next rune if it's equal to `valid`.
-func (lx *lexer) accept(valid rune) bool {
-	if lx.next() == valid {
-		return true
-	}
-	lx.backup()
-	return false
-}
-
-// peek returns but does not consume the next rune in the input.
-func (lx *lexer) peek() rune {
-	r := lx.next()
-	lx.backup()
-	return r
-}
-
-// skip ignores all input that matches the given predicate.
-func (lx *lexer) skip(pred func(rune) bool) {
-	for {
-		r := lx.next()
-		if pred(r) {
-			continue
-		}
-		lx.backup()
-		lx.ignore()
-		return
-	}
-}
-
-// errorf stops all lexing by emitting an error and returning `nil`.
-// Note that any value that is a character is escaped if it's a special
-// character (newlines, tabs, etc.).
-func (lx *lexer) errorf(format string, values ...interface{}) stateFn {
-	lx.items <- item{
-		itemError,
-		fmt.Sprintf(format, values...),
-		lx.line,
-	}
-	return nil
-}
-
-// lexTop consumes elements at the top level of TOML data.
-func lexTop(lx *lexer) stateFn {
-	r := lx.next()
-	if isWhitespace(r) || isNL(r) {
-		return lexSkip(lx, lexTop)
-	}
-	switch r {
-	case commentStart:
-		lx.push(lexTop)
-		return lexCommentStart
-	case tableStart:
-		return lexTableStart
-	case eof:
-		if lx.pos > lx.start {
-			return lx.errorf("unexpected EOF")
-		}
-		lx.emit(itemEOF)
-		return nil
-	}
-
-	// At this point, the only valid item can be a key, so we back up
-	// and let the key lexer do the rest.
-	lx.backup()
-	lx.push(lexTopEnd)
-	return lexKeyStart
-}
-
-// lexTopEnd is entered whenever a top-level item has been consumed. (A value
-// or a table.) It must see only whitespace, and will turn back to lexTop
-// upon a newline. If it sees EOF, it will quit the lexer successfully.
-func lexTopEnd(lx *lexer) stateFn {
-	r := lx.next()
-	switch {
-	case r == commentStart:
-		// a comment will read to a newline for us.
-		lx.push(lexTop)
-		return lexCommentStart
-	case isWhitespace(r):
-		return lexTopEnd
-	case isNL(r):
-		lx.ignore()
-		return lexTop
-	case r == eof:
-		lx.emit(itemEOF)
-		return nil
-	}
-	return lx.errorf("expected a top-level item to end with a newline, "+
-		"comment, or EOF, but got %q instead", r)
-}
-
-// lexTable lexes the beginning of a table. Namely, it makes sure that
-// it starts with a character other than '.' and ']'.
-// It assumes that '[' has already been consumed.
-// It also handles the case that this is an item in an array of tables.
-// e.g., '[[name]]'.
-func lexTableStart(lx *lexer) stateFn {
-	if lx.peek() == arrayTableStart {
-		lx.next()
-		lx.emit(itemArrayTableStart)
-		lx.push(lexArrayTableEnd)
-	} else {
-		lx.emit(itemTableStart)
-		lx.push(lexTableEnd)
-	}
-	return lexTableNameStart
-}
-
-func lexTableEnd(lx *lexer) stateFn {
-	lx.emit(itemTableEnd)
-	return lexTopEnd
-}
-
-func lexArrayTableEnd(lx *lexer) stateFn {
-	if r := lx.next(); r != arrayTableEnd {
-		return lx.errorf("expected end of table array name delimiter %q, "+
-			"but got %q instead", arrayTableEnd, r)
-	}
-	lx.emit(itemArrayTableEnd)
-	return lexTopEnd
-}
-
-func lexTableNameStart(lx *lexer) stateFn {
-	lx.skip(isWhitespace)
-	switch r := lx.peek(); {
-	case r == tableEnd || r == eof:
-		return lx.errorf("unexpected end of table name " +
-			"(table names cannot be empty)")
-	case r == tableSep:
-		return lx.errorf("unexpected table separator " +
-			"(table names cannot be empty)")
-	case r == stringStart || r == rawStringStart:
-		lx.ignore()
-		lx.push(lexTableNameEnd)
-		return lexValue // reuse string lexing
-	default:
-		return lexBareTableName
-	}
-}
-
-// lexBareTableName lexes the name of a table. It assumes that at least one
-// valid character for the table has already been read.
-func lexBareTableName(lx *lexer) stateFn {
-	r := lx.next()
-	if isBareKeyChar(r) {
-		return lexBareTableName
-	}
-	lx.backup()
-	lx.emit(itemText)
-	return lexTableNameEnd
-}
-
-// lexTableNameEnd reads the end of a piece of a table name, optionally
-// consuming whitespace.
-func lexTableNameEnd(lx *lexer) stateFn {
-	lx.skip(isWhitespace)
-	switch r := lx.next(); {
-	case isWhitespace(r):
-		return lexTableNameEnd
-	case r == tableSep:
-		lx.ignore()
-		return lexTableNameStart
-	case r == tableEnd:
-		return lx.pop()
-	default:
-		return lx.errorf("expected '.' or ']' to end table name, "+
-			"but got %q instead", r)
-	}
-}
-
-// lexKeyStart consumes a key name up until the first non-whitespace character.
-// lexKeyStart will ignore whitespace.
-func lexKeyStart(lx *lexer) stateFn {
-	r := lx.peek()
-	switch {
-	case r == keySep:
-		return lx.errorf("unexpected key separator %q", keySep)
-	case isWhitespace(r) || isNL(r):
-		lx.next()
-		return lexSkip(lx, lexKeyStart)
-	case r == stringStart || r == rawStringStart:
-		lx.ignore()
-		lx.emit(itemKeyStart)
-		lx.push(lexKeyEnd)
-		return lexValue // reuse string lexing
-	default:
-		lx.ignore()
-		lx.emit(itemKeyStart)
-		return lexBareKey
-	}
-}
-
-// lexBareKey consumes the text of a bare key. Assumes that the first character
-// (which is not whitespace) has not yet been consumed.
-func lexBareKey(lx *lexer) stateFn {
-	switch r := lx.next(); {
-	case isBareKeyChar(r):
-		return lexBareKey
-	case isWhitespace(r):
-		lx.backup()
-		lx.emit(itemText)
-		return lexKeyEnd
-	case r == keySep:
-		lx.backup()
-		lx.emit(itemText)
-		return lexKeyEnd
-	default:
-		return lx.errorf("bare keys cannot contain %q", r)
-	}
-}
-
-// lexKeyEnd consumes the end of a key and trims whitespace (up to the key
-// separator).
-func lexKeyEnd(lx *lexer) stateFn {
-	switch r := lx.next(); {
-	case r == keySep:
-		return lexSkip(lx, lexValue)
-	case isWhitespace(r):
-		return lexSkip(lx, lexKeyEnd)
-	default:
-		return lx.errorf("expected key separator %q, but got %q instead",
-			keySep, r)
-	}
-}
-
-// lexValue starts the consumption of a value anywhere a value is expected.
-// lexValue will ignore whitespace.
-// After a value is lexed, the last state on the next is popped and returned.
-func lexValue(lx *lexer) stateFn {
-	// We allow whitespace to precede a value, but NOT newlines.
-	// In array syntax, the array states are responsible for ignoring newlines.
-	r := lx.next()
-	switch {
-	case isWhitespace(r):
-		return lexSkip(lx, lexValue)
-	case isDigit(r):
-		lx.backup() // avoid an extra state and use the same as above
-		return lexNumberOrDateStart
-	}
-	switch r {
-	case arrayStart:
-		lx.ignore()
-		lx.emit(itemArray)
-		return lexArrayValue
-	case inlineTableStart:
-		lx.ignore()
-		lx.emit(itemInlineTableStart)
-		return lexInlineTableValue
-	case stringStart:
-		if lx.accept(stringStart) {
-			if lx.accept(stringStart) {
-				lx.ignore() // Ignore """
-				return lexMultilineString
-			}
-			lx.backup()
-		}
-		lx.ignore() // ignore the '"'
-		return lexString
-	case rawStringStart:
-		if lx.accept(rawStringStart) {
-			if lx.accept(rawStringStart) {
-				lx.ignore() // Ignore """
-				return lexMultilineRawString
-			}
-			lx.backup()
-		}
-		lx.ignore() // ignore the "'"
-		return lexRawString
-	case '+', '-':
-		return lexNumberStart
-	case '.': // special error case, be kind to users
-		return lx.errorf("floats must start with a digit, not '.'")
-	}
-	if unicode.IsLetter(r) {
-		// Be permissive here; lexBool will give a nice error if the
-		// user wrote something like
-		//   x = foo
-		// (i.e. not 'true' or 'false' but is something else word-like.)
-		lx.backup()
-		return lexBool
-	}
-	return lx.errorf("expected value but found %q instead", r)
-}
-
-// lexArrayValue consumes one value in an array. It assumes that '[' or ','
-// have already been consumed. All whitespace and newlines are ignored.
-func lexArrayValue(lx *lexer) stateFn {
-	r := lx.next()
-	switch {
-	case isWhitespace(r) || isNL(r):
-		return lexSkip(lx, lexArrayValue)
-	case r == commentStart:
-		lx.push(lexArrayValue)
-		return lexCommentStart
-	case r == comma:
-		return lx.errorf("unexpected comma")
-	case r == arrayEnd:
-		// NOTE(caleb): The spec isn't clear about whether you can have
-		// a trailing comma or not, so we'll allow it.
-		return lexArrayEnd
-	}
-
-	lx.backup()
-	lx.push(lexArrayValueEnd)
-	return lexValue
-}
-
-// lexArrayValueEnd consumes everything between the end of an array value and
-// the next value (or the end of the array): it ignores whitespace and newlines
-// and expects either a ',' or a ']'.
-func lexArrayValueEnd(lx *lexer) stateFn {
-	r := lx.next()
-	switch {
-	case isWhitespace(r) || isNL(r):
-		return lexSkip(lx, lexArrayValueEnd)
-	case r == commentStart:
-		lx.push(lexArrayValueEnd)
-		return lexCommentStart
-	case r == comma:
-		lx.ignore()
-		return lexArrayValue // move on to the next value
-	case r == arrayEnd:
-		return lexArrayEnd
-	}
-	return lx.errorf(
-		"expected a comma or array terminator %q, but got %q instead",
-		arrayEnd, r,
-	)
-}
-
-// lexArrayEnd finishes the lexing of an array.
-// It assumes that a ']' has just been consumed.
-func lexArrayEnd(lx *lexer) stateFn {
-	lx.ignore()
-	lx.emit(itemArrayEnd)
-	return lx.pop()
-}
-
-// lexInlineTableValue consumes one key/value pair in an inline table.
-// It assumes that '{' or ',' have already been consumed. Whitespace is ignored.
-func lexInlineTableValue(lx *lexer) stateFn {
-	r := lx.next()
-	switch {
-	case isWhitespace(r):
-		return lexSkip(lx, lexInlineTableValue)
-	case isNL(r):
-		return lx.errorf("newlines not allowed within inline tables")
-	case r == commentStart:
-		lx.push(lexInlineTableValue)
-		return lexCommentStart
-	case r == comma:
-		return lx.errorf("unexpected comma")
-	case r == inlineTableEnd:
-		return lexInlineTableEnd
-	}
-	lx.backup()
-	lx.push(lexInlineTableValueEnd)
-	return lexKeyStart
-}
-
-// lexInlineTableValueEnd consumes everything between the end of an inline table
-// key/value pair and the next pair (or the end of the table):
-// it ignores whitespace and expects either a ',' or a '}'.
-func lexInlineTableValueEnd(lx *lexer) stateFn {
-	r := lx.next()
-	switch {
-	case isWhitespace(r):
-		return lexSkip(lx, lexInlineTableValueEnd)
-	case isNL(r):
-		return lx.errorf("newlines not allowed within inline tables")
-	case r == commentStart:
-		lx.push(lexInlineTableValueEnd)
-		return lexCommentStart
-	case r == comma:
-		lx.ignore()
-		return lexInlineTableValue
-	case r == inlineTableEnd:
-		return lexInlineTableEnd
-	}
-	return lx.errorf("expected a comma or an inline table terminator %q, "+
-		"but got %q instead", inlineTableEnd, r)
-}
-
-// lexInlineTableEnd finishes the lexing of an inline table.
-// It assumes that a '}' has just been consumed.
-func lexInlineTableEnd(lx *lexer) stateFn {
-	lx.ignore()
-	lx.emit(itemInlineTableEnd)
-	return lx.pop()
-}
-
-// lexString consumes the inner contents of a string. It assumes that the
-// beginning '"' has already been consumed and ignored.
-func lexString(lx *lexer) stateFn {
-	r := lx.next()
-	switch {
-	case r == eof:
-		return lx.errorf("unexpected EOF")
-	case isNL(r):
-		return lx.errorf("strings cannot contain newlines")
-	case r == '\\':
-		lx.push(lexString)
-		return lexStringEscape
-	case r == stringEnd:
-		lx.backup()
-		lx.emit(itemString)
-		lx.next()
-		lx.ignore()
-		return lx.pop()
-	}
-	return lexString
-}
-
-// lexMultilineString consumes the inner contents of a string. It assumes that
-// the beginning '"""' has already been consumed and ignored.
-func lexMultilineString(lx *lexer) stateFn {
-	switch lx.next() {
-	case eof:
-		return lx.errorf("unexpected EOF")
-	case '\\':
-		return lexMultilineStringEscape
-	case stringEnd:
-		if lx.accept(stringEnd) {
-			if lx.accept(stringEnd) {
-				lx.backup()
-				lx.backup()
-				lx.backup()
-				lx.emit(itemMultilineString)
-				lx.next()
-				lx.next()
-				lx.next()
-				lx.ignore()
-				return lx.pop()
-			}
-			lx.backup()
-		}
-	}
-	return lexMultilineString
-}
-
-// lexRawString consumes a raw string. Nothing can be escaped in such a string.
-// It assumes that the beginning "'" has already been consumed and ignored.
-func lexRawString(lx *lexer) stateFn {
-	r := lx.next()
-	switch {
-	case r == eof:
-		return lx.errorf("unexpected EOF")
-	case isNL(r):
-		return lx.errorf("strings cannot contain newlines")
-	case r == rawStringEnd:
-		lx.backup()
-		lx.emit(itemRawString)
-		lx.next()
-		lx.ignore()
-		return lx.pop()
-	}
-	return lexRawString
-}
-
-// lexMultilineRawString consumes a raw string. Nothing can be escaped in such
-// a string. It assumes that the beginning "'''" has already been consumed and
-// ignored.
-func lexMultilineRawString(lx *lexer) stateFn {
-	switch lx.next() {
-	case eof:
-		return lx.errorf("unexpected EOF")
-	case rawStringEnd:
-		if lx.accept(rawStringEnd) {
-			if lx.accept(rawStringEnd) {
-				lx.backup()
-				lx.backup()
-				lx.backup()
-				lx.emit(itemRawMultilineString)
-				lx.next()
-				lx.next()
-				lx.next()
-				lx.ignore()
-				return lx.pop()
-			}
-			lx.backup()
-		}
-	}
-	return lexMultilineRawString
-}
-
-// lexMultilineStringEscape consumes an escaped character. It assumes that the
-// preceding '\\' has already been consumed.
-func lexMultilineStringEscape(lx *lexer) stateFn {
-	// Handle the special case first:
-	if isNL(lx.next()) {
-		return lexMultilineString
-	}
-	lx.backup()
-	lx.push(lexMultilineString)
-	return lexStringEscape(lx)
-}
-
-func lexStringEscape(lx *lexer) stateFn {
-	r := lx.next()
-	switch r {
-	case 'b':
-		fallthrough
-	case 't':
-		fallthrough
-	case 'n':
-		fallthrough
-	case 'f':
-		fallthrough
-	case 'r':
-		fallthrough
-	case '"':
-		fallthrough
-	case '\\':
-		return lx.pop()
-	case 'u':
-		return lexShortUnicodeEscape
-	case 'U':
-		return lexLongUnicodeEscape
-	}
-	return lx.errorf("invalid escape character %q; only the following "+
-		"escape characters are allowed: "+
-		`\b, \t, \n, \f, \r, \", \\, \uXXXX, and \UXXXXXXXX`, r)
-}
-
-func lexShortUnicodeEscape(lx *lexer) stateFn {
-	var r rune
-	for i := 0; i < 4; i++ {
-		r = lx.next()
-		if !isHexadecimal(r) {
-			return lx.errorf(`expected four hexadecimal digits after '\u', `+
-				"but got %q instead", lx.current())
-		}
-	}
-	return lx.pop()
-}
-
-func lexLongUnicodeEscape(lx *lexer) stateFn {
-	var r rune
-	for i := 0; i < 8; i++ {
-		r = lx.next()
-		if !isHexadecimal(r) {
-			return lx.errorf(`expected eight hexadecimal digits after '\U', `+
-				"but got %q instead", lx.current())
-		}
-	}
-	return lx.pop()
-}
-
-// lexNumberOrDateStart consumes either an integer, a float, or datetime.
-func lexNumberOrDateStart(lx *lexer) stateFn {
-	r := lx.next()
-	if isDigit(r) {
-		return lexNumberOrDate
-	}
-	switch r {
-	case '_':
-		return lexNumber
-	case 'e', 'E':
-		return lexFloat
-	case '.':
-		return lx.errorf("floats must start with a digit, not '.'")
-	}
-	return lx.errorf("expected a digit but got %q", r)
-}
-
-// lexNumberOrDate consumes either an integer, float or datetime.
-func lexNumberOrDate(lx *lexer) stateFn {
-	r := lx.next()
-	if isDigit(r) {
-		return lexNumberOrDate
-	}
-	switch r {
-	case '-':
-		return lexDatetime
-	case '_':
-		return lexNumber
-	case '.', 'e', 'E':
-		return lexFloat
-	}
-
-	lx.backup()
-	lx.emit(itemInteger)
-	return lx.pop()
-}
-
-// lexDatetime consumes a Datetime, to a first approximation.
-// The parser validates that it matches one of the accepted formats.
-func lexDatetime(lx *lexer) stateFn {
-	r := lx.next()
-	if isDigit(r) {
-		return lexDatetime
-	}
-	switch r {
-	case '-', 'T', ':', '.', 'Z', '+':
-		return lexDatetime
-	}
-
-	lx.backup()
-	lx.emit(itemDatetime)
-	return lx.pop()
-}
-
-// lexNumberStart consumes either an integer or a float. It assumes that a sign
-// has already been read, but that *no* digits have been consumed.
-// lexNumberStart will move to the appropriate integer or float states.
-func lexNumberStart(lx *lexer) stateFn {
-	// We MUST see a digit. Even floats have to start with a digit.
-	r := lx.next()
-	if !isDigit(r) {
-		if r == '.' {
-			return lx.errorf("floats must start with a digit, not '.'")
-		}
-		return lx.errorf("expected a digit but got %q", r)
-	}
-	return lexNumber
-}
-
-// lexNumber consumes an integer or a float after seeing the first digit.
-func lexNumber(lx *lexer) stateFn {
-	r := lx.next()
-	if isDigit(r) {
-		return lexNumber
-	}
-	switch r {
-	case '_':
-		return lexNumber
-	case '.', 'e', 'E':
-		return lexFloat
-	}
-
-	lx.backup()
-	lx.emit(itemInteger)
-	return lx.pop()
-}
-
-// lexFloat consumes the elements of a float. It allows any sequence of
-// float-like characters, so floats emitted by the lexer are only a first
-// approximation and must be validated by the parser.
-func lexFloat(lx *lexer) stateFn {
-	r := lx.next()
-	if isDigit(r) {
-		return lexFloat
-	}
-	switch r {
-	case '_', '.', '-', '+', 'e', 'E':
-		return lexFloat
-	}
-
-	lx.backup()
-	lx.emit(itemFloat)
-	return lx.pop()
-}
-
-// lexBool consumes a bool string: 'true' or 'false.
-func lexBool(lx *lexer) stateFn {
-	var rs []rune
-	for {
-		r := lx.next()
-		if !unicode.IsLetter(r) {
-			lx.backup()
-			break
-		}
-		rs = append(rs, r)
-	}
-	s := string(rs)
-	switch s {
-	case "true", "false":
-		lx.emit(itemBool)
-		return lx.pop()
-	}
-	return lx.errorf("expected value but found %q instead", s)
-}
-
-// lexCommentStart begins the lexing of a comment. It will emit
-// itemCommentStart and consume no characters, passing control to lexComment.
-func lexCommentStart(lx *lexer) stateFn {
-	lx.ignore()
-	lx.emit(itemCommentStart)
-	return lexComment
-}
-
-// lexComment lexes an entire comment. It assumes that '#' has been consumed.
-// It will consume *up to* the first newline character, and pass control
-// back to the last state on the stack.
-func lexComment(lx *lexer) stateFn {
-	r := lx.peek()
-	if isNL(r) || r == eof {
-		lx.emit(itemText)
-		return lx.pop()
-	}
-	lx.next()
-	return lexComment
-}
-
-// lexSkip ignores all slurped input and moves on to the next state.
-func lexSkip(lx *lexer, nextState stateFn) stateFn {
-	return func(lx *lexer) stateFn {
-		lx.ignore()
-		return nextState
-	}
-}
-
-// isWhitespace returns true if `r` is a whitespace character according
-// to the spec.
-func isWhitespace(r rune) bool {
-	return r == '\t' || r == ' '
-}
-
-func isNL(r rune) bool {
-	return r == '\n' || r == '\r'
-}
-
-func isDigit(r rune) bool {
-	return r >= '0' && r <= '9'
-}
-
-func isHexadecimal(r rune) bool {
-	return (r >= '0' && r <= '9') ||
-		(r >= 'a' && r <= 'f') ||
-		(r >= 'A' && r <= 'F')
-}
-
-func isBareKeyChar(r rune) bool {
-	return (r >= 'A' && r <= 'Z') ||
-		(r >= 'a' && r <= 'z') ||
-		(r >= '0' && r <= '9') ||
-		r == '_' ||
-		r == '-'
-}
-
-func (itype itemType) String() string {
-	switch itype {
-	case itemError:
-		return "Error"
-	case itemNIL:
-		return "NIL"
-	case itemEOF:
-		return "EOF"
-	case itemText:
-		return "Text"
-	case itemString, itemRawString, itemMultilineString, itemRawMultilineString:
-		return "String"
-	case itemBool:
-		return "Bool"
-	case itemInteger:
-		return "Integer"
-	case itemFloat:
-		return "Float"
-	case itemDatetime:
-		return "DateTime"
-	case itemTableStart:
-		return "TableStart"
-	case itemTableEnd:
-		return "TableEnd"
-	case itemKeyStart:
-		return "KeyStart"
-	case itemArray:
-		return "Array"
-	case itemArrayEnd:
-		return "ArrayEnd"
-	case itemCommentStart:
-		return "CommentStart"
-	}
-	panic(fmt.Sprintf("BUG: Unknown type '%d'.", int(itype)))
-}
-
-func (item item) String() string {
-	return fmt.Sprintf("(%s, %s)", item.typ.String(), item.val)
-}
--- a/vendor/github.com/BurntSushi/toml/parse.go
+++ b/vendor/github.com/BurntSushi/toml/parse.go
@@ -1,592 +0,0 @@
-package toml
-
-import (
-	"fmt"
-	"strconv"
-	"strings"
-	"time"
-	"unicode"
-	"unicode/utf8"
-)
-
-type parser struct {
-	mapping map[string]interface{}
-	types   map[string]tomlType
-	lx      *lexer
-
-	// A list of keys in the order that they appear in the TOML data.
-	ordered []Key
-
-	// the full key for the current hash in scope
-	context Key
-
-	// the base key name for everything except hashes
-	currentKey string
-
-	// rough approximation of line number
-	approxLine int
-
-	// A map of 'key.group.names' to whether they were created implicitly.
-	implicits map[string]bool
-}
-
-type parseError string
-
-func (pe parseError) Error() string {
-	return string(pe)
-}
-
-func parse(data string) (p *parser, err error) {
-	defer func() {
-		if r := recover(); r != nil {
-			var ok bool
-			if err, ok = r.(parseError); ok {
-				return
-			}
-			panic(r)
-		}
-	}()
-
-	p = &parser{
-		mapping:   make(map[string]interface{}),
-		types:     make(map[string]tomlType),
-		lx:        lex(data),
-		ordered:   make([]Key, 0),
-		implicits: make(map[string]bool),
-	}
-	for {
-		item := p.next()
-		if item.typ == itemEOF {
-			break
-		}
-		p.topLevel(item)
-	}
-
-	return p, nil
-}
-
-func (p *parser) panicf(format string, v ...interface{}) {
-	msg := fmt.Sprintf("Near line %d (last key parsed '%s'): %s",
-		p.approxLine, p.current(), fmt.Sprintf(format, v...))
-	panic(parseError(msg))
-}
-
-func (p *parser) next() item {
-	it := p.lx.nextItem()
-	if it.typ == itemError {
-		p.panicf("%s", it.val)
-	}
-	return it
-}
-
-func (p *parser) bug(format string, v ...interface{}) {
-	panic(fmt.Sprintf("BUG: "+format+"\n\n", v...))
-}
-
-func (p *parser) expect(typ itemType) item {
-	it := p.next()
-	p.assertEqual(typ, it.typ)
-	return it
-}
-
-func (p *parser) assertEqual(expected, got itemType) {
-	if expected != got {
-		p.bug("Expected '%s' but got '%s'.", expected, got)
-	}
-}
-
-func (p *parser) topLevel(item item) {
-	switch item.typ {
-	case itemCommentStart:
-		p.approxLine = item.line
-		p.expect(itemText)
-	case itemTableStart:
-		kg := p.next()
-		p.approxLine = kg.line
-
-		var key Key
-		for ; kg.typ != itemTableEnd && kg.typ != itemEOF; kg = p.next() {
-			key = append(key, p.keyString(kg))
-		}
-		p.assertEqual(itemTableEnd, kg.typ)
-
-		p.establishContext(key, false)
-		p.setType("", tomlHash)
-		p.ordered = append(p.ordered, key)
-	case itemArrayTableStart:
-		kg := p.next()
-		p.approxLine = kg.line
-
-		var key Key
-		for ; kg.typ != itemArrayTableEnd && kg.typ != itemEOF; kg = p.next() {
-			key = append(key, p.keyString(kg))
-		}
-		p.assertEqual(itemArrayTableEnd, kg.typ)
-
-		p.establishContext(key, true)
-		p.setType("", tomlArrayHash)
-		p.ordered = append(p.ordered, key)
-	case itemKeyStart:
-		kname := p.next()
-		p.approxLine = kname.line
-		p.currentKey = p.keyString(kname)
-
-		val, typ := p.value(p.next())
-		p.setValue(p.currentKey, val)
-		p.setType(p.currentKey, typ)
-		p.ordered = append(p.ordered, p.context.add(p.currentKey))
-		p.currentKey = ""
-	default:
-		p.bug("Unexpected type at top level: %s", item.typ)
-	}
-}
-
-// Gets a string for a key (or part of a key in a table name).
-func (p *parser) keyString(it item) string {
-	switch it.typ {
-	case itemText:
-		return it.val
-	case itemString, itemMultilineString,
-		itemRawString, itemRawMultilineString:
-		s, _ := p.value(it)
-		return s.(string)
-	default:
-		p.bug("Unexpected key type: %s", it.typ)
-		panic("unreachable")
-	}
-}
-
-// value translates an expected value from the lexer into a Go value wrapped
-// as an empty interface.
-func (p *parser) value(it item) (interface{}, tomlType) {
-	switch it.typ {
-	case itemString:
-		return p.replaceEscapes(it.val), p.typeOfPrimitive(it)
-	case itemMultilineString:
-		trimmed := stripFirstNewline(stripEscapedWhitespace(it.val))
-		return p.replaceEscapes(trimmed), p.typeOfPrimitive(it)
-	case itemRawString:
-		return it.val, p.typeOfPrimitive(it)
-	case itemRawMultilineString:
-		return stripFirstNewline(it.val), p.typeOfPrimitive(it)
-	case itemBool:
-		switch it.val {
-		case "true":
-			return true, p.typeOfPrimitive(it)
-		case "false":
-			return false, p.typeOfPrimitive(it)
-		}
-		p.bug("Expected boolean value, but got '%s'.", it.val)
-	case itemInteger:
-		if !numUnderscoresOK(it.val) {
-			p.panicf("Invalid integer %q: underscores must be surrounded by digits",
-				it.val)
-		}
-		val := strings.Replace(it.val, "_", "", -1)
-		num, err := strconv.ParseInt(val, 10, 64)
-		if err != nil {
-			// Distinguish integer values. Normally, it'd be a bug if the lexer
-			// provides an invalid integer, but it's possible that the number is
-			// out of range of valid values (which the lexer cannot determine).
-			// So mark the former as a bug but the latter as a legitimate user
-			// error.
-			if e, ok := err.(*strconv.NumError); ok &&
-				e.Err == strconv.ErrRange {
-
-				p.panicf("Integer '%s' is out of the range of 64-bit "+
-					"signed integers.", it.val)
-			} else {
-				p.bug("Expected integer value, but got '%s'.", it.val)
-			}
-		}
-		return num, p.typeOfPrimitive(it)
-	case itemFloat:
-		parts := strings.FieldsFunc(it.val, func(r rune) bool {
-			switch r {
-			case '.', 'e', 'E':
-				return true
-			}
-			return false
-		})
-		for _, part := range parts {
-			if !numUnderscoresOK(part) {
-				p.panicf("Invalid float %q: underscores must be "+
-					"surrounded by digits", it.val)
-			}
-		}
-		if !numPeriodsOK(it.val) {
-			// As a special case, numbers like '123.' or '1.e2',
-			// which are valid as far as Go/strconv are concerned,
-			// must be rejected because TOML says that a fractional
-			// part consists of '.' followed by 1+ digits.
-			p.panicf("Invalid float %q: '.' must be followed "+
-				"by one or more digits", it.val)
-		}
-		val := strings.Replace(it.val, "_", "", -1)
-		num, err := strconv.ParseFloat(val, 64)
-		if err != nil {
-			if e, ok := err.(*strconv.NumError); ok &&
-				e.Err == strconv.ErrRange {
-
-				p.panicf("Float '%s' is out of the range of 64-bit "+
-					"IEEE-754 floating-point numbers.", it.val)
-			} else {
-				p.panicf("Invalid float value: %q", it.val)
-			}
-		}
-		return num, p.typeOfPrimitive(it)
-	case itemDatetime:
-		var t time.Time
-		var ok bool
-		var err error
-		for _, format := range []string{
-			"2006-01-02T15:04:05Z07:00",
-			"2006-01-02T15:04:05",
-			"2006-01-02",
-		} {
-			t, err = time.ParseInLocation(format, it.val, time.Local)
-			if err == nil {
-				ok = true
-				break
-			}
-		}
-		if !ok {
-			p.panicf("Invalid TOML Datetime: %q.", it.val)
-		}
-		return t, p.typeOfPrimitive(it)
-	case itemArray:
-		array := make([]interface{}, 0)
-		types := make([]tomlType, 0)
-
-		for it = p.next(); it.typ != itemArrayEnd; it = p.next() {
-			if it.typ == itemCommentStart {
-				p.expect(itemText)
-				continue
-			}
-
-			val, typ := p.value(it)
-			array = append(array, val)
-			types = append(types, typ)
-		}
-		return array, p.typeOfArray(types)
-	case itemInlineTableStart:
-		var (
-			hash         = make(map[string]interface{})
-			outerContext = p.context
-			outerKey     = p.currentKey
-		)
-
-		p.context = append(p.context, p.currentKey)
-		p.currentKey = ""
-		for it := p.next(); it.typ != itemInlineTableEnd; it = p.next() {
-			if it.typ != itemKeyStart {
-				p.bug("Expected key start but instead found %q, around line %d",
-					it.val, p.approxLine)
-			}
-			if it.typ == itemCommentStart {
-				p.expect(itemText)
-				continue
-			}
-
-			// retrieve key
-			k := p.next()
-			p.approxLine = k.line
-			kname := p.keyString(k)
-
-			// retrieve value
-			p.currentKey = kname
-			val, typ := p.value(p.next())
-			// make sure we keep metadata up to date
-			p.setType(kname, typ)
-			p.ordered = append(p.ordered, p.context.add(p.currentKey))
-			hash[kname] = val
-		}
-		p.context = outerContext
-		p.currentKey = outerKey
-		return hash, tomlHash
-	}
-	p.bug("Unexpected value type: %s", it.typ)
-	panic("unreachable")
-}
-
-// numUnderscoresOK checks whether each underscore in s is surrounded by
-// characters that are not underscores.
-func numUnderscoresOK(s string) bool {
-	accept := false
-	for _, r := range s {
-		if r == '_' {
-			if !accept {
-				return false
-			}
-			accept = false
-			continue
-		}
-		accept = true
-	}
-	return accept
-}
-
-// numPeriodsOK checks whether every period in s is followed by a digit.
-func numPeriodsOK(s string) bool {
-	period := false
-	for _, r := range s {
-		if period && !isDigit(r) {
-			return false
-		}
-		period = r == '.'
-	}
-	return !period
-}
-
-// establishContext sets the current context of the parser,
-// where the context is either a hash or an array of hashes. Which one is
-// set depends on the value of the `array` parameter.
-//
-// Establishing the context also makes sure that the key isn't a duplicate, and
-// will create implicit hashes automatically.
-func (p *parser) establishContext(key Key, array bool) {
-	var ok bool
-
-	// Always start at the top level and drill down for our context.
-	hashContext := p.mapping
-	keyContext := make(Key, 0)
-
-	// We only need implicit hashes for key[0:-1]
-	for _, k := range key[0 : len(key)-1] {
-		_, ok = hashContext[k]
-		keyContext = append(keyContext, k)
-
-		// No key? Make an implicit hash and move on.
-		if !ok {
-			p.addImplicit(keyContext)
-			hashContext[k] = make(map[string]interface{})
-		}
-
-		// If the hash context is actually an array of tables, then set
-		// the hash context to the last element in that array.
-		//
-		// Otherwise, it better be a table, since this MUST be a key group (by
-		// virtue of it not being the last element in a key).
-		switch t := hashContext[k].(type) {
-		case []map[string]interface{}:
-			hashContext = t[len(t)-1]
-		case map[string]interface{}:
-			hashContext = t
-		default:
-			p.panicf("Key '%s' was already created as a hash.", keyContext)
-		}
-	}
-
-	p.context = keyContext
-	if array {
-		// If this is the first element for this array, then allocate a new
-		// list of tables for it.
-		k := key[len(key)-1]
-		if _, ok := hashContext[k]; !ok {
-			hashContext[k] = make([]map[string]interface{}, 0, 5)
-		}
-
-		// Add a new table. But make sure the key hasn't already been used
-		// for something else.
-		if hash, ok := hashContext[k].([]map[string]interface{}); ok {
-			hashContext[k] = append(hash, make(map[string]interface{}))
-		} else {
-			p.panicf("Key '%s' was already created and cannot be used as "+
-				"an array.", keyContext)
-		}
-	} else {
-		p.setValue(key[len(key)-1], make(map[string]interface{}))
-	}
-	p.context = append(p.context, key[len(key)-1])
-}
-
-// setValue sets the given key to the given value in the current context.
-// It will make sure that the key hasn't already been defined, account for
-// implicit key groups.
-func (p *parser) setValue(key string, value interface{}) {
-	var tmpHash interface{}
-	var ok bool
-
-	hash := p.mapping
-	keyContext := make(Key, 0)
-	for _, k := range p.context {
-		keyContext = append(keyContext, k)
-		if tmpHash, ok = hash[k]; !ok {
-			p.bug("Context for key '%s' has not been established.", keyContext)
-		}
-		switch t := tmpHash.(type) {
-		case []map[string]interface{}:
-			// The context is a table of hashes. Pick the most recent table
-			// defined as the current hash.
-			hash = t[len(t)-1]
-		case map[string]interface{}:
-			hash = t
-		default:
-			p.bug("Expected hash to have type 'map[string]interface{}', but "+
-				"it has '%T' instead.", tmpHash)
-		}
-	}
-	keyContext = append(keyContext, key)
-
-	if _, ok := hash[key]; ok {
-		// Typically, if the given key has already been set, then we have
-		// to raise an error since duplicate keys are disallowed. However,
-		// it's possible that a key was previously defined implicitly. In this
-		// case, it is allowed to be redefined concretely. (See the
-		// `tests/valid/implicit-and-explicit-after.toml` test in `toml-test`.)
-		//
-		// But we have to make sure to stop marking it as an implicit. (So that
-		// another redefinition provokes an error.)
-		//
-		// Note that since it has already been defined (as a hash), we don't
-		// want to overwrite it. So our business is done.
-		if p.isImplicit(keyContext) {
-			p.removeImplicit(keyContext)
-			return
-		}
-
-		// Otherwise, we have a concrete key trying to override a previous
-		// key, which is *always* wrong.
-		p.panicf("Key '%s' has already been defined.", keyContext)
-	}
-	hash[key] = value
-}
-
-// setType sets the type of a particular value at a given key.
-// It should be called immediately AFTER setValue.
-//
-// Note that if `key` is empty, then the type given will be applied to the
-// current context (which is either a table or an array of tables).
-func (p *parser) setType(key string, typ tomlType) {
-	keyContext := make(Key, 0, len(p.context)+1)
-	for _, k := range p.context {
-		keyContext = append(keyContext, k)
-	}
-	if len(key) > 0 { // allow type setting for hashes
-		keyContext = append(keyContext, key)
-	}
-	p.types[keyContext.String()] = typ
-}
-
-// addImplicit sets the given Key as having been created implicitly.
-func (p *parser) addImplicit(key Key) {
-	p.implicits[key.String()] = true
-}
-
-// removeImplicit stops tagging the given key as having been implicitly
-// created.
-func (p *parser) removeImplicit(key Key) {
-	p.implicits[key.String()] = false
-}
-
-// isImplicit returns true if the key group pointed to by the key was created
-// implicitly.
-func (p *parser) isImplicit(key Key) bool {
-	return p.implicits[key.String()]
-}
-
-// current returns the full key name of the current context.
-func (p *parser) current() string {
-	if len(p.currentKey) == 0 {
-		return p.context.String()
-	}
-	if len(p.context) == 0 {
-		return p.currentKey
-	}
-	return fmt.Sprintf("%s.%s", p.context, p.currentKey)
-}
-
-func stripFirstNewline(s string) string {
-	if len(s) == 0 || s[0] != '\n' {
-		return s
-	}
-	return s[1:]
-}
-
-func stripEscapedWhitespace(s string) string {
-	esc := strings.Split(s, "\\\n")
-	if len(esc) > 1 {
-		for i := 1; i < len(esc); i++ {
-			esc[i] = strings.TrimLeftFunc(esc[i], unicode.IsSpace)
-		}
-	}
-	return strings.Join(esc, "")
-}
-
-func (p *parser) replaceEscapes(str string) string {
-	var replaced []rune
-	s := []byte(str)
-	r := 0
-	for r < len(s) {
-		if s[r] != '\\' {
-			c, size := utf8.DecodeRune(s[r:])
-			r += size
-			replaced = append(replaced, c)
-			continue
-		}
-		r += 1
-		if r >= len(s) {
-			p.bug("Escape sequence at end of string.")
-			return ""
-		}
-		switch s[r] {
-		default:
-			p.bug("Expected valid escape code after \\, but got %q.", s[r])
-			return ""
-		case 'b':
-			replaced = append(replaced, rune(0x0008))
-			r += 1
-		case 't':
-			replaced = append(replaced, rune(0x0009))
-			r += 1
-		case 'n':
-			replaced = append(replaced, rune(0x000A))
-			r += 1
-		case 'f':
-			replaced = append(replaced, rune(0x000C))
-			r += 1
-		case 'r':
-			replaced = append(replaced, rune(0x000D))
-			r += 1
-		case '"':
-			replaced = append(replaced, rune(0x0022))
-			r += 1
-		case '\\':
-			replaced = append(replaced, rune(0x005C))
-			r += 1
-		case 'u':
-			// At this point, we know we have a Unicode escape of the form
-			// `uXXXX` at [r, r+5). (Because the lexer guarantees this
-			// for us.)
-			escaped := p.asciiEscapeToUnicode(s[r+1 : r+5])
-			replaced = append(replaced, escaped)
-			r += 5
-		case 'U':
-			// At this point, we know we have a Unicode escape of the form
-			// `uXXXX` at [r, r+9). (Because the lexer guarantees this
-			// for us.)
-			escaped := p.asciiEscapeToUnicode(s[r+1 : r+9])
-			replaced = append(replaced, escaped)
-			r += 9
-		}
-	}
-	return string(replaced)
-}
-
-func (p *parser) asciiEscapeToUnicode(bs []byte) rune {
-	s := string(bs)
-	hex, err := strconv.ParseUint(strings.ToLower(s), 16, 32)
-	if err != nil {
-		p.bug("Could not parse '%s' as a hexadecimal number, but the "+
-			"lexer claims it's OK: %s", s, err)
-	}
-	if !utf8.ValidRune(rune(hex)) {
-		p.panicf("Escaped character '\\u%s' is not valid UTF-8.", s)
-	}
-	return rune(hex)
-}
-
-func isStringType(ty itemType) bool {
-	return ty == itemString || ty == itemMultilineString ||
-		ty == itemRawString || ty == itemRawMultilineString
-}
--- a/vendor/github.com/BurntSushi/toml/session.vim
+++ b/vendor/github.com/BurntSushi/toml/session.vim
@@ -1 +0,0 @@
-au BufWritePost *.go silent!make tags > /dev/null 2>&1
--- a/vendor/github.com/BurntSushi/toml/type_check.go
+++ b/vendor/github.com/BurntSushi/toml/type_check.go
@@ -1,91 +0,0 @@
-package toml
-
-// tomlType represents any Go type that corresponds to a TOML type.
-// While the first draft of the TOML spec has a simplistic type system that
-// probably doesn't need this level of sophistication, we seem to be militating
-// toward adding real composite types.
-type tomlType interface {
-	typeString() string
-}
-
-// typeEqual accepts any two types and returns true if they are equal.
-func typeEqual(t1, t2 tomlType) bool {
-	if t1 == nil || t2 == nil {
-		return false
-	}
-	return t1.typeString() == t2.typeString()
-}
-
-func typeIsHash(t tomlType) bool {
-	return typeEqual(t, tomlHash) || typeEqual(t, tomlArrayHash)
-}
-
-type tomlBaseType string
-
-func (btype tomlBaseType) typeString() string {
-	return string(btype)
-}
-
-func (btype tomlBaseType) String() string {
-	return btype.typeString()
-}
-
-var (
-	tomlInteger   tomlBaseType = "Integer"
-	tomlFloat     tomlBaseType = "Float"
-	tomlDatetime  tomlBaseType = "Datetime"
-	tomlString    tomlBaseType = "String"
-	tomlBool      tomlBaseType = "Bool"
-	tomlArray     tomlBaseType = "Array"
-	tomlHash      tomlBaseType = "Hash"
-	tomlArrayHash tomlBaseType = "ArrayHash"
-)
-
-// typeOfPrimitive returns a tomlType of any primitive value in TOML.
-// Primitive values are: Integer, Float, Datetime, String and Bool.
-//
-// Passing a lexer item other than the following will cause a BUG message
-// to occur: itemString, itemBool, itemInteger, itemFloat, itemDatetime.
-func (p *parser) typeOfPrimitive(lexItem item) tomlType {
-	switch lexItem.typ {
-	case itemInteger:
-		return tomlInteger
-	case itemFloat:
-		return tomlFloat
-	case itemDatetime:
-		return tomlDatetime
-	case itemString:
-		return tomlString
-	case itemMultilineString:
-		return tomlString
-	case itemRawString:
-		return tomlString
-	case itemRawMultilineString:
-		return tomlString
-	case itemBool:
-		return tomlBool
-	}
-	p.bug("Cannot infer primitive type of lex item '%s'.", lexItem)
-	panic("unreachable")
-}
-
-// typeOfArray returns a tomlType for an array given a list of types of its
-// values.
-//
-// In the current spec, if an array is homogeneous, then its type is always
-// "Array". If the array is not homogeneous, an error is generated.
-func (p *parser) typeOfArray(types []tomlType) tomlType {
-	// Empty arrays are cool.
-	if len(types) == 0 {
-		return tomlArray
-	}
-
-	theType := types[0]
-	for _, t := range types[1:] {
-		if !typeEqual(theType, t) {
-			p.panicf("Array contains values of type '%s' and '%s', but "+
-				"arrays must be homogeneous.", theType, t)
-		}
-	}
-	return tomlArray
-}
--- a/vendor/github.com/BurntSushi/toml/type_fields.go
+++ b/vendor/github.com/BurntSushi/toml/type_fields.go
@@ -1,242 +0,0 @@
-package toml
-
-// Struct field handling is adapted from code in encoding/json:
-//
-// 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 Go distribution.
-
-import (
-	"reflect"
-	"sort"
-	"sync"
-)
-
-// A field represents a single field found in a struct.
-type field struct {
-	name  string       // the name of the field (`toml` tag included)
-	tag   bool         // whether field has a `toml` tag
-	index []int        // represents the depth of an anonymous field
-	typ   reflect.Type // the type of the field
-}
-
-// byName sorts field by name, breaking ties with depth,
-// then breaking ties with "name came from toml tag", then
-// breaking ties with index sequence.
-type byName []field
-
-func (x byName) Len() int { return len(x) }
-
-func (x byName) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
-
-func (x byName) Less(i, j int) bool {
-	if x[i].name != x[j].name {
-		return x[i].name < x[j].name
-	}
-	if len(x[i].index) != len(x[j].index) {
-		return len(x[i].index) < len(x[j].index)
-	}
-	if x[i].tag != x[j].tag {
-		return x[i].tag
-	}
-	return byIndex(x).Less(i, j)
-}
-
-// byIndex sorts field by index sequence.
-type byIndex []field
-
-func (x byIndex) Len() int { return len(x) }
-
-func (x byIndex) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
-
-func (x byIndex) Less(i, j int) bool {
-	for k, xik := range x[i].index {
-		if k >= len(x[j].index) {
-			return false
-		}
-		if xik != x[j].index[k] {
-			return xik < x[j].index[k]
-		}
-	}
-	return len(x[i].index) < len(x[j].index)
-}
-
-// typeFields returns a list of fields that TOML should recognize for the given
-// type. The algorithm is breadth-first search over the set of structs to
-// include - the top struct and then any reachable anonymous structs.
-func typeFields(t reflect.Type) []field {
-	// Anonymous fields to explore at the current level and the next.
-	current := []field{}
-	next := []field{{typ: t}}
-
-	// Count of queued names for current level and the next.
-	count := map[reflect.Type]int{}
-	nextCount := map[reflect.Type]int{}
-
-	// Types already visited at an earlier level.
-	visited := map[reflect.Type]bool{}
-
-	// Fields found.
-	var fields []field
-
-	for len(next) > 0 {
-		current, next = next, current[:0]
-		count, nextCount = nextCount, map[reflect.Type]int{}
-
-		for _, f := range current {
-			if visited[f.typ] {
-				continue
-			}
-			visited[f.typ] = true
-
-			// Scan f.typ for fields to include.
-			for i := 0; i < f.typ.NumField(); i++ {
-				sf := f.typ.Field(i)
-				if sf.PkgPath != "" && !sf.Anonymous { // unexported
-					continue
-				}
-				opts := getOptions(sf.Tag)
-				if opts.skip {
-					continue
-				}
-				index := make([]int, len(f.index)+1)
-				copy(index, f.index)
-				index[len(f.index)] = i
-
-				ft := sf.Type
-				if ft.Name() == "" && ft.Kind() == reflect.Ptr {
-					// Follow pointer.
-					ft = ft.Elem()
-				}
-
-				// Record found field and index sequence.
-				if opts.name != "" || !sf.Anonymous || ft.Kind() != reflect.Struct {
-					tagged := opts.name != ""
-					name := opts.name
-					if name == "" {
-						name = sf.Name
-					}
-					fields = append(fields, field{name, tagged, index, ft})
-					if count[f.typ] > 1 {
-						// If there were multiple instances, add a second,
-						// so that the annihilation code will see a duplicate.
-						// It only cares about the distinction between 1 or 2,
-						// so don't bother generating any more copies.
-						fields = append(fields, fields[len(fields)-1])
-					}
-					continue
-				}
-
-				// Record new anonymous struct to explore in next round.
-				nextCount[ft]++
-				if nextCount[ft] == 1 {
-					f := field{name: ft.Name(), index: index, typ: ft}
-					next = append(next, f)
-				}
-			}
-		}
-	}
-
-	sort.Sort(byName(fields))
-
-	// Delete all fields that are hidden by the Go rules for embedded fields,
-	// except that fields with TOML tags are promoted.
-
-	// The fields are sorted in primary order of name, secondary order
-	// of field index length. Loop over names; for each name, delete
-	// hidden fields by choosing the one dominant field that survives.
-	out := fields[:0]
-	for advance, i := 0, 0; i < len(fields); i += advance {
-		// One iteration per name.
-		// Find the sequence of fields with the name of this first field.
-		fi := fields[i]
-		name := fi.name
-		for advance = 1; i+advance < len(fields); advance++ {
-			fj := fields[i+advance]
-			if fj.name != name {
-				break
-			}
-		}
-		if advance == 1 { // Only one field with this name
-			out = append(out, fi)
-			continue
-		}
-		dominant, ok := dominantField(fields[i : i+advance])
-		if ok {
-			out = append(out, dominant)
-		}
-	}
-
-	fields = out
-	sort.Sort(byIndex(fields))
-
-	return fields
-}
-
-// dominantField looks through the fields, all of which are known to
-// have the same name, to find the single field that dominates the
-// others using Go's embedding rules, modified by the presence of
-// TOML tags. If there are multiple top-level fields, the boolean
-// will be false: This condition is an error in Go and we skip all
-// the fields.
-func dominantField(fields []field) (field, bool) {
-	// The fields are sorted in increasing index-length order. The winner
-	// must therefore be one with the shortest index length. Drop all
-	// longer entries, which is easy: just truncate the slice.
-	length := len(fields[0].index)
-	tagged := -1 // Index of first tagged field.
-	for i, f := range fields {
-		if len(f.index) > length {
-			fields = fields[:i]
-			break
-		}
-		if f.tag {
-			if tagged >= 0 {
-				// Multiple tagged fields at the same level: conflict.
-				// Return no field.
-				return field{}, false
-			}
-			tagged = i
-		}
-	}
-	if tagged >= 0 {
-		return fields[tagged], true
-	}
-	// All remaining fields have the same length. If there's more than one,
-	// we have a conflict (two fields named "X" at the same level) and we
-	// return no field.
-	if len(fields) > 1 {
-		return field{}, false
-	}
-	return fields[0], true
-}
-
-var fieldCache struct {
-	sync.RWMutex
-	m map[reflect.Type][]field
-}
-
-// cachedTypeFields is like typeFields but uses a cache to avoid repeated work.
-func cachedTypeFields(t reflect.Type) []field {
-	fieldCache.RLock()
-	f := fieldCache.m[t]
-	fieldCache.RUnlock()
-	if f != nil {
-		return f
-	}
-
-	// Compute fields without lock.
-	// Might duplicate effort but won't hold other computations back.
-	f = typeFields(t)
-	if f == nil {
-		f = []field{}
-	}
-
-	fieldCache.Lock()
-	if fieldCache.m == nil {
-		fieldCache.m = map[reflect.Type][]field{}
-	}
-	fieldCache.m[t] = f
-	fieldCache.Unlock()
-	return f
-}
--- a/vendor/github.com/PuerkitoBio/goquery/.gitattributes
+++ b/vendor/github.com/PuerkitoBio/goquery/.gitattributes
@@ -1 +0,0 @@
-testdata/* linguist-vendored
--- a/vendor/github.com/PuerkitoBio/goquery/.gitignore
+++ b/vendor/github.com/PuerkitoBio/goquery/.gitignore
@@ -1,16 +0,0 @@
-# editor temporary files
-*.sublime-*
-.DS_Store
-*.swp
-#*.*#
-tags
-
-# direnv config
-.env*
-
-# test binaries
-*.test
-
-# coverage and profilte outputs
-*.out
-
--- a/vendor/github.com/PuerkitoBio/goquery/.travis.yml
+++ b/vendor/github.com/PuerkitoBio/goquery/.travis.yml
@@ -1,16 +0,0 @@
-language: go
-
-go:
-    - 1.1
-    - 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
-
--- a/vendor/github.com/PuerkitoBio/goquery/LICENSE
+++ b/vendor/github.com/PuerkitoBio/goquery/LICENSE
@@ -1,12 +0,0 @@
-Copyright (c) 2012-2016, Martin Angers & Contributors
-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 author 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.
--- a/vendor/github.com/PuerkitoBio/goquery/README.md
+++ b/vendor/github.com/PuerkitoBio/goquery/README.md
@@ -1,179 +0,0 @@
-# goquery - a little like that j-thing, only in Go
-[![build status](https://secure.travis-ci.org/PuerkitoBio/goquery.svg?branch=master)](http://travis-ci.org/PuerkitoBio/goquery) [![GoDoc](https://godoc.org/github.com/PuerkitoBio/goquery?status.png)](http://godoc.org/github.com/PuerkitoBio/goquery) [![Sourcegraph Badge](https://sourcegraph.com/github.com/PuerkitoBio/goquery/-/badge.svg)](https://sourcegraph.com/github.com/PuerkitoBio/goquery?badge)
-
-goquery brings a syntax and a set of features similar to [jQuery][] to the [Go language][go]. It is based on Go's [net/html package][html] and the CSS Selector library [cascadia][]. Since the net/html parser returns nodes, and not a full-featured DOM tree, jQuery's stateful manipulation functions (like height(), css(), detach()) have been left off.
-
-Also, because the net/html parser requires UTF-8 encoding, so does goquery: it is the caller's responsibility to ensure that the source document provides UTF-8 encoded HTML. See the [wiki][] for various options to do this.
-
-Syntax-wise, it is as close as possible to jQuery, with the same function names when possible, and that warm and fuzzy chainable interface. jQuery being the ultra-popular library that it is, I felt that writing a similar HTML-manipulating library was better to follow its API than to start anew (in the same spirit as Go's `fmt` package), even though some of its methods are less than intuitive (looking at you, [index()][index]...).
-
-## Table of Contents
-
-* [Installation](#installation)
-* [Changelog](#changelog)
-* [API](#api)
-* [Examples](#examples)
-* [Related Projects](#related-projects)
-* [Support](#support)
-* [License](#license)
-
-## Installation
-
-Please note that because of the net/html dependency, goquery requires Go1.1+.
-
-    $ go get github.com/PuerkitoBio/goquery
-
-(optional) To run unit tests:
-
-    $ cd $GOPATH/src/github.com/PuerkitoBio/goquery
-    $ go test
-
-(optional) To run benchmarks (warning: it runs for a few minutes):
-
-    $ cd $GOPATH/src/github.com/PuerkitoBio/goquery
-    $ go test -bench=".*"
-
-## Changelog
-
-**Note that goquery's API is now stable, and will not break.**
-
-*    **2018-11-15 (v1.5.0)** : Go module support (thanks @Zaba505).
-*    **2018-06-07 (v1.4.1)** : Add `NewDocumentFromReader` examples.
-*    **2018-03-24 (v1.4.0)** : Deprecate `NewDocument(url)` and `NewDocumentFromResponse(response)`.
-*    **2018-01-28 (v1.3.0)** : Add `ToEnd` constant to `Slice` until the end of the selection (thanks to @davidjwilkins for raising the issue).
-*    **2018-01-11 (v1.2.0)** : Add `AddBack*` and deprecate `AndSelf` (thanks to @davidjwilkins).
-*    **2017-02-12 (v1.1.0)** : Add `SetHtml` and `SetText` (thanks to @glebtv).
-*    **2016-12-29 (v1.0.2)** : Optimize allocations for `Selection.Text` (thanks to @radovskyb).
-*    **2016-08-28 (v1.0.1)** : Optimize performance for large documents.
-*    **2016-07-27 (v1.0.0)** : Tag version 1.0.0.
-*    **2016-06-15** : Invalid selector strings internally compile to a `Matcher` implementation that never matches any node (instead of a panic). So for example, `doc.Find("~")` returns an empty `*Selection` object.
-*    **2016-02-02** : Add `NodeName` utility function similar to the DOM's `nodeName` property. It returns the tag name of the first element in a selection, and other relevant values of non-element nodes (see godoc for details). Add `OuterHtml` utility function similar to the DOM's `outerHTML` property (named `OuterHtml` in small caps for consistency with the existing `Html` method on the `Selection`).
-*    **2015-04-20** : Add `AttrOr` helper method to return the attribute's value or a default value if absent. Thanks to [piotrkowalczuk][piotr].
-*    **2015-02-04** : Add more manipulation functions - Prepend* - thanks again to [Andrew Stone][thatguystone].
-*    **2014-11-28** : Add more manipulation functions - ReplaceWith*, Wrap* and Unwrap - thanks again to [Andrew Stone][thatguystone].
-*    **2014-11-07** : Add manipulation functions (thanks to [Andrew Stone][thatguystone]) and `*Matcher` functions, that receive compiled cascadia selectors instead of selector strings, thus avoiding potential panics thrown by goquery via `cascadia.MustCompile` calls. This results in better performance (selectors can be compiled once and reused) and more idiomatic error handling (you can handle cascadia's compilation errors, instead of recovering from panics, which had been bugging me for a long time). Note that the actual type expected is a `Matcher` interface, that `cascadia.Selector` implements. Other matcher implementations could be used.
-*    **2014-11-06** : Change import paths of net/html to golang.org/x/net/html (see https://groups.google.com/forum/#!topic/golang-nuts/eD8dh3T9yyA). Make sure to update your code to use the new import path too when you call goquery with `html.Node`s.
-*    **v0.3.2** : Add `NewDocumentFromReader()` (thanks jweir) which allows creating a goquery document from an io.Reader.
-*    **v0.3.1** : Add `NewDocumentFromResponse()` (thanks assassingj) which allows creating a goquery document from an http response.
-*    **v0.3.0** : Add `EachWithBreak()` which allows to break out of an `Each()` loop by returning false. This function was added instead of changing the existing `Each()` to avoid breaking compatibility.
-*    **v0.2.1** : Make go-getable, now that [go.net/html is Go1.0-compatible][gonet] (thanks to @matrixik for pointing this out).
-*    **v0.2.0** : Add support for negative indices in Slice(). **BREAKING CHANGE** `Document.Root` is removed, `Document` is now a `Selection` itself (a selection of one, the root element, just like `Document.Root` was before). Add jQuery's Closest() method.
-*    **v0.1.1** : Add benchmarks to use as baseline for refactorings, refactor Next...() and Prev...() methods to use the new html package's linked list features (Next/PrevSibling, FirstChild). Good performance boost (40+% in some cases).
-*    **v0.1.0** : Initial release.
-
-## API
-
-goquery exposes two structs, `Document` and `Selection`, and the `Matcher` interface. Unlike jQuery, which is loaded as part of a DOM document, and thus acts on its containing document, goquery doesn't know which HTML document to act upon. So it needs to be told, and that's what the `Document` type is for. It holds the root document node as the initial Selection value to manipulate.
-
-jQuery often has many variants for the same function (no argument, a selector string argument, a jQuery object argument, a DOM element argument, ...). Instead of exposing the same features in goquery as a single method with variadic empty interface arguments, statically-typed signatures are used following this naming convention:
-
-*    When the jQuery equivalent can be called with no argument, it has the same name as jQuery for the no argument signature (e.g.: `Prev()`), and the version with a selector string argument is called `XxxFiltered()` (e.g.: `PrevFiltered()`)
-*    When the jQuery equivalent **requires** one argument, the same name as jQuery is used for the selector string version (e.g.: `Is()`)
-*    The signatures accepting a jQuery object as argument are defined in goquery as `XxxSelection()` and take a `*Selection` object as argument (e.g.: `FilterSelection()`)
-*    The signatures accepting a DOM element as argument in jQuery are defined in goquery as `XxxNodes()` and take a variadic argument of type `*html.Node` (e.g.: `FilterNodes()`)
-*    The signatures accepting a function as argument in jQuery are defined in goquery as `XxxFunction()` and take a function as argument (e.g.: `FilterFunction()`)
-*    The goquery methods that can be called with a selector string have a corresponding version that take a `Matcher` interface and are defined as `XxxMatcher()` (e.g.: `IsMatcher()`)
-
-Utility functions that are not in jQuery but are useful in Go are implemented as functions (that take a `*Selection` as parameter), to avoid a potential naming clash on the `*Selection`'s methods (reserved for jQuery-equivalent behaviour).
-
-The complete [godoc reference documentation can be found here][doc].
-
-Please note that Cascadia's selectors do not necessarily match all supported selectors of jQuery (Sizzle). See the [cascadia project][cascadia] for details. Invalid selector strings compile to a `Matcher` that fails to match any node. Behaviour of the various functions that take a selector string as argument follows from that fact, e.g. (where `~` is an invalid selector string):
-
-* `Find("~")` returns an empty selection because the selector string doesn't match anything.
-* `Add("~")` returns a new selection that holds the same nodes as the original selection, because it didn't add any node (selector string didn't match anything).
-* `ParentsFiltered("~")` returns an empty selection because the selector string doesn't match anything.
-* `ParentsUntil("~")` returns all parents of the selection because the selector string didn't match any element to stop before the top element.
-
-## Examples
-
-See some tips and tricks in the [wiki][].
-
-Adapted from example_test.go:
-
-```Go
-package main
-
-import (
-  "fmt"
-  "log"
-  "net/http"
-
-  "github.com/PuerkitoBio/goquery"
-)
-
-func ExampleScrape() {
-  // Request the HTML page.
-  res, err := http.Get("http://metalsucks.net")
-  if err != nil {
-    log.Fatal(err)
-  }
-  defer res.Body.Close()
-  if res.StatusCode != 200 {
-    log.Fatalf("status code error: %d %s", res.StatusCode, res.Status)
-  }
-
-  // Load the HTML document
-  doc, err := goquery.NewDocumentFromReader(res.Body)
-  if err != nil {
-    log.Fatal(err)
-  }
-
-  // Find the review items
-  doc.Find(".sidebar-reviews article .content-block").Each(func(i int, s *goquery.Selection) {
-    // For each item found, get the band and title
-    band := s.Find("a").Text()
-    title := s.Find("i").Text()
-    fmt.Printf("Review %d: %s - %s\n", i, band, title)
-  })
-}
-
-func main() {
-  ExampleScrape()
-}
-```
-
-## Related Projects
-
- [Goq][goq], an HTML deserialization and scraping library based on goquery and struct tags.
- [andybalholm/cascadia][cascadia], the CSS selector library used by goquery.
- [suntong/cascadia][cascadiacli], a command-line interface to the cascadia CSS selector library, useful to test selectors.
- [asciimoo/colly](https://github.com/asciimoo/colly), a lightning fast and elegant Scraping Framework
- [gnulnx/goperf](https://github.com/gnulnx/goperf), a website performance test tool that also fetches static assets.
- [MontFerret/ferret](https://github.com/MontFerret/ferret), declarative web scraping.
-
-## Support
-
-There are a number of ways you can support the project:
-
-* Use it, star it, build something with it, spread the word!
-  - If you do build something open-source or otherwise publicly-visible, let me know so I can add it to the [Related Projects](#related-projects) section!
-* Raise issues to improve the project (note: doc typos and clarifications are issues too!)
-  - Please search existing issues before opening a new one - it may have already been adressed.
-* Pull requests: please discuss new code in an issue first, unless the fix is really trivial.
-  - Make sure new code is tested.
-  - Be mindful of existing code - PRs that break existing code have a high probability of being declined, unless it fixes a serious issue.
-
-If you desperately want to send money my way, I have a BuyMeACoffee.com page:
-
-<a href="https://www.buymeacoffee.com/mna" target="_blank"><img src="https://www.buymeacoffee.com/assets/img/custom_images/orange_img.png" alt="Buy Me A Coffee" style="height: 41px !important;width: 174px !important;box-shadow: 0px 3px 2px 0px rgba(190, 190, 190, 0.5) !important;-webkit-box-shadow: 0px 3px 2px 0px rgba(190, 190, 190, 0.5) !important;" ></a>
-
-## License
-
-The [BSD 3-Clause license][bsd], the same as the [Go language][golic]. Cascadia's license is [here][caslic].
-
-[jquery]: http://jquery.com/
-[go]: http://golang.org/
-[cascadia]: https://github.com/andybalholm/cascadia
-[cascadiacli]: https://github.com/suntong/cascadia
-[bsd]: http://opensource.org/licenses/BSD-3-Clause
-[golic]: http://golang.org/LICENSE
-[caslic]: https://github.com/andybalholm/cascadia/blob/master/LICENSE
-[doc]: http://godoc.org/github.com/PuerkitoBio/goquery
-[index]: http://api.jquery.com/index/
-[gonet]: https://github.com/golang/net/
-[html]: http://godoc.org/golang.org/x/net/html
-[wiki]: https://github.com/PuerkitoBio/goquery/wiki/Tips-and-tricks
-[thatguystone]: https://github.com/thatguystone
-[piotr]: https://github.com/piotrkowalczuk
-[goq]: https://github.com/andrewstuart/goq
--- a/vendor/github.com/PuerkitoBio/goquery/array.go
+++ b/vendor/github.com/PuerkitoBio/goquery/array.go
@@ -1,124 +0,0 @@
-package goquery
-
-import (
-	"golang.org/x/net/html"
-)
-
-const (
-	maxUint = ^uint(0)
-	maxInt  = int(maxUint >> 1)
-
-	// ToEnd is a special index value that can be used as end index in a call
-	// to Slice so that all elements are selected until the end of the Selection.
-	// It is equivalent to passing (*Selection).Length().
-	ToEnd = maxInt
-)
-
-// First reduces the set of matched elements to the first in the set.
-// It returns a new Selection object, and an empty Selection object if the
-// the selection is empty.
-func (s *Selection) First() *Selection {
-	return s.Eq(0)
-}
-
-// Last reduces the set of matched elements to the last in the set.
-// It returns a new Selection object, and an empty Selection object if
-// the selection is empty.
-func (s *Selection) Last() *Selection {
-	return s.Eq(-1)
-}
-
-// Eq reduces the set of matched elements to the one at the specified index.
-// If a negative index is given, it counts backwards starting at the end of the
-// set. It returns a new Selection object, and an empty Selection object if the
-// index is invalid.
-func (s *Selection) Eq(index int) *Selection {
-	if index < 0 {
-		index += len(s.Nodes)
-	}
-
-	if index >= len(s.Nodes) || index < 0 {
-		return newEmptySelection(s.document)
-	}
-
-	return s.Slice(index, index+1)
-}
-
-// Slice reduces the set of matched elements to a subset specified by a range
-// of indices. The start index is 0-based and indicates the index of the first
-// element to select. The end index is 0-based and indicates the index at which
-// the elements stop being selected (the end index is not selected).
-//
-// The indices may be negative, in which case they represent an offset from the
-// end of the selection.
-//
-// The special value ToEnd may be specified as end index, in which case all elements
-// until the end are selected. This works both for a positive and negative start
-// index.
-func (s *Selection) Slice(start, end int) *Selection {
-	if start < 0 {
-		start += len(s.Nodes)
-	}
-	if end == ToEnd {
-		end = len(s.Nodes)
-	} else if end < 0 {
-		end += len(s.Nodes)
-	}
-	return pushStack(s, s.Nodes[start:end])
-}
-
-// Get retrieves the underlying node at the specified index.
-// Get without parameter is not implemented, since the node array is available
-// on the Selection object.
-func (s *Selection) Get(index int) *html.Node {
-	if index < 0 {
-		index += len(s.Nodes) // Negative index gets from the end
-	}
-	return s.Nodes[index]
-}
-
-// Index returns the position of the first element within the Selection object
-// relative to its sibling elements.
-func (s *Selection) Index() int {
-	if len(s.Nodes) > 0 {
-		return newSingleSelection(s.Nodes[0], s.document).PrevAll().Length()
-	}
-	return -1
-}
-
-// IndexSelector returns the position of the first element within the
-// Selection object relative to the elements matched by the selector, or -1 if
-// not found.
-func (s *Selection) IndexSelector(selector string) int {
-	if len(s.Nodes) > 0 {
-		sel := s.document.Find(selector)
-		return indexInSlice(sel.Nodes, s.Nodes[0])
-	}
-	return -1
-}
-
-// IndexMatcher returns the position of the first element within the
-// Selection object relative to the elements matched by the matcher, or -1 if
-// not found.
-func (s *Selection) IndexMatcher(m Matcher) int {
-	if len(s.Nodes) > 0 {
-		sel := s.document.FindMatcher(m)
-		return indexInSlice(sel.Nodes, s.Nodes[0])
-	}
-	return -1
-}
-
-// IndexOfNode returns the position of the specified node within the Selection
-// object, or -1 if not found.
-func (s *Selection) IndexOfNode(node *html.Node) int {
-	return indexInSlice(s.Nodes, node)
-}
-
-// IndexOfSelection returns the position of the first node in the specified
-// Selection object within this Selection object, or -1 if not found.
-func (s *Selection) IndexOfSelection(sel *Selection) int {
-	if sel != nil && len(sel.Nodes) > 0 {
-		return indexInSlice(s.Nodes, sel.Nodes[0])
-	}
-	return -1
-}
--- a/vendor/github.com/PuerkitoBio/goquery/doc.go
+++ b/vendor/github.com/PuerkitoBio/goquery/doc.go
@@ -1,123 +0,0 @@
-// Copyright (c) 2012-2016, Martin Angers & Contributors
-// 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 author 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 goquery implements features similar to jQuery, including the chainable
-syntax, to manipulate and query an HTML document.
-
-It brings a syntax and a set of features similar to jQuery to the Go language.
-It is based on Go's net/html package and the CSS Selector library cascadia.
-Since the net/html parser returns nodes, and not a full-featured DOM
-tree, jQuery's stateful manipulation functions (like height(), css(), detach())
-have been left off.
-
-Also, because the net/html parser requires UTF-8 encoding, so does goquery: it is
-the caller's responsibility to ensure that the source document provides UTF-8 encoded HTML.
-See the repository's wiki for various options on how to do this.
-
-Syntax-wise, it is as close as possible to jQuery, with the same method names when
-possible, and that warm and fuzzy chainable interface. jQuery being the
-ultra-popular library that it is, writing a similar HTML-manipulating
-library was better to follow its API than to start anew (in the same spirit as
-Go's fmt package), even though some of its methods are less than intuitive (looking
-at you, index()...).
-
-It is hosted on GitHub, along with additional documentation in the README.md
-file: https://github.com/puerkitobio/goquery
-
-Please note that because of the net/html dependency, goquery requires Go1.1+.
-
-The various methods are split into files based on the category of behavior.
-The three dots (...) indicate that various "overloads" are available.
-
-* array.go : array-like positional manipulation of the selection.
-    - Eq()
-    - First()
-    - Get()
-    - Index...()
-    - Last()
-    - Slice()
-
-* expand.go : methods that expand or augment the selection's set.
-    - Add...()
-    - AndSelf()
-    - Union(), which is an alias for AddSelection()
-
-* filter.go : filtering methods, that reduce the selection's set.
-    - End()
-    - Filter...()
-    - Has...()
-    - Intersection(), which is an alias of FilterSelection()
-    - Not...()
-
-* iteration.go : methods to loop over the selection's nodes.
-    - Each()
-    - EachWithBreak()
-    - Map()
-
-* manipulation.go : methods for modifying the document
-    - After...()
-    - Append...()
-    - Before...()
-    - Clone()
-    - Empty()
-    - Prepend...()
-    - Remove...()
-    - ReplaceWith...()
-    - Unwrap()
-    - Wrap...()
-    - WrapAll...()
-    - WrapInner...()
-
-* property.go : methods that inspect and get the node's properties values.
-    - Attr*(), RemoveAttr(), SetAttr()
-    - AddClass(), HasClass(), RemoveClass(), ToggleClass()
-    - Html()
-    - Length()
-    - Size(), which is an alias for Length()
-    - Text()
-
-* query.go : methods that query, or reflect, a node's identity.
-    - Contains()
-    - Is...()
-
-* traversal.go : methods to traverse the HTML document tree.
-    - Children...()
-    - Contents()
-    - Find...()
-    - Next...()
-    - Parent[s]...()
-    - Prev...()
-    - Siblings...()
-
-* type.go : definition of the types exposed by goquery.
-    - Document
-    - Selection
-    - Matcher
-
-* utilities.go : definition of helper functions (and not methods on a *Selection)
-that are not part of jQuery, but are useful to goquery.
-    - NodeName
-    - OuterHtml
-*/
-package goquery
--- a/vendor/github.com/PuerkitoBio/goquery/expand.go
+++ b/vendor/github.com/PuerkitoBio/goquery/expand.go
@@ -1,70 +0,0 @@
-package goquery
-
-import "golang.org/x/net/html"
-
-// Add adds the selector string's matching nodes to those in the current
-// selection and returns a new Selection object.
-// The selector string is run in the context of the document of the current
-// Selection object.
-func (s *Selection) Add(selector string) *Selection {
-	return s.AddNodes(findWithMatcher([]*html.Node{s.document.rootNode}, compileMatcher(selector))...)
-}
-
-// AddMatcher adds the matcher's matching nodes to those in the current
-// selection and returns a new Selection object.
-// The matcher is run in the context of the document of the current
-// Selection object.
-func (s *Selection) AddMatcher(m Matcher) *Selection {
-	return s.AddNodes(findWithMatcher([]*html.Node{s.document.rootNode}, m)...)
-}
-
-// AddSelection adds the specified Selection object's nodes to those in the
-// current selection and returns a new Selection object.
-func (s *Selection) AddSelection(sel *Selection) *Selection {
-	if sel == nil {
-		return s.AddNodes()
-	}
-	return s.AddNodes(sel.Nodes...)
-}
-
-// Union is an alias for AddSelection.
-func (s *Selection) Union(sel *Selection) *Selection {
-	return s.AddSelection(sel)
-}
-
-// AddNodes adds the specified nodes to those in the
-// current selection and returns a new Selection object.
-func (s *Selection) AddNodes(nodes ...*html.Node) *Selection {
-	return pushStack(s, appendWithoutDuplicates(s.Nodes, nodes, nil))
-}
-
-// AndSelf adds the previous set of elements on the stack to the current set.
-// It returns a new Selection object containing the current Selection combined
-// with the previous one.
-// Deprecated: This function has been deprecated and is now an alias for AddBack().
-func (s *Selection) AndSelf() *Selection {
-	return s.AddBack()
-}
-
-// AddBack adds the previous set of elements on the stack to the current set.
-// It returns a new Selection object containing the current Selection combined
-// with the previous one.
-func (s *Selection) AddBack() *Selection {
-	return s.AddSelection(s.prevSel)
-}
-
-// AddBackFiltered reduces the previous set of elements on the stack to those that
-// match the selector string, and adds them to the current set.
-// It returns a new Selection object containing the current Selection combined
-// with the filtered previous one
-func (s *Selection) AddBackFiltered(selector string) *Selection {
-	return s.AddSelection(s.prevSel.Filter(selector))
-}
-
-// AddBackMatcher reduces the previous set of elements on the stack to those that match
-// the mateher, and adds them to the curernt set.
-// It returns a new Selection object containing the current Selection combined
-// with the filtered previous one
-func (s *Selection) AddBackMatcher(m Matcher) *Selection {
-	return s.AddSelection(s.prevSel.FilterMatcher(m))
-}
--- a/vendor/github.com/PuerkitoBio/goquery/filter.go
+++ b/vendor/github.com/PuerkitoBio/goquery/filter.go
@@ -1,163 +0,0 @@
-package goquery
-
-import "golang.org/x/net/html"
-
-// Filter reduces the set of matched elements to those that match the selector string.
-// It returns a new Selection object for this subset of matching elements.
-func (s *Selection) Filter(selector string) *Selection {
-	return s.FilterMatcher(compileMatcher(selector))
-}
-
-// FilterMatcher reduces the set of matched elements to those that match
-// the given matcher. It returns a new Selection object for this subset
-// of matching elements.
-func (s *Selection) FilterMatcher(m Matcher) *Selection {
-	return pushStack(s, winnow(s, m, true))
-}
-
-// Not removes elements from the Selection that match the selector string.
-// It returns a new Selection object with the matching elements removed.
-func (s *Selection) Not(selector string) *Selection {
-	return s.NotMatcher(compileMatcher(selector))
-}
-
-// NotMatcher removes elements from the Selection that match the given matcher.
-// It returns a new Selection object with the matching elements removed.
-func (s *Selection) NotMatcher(m Matcher) *Selection {
-	return pushStack(s, winnow(s, m, false))
-}
-
-// FilterFunction reduces the set of matched elements to those that pass the function's test.
-// It returns a new Selection object for this subset of elements.
-func (s *Selection) FilterFunction(f func(int, *Selection) bool) *Selection {
-	return pushStack(s, winnowFunction(s, f, true))
-}
-
-// NotFunction removes elements from the Selection that pass the function's test.
-// It returns a new Selection object with the matching elements removed.
-func (s *Selection) NotFunction(f func(int, *Selection) bool) *Selection {
-	return pushStack(s, winnowFunction(s, f, false))
-}
-
-// FilterNodes reduces the set of matched elements to those that match the specified nodes.
-// It returns a new Selection object for this subset of elements.
-func (s *Selection) FilterNodes(nodes ...*html.Node) *Selection {
-	return pushStack(s, winnowNodes(s, nodes, true))
-}
-
-// NotNodes removes elements from the Selection that match the specified nodes.
-// It returns a new Selection object with the matching elements removed.
-func (s *Selection) NotNodes(nodes ...*html.Node) *Selection {
-	return pushStack(s, winnowNodes(s, nodes, false))
-}
-
-// FilterSelection reduces the set of matched elements to those that match a
-// node in the specified Selection object.
-// It returns a new Selection object for this subset of elements.
-func (s *Selection) FilterSelection(sel *Selection) *Selection {
-	if sel == nil {
-		return pushStack(s, winnowNodes(s, nil, true))
-	}
-	return pushStack(s, winnowNodes(s, sel.Nodes, true))
-}
-
-// NotSelection removes elements from the Selection that match a node in the specified
-// Selection object. It returns a new Selection object with the matching elements removed.
-func (s *Selection) NotSelection(sel *Selection) *Selection {
-	if sel == nil {
-		return pushStack(s, winnowNodes(s, nil, false))
-	}
-	return pushStack(s, winnowNodes(s, sel.Nodes, false))
-}
-
-// Intersection is an alias for FilterSelection.
-func (s *Selection) Intersection(sel *Selection) *Selection {
-	return s.FilterSelection(sel)
-}
-
-// Has reduces the set of matched elements to those that have a descendant
-// that matches the selector.
-// It returns a new Selection object with the matching elements.
-func (s *Selection) Has(selector string) *Selection {
-	return s.HasSelection(s.document.Find(selector))
-}
-
-// HasMatcher reduces the set of matched elements to those that have a descendant
-// that matches the matcher.
-// It returns a new Selection object with the matching elements.
-func (s *Selection) HasMatcher(m Matcher) *Selection {
-	return s.HasSelection(s.document.FindMatcher(m))
-}
-
-// HasNodes reduces the set of matched elements to those that have a
-// descendant that matches one of the nodes.
-// It returns a new Selection object with the matching elements.
-func (s *Selection) HasNodes(nodes ...*html.Node) *Selection {
-	return s.FilterFunction(func(_ int, sel *Selection) bool {
-		// Add all nodes that contain one of the specified nodes
-		for _, n := range nodes {
-			if sel.Contains(n) {
-				return true
-			}
-		}
-		return false
-	})
-}
-
-// HasSelection reduces the set of matched elements to those that have a
-// descendant that matches one of the nodes of the specified Selection object.
-// It returns a new Selection object with the matching elements.
-func (s *Selection) HasSelection(sel *Selection) *Selection {
-	if sel == nil {
-		return s.HasNodes()
-	}
-	return s.HasNodes(sel.Nodes...)
-}
-
-// End ends the most recent filtering operation in the current chain and
-// returns the set of matched elements to its previous state.
-func (s *Selection) End() *Selection {
-	if s.prevSel != nil {
-		return s.prevSel
-	}
-	return newEmptySelection(s.document)
-}
-
-// Filter based on the matcher, and the indicator to keep (Filter) or
-// to get rid of (Not) the matching elements.
-func winnow(sel *Selection, m Matcher, keep bool) []*html.Node {
-	// Optimize if keep is requested
-	if keep {
-		return m.Filter(sel.Nodes)
-	}
-	// Use grep
-	return grep(sel, func(i int, s *Selection) bool {
-		return !m.Match(s.Get(0))
-	})
-}
-
-// Filter based on an array of nodes, and the indicator to keep (Filter) or
-// to get rid of (Not) the matching elements.
-func winnowNodes(sel *Selection, nodes []*html.Node, keep bool) []*html.Node {
-	if len(nodes)+len(sel.Nodes) < minNodesForSet {
-		return grep(sel, func(i int, s *Selection) bool {
-			return isInSlice(nodes, s.Get(0)) == keep
-		})
-	}
-
-	set := make(map[*html.Node]bool)
-	for _, n := range nodes {
-		set[n] = true
-	}
-	return grep(sel, func(i int, s *Selection) bool {
-		return set[s.Get(0)] == keep
-	})
-}
-
-// Filter based on a function test, and the indicator to keep (Filter) or
-// to get rid of (Not) the matching elements.
-func winnowFunction(sel *Selection, f func(int, *Selection) bool, keep bool) []*html.Node {
-	return grep(sel, func(i int, s *Selection) bool {
-		return f(i, s) == keep
-	})
-}
--- a/vendor/github.com/PuerkitoBio/goquery/go.mod
+++ b/vendor/github.com/PuerkitoBio/goquery/go.mod
@@ -1,6 +0,0 @@
-module github.com/PuerkitoBio/goquery
-
-require (
-	github.com/andybalholm/cascadia v1.0.0
-	golang.org/x/net v0.0.0-20181114220301-adae6a3d119a
-)
--- a/vendor/github.com/PuerkitoBio/goquery/go.sum
+++ b/vendor/github.com/PuerkitoBio/goquery/go.sum
@@ -1,5 +0,0 @@
-github.com/andybalholm/cascadia v1.0.0 h1:hOCXnnZ5A+3eVDX8pvgl4kofXv2ELss0bKcqRySc45o=
-github.com/andybalholm/cascadia v1.0.0/go.mod h1:GsXiBklL0woXo1j/WYWtSYYC4ouU9PqHO0sqidkEA4Y=
-golang.org/x/net v0.0.0-20180218175443-cbe0f9307d01/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20181114220301-adae6a3d119a h1:gOpx8G595UYyvj8UK4+OFyY4rx037g3fmfhe5SasG3U=
-golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
--- a/vendor/github.com/PuerkitoBio/goquery/iteration.go
+++ b/vendor/github.com/PuerkitoBio/goquery/iteration.go
@@ -1,39 +0,0 @@
-package goquery
-
-// Each iterates over a Selection object, executing a function for each
-// matched element. It returns the current Selection object. The function
-// f is called for each element in the selection with the index of the
-// element in that selection starting at 0, and a *Selection that contains
-// only that element.
-func (s *Selection) Each(f func(int, *Selection)) *Selection {
-	for i, n := range s.Nodes {
-		f(i, newSingleSelection(n, s.document))
-	}
-	return s
-}
-
-// EachWithBreak iterates over a Selection object, executing a function for each
-// matched element. It is identical to Each except that it is possible to break
-// out of the loop by returning false in the callback function. It returns the
-// current Selection object.
-func (s *Selection) EachWithBreak(f func(int, *Selection) bool) *Selection {
-	for i, n := range s.Nodes {
-		if !f(i, newSingleSelection(n, s.document)) {
-			return s
-		}
-	}
-	return s
-}
-
-// Map passes each element in the current matched set through a function,
-// producing a slice of string holding the returned values. The function
-// f is called for each element in the selection with the index of the
-// element in that selection starting at 0, and a *Selection that contains
-// only that element.
-func (s *Selection) Map(f func(int, *Selection) string) (result []string) {
-	for i, n := range s.Nodes {
-		result = append(result, f(i, newSingleSelection(n, s.document)))
-	}
-
-	return result
-}
--- a/vendor/github.com/PuerkitoBio/goquery/manipulation.go
+++ b/vendor/github.com/PuerkitoBio/goquery/manipulation.go
@@ -1,574 +0,0 @@
-package goquery
-
-import (
-	"strings"
-
-	"golang.org/x/net/html"
-)
-
-// After applies the selector from the root document and inserts the matched elements
-// after the elements in the set of matched elements.
-//
-// If one of the matched elements in the selection is not currently in the
-// document, it's impossible to insert nodes after it, so it will be ignored.
-//
-// This follows the same rules as Selection.Append.
-func (s *Selection) After(selector string) *Selection {
-	return s.AfterMatcher(compileMatcher(selector))
-}
-
-// AfterMatcher applies the matcher from the root document and inserts the matched elements
-// after the elements in the set of matched elements.
-//
-// If one of the matched elements in the selection is not currently in the
-// document, it's impossible to insert nodes after it, so it will be ignored.
-//
-// This follows the same rules as Selection.Append.
-func (s *Selection) AfterMatcher(m Matcher) *Selection {
-	return s.AfterNodes(m.MatchAll(s.document.rootNode)...)
-}
-
-// AfterSelection inserts the elements in the selection after each element in the set of matched
-// elements.
-//
-// This follows the same rules as Selection.Append.
-func (s *Selection) AfterSelection(sel *Selection) *Selection {
-	return s.AfterNodes(sel.Nodes...)
-}
-
-// AfterHtml parses the html and inserts it after the set of matched elements.
-//
-// This follows the same rules as Selection.Append.
-func (s *Selection) AfterHtml(html string) *Selection {
-	return s.AfterNodes(parseHtml(html)...)
-}
-
-// AfterNodes inserts the nodes after each element in the set of matched elements.
-//
-// This follows the same rules as Selection.Append.
-func (s *Selection) AfterNodes(ns ...*html.Node) *Selection {
-	return s.manipulateNodes(ns, true, func(sn *html.Node, n *html.Node) {
-		if sn.Parent != nil {
-			sn.Parent.InsertBefore(n, sn.NextSibling)
-		}
-	})
-}
-
-// Append appends the elements specified by the selector to the end of each element
-// in the set of matched elements, following those rules:
-//
-// 1) The selector is applied to the root document.
-//
-// 2) Elements that are part of the document will be moved to the new location.
-//
-// 3) If there are multiple locations to append to, cloned nodes will be
-// appended to all target locations except the last one, which will be moved
-// as noted in (2).
-func (s *Selection) Append(selector string) *Selection {
-	return s.AppendMatcher(compileMatcher(selector))
-}
-
-// AppendMatcher appends the elements specified by the matcher to the end of each element
-// in the set of matched elements.
-//
-// This follows the same rules as Selection.Append.
-func (s *Selection) AppendMatcher(m Matcher) *Selection {
-	return s.AppendNodes(m.MatchAll(s.document.rootNode)...)
-}
-
-// AppendSelection appends the elements in the selection to the end of each element
-// in the set of matched elements.
-//
-// This follows the same rules as Selection.Append.
-func (s *Selection) AppendSelection(sel *Selection) *Selection {
-	return s.AppendNodes(sel.Nodes...)
-}
-
-// AppendHtml parses the html and appends it to the set of matched elements.
-func (s *Selection) AppendHtml(html string) *Selection {
-	return s.AppendNodes(parseHtml(html)...)
-}
-
-// AppendNodes appends the specified nodes to each node in the set of matched elements.
-//
-// This follows the same rules as Selection.Append.
-func (s *Selection) AppendNodes(ns ...*html.Node) *Selection {
-	return s.manipulateNodes(ns, false, func(sn *html.Node, n *html.Node) {
-		sn.AppendChild(n)
-	})
-}
-
-// Before inserts the matched elements before each element in the set of matched elements.
-//
-// This follows the same rules as Selection.Append.
-func (s *Selection) Before(selector string) *Selection {
-	return s.BeforeMatcher(compileMatcher(selector))
-}
-
-// BeforeMatcher inserts the matched elements before each element in the set of matched elements.
-//
-// This follows the same rules as Selection.Append.
-func (s *Selection) BeforeMatcher(m Matcher) *Selection {
-	return s.BeforeNodes(m.MatchAll(s.document.rootNode)...)
-}
-
-// BeforeSelection inserts the elements in the selection before each element in the set of matched
-// elements.
-//
-// This follows the same rules as Selection.Append.
-func (s *Selection) BeforeSelection(sel *Selection) *Selection {
-	return s.BeforeNodes(sel.Nodes...)
-}
-
-// BeforeHtml parses the html and inserts it before the set of matched elements.
-//
-// This follows the same rules as Selection.Append.
-func (s *Selection) BeforeHtml(html string) *Selection {
-	return s.BeforeNodes(parseHtml(html)...)
-}
-
-// BeforeNodes inserts the nodes before each element in the set of matched elements.
-//
-// This follows the same rules as Selection.Append.
-func (s *Selection) BeforeNodes(ns ...*html.Node) *Selection {
-	return s.manipulateNodes(ns, false, func(sn *html.Node, n *html.Node) {
-		if sn.Parent != nil {
-			sn.Parent.InsertBefore(n, sn)
-		}
-	})
-}
-
-// Clone creates a deep copy of the set of matched nodes. The new nodes will not be
-// attached to the document.
-func (s *Selection) Clone() *Selection {
-	ns := newEmptySelection(s.document)
-	ns.Nodes = cloneNodes(s.Nodes)
-	return ns
-}
-
-// Empty removes all children nodes from the set of matched elements.
-// It returns the children nodes in a new Selection.
-func (s *Selection) Empty() *Selection {
-	var nodes []*html.Node
-
-	for _, n := range s.Nodes {
-		for c := n.FirstChild; c != nil; c = n.FirstChild {
-			n.RemoveChild(c)
-			nodes = append(nodes, c)
-		}
-	}
-
-	return pushStack(s, nodes)
-}
-
-// Prepend prepends the elements specified by the selector to each element in
-// the set of matched elements, following the same rules as Append.
-func (s *Selection) Prepend(selector string) *Selection {
-	return s.PrependMatcher(compileMatcher(selector))
-}
-
-// PrependMatcher prepends the elements specified by the matcher to each
-// element in the set of matched elements.
-//
-// This follows the same rules as Selection.Append.
-func (s *Selection) PrependMatcher(m Matcher) *Selection {
-	return s.PrependNodes(m.MatchAll(s.document.rootNode)...)
-}
-
-// PrependSelection prepends the elements in the selection to each element in
-// the set of matched elements.
-//
-// This follows the same rules as Selection.Append.
-func (s *Selection) PrependSelection(sel *Selection) *Selection {
-	return s.PrependNodes(sel.Nodes...)
-}
-
-// PrependHtml parses the html and prepends it to the set of matched elements.
-func (s *Selection) PrependHtml(html string) *Selection {
-	return s.PrependNodes(parseHtml(html)...)
-}
-
-// PrependNodes prepends the specified nodes to each node in the set of
-// matched elements.
-//
-// This follows the same rules as Selection.Append.
-func (s *Selection) PrependNodes(ns ...*html.Node) *Selection {
-	return s.manipulateNodes(ns, true, func(sn *html.Node, n *html.Node) {
-		// sn.FirstChild may be nil, in which case this functions like
-		// sn.AppendChild()
-		sn.InsertBefore(n, sn.FirstChild)
-	})
-}
-
-// Remove removes the set of matched elements from the document.
-// It returns the same selection, now consisting of nodes not in the document.
-func (s *Selection) Remove() *Selection {
-	for _, n := range s.Nodes {
-		if n.Parent != nil {
-			n.Parent.RemoveChild(n)
-		}
-	}
-
-	return s
-}
-
-// RemoveFiltered removes the set of matched elements by selector.
-// It returns the Selection of removed nodes.
-func (s *Selection) RemoveFiltered(selector string) *Selection {
-	return s.RemoveMatcher(compileMatcher(selector))
-}
-
-// RemoveMatcher removes the set of matched elements.
-// It returns the Selection of removed nodes.
-func (s *Selection) RemoveMatcher(m Matcher) *Selection {
-	return s.FilterMatcher(m).Remove()
-}
-
-// ReplaceWith replaces each element in the set of matched elements with the
-// nodes matched by the given selector.
-// It returns the removed elements.
-//
-// This follows the same rules as Selection.Append.
-func (s *Selection) ReplaceWith(selector string) *Selection {
-	return s.ReplaceWithMatcher(compileMatcher(selector))
-}
-
-// ReplaceWithMatcher replaces each element in the set of matched elements with
-// the nodes matched by the given Matcher.
-// It returns the removed elements.
-//
-// This follows the same rules as Selection.Append.
-func (s *Selection) ReplaceWithMatcher(m Matcher) *Selection {
-	return s.ReplaceWithNodes(m.MatchAll(s.document.rootNode)...)
-}
-
-// ReplaceWithSelection replaces each element in the set of matched elements with
-// the nodes from the given Selection.
-// It returns the removed elements.
-//
-// This follows the same rules as Selection.Append.
-func (s *Selection) ReplaceWithSelection(sel *Selection) *Selection {
-	return s.ReplaceWithNodes(sel.Nodes...)
-}
-
-// ReplaceWithHtml replaces each element in the set of matched elements with
-// the parsed HTML.
-// It returns the removed elements.
-//
-// This follows the same rules as Selection.Append.
-func (s *Selection) ReplaceWithHtml(html string) *Selection {
-	return s.ReplaceWithNodes(parseHtml(html)...)
-}
-
-// ReplaceWithNodes replaces each element in the set of matched elements with
-// the given nodes.
-// It returns the removed elements.
-//
-// This follows the same rules as Selection.Append.
-func (s *Selection) ReplaceWithNodes(ns ...*html.Node) *Selection {
-	s.AfterNodes(ns...)
-	return s.Remove()
-}
-
-// SetHtml sets the html content of each element in the selection to
-// specified html string.
-func (s *Selection) SetHtml(html string) *Selection {
-	return setHtmlNodes(s, parseHtml(html)...)
-}
-
-// SetText sets the content of each element in the selection to specified content.
-// The provided text string is escaped.
-func (s *Selection) SetText(text string) *Selection {
-	return s.SetHtml(html.EscapeString(text))
-}
-
-// Unwrap removes the parents of the set of matched elements, leaving the matched
-// elements (and their siblings, if any) in their place.
-// It returns the original selection.
-func (s *Selection) Unwrap() *Selection {
-	s.Parent().Each(func(i int, ss *Selection) {
-		// For some reason, jquery allows unwrap to remove the <head> element, so
-		// allowing it here too. Same for <html>. Why it allows those elements to
-		// be unwrapped while not allowing body is a mystery to me.
-		if ss.Nodes[0].Data != "body" {
-			ss.ReplaceWithSelection(ss.Contents())
-		}
-	})
-
-	return s
-}
-
-// Wrap wraps each element in the set of matched elements inside the first
-// element matched by the given selector. The matched child is cloned before
-// being inserted into the document.
-//
-// It returns the original set of elements.
-func (s *Selection) Wrap(selector string) *Selection {
-	return s.WrapMatcher(compileMatcher(selector))
-}
-
-// WrapMatcher wraps each element in the set of matched elements inside the
-// first element matched by the given matcher. The matched child is cloned
-// before being inserted into the document.
-//
-// It returns the original set of elements.
-func (s *Selection) WrapMatcher(m Matcher) *Selection {
-	return s.wrapNodes(m.MatchAll(s.document.rootNode)...)
-}
-
-// WrapSelection wraps each element in the set of matched elements inside the
-// first element in the given Selection. The element is cloned before being
-// inserted into the document.
-//
-// It returns the original set of elements.
-func (s *Selection) WrapSelection(sel *Selection) *Selection {
-	return s.wrapNodes(sel.Nodes...)
-}
-
-// WrapHtml wraps each element in the set of matched elements inside the inner-
-// most child of the given HTML.
-//
-// It returns the original set of elements.
-func (s *Selection) WrapHtml(html string) *Selection {
-	return s.wrapNodes(parseHtml(html)...)
-}
-
-// WrapNode wraps each element in the set of matched elements inside the inner-
-// most child of the given node. The given node is copied before being inserted
-// into the document.
-//
-// It returns the original set of elements.
-func (s *Selection) WrapNode(n *html.Node) *Selection {
-	return s.wrapNodes(n)
-}
-
-func (s *Selection) wrapNodes(ns ...*html.Node) *Selection {
-	s.Each(func(i int, ss *Selection) {
-		ss.wrapAllNodes(ns...)
-	})
-
-	return s
-}
-
-// WrapAll wraps a single HTML structure, matched by the given selector, around
-// all elements in the set of matched elements. The matched child is cloned
-// before being inserted into the document.
-//
-// It returns the original set of elements.
-func (s *Selection) WrapAll(selector string) *Selection {
-	return s.WrapAllMatcher(compileMatcher(selector))
-}
-
-// WrapAllMatcher wraps a single HTML structure, matched by the given Matcher,
-// around all elements in the set of matched elements. The matched child is
-// cloned before being inserted into the document.
-//
-// It returns the original set of elements.
-func (s *Selection) WrapAllMatcher(m Matcher) *Selection {
-	return s.wrapAllNodes(m.MatchAll(s.document.rootNode)...)
-}
-
-// WrapAllSelection wraps a single HTML structure, the first node of the given
-// Selection, around all elements in the set of matched elements. The matched
-// child is cloned before being inserted into the document.
-//
-// It returns the original set of elements.
-func (s *Selection) WrapAllSelection(sel *Selection) *Selection {
-	return s.wrapAllNodes(sel.Nodes...)
-}
-
-// WrapAllHtml wraps the given HTML structure around all elements in the set of
-// matched elements. The matched child is cloned before being inserted into the
-// document.
-//
-// It returns the original set of elements.
-func (s *Selection) WrapAllHtml(html string) *Selection {
-	return s.wrapAllNodes(parseHtml(html)...)
-}
-
-func (s *Selection) wrapAllNodes(ns ...*html.Node) *Selection {
-	if len(ns) > 0 {
-		return s.WrapAllNode(ns[0])
-	}
-	return s
-}
-
-// WrapAllNode wraps the given node around the first element in the Selection,
-// making all other nodes in the Selection children of the given node. The node
-// is cloned before being inserted into the document.
-//
-// It returns the original set of elements.
-func (s *Selection) WrapAllNode(n *html.Node) *Selection {
-	if s.Size() == 0 {
-		return s
-	}
-
-	wrap := cloneNode(n)
-
-	first := s.Nodes[0]
-	if first.Parent != nil {
-		first.Parent.InsertBefore(wrap, first)
-		first.Parent.RemoveChild(first)
-	}
-
-	for c := getFirstChildEl(wrap); c != nil; c = getFirstChildEl(wrap) {
-		wrap = c
-	}
-
-	newSingleSelection(wrap, s.document).AppendSelection(s)
-
-	return s
-}
-
-// WrapInner wraps an HTML structure, matched by the given selector, around the
-// content of element in the set of matched elements. The matched child is
-// cloned before being inserted into the document.
-//
-// It returns the original set of elements.
-func (s *Selection) WrapInner(selector string) *Selection {
-	return s.WrapInnerMatcher(compileMatcher(selector))
-}
-
-// WrapInnerMatcher wraps an HTML structure, matched by the given selector,
-// around the content of element in the set of matched elements. The matched
-// child is cloned before being inserted into the document.
-//
-// It returns the original set of elements.
-func (s *Selection) WrapInnerMatcher(m Matcher) *Selection {
-	return s.wrapInnerNodes(m.MatchAll(s.document.rootNode)...)
-}
-
-// WrapInnerSelection wraps an HTML structure, matched by the given selector,
-// around the content of element in the set of matched elements. The matched
-// child is cloned before being inserted into the document.
-//
-// It returns the original set of elements.
-func (s *Selection) WrapInnerSelection(sel *Selection) *Selection {
-	return s.wrapInnerNodes(sel.Nodes...)
-}
-
-// WrapInnerHtml wraps an HTML structure, matched by the given selector, around
-// the content of element in the set of matched elements. The matched child is
-// cloned before being inserted into the document.
-//
-// It returns the original set of elements.
-func (s *Selection) WrapInnerHtml(html string) *Selection {
-	return s.wrapInnerNodes(parseHtml(html)...)
-}
-
-// WrapInnerNode wraps an HTML structure, matched by the given selector, around
-// the content of element in the set of matched elements. The matched child is
-// cloned before being inserted into the document.
-//
-// It returns the original set of elements.
-func (s *Selection) WrapInnerNode(n *html.Node) *Selection {
-	return s.wrapInnerNodes(n)
-}
-
-func (s *Selection) wrapInnerNodes(ns ...*html.Node) *Selection {
-	if len(ns) == 0 {
-		return s
-	}
-
-	s.Each(func(i int, s *Selection) {
-		contents := s.Contents()
-
-		if contents.Size() > 0 {
-			contents.wrapAllNodes(ns...)
-		} else {
-			s.AppendNodes(cloneNode(ns[0]))
-		}
-	})
-
-	return s
-}
-
-func parseHtml(h string) []*html.Node {
-	// Errors are only returned when the io.Reader returns any error besides
-	// EOF, but strings.Reader never will
-	nodes, err := html.ParseFragment(strings.NewReader(h), &html.Node{Type: html.ElementNode})
-	if err != nil {
-		panic("goquery: failed to parse HTML: " + err.Error())
-	}
-	return nodes
-}
-
-func setHtmlNodes(s *Selection, ns ...*html.Node) *Selection {
-	for _, n := range s.Nodes {
-		for c := n.FirstChild; c != nil; c = n.FirstChild {
-			n.RemoveChild(c)
-		}
-		for _, c := range ns {
-			n.AppendChild(cloneNode(c))
-		}
-	}
-	return s
-}
-
-// Get the first child that is an ElementNode
-func getFirstChildEl(n *html.Node) *html.Node {
-	c := n.FirstChild
-	for c != nil && c.Type != html.ElementNode {
-		c = c.NextSibling
-	}
-	return c
-}
-
-// Deep copy a slice of nodes.
-func cloneNodes(ns []*html.Node) []*html.Node {
-	cns := make([]*html.Node, 0, len(ns))
-
-	for _, n := range ns {
-		cns = append(cns, cloneNode(n))
-	}
-
-	return cns
-}
-
-// Deep copy a node. The new node has clones of all the original node's
-// children but none of its parents or siblings.
-func cloneNode(n *html.Node) *html.Node {
-	nn := &html.Node{
-		Type:     n.Type,
-		DataAtom: n.DataAtom,
-		Data:     n.Data,
-		Attr:     make([]html.Attribute, len(n.Attr)),
-	}
-
-	copy(nn.Attr, n.Attr)
-	for c := n.FirstChild; c != nil; c = c.NextSibling {
-		nn.AppendChild(cloneNode(c))
-	}
-
-	return nn
-}
-
-func (s *Selection) manipulateNodes(ns []*html.Node, reverse bool,
-	f func(sn *html.Node, n *html.Node)) *Selection {
-
-	lasti := s.Size() - 1
-
-	// net.Html doesn't provide document fragments for insertion, so to get
-	// things in the correct order with After() and Prepend(), the callback
-	// needs to be called on the reverse of the nodes.
-	if reverse {
-		for i, j := 0, len(ns)-1; i < j; i, j = i+1, j-1 {
-			ns[i], ns[j] = ns[j], ns[i]
-		}
-	}
-
-	for i, sn := range s.Nodes {
-		for _, n := range ns {
-			if i != lasti {
-				f(sn, cloneNode(n))
-			} else {
-				if n.Parent != nil {
-					n.Parent.RemoveChild(n)
-				}
-				f(sn, n)
-			}
-		}
-	}
-
-	return s
-}
--- a/vendor/github.com/PuerkitoBio/goquery/property.go
+++ b/vendor/github.com/PuerkitoBio/goquery/property.go
@@ -1,275 +0,0 @@
-package goquery
-
-import (
-	"bytes"
-	"regexp"
-	"strings"
-
-	"golang.org/x/net/html"
-)
-
-var rxClassTrim = regexp.MustCompile("[\t\r\n]")
-
-// Attr gets the specified attribute's value for the first element in the
-// Selection. To get the value for each element individually, use a looping
-// construct such as Each or Map method.
-func (s *Selection) Attr(attrName string) (val string, exists bool) {
-	if len(s.Nodes) == 0 {
-		return
-	}
-	return getAttributeValue(attrName, s.Nodes[0])
-}
-
-// AttrOr works like Attr but returns default value if attribute is not present.
-func (s *Selection) AttrOr(attrName, defaultValue string) string {
-	if len(s.Nodes) == 0 {
-		return defaultValue
-	}
-
-	val, exists := getAttributeValue(attrName, s.Nodes[0])
-	if !exists {
-		return defaultValue
-	}
-
-	return val
-}
-
-// RemoveAttr removes the named attribute from each element in the set of matched elements.
-func (s *Selection) RemoveAttr(attrName string) *Selection {
-	for _, n := range s.Nodes {
-		removeAttr(n, attrName)
-	}
-
-	return s
-}
-
-// SetAttr sets the given attribute on each element in the set of matched elements.
-func (s *Selection) SetAttr(attrName, val string) *Selection {
-	for _, n := range s.Nodes {
-		attr := getAttributePtr(attrName, n)
-		if attr == nil {
-			n.Attr = append(n.Attr, html.Attribute{Key: attrName, Val: val})
-		} else {
-			attr.Val = val
-		}
-	}
-
-	return s
-}
-
-// Text gets the combined text contents of each element in the set of matched
-// elements, including their descendants.
-func (s *Selection) Text() string {
-	var buf bytes.Buffer
-
-	// Slightly optimized vs calling Each: no single selection object created
-	var f func(*html.Node)
-	f = func(n *html.Node) {
-		if n.Type == html.TextNode {
-			// Keep newlines and spaces, like jQuery
-			buf.WriteString(n.Data)
-		}
-		if n.FirstChild != nil {
-			for c := n.FirstChild; c != nil; c = c.NextSibling {
-				f(c)
-			}
-		}
-	}
-	for _, n := range s.Nodes {
-		f(n)
-	}
-
-	return buf.String()
-}
-
-// Size is an alias for Length.
-func (s *Selection) Size() int {
-	return s.Length()
-}
-
-// Length returns the number of elements in the Selection object.
-func (s *Selection) Length() int {
-	return len(s.Nodes)
-}
-
-// Html gets the HTML contents of the first element in the set of matched
-// elements. It includes text and comment nodes.
-func (s *Selection) Html() (ret string, e error) {
-	// Since there is no .innerHtml, the HTML content must be re-created from
-	// the nodes using html.Render.
-	var buf bytes.Buffer
-
-	if len(s.Nodes) > 0 {
-		for c := s.Nodes[0].FirstChild; c != nil; c = c.NextSibling {
-			e = html.Render(&buf, c)
-			if e != nil {
-				return
-			}
-		}
-		ret = buf.String()
-	}
-
-	return
-}
-
-// AddClass adds the given class(es) to each element in the set of matched elements.
-// Multiple class names can be specified, separated by a space or via multiple arguments.
-func (s *Selection) AddClass(class ...string) *Selection {
-	classStr := strings.TrimSpace(strings.Join(class, " "))
-
-	if classStr == "" {
-		return s
-	}
-
-	tcls := getClassesSlice(classStr)
-	for _, n := range s.Nodes {
-		curClasses, attr := getClassesAndAttr(n, true)
-		for _, newClass := range tcls {
-			if !strings.Contains(curClasses, " "+newClass+" ") {
-				curClasses += newClass + " "
-			}
-		}
-
-		setClasses(n, attr, curClasses)
-	}
-
-	return s
-}
-
-// HasClass determines whether any of the matched elements are assigned the
-// given class.
-func (s *Selection) HasClass(class string) bool {
-	class = " " + class + " "
-	for _, n := range s.Nodes {
-		classes, _ := getClassesAndAttr(n, false)
-		if strings.Contains(classes, class) {
-			return true
-		}
-	}
-	return false
-}
-
-// RemoveClass removes the given class(es) from each element in the set of matched elements.
-// Multiple class names can be specified, separated by a space or via multiple arguments.
-// If no class name is provided, all classes are removed.
-func (s *Selection) RemoveClass(class ...string) *Selection {
-	var rclasses []string
-
-	classStr := strings.TrimSpace(strings.Join(class, " "))
-	remove := classStr == ""
-
-	if !remove {
-		rclasses = getClassesSlice(classStr)
-	}
-
-	for _, n := range s.Nodes {
-		if remove {
-			removeAttr(n, "class")
-		} else {
-			classes, attr := getClassesAndAttr(n, true)
-			for _, rcl := range rclasses {
-				classes = strings.Replace(classes, " "+rcl+" ", " ", -1)
-			}
-
-			setClasses(n, attr, classes)
-		}
-	}
-
-	return s
-}
-
-// ToggleClass adds or removes the given class(es) for each element in the set of matched elements.
-// Multiple class names can be specified, separated by a space or via multiple arguments.
-func (s *Selection) ToggleClass(class ...string) *Selection {
-	classStr := strings.TrimSpace(strings.Join(class, " "))
-
-	if classStr == "" {
-		return s
-	}
-
-	tcls := getClassesSlice(classStr)
-
-	for _, n := range s.Nodes {
-		classes, attr := getClassesAndAttr(n, true)
-		for _, tcl := range tcls {
-			if strings.Contains(classes, " "+tcl+" ") {
-				classes = strings.Replace(classes, " "+tcl+" ", " ", -1)
-			} else {
-				classes += tcl + " "
-			}
-		}
-
-		setClasses(n, attr, classes)
-	}
-
-	return s
-}
-
-func getAttributePtr(attrName string, n *html.Node) *html.Attribute {
-	if n == nil {
-		return nil
-	}
-
-	for i, a := range n.Attr {
-		if a.Key == attrName {
-			return &n.Attr[i]
-		}
-	}
-	return nil
-}
-
-// Private function to get the specified attribute's value from a node.
-func getAttributeValue(attrName string, n *html.Node) (val string, exists bool) {
-	if a := getAttributePtr(attrName, n); a != nil {
-		val = a.Val
-		exists = true
-	}
-	return
-}
-
-// Get and normalize the "class" attribute from the node.
-func getClassesAndAttr(n *html.Node, create bool) (classes string, attr *html.Attribute) {
-	// Applies only to element nodes
-	if n.Type == html.ElementNode {
-		attr = getAttributePtr("class", n)
-		if attr == nil && create {
-			n.Attr = append(n.Attr, html.Attribute{
-				Key: "class",
-				Val: "",
-			})
-			attr = &n.Attr[len(n.Attr)-1]
-		}
-	}
-
-	if attr == nil {
-		classes = " "
-	} else {
-		classes = rxClassTrim.ReplaceAllString(" "+attr.Val+" ", " ")
-	}
-
-	return
-}
-
-func getClassesSlice(classes string) []string {
-	return strings.Split(rxClassTrim.ReplaceAllString(" "+classes+" ", " "), " ")
-}
-
-func removeAttr(n *html.Node, attrName string) {
-	for i, a := range n.Attr {
-		if a.Key == attrName {
-			n.Attr[i], n.Attr[len(n.Attr)-1], n.Attr =
-				n.Attr[len(n.Attr)-1], html.Attribute{}, n.Attr[:len(n.Attr)-1]
-			return
-		}
-	}
-}
-
-func setClasses(n *html.Node, attr *html.Attribute, classes string) {
-	classes = strings.TrimSpace(classes)
-	if classes == "" {
-		removeAttr(n, "class")
-		return
-	}
-
-	attr.Val = classes
-}
--- a/vendor/github.com/PuerkitoBio/goquery/query.go
+++ b/vendor/github.com/PuerkitoBio/goquery/query.go
@@ -1,49 +0,0 @@
-package goquery
-
-import "golang.org/x/net/html"
-
-// Is checks the current matched set of elements against a selector and
-// returns true if at least one of these elements matches.
-func (s *Selection) Is(selector string) bool {
-	return s.IsMatcher(compileMatcher(selector))
-}
-
-// IsMatcher checks the current matched set of elements against a matcher and
-// returns true if at least one of these elements matches.
-func (s *Selection) IsMatcher(m Matcher) bool {
-	if len(s.Nodes) > 0 {
-		if len(s.Nodes) == 1 {
-			return m.Match(s.Nodes[0])
-		}
-		return len(m.Filter(s.Nodes)) > 0
-	}
-
-	return false
-}
-
-// IsFunction checks the current matched set of elements against a predicate and
-// returns true if at least one of these elements matches.
-func (s *Selection) IsFunction(f func(int, *Selection) bool) bool {
-	return s.FilterFunction(f).Length() > 0
-}
-
-// IsSelection checks the current matched set of elements against a Selection object
-// and returns true if at least one of these elements matches.
-func (s *Selection) IsSelection(sel *Selection) bool {
-	return s.FilterSelection(sel).Length() > 0
-}
-
-// IsNodes checks the current matched set of elements against the specified nodes
-// and returns true if at least one of these elements matches.
-func (s *Selection) IsNodes(nodes ...*html.Node) bool {
-	return s.FilterNodes(nodes...).Length() > 0
-}
-
-// Contains returns true if the specified Node is within,
-// at any depth, one of the nodes in the Selection object.
-// It is NOT inclusive, to behave like jQuery's implementation, and
-// unlike Javascript's .contains, so if the contained
-// node is itself in the selection, it returns false.
-func (s *Selection) Contains(n *html.Node) bool {
-	return sliceContains(s.Nodes, n)
-}
--- a/vendor/github.com/PuerkitoBio/goquery/traversal.go
+++ b/vendor/github.com/PuerkitoBio/goquery/traversal.go
@@ -1,698 +0,0 @@
-package goquery
-
-import "golang.org/x/net/html"
-
-type siblingType int
-
-// Sibling type, used internally when iterating over children at the same
-// level (siblings) to specify which nodes are requested.
-const (
-	siblingPrevUntil siblingType = iota - 3
-	siblingPrevAll
-	siblingPrev
-	siblingAll
-	siblingNext
-	siblingNextAll
-	siblingNextUntil
-	siblingAllIncludingNonElements
-)
-
-// Find gets the descendants of each element in the current set of matched
-// elements, filtered by a selector. It returns a new Selection object
-// containing these matched elements.
-func (s *Selection) Find(selector string) *Selection {
-	return pushStack(s, findWithMatcher(s.Nodes, compileMatcher(selector)))
-}
-
-// FindMatcher gets the descendants of each element in the current set of matched
-// elements, filtered by the matcher. It returns a new Selection object
-// containing these matched elements.
-func (s *Selection) FindMatcher(m Matcher) *Selection {
-	return pushStack(s, findWithMatcher(s.Nodes, m))
-}
-
-// FindSelection gets the descendants of each element in the current
-// Selection, filtered by a Selection. It returns a new Selection object
-// containing these matched elements.
-func (s *Selection) FindSelection(sel *Selection) *Selection {
-	if sel == nil {
-		return pushStack(s, nil)
-	}
-	return s.FindNodes(sel.Nodes...)
-}
-
-// FindNodes gets the descendants of each element in the current
-// Selection, filtered by some nodes. It returns a new Selection object
-// containing these matched elements.
-func (s *Selection) FindNodes(nodes ...*html.Node) *Selection {
-	return pushStack(s, mapNodes(nodes, func(i int, n *html.Node) []*html.Node {
-		if sliceContains(s.Nodes, n) {
-			return []*html.Node{n}
-		}
-		return nil
-	}))
-}
-
-// Contents gets the children of each element in the Selection,
-// including text and comment nodes. It returns a new Selection object
-// containing these elements.
-func (s *Selection) Contents() *Selection {
-	return pushStack(s, getChildrenNodes(s.Nodes, siblingAllIncludingNonElements))
-}
-
-// ContentsFiltered gets the children of each element in the Selection,
-// filtered by the specified selector. It returns a new Selection
-// object containing these elements. Since selectors only act on Element nodes,
-// this function is an alias to ChildrenFiltered unless the selector is empty,
-// in which case it is an alias to Contents.
-func (s *Selection) ContentsFiltered(selector string) *Selection {
-	if selector != "" {
-		return s.ChildrenFiltered(selector)
-	}
-	return s.Contents()
-}
-
-// ContentsMatcher gets the children of each element in the Selection,
-// filtered by the specified matcher. It returns a new Selection
-// object containing these elements. Since matchers only act on Element nodes,
-// this function is an alias to ChildrenMatcher.
-func (s *Selection) ContentsMatcher(m Matcher) *Selection {
-	return s.ChildrenMatcher(m)
-}
-
-// Children gets the child elements of each element in the Selection.
-// It returns a new Selection object containing these elements.
-func (s *Selection) Children() *Selection {
-	return pushStack(s, getChildrenNodes(s.Nodes, siblingAll))
-}
-
-// ChildrenFiltered gets the child elements of each element in the Selection,
-// filtered by the specified selector. It returns a new
-// Selection object containing these elements.
-func (s *Selection) ChildrenFiltered(selector string) *Selection {
-	return filterAndPush(s, getChildrenNodes(s.Nodes, siblingAll), compileMatcher(selector))
-}
-
-// ChildrenMatcher gets the child elements of each element in the Selection,
-// filtered by the specified matcher. It returns a new
-// Selection object containing these elements.
-func (s *Selection) ChildrenMatcher(m Matcher) *Selection {
-	return filterAndPush(s, getChildrenNodes(s.Nodes, siblingAll), m)
-}
-
-// Parent gets the parent of each element in the Selection. It returns a
-// new Selection object containing the matched elements.
-func (s *Selection) Parent() *Selection {
-	return pushStack(s, getParentNodes(s.Nodes))
-}
-
-// ParentFiltered gets the parent of each element in the Selection filtered by a
-// selector. It returns a new Selection object containing the matched elements.
-func (s *Selection) ParentFiltered(selector string) *Selection {
-	return filterAndPush(s, getParentNodes(s.Nodes), compileMatcher(selector))
-}
-
-// ParentMatcher gets the parent of each element in the Selection filtered by a
-// matcher. It returns a new Selection object containing the matched elements.
-func (s *Selection) ParentMatcher(m Matcher) *Selection {
-	return filterAndPush(s, getParentNodes(s.Nodes), m)
-}
-
-// Closest gets the first element that matches the selector by testing the
-// element itself and traversing up through its ancestors in the DOM tree.
-func (s *Selection) Closest(selector string) *Selection {
-	cs := compileMatcher(selector)
-	return s.ClosestMatcher(cs)
-}
-
-// ClosestMatcher gets the first element that matches the matcher by testing the
-// element itself and traversing up through its ancestors in the DOM tree.
-func (s *Selection) ClosestMatcher(m Matcher) *Selection {
-	return pushStack(s, mapNodes(s.Nodes, func(i int, n *html.Node) []*html.Node {
-		// For each node in the selection, test the node itself, then each parent
-		// until a match is found.
-		for ; n != nil; n = n.Parent {
-			if m.Match(n) {
-				return []*html.Node{n}
-			}
-		}
-		return nil
-	}))
-}
-
-// ClosestNodes gets the first element that matches one of the nodes by testing the
-// element itself and traversing up through its ancestors in the DOM tree.
-func (s *Selection) ClosestNodes(nodes ...*html.Node) *Selection {
-	set := make(map[*html.Node]bool)
-	for _, n := range nodes {
-		set[n] = true
-	}
-	return pushStack(s, mapNodes(s.Nodes, func(i int, n *html.Node) []*html.Node {
-		// For each node in the selection, test the node itself, then each parent
-		// until a match is found.
-		for ; n != nil; n = n.Parent {
-			if set[n] {
-				return []*html.Node{n}
-			}
-		}
-		return nil
-	}))
-}
-
-// ClosestSelection gets the first element that matches one of the nodes in the
-// Selection by testing the element itself and traversing up through its ancestors
-// in the DOM tree.
-func (s *Selection) ClosestSelection(sel *Selection) *Selection {
-	if sel == nil {
-		return pushStack(s, nil)
-	}
-	return s.ClosestNodes(sel.Nodes...)
-}
-
-// Parents gets the ancestors of each element in the current Selection. It
-// returns a new Selection object with the matched elements.
-func (s *Selection) Parents() *Selection {
-	return pushStack(s, getParentsNodes(s.Nodes, nil, nil))
-}
-
-// ParentsFiltered gets the ancestors of each element in the current
-// Selection. It returns a new Selection object with the matched elements.
-func (s *Selection) ParentsFiltered(selector string) *Selection {
-	return filterAndPush(s, getParentsNodes(s.Nodes, nil, nil), compileMatcher(selector))
-}
-
-// ParentsMatcher gets the ancestors of each element in the current
-// Selection. It returns a new Selection object with the matched elements.
-func (s *Selection) ParentsMatcher(m Matcher) *Selection {
-	return filterAndPush(s, getParentsNodes(s.Nodes, nil, nil), m)
-}
-
-// ParentsUntil gets the ancestors of each element in the Selection, up to but
-// not including the element matched by the selector. It returns a new Selection
-// object containing the matched elements.
-func (s *Selection) ParentsUntil(selector string) *Selection {
-	return pushStack(s, getParentsNodes(s.Nodes, compileMatcher(selector), nil))
-}
-
-// ParentsUntilMatcher gets the ancestors of each element in the Selection, up to but
-// not including the element matched by the matcher. It returns a new Selection
-// object containing the matched elements.
-func (s *Selection) ParentsUntilMatcher(m Matcher) *Selection {
-	return pushStack(s, getParentsNodes(s.Nodes, m, nil))
-}
-
-// ParentsUntilSelection gets the ancestors of each element in the Selection,
-// up to but not including the elements in the specified Selection. It returns a
-// new Selection object containing the matched elements.
-func (s *Selection) ParentsUntilSelection(sel *Selection) *Selection {
-	if sel == nil {
-		return s.Parents()
-	}
-	return s.ParentsUntilNodes(sel.Nodes...)
-}
-
-// ParentsUntilNodes gets the ancestors of each element in the Selection,
-// up to but not including the specified nodes. It returns a
-// new Selection object containing the matched elements.
-func (s *Selection) ParentsUntilNodes(nodes ...*html.Node) *Selection {
-	return pushStack(s, getParentsNodes(s.Nodes, nil, nodes))
-}
-
-// ParentsFilteredUntil is like ParentsUntil, with the option to filter the
-// results based on a selector string. It returns a new Selection
-// object containing the matched elements.
-func (s *Selection) ParentsFilteredUntil(filterSelector, untilSelector string) *Selection {
-	return filterAndPush(s, getParentsNodes(s.Nodes, compileMatcher(untilSelector), nil), compileMatcher(filterSelector))
-}
-
-// ParentsFilteredUntilMatcher is like ParentsUntilMatcher, with the option to filter the
-// results based on a matcher. It returns a new Selection object containing the matched elements.
-func (s *Selection) ParentsFilteredUntilMatcher(filter, until Matcher) *Selection {
-	return filterAndPush(s, getParentsNodes(s.Nodes, until, nil), filter)
-}
-
-// ParentsFilteredUntilSelection is like ParentsUntilSelection, with the
-// option to filter the results based on a selector string. It returns a new
-// Selection object containing the matched elements.
-func (s *Selection) ParentsFilteredUntilSelection(filterSelector string, sel *Selection) *Selection {
-	return s.ParentsMatcherUntilSelection(compileMatcher(filterSelector), sel)
-}
-
-// ParentsMatcherUntilSelection is like ParentsUntilSelection, with the
-// option to filter the results based on a matcher. It returns a new
-// Selection object containing the matched elements.
-func (s *Selection) ParentsMatcherUntilSelection(filter Matcher, sel *Selection) *Selection {
-	if sel == nil {
-		return s.ParentsMatcher(filter)
-	}
-	return s.ParentsMatcherUntilNodes(filter, sel.Nodes...)
-}
-
-// ParentsFilteredUntilNodes is like ParentsUntilNodes, with the
-// option to filter the results based on a selector string. It returns a new
-// Selection object containing the matched elements.
-func (s *Selection) ParentsFilteredUntilNodes(filterSelector string, nodes ...*html.Node) *Selection {
-	return filterAndPush(s, getParentsNodes(s.Nodes, nil, nodes), compileMatcher(filterSelector))
-}
-
-// ParentsMatcherUntilNodes is like ParentsUntilNodes, with the
-// option to filter the results based on a matcher. It returns a new
-// Selection object containing the matched elements.
-func (s *Selection) ParentsMatcherUntilNodes(filter Matcher, nodes ...*html.Node) *Selection {
-	return filterAndPush(s, getParentsNodes(s.Nodes, nil, nodes), filter)
-}
-
-// Siblings gets the siblings of each element in the Selection. It returns
-// a new Selection object containing the matched elements.
-func (s *Selection) Siblings() *Selection {
-	return pushStack(s, getSiblingNodes(s.Nodes, siblingAll, nil, nil))
-}
-
-// SiblingsFiltered gets the siblings of each element in the Selection
-// filtered by a selector. It returns a new Selection object containing the
-// matched elements.
-func (s *Selection) SiblingsFiltered(selector string) *Selection {
-	return filterAndPush(s, getSiblingNodes(s.Nodes, siblingAll, nil, nil), compileMatcher(selector))
-}
-
-// SiblingsMatcher gets the siblings of each element in the Selection
-// filtered by a matcher. It returns a new Selection object containing the
-// matched elements.
-func (s *Selection) SiblingsMatcher(m Matcher) *Selection {
-	return filterAndPush(s, getSiblingNodes(s.Nodes, siblingAll, nil, nil), m)
-}
-
-// Next gets the immediately following sibling of each element in the
-// Selection. It returns a new Selection object containing the matched elements.
-func (s *Selection) Next() *Selection {
-	return pushStack(s, getSiblingNodes(s.Nodes, siblingNext, nil, nil))
-}
-
-// NextFiltered gets the immediately following sibling of each element in the
-// Selection filtered by a selector. It returns a new Selection object
-// containing the matched elements.
-func (s *Selection) NextFiltered(selector string) *Selection {
-	return filterAndPush(s, getSiblingNodes(s.Nodes, siblingNext, nil, nil), compileMatcher(selector))
-}
-
-// NextMatcher gets the immediately following sibling of each element in the
-// Selection filtered by a matcher. It returns a new Selection object
-// containing the matched elements.
-func (s *Selection) NextMatcher(m Matcher) *Selection {
-	return filterAndPush(s, getSiblingNodes(s.Nodes, siblingNext, nil, nil), m)
-}
-
-// NextAll gets all the following siblings of each element in the
-// Selection. It returns a new Selection object containing the matched elements.
-func (s *Selection) NextAll() *Selection {
-	return pushStack(s, getSiblingNodes(s.Nodes, siblingNextAll, nil, nil))
-}
-
-// NextAllFiltered gets all the following siblings of each element in the
-// Selection filtered by a selector. It returns a new Selection object
-// containing the matched elements.
-func (s *Selection) NextAllFiltered(selector string) *Selection {
-	return filterAndPush(s, getSiblingNodes(s.Nodes, siblingNextAll, nil, nil), compileMatcher(selector))
-}
-
-// NextAllMatcher gets all the following siblings of each element in the
-// Selection filtered by a matcher. It returns a new Selection object
-// containing the matched elements.
-func (s *Selection) NextAllMatcher(m Matcher) *Selection {
-	return filterAndPush(s, getSiblingNodes(s.Nodes, siblingNextAll, nil, nil), m)
-}
-
-// Prev gets the immediately preceding sibling of each element in the
-// Selection. It returns a new Selection object containing the matched elements.
-func (s *Selection) Prev() *Selection {
-	return pushStack(s, getSiblingNodes(s.Nodes, siblingPrev, nil, nil))
-}
-
-// PrevFiltered gets the immediately preceding sibling of each element in the
-// Selection filtered by a selector. It returns a new Selection object
-// containing the matched elements.
-func (s *Selection) PrevFiltered(selector string) *Selection {
-	return filterAndPush(s, getSiblingNodes(s.Nodes, siblingPrev, nil, nil), compileMatcher(selector))
-}
-
-// PrevMatcher gets the immediately preceding sibling of each element in the
-// Selection filtered by a matcher. It returns a new Selection object
-// containing the matched elements.
-func (s *Selection) PrevMatcher(m Matcher) *Selection {
-	return filterAndPush(s, getSiblingNodes(s.Nodes, siblingPrev, nil, nil), m)
-}
-
-// PrevAll gets all the preceding siblings of each element in the
-// Selection. It returns a new Selection object containing the matched elements.
-func (s *Selection) PrevAll() *Selection {
-	return pushStack(s, getSiblingNodes(s.Nodes, siblingPrevAll, nil, nil))
-}
-
-// PrevAllFiltered gets all the preceding siblings of each element in the
-// Selection filtered by a selector. It returns a new Selection object
-// containing the matched elements.
-func (s *Selection) PrevAllFiltered(selector string) *Selection {
-	return filterAndPush(s, getSiblingNodes(s.Nodes, siblingPrevAll, nil, nil), compileMatcher(selector))
-}
-
-// PrevAllMatcher gets all the preceding siblings of each element in the
-// Selection filtered by a matcher. It returns a new Selection object
-// containing the matched elements.
-func (s *Selection) PrevAllMatcher(m Matcher) *Selection {
-	return filterAndPush(s, getSiblingNodes(s.Nodes, siblingPrevAll, nil, nil), m)
-}
-
-// NextUntil gets all following siblings of each element up to but not
-// including the element matched by the selector. It returns a new Selection
-// object containing the matched elements.
-func (s *Selection) NextUntil(selector string) *Selection {
-	return pushStack(s, getSiblingNodes(s.Nodes, siblingNextUntil,
-		compileMatcher(selector), nil))
-}
-
-// NextUntilMatcher gets all following siblings of each element up to but not
-// including the element matched by the matcher. It returns a new Selection
-// object containing the matched elements.
-func (s *Selection) NextUntilMatcher(m Matcher) *Selection {
-	return pushStack(s, getSiblingNodes(s.Nodes, siblingNextUntil,
-		m, nil))
-}
-
-// NextUntilSelection gets all following siblings of each element up to but not
-// including the element matched by the Selection. It returns a new Selection
-// object containing the matched elements.
-func (s *Selection) NextUntilSelection(sel *Selection) *Selection {
-	if sel == nil {
-		return s.NextAll()
-	}
-	return s.NextUntilNodes(sel.Nodes...)
-}
-
-// NextUntilNodes gets all following siblings of each element up to but not
-// including the element matched by the nodes. It returns a new Selection
-// object containing the matched elements.
-func (s *Selection) NextUntilNodes(nodes ...*html.Node) *Selection {
-	return pushStack(s, getSiblingNodes(s.Nodes, siblingNextUntil,
-		nil, nodes))
-}
-
-// PrevUntil gets all preceding siblings of each element up to but not
-// including the element matched by the selector. It returns a new Selection
-// object containing the matched elements.
-func (s *Selection) PrevUntil(selector string) *Selection {
-	return pushStack(s, getSiblingNodes(s.Nodes, siblingPrevUntil,
-		compileMatcher(selector), nil))
-}
-
-// PrevUntilMatcher gets all preceding siblings of each element up to but not
-// including the element matched by the matcher. It returns a new Selection
-// object containing the matched elements.
-func (s *Selection) PrevUntilMatcher(m Matcher) *Selection {
-	return pushStack(s, getSiblingNodes(s.Nodes, siblingPrevUntil,
-		m, nil))
-}
-
-// PrevUntilSelection gets all preceding siblings of each element up to but not
-// including the element matched by the Selection. It returns a new Selection
-// object containing the matched elements.
-func (s *Selection) PrevUntilSelection(sel *Selection) *Selection {
-	if sel == nil {
-		return s.PrevAll()
-	}
-	return s.PrevUntilNodes(sel.Nodes...)
-}
-
-// PrevUntilNodes gets all preceding siblings of each element up to but not
-// including the element matched by the nodes. It returns a new Selection
-// object containing the matched elements.
-func (s *Selection) PrevUntilNodes(nodes ...*html.Node) *Selection {
-	return pushStack(s, getSiblingNodes(s.Nodes, siblingPrevUntil,
-		nil, nodes))
-}
-
-// NextFilteredUntil is like NextUntil, with the option to filter
-// the results based on a selector string.
-// It returns a new Selection object containing the matched elements.
-func (s *Selection) NextFilteredUntil(filterSelector, untilSelector string) *Selection {
-	return filterAndPush(s, getSiblingNodes(s.Nodes, siblingNextUntil,
-		compileMatcher(untilSelector), nil), compileMatcher(filterSelector))
-}
-
-// NextFilteredUntilMatcher is like NextUntilMatcher, with the option to filter
-// the results based on a matcher.
-// It returns a new Selection object containing the matched elements.
-func (s *Selection) NextFilteredUntilMatcher(filter, until Matcher) *Selection {
-	return filterAndPush(s, getSiblingNodes(s.Nodes, siblingNextUntil,
-		until, nil), filter)
-}
-
-// NextFilteredUntilSelection is like NextUntilSelection, with the
-// option to filter the results based on a selector string. It returns a new
-// Selection object containing the matched elements.
-func (s *Selection) NextFilteredUntilSelection(filterSelector string, sel *Selection) *Selection {
-	return s.NextMatcherUntilSelection(compileMatcher(filterSelector), sel)
-}
-
-// NextMatcherUntilSelection is like NextUntilSelection, with the
-// option to filter the results based on a matcher. It returns a new
-// Selection object containing the matched elements.
-func (s *Selection) NextMatcherUntilSelection(filter Matcher, sel *Selection) *Selection {
-	if sel == nil {
-		return s.NextMatcher(filter)
-	}
-	return s.NextMatcherUntilNodes(filter, sel.Nodes...)
-}
-
-// NextFilteredUntilNodes is like NextUntilNodes, with the
-// option to filter the results based on a selector string. It returns a new
-// Selection object containing the matched elements.
-func (s *Selection) NextFilteredUntilNodes(filterSelector string, nodes ...*html.Node) *Selection {
-	return filterAndPush(s, getSiblingNodes(s.Nodes, siblingNextUntil,
-		nil, nodes), compileMatcher(filterSelector))
-}
-
-// NextMatcherUntilNodes is like NextUntilNodes, with the
-// option to filter the results based on a matcher. It returns a new
-// Selection object containing the matched elements.
-func (s *Selection) NextMatcherUntilNodes(filter Matcher, nodes ...*html.Node) *Selection {
-	return filterAndPush(s, getSiblingNodes(s.Nodes, siblingNextUntil,
-		nil, nodes), filter)
-}
-
-// PrevFilteredUntil is like PrevUntil, with the option to filter
-// the results based on a selector string.
-// It returns a new Selection object containing the matched elements.
-func (s *Selection) PrevFilteredUntil(filterSelector, untilSelector string) *Selection {
-	return filterAndPush(s, getSiblingNodes(s.Nodes, siblingPrevUntil,
-		compileMatcher(untilSelector), nil), compileMatcher(filterSelector))
-}
-
-// PrevFilteredUntilMatcher is like PrevUntilMatcher, with the option to filter
-// the results based on a matcher.
-// It returns a new Selection object containing the matched elements.
-func (s *Selection) PrevFilteredUntilMatcher(filter, until Matcher) *Selection {
-	return filterAndPush(s, getSiblingNodes(s.Nodes, siblingPrevUntil,
-		until, nil), filter)
-}
-
-// PrevFilteredUntilSelection is like PrevUntilSelection, with the
-// option to filter the results based on a selector string. It returns a new
-// Selection object containing the matched elements.
-func (s *Selection) PrevFilteredUntilSelection(filterSelector string, sel *Selection) *Selection {
-	return s.PrevMatcherUntilSelection(compileMatcher(filterSelector), sel)
-}
-
-// PrevMatcherUntilSelection is like PrevUntilSelection, with the
-// option to filter the results based on a matcher. It returns a new
-// Selection object containing the matched elements.
-func (s *Selection) PrevMatcherUntilSelection(filter Matcher, sel *Selection) *Selection {
-	if sel == nil {
-		return s.PrevMatcher(filter)
-	}
-	return s.PrevMatcherUntilNodes(filter, sel.Nodes...)
-}
-
-// PrevFilteredUntilNodes is like PrevUntilNodes, with the
-// option to filter the results based on a selector string. It returns a new
-// Selection object containing the matched elements.
-func (s *Selection) PrevFilteredUntilNodes(filterSelector string, nodes ...*html.Node) *Selection {
-	return filterAndPush(s, getSiblingNodes(s.Nodes, siblingPrevUntil,
-		nil, nodes), compileMatcher(filterSelector))
-}
-
-// PrevMatcherUntilNodes is like PrevUntilNodes, with the
-// option to filter the results based on a matcher. It returns a new
-// Selection object containing the matched elements.
-func (s *Selection) PrevMatcherUntilNodes(filter Matcher, nodes ...*html.Node) *Selection {
-	return filterAndPush(s, getSiblingNodes(s.Nodes, siblingPrevUntil,
-		nil, nodes), filter)
-}
-
-// Filter and push filters the nodes based on a matcher, and pushes the results
-// on the stack, with the srcSel as previous selection.
-func filterAndPush(srcSel *Selection, nodes []*html.Node, m Matcher) *Selection {
-	// Create a temporary Selection with the specified nodes to filter using winnow
-	sel := &Selection{nodes, srcSel.document, nil}
-	// Filter based on matcher and push on stack
-	return pushStack(srcSel, winnow(sel, m, true))
-}
-
-// Internal implementation of Find that return raw nodes.
-func findWithMatcher(nodes []*html.Node, m Matcher) []*html.Node {
-	// Map nodes to find the matches within the children of each node
-	return mapNodes(nodes, func(i int, n *html.Node) (result []*html.Node) {
-		// Go down one level, becausejQuery's Find selects only within descendants
-		for c := n.FirstChild; c != nil; c = c.NextSibling {
-			if c.Type == html.ElementNode {
-				result = append(result, m.MatchAll(c)...)
-			}
-		}
-		return
-	})
-}
-
-// Internal implementation to get all parent nodes, stopping at the specified
-// node (or nil if no stop).
-func getParentsNodes(nodes []*html.Node, stopm Matcher, stopNodes []*html.Node) []*html.Node {
-	return mapNodes(nodes, func(i int, n *html.Node) (result []*html.Node) {
-		for p := n.Parent; p != nil; p = p.Parent {
-			sel := newSingleSelection(p, nil)
-			if stopm != nil {
-				if sel.IsMatcher(stopm) {
-					break
-				}
-			} else if len(stopNodes) > 0 {
-				if sel.IsNodes(stopNodes...) {
-					break
-				}
-			}
-			if p.Type == html.ElementNode {
-				result = append(result, p)
-			}
-		}
-		return
-	})
-}
-
-// Internal implementation of sibling nodes that return a raw slice of matches.
-func getSiblingNodes(nodes []*html.Node, st siblingType, untilm Matcher, untilNodes []*html.Node) []*html.Node {
-	var f func(*html.Node) bool
-
-	// If the requested siblings are ...Until, create the test function to
-	// determine if the until condition is reached (returns true if it is)
-	if st == siblingNextUntil || st == siblingPrevUntil {
-		f = func(n *html.Node) bool {
-			if untilm != nil {
-				// Matcher-based condition
-				sel := newSingleSelection(n, nil)
-				return sel.IsMatcher(untilm)
-			} else if len(untilNodes) > 0 {
-				// Nodes-based condition
-				sel := newSingleSelection(n, nil)
-				return sel.IsNodes(untilNodes...)
-			}
-			return false
-		}
-	}
-
-	return mapNodes(nodes, func(i int, n *html.Node) []*html.Node {
-		return getChildrenWithSiblingType(n.Parent, st, n, f)
-	})
-}
-
-// Gets the children nodes of each node in the specified slice of nodes,
-// based on the sibling type request.
-func getChildrenNodes(nodes []*html.Node, st siblingType) []*html.Node {
-	return mapNodes(nodes, func(i int, n *html.Node) []*html.Node {
-		return getChildrenWithSiblingType(n, st, nil, nil)
-	})
-}
-
-// Gets the children of the specified parent, based on the requested sibling
-// type, skipping a specified node if required.
-func getChildrenWithSiblingType(parent *html.Node, st siblingType, skipNode *html.Node,
-	untilFunc func(*html.Node) bool) (result []*html.Node) {
-
-	// Create the iterator function
-	var iter = func(cur *html.Node) (ret *html.Node) {
-		// Based on the sibling type requested, iterate the right way
-		for {
-			switch st {
-			case siblingAll, siblingAllIncludingNonElements:
-				if cur == nil {
-					// First iteration, start with first child of parent
-					// Skip node if required
-					if ret = parent.FirstChild; ret == skipNode && skipNode != nil {
-						ret = skipNode.NextSibling
-					}
-				} else {
-					// Skip node if required
-					if ret = cur.NextSibling; ret == skipNode && skipNode != nil {
-						ret = skipNode.NextSibling
-					}
-				}
-			case siblingPrev, siblingPrevAll, siblingPrevUntil:
-				if cur == nil {
-					// Start with previous sibling of the skip node
-					ret = skipNode.PrevSibling
-				} else {
-					ret = cur.PrevSibling
-				}
-			case siblingNext, siblingNextAll, siblingNextUntil:
-				if cur == nil {
-					// Start with next sibling of the skip node
-					ret = skipNode.NextSibling
-				} else {
-					ret = cur.NextSibling
-				}
-			default:
-				panic("Invalid sibling type.")
-			}
-			if ret == nil || ret.Type == html.ElementNode || st == siblingAllIncludingNonElements {
-				return
-			}
-			// Not a valid node, try again from this one
-			cur = ret
-		}
-	}
-
-	for c := iter(nil); c != nil; c = iter(c) {
-		// If this is an ...Until case, test before append (returns true
-		// if the until condition is reached)
-		if st == siblingNextUntil || st == siblingPrevUntil {
-			if untilFunc(c) {
-				return
-			}
-		}
-		result = append(result, c)
-		if st == siblingNext || st == siblingPrev {
-			// Only one node was requested (immediate next or previous), so exit
-			return
-		}
-	}
-	return
-}
-
-// Internal implementation of parent nodes that return a raw slice of Nodes.
-func getParentNodes(nodes []*html.Node) []*html.Node {
-	return mapNodes(nodes, func(i int, n *html.Node) []*html.Node {
-		if n.Parent != nil && n.Parent.Type == html.ElementNode {
-			return []*html.Node{n.Parent}
-		}
-		return nil
-	})
-}
-
-// Internal map function used by many traversing methods. Takes the source nodes
-// to iterate on and the mapping function that returns an array of nodes.
-// Returns an array of nodes mapped by calling the callback function once for
-// each node in the source nodes.
-func mapNodes(nodes []*html.Node, f func(int, *html.Node) []*html.Node) (result []*html.Node) {
-	set := make(map[*html.Node]bool)
-	for i, n := range nodes {
-		if vals := f(i, n); len(vals) > 0 {
-			result = appendWithoutDuplicates(result, vals, set)
-		}
-	}
-	return result
-}
--- a/vendor/github.com/PuerkitoBio/goquery/type.go
+++ b/vendor/github.com/PuerkitoBio/goquery/type.go
@@ -1,141 +0,0 @@
-package goquery
-
-import (
-	"errors"
-	"io"
-	"net/http"
-	"net/url"
-
-	"github.com/andybalholm/cascadia"
-
-	"golang.org/x/net/html"
-)
-
-// Document represents an HTML document to be manipulated. Unlike jQuery, which
-// is loaded as part of a DOM document, and thus acts upon its containing
-// document, GoQuery doesn't know which HTML document to act upon. So it needs
-// to be told, and that's what the Document class is for. It holds the root
-// document node to manipulate, and can make selections on this document.
-type Document struct {
-	*Selection
-	Url      *url.URL
-	rootNode *html.Node
-}
-
-// NewDocumentFromNode is a Document constructor that takes a root html Node
-// as argument.
-func NewDocumentFromNode(root *html.Node) *Document {
-	return newDocument(root, nil)
-}
-
-// NewDocument is a Document constructor that takes a string URL as argument.
-// It loads the specified document, parses it, and stores the root Document
-// node, ready to be manipulated.
-//
-// Deprecated: Use the net/http standard library package to make the request
-// and validate the response before calling goquery.NewDocumentFromReader
-// with the response's body.
-func NewDocument(url string) (*Document, error) {
-	// Load the URL
-	res, e := http.Get(url)
-	if e != nil {
-		return nil, e
-	}
-	return NewDocumentFromResponse(res)
-}
-
-// NewDocumentFromReader returns a Document from an io.Reader.
-// It returns an error as second value if the reader's data cannot be parsed
-// as html. It does not check if the reader is also an io.Closer, the
-// provided reader is never closed by this call. It is the responsibility
-// of the caller to close it if required.
-func NewDocumentFromReader(r io.Reader) (*Document, error) {
-	root, e := html.Parse(r)
-	if e != nil {
-		return nil, e
-	}
-	return newDocument(root, nil), nil
-}
-
-// NewDocumentFromResponse is another Document constructor that takes an http response as argument.
-// It loads the specified response's document, parses it, and stores the root Document
-// node, ready to be manipulated. The response's body is closed on return.
-//
-// Deprecated: Use goquery.NewDocumentFromReader with the response's body.
-func NewDocumentFromResponse(res *http.Response) (*Document, error) {
-	if res == nil {
-		return nil, errors.New("Response is nil")
-	}
-	defer res.Body.Close()
-	if res.Request == nil {
-		return nil, errors.New("Response.Request is nil")
-	}
-
-	// Parse the HTML into nodes
-	root, e := html.Parse(res.Body)
-	if e != nil {
-		return nil, e
-	}
-
-	// Create and fill the document
-	return newDocument(root, res.Request.URL), nil
-}
-
-// CloneDocument creates a deep-clone of a document.
-func CloneDocument(doc *Document) *Document {
-	return newDocument(cloneNode(doc.rootNode), doc.Url)
-}
-
-// Private constructor, make sure all fields are correctly filled.
-func newDocument(root *html.Node, url *url.URL) *Document {
-	// Create and fill the document
-	d := &Document{nil, url, root}
-	d.Selection = newSingleSelection(root, d)
-	return d
-}
-
-// Selection represents a collection of nodes matching some criteria. The
-// initial Selection can be created by using Document.Find, and then
-// manipulated using the jQuery-like chainable syntax and methods.
-type Selection struct {
-	Nodes    []*html.Node
-	document *Document
-	prevSel  *Selection
-}
-
-// Helper constructor to create an empty selection
-func newEmptySelection(doc *Document) *Selection {
-	return &Selection{nil, doc, nil}
-}
-
-// Helper constructor to create a selection of only one node
-func newSingleSelection(node *html.Node, doc *Document) *Selection {
-	return &Selection{[]*html.Node{node}, doc, nil}
-}
-
-// Matcher is an interface that defines the methods to match
-// HTML nodes against a compiled selector string. Cascadia's
-// Selector implements this interface.
-type Matcher interface {
-	Match(*html.Node) bool
-	MatchAll(*html.Node) []*html.Node
-	Filter([]*html.Node) []*html.Node
-}
-
-// compileMatcher compiles the selector string s and returns
-// the corresponding Matcher. If s is an invalid selector string,
-// it returns a Matcher that fails all matches.
-func compileMatcher(s string) Matcher {
-	cs, err := cascadia.Compile(s)
-	if err != nil {
-		return invalidMatcher{}
-	}
-	return cs
-}
-
-// invalidMatcher is a Matcher that always fails to match.
-type invalidMatcher struct{}
-
-func (invalidMatcher) Match(n *html.Node) bool             { return false }
-func (invalidMatcher) MatchAll(n *html.Node) []*html.Node  { return nil }
-func (invalidMatcher) Filter(ns []*html.Node) []*html.Node { return nil }
--- a/vendor/github.com/PuerkitoBio/goquery/utilities.go
+++ b/vendor/github.com/PuerkitoBio/goquery/utilities.go
@@ -1,161 +0,0 @@
-package goquery
-
-import (
-	"bytes"
-
-	"golang.org/x/net/html"
-)
-
-// used to determine if a set (map[*html.Node]bool) should be used
-// instead of iterating over a slice. The set uses more memory and
-// is slower than slice iteration for small N.
-const minNodesForSet = 1000
-
-var nodeNames = []string{
-	html.ErrorNode:    "#error",
-	html.TextNode:     "#text",
-	html.DocumentNode: "#document",
-	html.CommentNode:  "#comment",
-}
-
-// NodeName returns the node name of the first element in the selection.
-// It tries to behave in a similar way as the DOM's nodeName property
-// (https://developer.mozilla.org/en-US/docs/Web/API/Node/nodeName).
-//
-// Go's net/html package defines the following node types, listed with
-// the corresponding returned value from this function:
-//
-//     ErrorNode : #error
-//     TextNode : #text
-//     DocumentNode : #document
-//     ElementNode : the element's tag name
-//     CommentNode : #comment
-//     DoctypeNode : the name of the document type
-//
-func NodeName(s *Selection) string {
-	if s.Length() == 0 {
-		return ""
-	}
-	switch n := s.Get(0); n.Type {
-	case html.ElementNode, html.DoctypeNode:
-		return n.Data
-	default:
-		if n.Type >= 0 && int(n.Type) < len(nodeNames) {
-			return nodeNames[n.Type]
-		}
-		return ""
-	}
-}
-
-// OuterHtml returns the outer HTML rendering of the first item in
-// the selection - that is, the HTML including the first element's
-// tag and attributes.
-//
-// Unlike InnerHtml, this is a function and not a method on the Selection,
-// because this is not a jQuery method (in javascript-land, this is
-// a property provided by the DOM).
-func OuterHtml(s *Selection) (string, error) {
-	var buf bytes.Buffer
-
-	if s.Length() == 0 {
-		return "", nil
-	}
-	n := s.Get(0)
-	if err := html.Render(&buf, n); err != nil {
-		return "", err
-	}
-	return buf.String(), nil
-}
-
-// Loop through all container nodes to search for the target node.
-func sliceContains(container []*html.Node, contained *html.Node) bool {
-	for _, n := range container {
-		if nodeContains(n, contained) {
-			return true
-		}
-	}
-
-	return false
-}
-
-// Checks if the contained node is within the container node.
-func nodeContains(container *html.Node, contained *html.Node) bool {
-	// Check if the parent of the contained node is the container node, traversing
-	// upward until the top is reached, or the container is found.
-	for contained = contained.Parent; contained != nil; contained = contained.Parent {
-		if container == contained {
-			return true
-		}
-	}
-	return false
-}
-
-// Checks if the target node is in the slice of nodes.
-func isInSlice(slice []*html.Node, node *html.Node) bool {
-	return indexInSlice(slice, node) > -1
-}
-
-// Returns the index of the target node in the slice, or -1.
-func indexInSlice(slice []*html.Node, node *html.Node) int {
-	if node != nil {
-		for i, n := range slice {
-			if n == node {
-				return i
-			}
-		}
-	}
-	return -1
-}
-
-// Appends the new nodes to the target slice, making sure no duplicate is added.
-// There is no check to the original state of the target slice, so it may still
-// contain duplicates. The target slice is returned because append() may create
-// a new underlying array. If targetSet is nil, a local set is created with the
-// target if len(target) + len(nodes) is greater than minNodesForSet.
-func appendWithoutDuplicates(target []*html.Node, nodes []*html.Node, targetSet map[*html.Node]bool) []*html.Node {
-	// if there are not that many nodes, don't use the map, faster to just use nested loops
-	// (unless a non-nil targetSet is passed, in which case the caller knows better).
-	if targetSet == nil && len(target)+len(nodes) < minNodesForSet {
-		for _, n := range nodes {
-			if !isInSlice(target, n) {
-				target = append(target, n)
-			}
-		}
-		return target
-	}
-
-	// if a targetSet is passed, then assume it is reliable, otherwise create one
-	// and initialize it with the current target contents.
-	if targetSet == nil {
-		targetSet = make(map[*html.Node]bool, len(target))
-		for _, n := range target {
-			targetSet[n] = true
-		}
-	}
-	for _, n := range nodes {
-		if !targetSet[n] {
-			target = append(target, n)
-			targetSet[n] = true
-		}
-	}
-
-	return target
-}
-
-// Loop through a selection, returning only those nodes that pass the predicate
-// function.
-func grep(sel *Selection, predicate func(i int, s *Selection) bool) (result []*html.Node) {
-	for i, n := range sel.Nodes {
-		if predicate(i, newSingleSelection(n, sel.document)) {
-			result = append(result, n)
-		}
-	}
-	return result
-}
-
-// Creates a new Selection object based on the specified nodes, and keeps the
-// source Selection object on the stack (linked list).
-func pushStack(fromSel *Selection, nodes []*html.Node) *Selection {
-	result := &Selection{nodes, fromSel.document, fromSel}
-	return result
-}
--- a/vendor/github.com/agnivade/levenshtein/.gitignore
+++ b/vendor/github.com/agnivade/levenshtein/.gitignore
@@ -1,5 +0,0 @@
-coverage.txt
-fuzz/fuzz-fuzz.zip
-fuzz/corpus/corpus/*
-fuzz/corpus/suppressions/*
-fuzz/corpus/crashes/*
--- a/vendor/github.com/agnivade/levenshtein/.travis.yml
+++ b/vendor/github.com/agnivade/levenshtein/.travis.yml
@@ -1,7 +0,0 @@
-language: go
-
-go:
- 1.9.x
- 1.10.x
- 1.11.x
- tip
--- a/vendor/github.com/agnivade/levenshtein/License.txt
+++ b/vendor/github.com/agnivade/levenshtein/License.txt
@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2015 Agniva De Sarker
-
-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.
--- a/vendor/github.com/agnivade/levenshtein/Makefile
+++ b/vendor/github.com/agnivade/levenshtein/Makefile
@@ -1,13 +0,0 @@
-all: test install
-
-install:
-	go install
-
-lint:
-	gofmt -l -s -w . && go tool vet -all . && golint
-
-test:
-	go test -race -v -coverprofile=coverage.txt -covermode=atomic
-
-bench:
-	go test -run=XXX -bench=. -benchmem
--- a/vendor/github.com/agnivade/levenshtein/README.md
+++ b/vendor/github.com/agnivade/levenshtein/README.md
@@ -1,57 +0,0 @@
-levenshtein [![Build Status](https://travis-ci.org/agnivade/levenshtein.svg?branch=master)](https://travis-ci.org/agnivade/levenshtein) [![Go Report Card](https://goreportcard.com/badge/github.com/agnivade/levenshtein)](https://goreportcard.com/report/github.com/agnivade/levenshtein) [![GoDoc](https://godoc.org/github.com/agnivade/levenshtein?status.svg)](https://godoc.org/github.com/agnivade/levenshtein)
-===========
-
-[Go](http://golang.org) package to calculate the [Levenshtein Distance](http://en.wikipedia.org/wiki/Levenshtein_distance)
-
-The library is fully capable of working with non-ascii strings. But the strings are not normalized. That is left as a user-dependant use case. Please normalize the strings before passing it to the library if you have such a requirement.
- https://blog.golang.org/normalization
-
-Install
-------
-
-    go get github.com/agnivade/levenshtein
-
-Example
-------
-
-```go
-package main
-
-import (
-	"fmt"
-	"github.com/agnivade/levenshtein"
-)
-
-func main() {
-	s1 := "kitten"
-	s2 := "sitting"
-	distance := levenshtein.ComputeDistance(s1, s2)
-	fmt.Printf("The distance between %s and %s is %d.\n", s1, s2, distance)
-	// Output:
-	// The distance between kitten and sitting is 3.
-}
-
-```
-
-Benchmarks
----------
-
-```
-name              time/op
-Simple/ASCII-4     537ns ± 2%
-Simple/French-4    956ns ± 0%
-Simple/Nordic-4   1.95µs ± 1%
-Simple/Tibetan-4  1.53µs ± 2%
-
-name              alloc/op
-Simple/ASCII-4     96.0B ± 0%
-Simple/French-4     128B ± 0%
-Simple/Nordic-4     192B ± 0%
-Simple/Tibetan-4    144B ± 0%
-
-name              allocs/op
-Simple/ASCII-4      1.00 ± 0%
-Simple/French-4     1.00 ± 0%
-Simple/Nordic-4     1.00 ± 0%
-Simple/Tibetan-4    1.00 ± 0%
-```
--- a/vendor/github.com/agnivade/levenshtein/go.mod
+++ b/vendor/github.com/agnivade/levenshtein/go.mod
@@ -1 +0,0 @@
-module github.com/agnivade/levenshtein
--- a/vendor/github.com/agnivade/levenshtein/levenshtein.go
+++ b/vendor/github.com/agnivade/levenshtein/levenshtein.go
@@ -1,75 +0,0 @@
-// Package levenshtein is a Go implementation to calculate Levenshtein Distance.
-//
-// Implementation taken from
-// https://gist.github.com/andrei-m/982927#gistcomment-1931258
-package levenshtein
-
-import "unicode/utf8"
-
-// ComputeDistance computes the levenshtein distance between the two
-// strings passed as an argument. The return value is the levenshtein distance
-//
-// Works on runes (Unicode code points) but does not normalize
-// the input strings. See https://blog.golang.org/normalization
-// and the golang.org/x/text/unicode/norm pacage.
-func ComputeDistance(a, b string) int {
-	if len(a) == 0 {
-		return utf8.RuneCountInString(b)
-	}
-
-	if len(b) == 0 {
-		return utf8.RuneCountInString(a)
-	}
-
-	if a == b {
-		return 0
-	}
-
-	// We need to convert to []rune if the strings are non-ascii.
-	// This could be avoided by using utf8.RuneCountInString
-	// and then doing some juggling with rune indices.
-	// The primary challenge is keeping track of the previous rune.
-	// With a range loop, its not that easy. And with a for-loop
-	// we need to keep track of the inter-rune width using utf8.DecodeRuneInString
-	s1 := []rune(a)
-	s2 := []rune(b)
-
-	// swap to save some memory O(min(a,b)) instead of O(a)
-	if len(s1) > len(s2) {
-		s1, s2 = s2, s1
-	}
-	lenS1 := len(s1)
-	lenS2 := len(s2)
-
-	// init the row
-	x := make([]int, lenS1+1)
-	for i := 0; i <= lenS1; i++ {
-		x[i] = i
-	}
-
-	// fill in the rest
-	for i := 1; i <= lenS2; i++ {
-		prev := i
-		var current int
-
-		for j := 1; j <= lenS1; j++ {
-
-			if s2[i-1] == s1[j-1] {
-				current = x[j-1] // match
-			} else {
-				current = min(min(x[j-1]+1, prev+1), x[j]+1)
-			}
-			x[j-1] = prev
-			prev = current
-		}
-		x[lenS1] = prev
-	}
-	return x[lenS1]
-}
-
-func min(a, b int) int {
-	if a < b {
-		return a
-	}
-	return b
-}
--- a/vendor/github.com/andybalholm/cascadia/.travis.yml
+++ b/vendor/github.com/andybalholm/cascadia/.travis.yml
@@ -1,14 +0,0 @@
-language: go
-
-go:
-  - 1.3
-  - 1.4
-
-install:
-  - go get github.com/andybalholm/cascadia
-
-script:
- - go test -v
-
-notifications:
-  email: false
--- a/vendor/github.com/andybalholm/cascadia/LICENSE
+++ b/vendor/github.com/andybalholm/cascadia/LICENSE
@@ -1,24 +0,0 @@
-Copyright (c) 2011 Andy Balholm. 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.
-
-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.
--- a/vendor/github.com/andybalholm/cascadia/README.md
+++ b/vendor/github.com/andybalholm/cascadia/README.md
@@ -1,7 +0,0 @@
-# cascadia
-
-[![](https://travis-ci.org/andybalholm/cascadia.svg)](https://travis-ci.org/andybalholm/cascadia)
-
-The Cascadia package implements CSS selectors for use with the parse trees produced by the html package.
-
-To test CSS selectors without writing Go code, check out [cascadia](https://github.com/suntong/cascadia) the command line tool, a thin wrapper around this package.
--- a/vendor/github.com/andybalholm/cascadia/go.mod
+++ b/vendor/github.com/andybalholm/cascadia/go.mod
@@ -1,3 +0,0 @@
-module "github.com/andybalholm/cascadia"
-
-require "golang.org/x/net" v0.0.0-20180218175443-cbe0f9307d01
--- a/vendor/github.com/andybalholm/cascadia/parser.go
+++ b/vendor/github.com/andybalholm/cascadia/parser.go
@@ -1,835 +0,0 @@
-// Package cascadia is an implementation of CSS selectors.
-package cascadia
-
-import (
-	"errors"
-	"fmt"
-	"regexp"
-	"strconv"
-	"strings"
-
-	"golang.org/x/net/html"
-)
-
-// a parser for CSS selectors
-type parser struct {
-	s string // the source text
-	i int    // the current position
-}
-
-// parseEscape parses a backslash escape.
-func (p *parser) parseEscape() (result string, err error) {
-	if len(p.s) < p.i+2 || p.s[p.i] != '\\' {
-		return "", errors.New("invalid escape sequence")
-	}
-
-	start := p.i + 1
-	c := p.s[start]
-	switch {
-	case c == '\r' || c == '\n' || c == '\f':
-		return "", errors.New("escaped line ending outside string")
-	case hexDigit(c):
-		// unicode escape (hex)
-		var i int
-		for i = start; i < p.i+6 && i < len(p.s) && hexDigit(p.s[i]); i++ {
-			// empty
-		}
-		v, _ := strconv.ParseUint(p.s[start:i], 16, 21)
-		if len(p.s) > i {
-			switch p.s[i] {
-			case '\r':
-				i++
-				if len(p.s) > i && p.s[i] == '\n' {
-					i++
-				}
-			case ' ', '\t', '\n', '\f':
-				i++
-			}
-		}
-		p.i = i
-		return string(rune(v)), nil
-	}
-
-	// Return the literal character after the backslash.
-	result = p.s[start : start+1]
-	p.i += 2
-	return result, nil
-}
-
-func hexDigit(c byte) bool {
-	return '0' <= c && c <= '9' || 'a' <= c && c <= 'f' || 'A' <= c && c <= 'F'
-}
-
-// nameStart returns whether c can be the first character of an identifier
-// (not counting an initial hyphen, or an escape sequence).
-func nameStart(c byte) bool {
-	return 'a' <= c && c <= 'z' || 'A' <= c && c <= 'Z' || c == '_' || c > 127
-}
-
-// nameChar returns whether c can be a character within an identifier
-// (not counting an escape sequence).
-func nameChar(c byte) bool {
-	return 'a' <= c && c <= 'z' || 'A' <= c && c <= 'Z' || c == '_' || c > 127 ||
-		c == '-' || '0' <= c && c <= '9'
-}
-
-// parseIdentifier parses an identifier.
-func (p *parser) parseIdentifier() (result string, err error) {
-	startingDash := false
-	if len(p.s) > p.i && p.s[p.i] == '-' {
-		startingDash = true
-		p.i++
-	}
-
-	if len(p.s) <= p.i {
-		return "", errors.New("expected identifier, found EOF instead")
-	}
-
-	if c := p.s[p.i]; !(nameStart(c) || c == '\\') {
-		return "", fmt.Errorf("expected identifier, found %c instead", c)
-	}
-
-	result, err = p.parseName()
-	if startingDash && err == nil {
-		result = "-" + result
-	}
-	return
-}
-
-// parseName parses a name (which is like an identifier, but doesn't have
-// extra restrictions on the first character).
-func (p *parser) parseName() (result string, err error) {
-	i := p.i
-loop:
-	for i < len(p.s) {
-		c := p.s[i]
-		switch {
-		case nameChar(c):
-			start := i
-			for i < len(p.s) && nameChar(p.s[i]) {
-				i++
-			}
-			result += p.s[start:i]
-		case c == '\\':
-			p.i = i
-			val, err := p.parseEscape()
-			if err != nil {
-				return "", err
-			}
-			i = p.i
-			result += val
-		default:
-			break loop
-		}
-	}
-
-	if result == "" {
-		return "", errors.New("expected name, found EOF instead")
-	}
-
-	p.i = i
-	return result, nil
-}
-
-// parseString parses a single- or double-quoted string.
-func (p *parser) parseString() (result string, err error) {
-	i := p.i
-	if len(p.s) < i+2 {
-		return "", errors.New("expected string, found EOF instead")
-	}
-
-	quote := p.s[i]
-	i++
-
-loop:
-	for i < len(p.s) {
-		switch p.s[i] {
-		case '\\':
-			if len(p.s) > i+1 {
-				switch c := p.s[i+1]; c {
-				case '\r':
-					if len(p.s) > i+2 && p.s[i+2] == '\n' {
-						i += 3
-						continue loop
-					}
-					fallthrough
-				case '\n', '\f':
-					i += 2
-					continue loop
-				}
-			}
-			p.i = i
-			val, err := p.parseEscape()
-			if err != nil {
-				return "", err
-			}
-			i = p.i
-			result += val
-		case quote:
-			break loop
-		case '\r', '\n', '\f':
-			return "", errors.New("unexpected end of line in string")
-		default:
-			start := i
-			for i < len(p.s) {
-				if c := p.s[i]; c == quote || c == '\\' || c == '\r' || c == '\n' || c == '\f' {
-					break
-				}
-				i++
-			}
-			result += p.s[start:i]
-		}
-	}
-
-	if i >= len(p.s) {
-		return "", errors.New("EOF in string")
-	}
-
-	// Consume the final quote.
-	i++
-
-	p.i = i
-	return result, nil
-}
-
-// parseRegex parses a regular expression; the end is defined by encountering an
-// unmatched closing ')' or ']' which is not consumed
-func (p *parser) parseRegex() (rx *regexp.Regexp, err error) {
-	i := p.i
-	if len(p.s) < i+2 {
-		return nil, errors.New("expected regular expression, found EOF instead")
-	}
-
-	// number of open parens or brackets;
-	// when it becomes negative, finished parsing regex
-	open := 0
-
-loop:
-	for i < len(p.s) {
-		switch p.s[i] {
-		case '(', '[':
-			open++
-		case ')', ']':
-			open--
-			if open < 0 {
-				break loop
-			}
-		}
-		i++
-	}
-
-	if i >= len(p.s) {
-		return nil, errors.New("EOF in regular expression")
-	}
-	rx, err = regexp.Compile(p.s[p.i:i])
-	p.i = i
-	return rx, err
-}
-
-// skipWhitespace consumes whitespace characters and comments.
-// It returns true if there was actually anything to skip.
-func (p *parser) skipWhitespace() bool {
-	i := p.i
-	for i < len(p.s) {
-		switch p.s[i] {
-		case ' ', '\t', '\r', '\n', '\f':
-			i++
-			continue
-		case '/':
-			if strings.HasPrefix(p.s[i:], "/*") {
-				end := strings.Index(p.s[i+len("/*"):], "*/")
-				if end != -1 {
-					i += end + len("/**/")
-					continue
-				}
-			}
-		}
-		break
-	}
-
-	if i > p.i {
-		p.i = i
-		return true
-	}
-
-	return false
-}
-
-// consumeParenthesis consumes an opening parenthesis and any following
-// whitespace. It returns true if there was actually a parenthesis to skip.
-func (p *parser) consumeParenthesis() bool {
-	if p.i < len(p.s) && p.s[p.i] == '(' {
-		p.i++
-		p.skipWhitespace()
-		return true
-	}
-	return false
-}
-
-// consumeClosingParenthesis consumes a closing parenthesis and any preceding
-// whitespace. It returns true if there was actually a parenthesis to skip.
-func (p *parser) consumeClosingParenthesis() bool {
-	i := p.i
-	p.skipWhitespace()
-	if p.i < len(p.s) && p.s[p.i] == ')' {
-		p.i++
-		return true
-	}
-	p.i = i
-	return false
-}
-
-// parseTypeSelector parses a type selector (one that matches by tag name).
-func (p *parser) parseTypeSelector() (result Selector, err error) {
-	tag, err := p.parseIdentifier()
-	if err != nil {
-		return nil, err
-	}
-
-	return typeSelector(tag), nil
-}
-
-// parseIDSelector parses a selector that matches by id attribute.
-func (p *parser) parseIDSelector() (Selector, error) {
-	if p.i >= len(p.s) {
-		return nil, fmt.Errorf("expected id selector (#id), found EOF instead")
-	}
-	if p.s[p.i] != '#' {
-		return nil, fmt.Errorf("expected id selector (#id), found '%c' instead", p.s[p.i])
-	}
-
-	p.i++
-	id, err := p.parseName()
-	if err != nil {
-		return nil, err
-	}
-
-	return attributeEqualsSelector("id", id), nil
-}
-
-// parseClassSelector parses a selector that matches by class attribute.
-func (p *parser) parseClassSelector() (Selector, error) {
-	if p.i >= len(p.s) {
-		return nil, fmt.Errorf("expected class selector (.class), found EOF instead")
-	}
-	if p.s[p.i] != '.' {
-		return nil, fmt.Errorf("expected class selector (.class), found '%c' instead", p.s[p.i])
-	}
-
-	p.i++
-	class, err := p.parseIdentifier()
-	if err != nil {
-		return nil, err
-	}
-
-	return attributeIncludesSelector("class", class), nil
-}
-
-// parseAttributeSelector parses a selector that matches by attribute value.
-func (p *parser) parseAttributeSelector() (Selector, error) {
-	if p.i >= len(p.s) {
-		return nil, fmt.Errorf("expected attribute selector ([attribute]), found EOF instead")
-	}
-	if p.s[p.i] != '[' {
-		return nil, fmt.Errorf("expected attribute selector ([attribute]), found '%c' instead", p.s[p.i])
-	}
-
-	p.i++
-	p.skipWhitespace()
-	key, err := p.parseIdentifier()
-	if err != nil {
-		return nil, err
-	}
-
-	p.skipWhitespace()
-	if p.i >= len(p.s) {
-		return nil, errors.New("unexpected EOF in attribute selector")
-	}
-
-	if p.s[p.i] == ']' {
-		p.i++
-		return attributeExistsSelector(key), nil
-	}
-
-	if p.i+2 >= len(p.s) {
-		return nil, errors.New("unexpected EOF in attribute selector")
-	}
-
-	op := p.s[p.i : p.i+2]
-	if op[0] == '=' {
-		op = "="
-	} else if op[1] != '=' {
-		return nil, fmt.Errorf(`expected equality operator, found "%s" instead`, op)
-	}
-	p.i += len(op)
-
-	p.skipWhitespace()
-	if p.i >= len(p.s) {
-		return nil, errors.New("unexpected EOF in attribute selector")
-	}
-	var val string
-	var rx *regexp.Regexp
-	if op == "#=" {
-		rx, err = p.parseRegex()
-	} else {
-		switch p.s[p.i] {
-		case '\'', '"':
-			val, err = p.parseString()
-		default:
-			val, err = p.parseIdentifier()
-		}
-	}
-	if err != nil {
-		return nil, err
-	}
-
-	p.skipWhitespace()
-	if p.i >= len(p.s) {
-		return nil, errors.New("unexpected EOF in attribute selector")
-	}
-	if p.s[p.i] != ']' {
-		return nil, fmt.Errorf("expected ']', found '%c' instead", p.s[p.i])
-	}
-	p.i++
-
-	switch op {
-	case "=":
-		return attributeEqualsSelector(key, val), nil
-	case "!=":
-		return attributeNotEqualSelector(key, val), nil
-	case "~=":
-		return attributeIncludesSelector(key, val), nil
-	case "|=":
-		return attributeDashmatchSelector(key, val), nil
-	case "^=":
-		return attributePrefixSelector(key, val), nil
-	case "$=":
-		return attributeSuffixSelector(key, val), nil
-	case "*=":
-		return attributeSubstringSelector(key, val), nil
-	case "#=":
-		return attributeRegexSelector(key, rx), nil
-	}
-
-	return nil, fmt.Errorf("attribute operator %q is not supported", op)
-}
-
-var errExpectedParenthesis = errors.New("expected '(' but didn't find it")
-var errExpectedClosingParenthesis = errors.New("expected ')' but didn't find it")
-var errUnmatchedParenthesis = errors.New("unmatched '('")
-
-// parsePseudoclassSelector parses a pseudoclass selector like :not(p).
-func (p *parser) parsePseudoclassSelector() (Selector, error) {
-	if p.i >= len(p.s) {
-		return nil, fmt.Errorf("expected pseudoclass selector (:pseudoclass), found EOF instead")
-	}
-	if p.s[p.i] != ':' {
-		return nil, fmt.Errorf("expected attribute selector (:pseudoclass), found '%c' instead", p.s[p.i])
-	}
-
-	p.i++
-	name, err := p.parseIdentifier()
-	if err != nil {
-		return nil, err
-	}
-	name = toLowerASCII(name)
-
-	switch name {
-	case "not", "has", "haschild":
-		if !p.consumeParenthesis() {
-			return nil, errExpectedParenthesis
-		}
-		sel, parseErr := p.parseSelectorGroup()
-		if parseErr != nil {
-			return nil, parseErr
-		}
-		if !p.consumeClosingParenthesis() {
-			return nil, errExpectedClosingParenthesis
-		}
-
-		switch name {
-		case "not":
-			return negatedSelector(sel), nil
-		case "has":
-			return hasDescendantSelector(sel), nil
-		case "haschild":
-			return hasChildSelector(sel), nil
-		}
-
-	case "contains", "containsown":
-		if !p.consumeParenthesis() {
-			return nil, errExpectedParenthesis
-		}
-		if p.i == len(p.s) {
-			return nil, errUnmatchedParenthesis
-		}
-		var val string
-		switch p.s[p.i] {
-		case '\'', '"':
-			val, err = p.parseString()
-		default:
-			val, err = p.parseIdentifier()
-		}
-		if err != nil {
-			return nil, err
-		}
-		val = strings.ToLower(val)
-		p.skipWhitespace()
-		if p.i >= len(p.s) {
-			return nil, errors.New("unexpected EOF in pseudo selector")
-		}
-		if !p.consumeClosingParenthesis() {
-			return nil, errExpectedClosingParenthesis
-		}
-
-		switch name {
-		case "contains":
-			return textSubstrSelector(val), nil
-		case "containsown":
-			return ownTextSubstrSelector(val), nil
-		}
-
-	case "matches", "matchesown":
-		if !p.consumeParenthesis() {
-			return nil, errExpectedParenthesis
-		}
-		rx, err := p.parseRegex()
-		if err != nil {
-			return nil, err
-		}
-		if p.i >= len(p.s) {
-			return nil, errors.New("unexpected EOF in pseudo selector")
-		}
-		if !p.consumeClosingParenthesis() {
-			return nil, errExpectedClosingParenthesis
-		}
-
-		switch name {
-		case "matches":
-			return textRegexSelector(rx), nil
-		case "matchesown":
-			return ownTextRegexSelector(rx), nil
-		}
-
-	case "nth-child", "nth-last-child", "nth-of-type", "nth-last-of-type":
-		if !p.consumeParenthesis() {
-			return nil, errExpectedParenthesis
-		}
-		a, b, err := p.parseNth()
-		if err != nil {
-			return nil, err
-		}
-		if !p.consumeClosingParenthesis() {
-			return nil, errExpectedClosingParenthesis
-		}
-		if a == 0 {
-			switch name {
-			case "nth-child":
-				return simpleNthChildSelector(b, false), nil
-			case "nth-of-type":
-				return simpleNthChildSelector(b, true), nil
-			case "nth-last-child":
-				return simpleNthLastChildSelector(b, false), nil
-			case "nth-last-of-type":
-				return simpleNthLastChildSelector(b, true), nil
-			}
-		}
-		return nthChildSelector(a, b,
-				name == "nth-last-child" || name == "nth-last-of-type",
-				name == "nth-of-type" || name == "nth-last-of-type"),
-			nil
-
-	case "first-child":
-		return simpleNthChildSelector(1, false), nil
-	case "last-child":
-		return simpleNthLastChildSelector(1, false), nil
-	case "first-of-type":
-		return simpleNthChildSelector(1, true), nil
-	case "last-of-type":
-		return simpleNthLastChildSelector(1, true), nil
-	case "only-child":
-		return onlyChildSelector(false), nil
-	case "only-of-type":
-		return onlyChildSelector(true), nil
-	case "input":
-		return inputSelector, nil
-	case "empty":
-		return emptyElementSelector, nil
-	case "root":
-		return rootSelector, nil
-	}
-
-	return nil, fmt.Errorf("unknown pseudoclass :%s", name)
-}
-
-// parseInteger parses a  decimal integer.
-func (p *parser) parseInteger() (int, error) {
-	i := p.i
-	start := i
-	for i < len(p.s) && '0' <= p.s[i] && p.s[i] <= '9' {
-		i++
-	}
-	if i == start {
-		return 0, errors.New("expected integer, but didn't find it")
-	}
-	p.i = i
-
-	val, err := strconv.Atoi(p.s[start:i])
-	if err != nil {
-		return 0, err
-	}
-
-	return val, nil
-}
-
-// parseNth parses the argument for :nth-child (normally of the form an+b).
-func (p *parser) parseNth() (a, b int, err error) {
-	// initial state
-	if p.i >= len(p.s) {
-		goto eof
-	}
-	switch p.s[p.i] {
-	case '-':
-		p.i++
-		goto negativeA
-	case '+':
-		p.i++
-		goto positiveA
-	case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
-		goto positiveA
-	case 'n', 'N':
-		a = 1
-		p.i++
-		goto readN
-	case 'o', 'O', 'e', 'E':
-		id, nameErr := p.parseName()
-		if nameErr != nil {
-			return 0, 0, nameErr
-		}
-		id = toLowerASCII(id)
-		if id == "odd" {
-			return 2, 1, nil
-		}
-		if id == "even" {
-			return 2, 0, nil
-		}
-		return 0, 0, fmt.Errorf("expected 'odd' or 'even', but found '%s' instead", id)
-	default:
-		goto invalid
-	}
-
-positiveA:
-	if p.i >= len(p.s) {
-		goto eof
-	}
-	switch p.s[p.i] {
-	case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
-		a, err = p.parseInteger()
-		if err != nil {
-			return 0, 0, err
-		}
-		goto readA
-	case 'n', 'N':
-		a = 1
-		p.i++
-		goto readN
-	default:
-		goto invalid
-	}
-
-negativeA:
-	if p.i >= len(p.s) {
-		goto eof
-	}
-	switch p.s[p.i] {
-	case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
-		a, err = p.parseInteger()
-		if err != nil {
-			return 0, 0, err
-		}
-		a = -a
-		goto readA
-	case 'n', 'N':
-		a = -1
-		p.i++
-		goto readN
-	default:
-		goto invalid
-	}
-
-readA:
-	if p.i >= len(p.s) {
-		goto eof
-	}
-	switch p.s[p.i] {
-	case 'n', 'N':
-		p.i++
-		goto readN
-	default:
-		// The number we read as a is actually b.
-		return 0, a, nil
-	}
-
-readN:
-	p.skipWhitespace()
-	if p.i >= len(p.s) {
-		goto eof
-	}
-	switch p.s[p.i] {
-	case '+':
-		p.i++
-		p.skipWhitespace()
-		b, err = p.parseInteger()
-		if err != nil {
-			return 0, 0, err
-		}
-		return a, b, nil
-	case '-':
-		p.i++
-		p.skipWhitespace()
-		b, err = p.parseInteger()
-		if err != nil {
-			return 0, 0, err
-		}
-		return a, -b, nil
-	default:
-		return a, 0, nil
-	}
-
-eof:
-	return 0, 0, errors.New("unexpected EOF while attempting to parse expression of form an+b")
-
-invalid:
-	return 0, 0, errors.New("unexpected character while attempting to parse expression of form an+b")
-}
-
-// parseSimpleSelectorSequence parses a selector sequence that applies to
-// a single element.
-func (p *parser) parseSimpleSelectorSequence() (Selector, error) {
-	var result Selector
-
-	if p.i >= len(p.s) {
-		return nil, errors.New("expected selector, found EOF instead")
-	}
-
-	switch p.s[p.i] {
-	case '*':
-		// It's the universal selector. Just skip over it, since it doesn't affect the meaning.
-		p.i++
-	case '#', '.', '[', ':':
-		// There's no type selector. Wait to process the other till the main loop.
-	default:
-		r, err := p.parseTypeSelector()
-		if err != nil {
-			return nil, err
-		}
-		result = r
-	}
-
-loop:
-	for p.i < len(p.s) {
-		var ns Selector
-		var err error
-		switch p.s[p.i] {
-		case '#':
-			ns, err = p.parseIDSelector()
-		case '.':
-			ns, err = p.parseClassSelector()
-		case '[':
-			ns, err = p.parseAttributeSelector()
-		case ':':
-			ns, err = p.parsePseudoclassSelector()
-		default:
-			break loop
-		}
-		if err != nil {
-			return nil, err
-		}
-		if result == nil {
-			result = ns
-		} else {
-			result = intersectionSelector(result, ns)
-		}
-	}
-
-	if result == nil {
-		result = func(n *html.Node) bool {
-			return n.Type == html.ElementNode
-		}
-	}
-
-	return result, nil
-}
-
-// parseSelector parses a selector that may include combinators.
-func (p *parser) parseSelector() (result Selector, err error) {
-	p.skipWhitespace()
-	result, err = p.parseSimpleSelectorSequence()
-	if err != nil {
-		return
-	}
-
-	for {
-		var combinator byte
-		if p.skipWhitespace() {
-			combinator = ' '
-		}
-		if p.i >= len(p.s) {
-			return
-		}
-
-		switch p.s[p.i] {
-		case '+', '>', '~':
-			combinator = p.s[p.i]
-			p.i++
-			p.skipWhitespace()
-		case ',', ')':
-			// These characters can't begin a selector, but they can legally occur after one.
-			return
-		}
-
-		if combinator == 0 {
-			return
-		}
-
-		c, err := p.parseSimpleSelectorSequence()
-		if err != nil {
-			return nil, err
-		}
-
-		switch combinator {
-		case ' ':
-			result = descendantSelector(result, c)
-		case '>':
-			result = childSelector(result, c)
-		case '+':
-			result = siblingSelector(result, c, true)
-		case '~':
-			result = siblingSelector(result, c, false)
-		}
-	}
-
-	panic("unreachable")
-}
-
-// parseSelectorGroup parses a group of selectors, separated by commas.
-func (p *parser) parseSelectorGroup() (result Selector, err error) {
-	result, err = p.parseSelector()
-	if err != nil {
-		return
-	}
-
-	for p.i < len(p.s) {
-		if p.s[p.i] != ',' {
-			return result, nil
-		}
-		p.i++
-		c, err := p.parseSelector()
-		if err != nil {
-			return nil, err
-		}
-		result = unionSelector(result, c)
-	}
-
-	return
-}
--- a/vendor/github.com/andybalholm/cascadia/selector.go
+++ b/vendor/github.com/andybalholm/cascadia/selector.go
@@ -1,622 +0,0 @@
-package cascadia
-
-import (
-	"bytes"
-	"fmt"
-	"regexp"
-	"strings"
-
-	"golang.org/x/net/html"
-)
-
-// the Selector type, and functions for creating them
-
-// A Selector is a function which tells whether a node matches or not.
-type Selector func(*html.Node) bool
-
-// hasChildMatch returns whether n has any child that matches a.
-func hasChildMatch(n *html.Node, a Selector) bool {
-	for c := n.FirstChild; c != nil; c = c.NextSibling {
-		if a(c) {
-			return true
-		}
-	}
-	return false
-}
-
-// hasDescendantMatch performs a depth-first search of n's descendants,
-// testing whether any of them match a. It returns true as soon as a match is
-// found, or false if no match is found.
-func hasDescendantMatch(n *html.Node, a Selector) bool {
-	for c := n.FirstChild; c != nil; c = c.NextSibling {
-		if a(c) || (c.Type == html.ElementNode && hasDescendantMatch(c, a)) {
-			return true
-		}
-	}
-	return false
-}
-
-// Compile parses a selector and returns, if successful, a Selector object
-// that can be used to match against html.Node objects.
-func Compile(sel string) (Selector, error) {
-	p := &parser{s: sel}
-	compiled, err := p.parseSelectorGroup()
-	if err != nil {
-		return nil, err
-	}
-
-	if p.i < len(sel) {
-		return nil, fmt.Errorf("parsing %q: %d bytes left over", sel, len(sel)-p.i)
-	}
-
-	return compiled, nil
-}
-
-// MustCompile is like Compile, but panics instead of returning an error.
-func MustCompile(sel string) Selector {
-	compiled, err := Compile(sel)
-	if err != nil {
-		panic(err)
-	}
-	return compiled
-}
-
-// MatchAll returns a slice of the nodes that match the selector,
-// from n and its children.
-func (s Selector) MatchAll(n *html.Node) []*html.Node {
-	return s.matchAllInto(n, nil)
-}
-
-func (s Selector) matchAllInto(n *html.Node, storage []*html.Node) []*html.Node {
-	if s(n) {
-		storage = append(storage, n)
-	}
-
-	for child := n.FirstChild; child != nil; child = child.NextSibling {
-		storage = s.matchAllInto(child, storage)
-	}
-
-	return storage
-}
-
-// Match returns true if the node matches the selector.
-func (s Selector) Match(n *html.Node) bool {
-	return s(n)
-}
-
-// MatchFirst returns the first node that matches s, from n and its children.
-func (s Selector) MatchFirst(n *html.Node) *html.Node {
-	if s.Match(n) {
-		return n
-	}
-
-	for c := n.FirstChild; c != nil; c = c.NextSibling {
-		m := s.MatchFirst(c)
-		if m != nil {
-			return m
-		}
-	}
-	return nil
-}
-
-// Filter returns the nodes in nodes that match the selector.
-func (s Selector) Filter(nodes []*html.Node) (result []*html.Node) {
-	for _, n := range nodes {
-		if s(n) {
-			result = append(result, n)
-		}
-	}
-	return result
-}
-
-// typeSelector returns a Selector that matches elements with a given tag name.
-func typeSelector(tag string) Selector {
-	tag = toLowerASCII(tag)
-	return func(n *html.Node) bool {
-		return n.Type == html.ElementNode && n.Data == tag
-	}
-}
-
-// toLowerASCII returns s with all ASCII capital letters lowercased.
-func toLowerASCII(s string) string {
-	var b []byte
-	for i := 0; i < len(s); i++ {
-		if c := s[i]; 'A' <= c && c <= 'Z' {
-			if b == nil {
-				b = make([]byte, len(s))
-				copy(b, s)
-			}
-			b[i] = s[i] + ('a' - 'A')
-		}
-	}
-
-	if b == nil {
-		return s
-	}
-
-	return string(b)
-}
-
-// attributeSelector returns a Selector that matches elements
-// where the attribute named key satisifes the function f.
-func attributeSelector(key string, f func(string) bool) Selector {
-	key = toLowerASCII(key)
-	return func(n *html.Node) bool {
-		if n.Type != html.ElementNode {
-			return false
-		}
-		for _, a := range n.Attr {
-			if a.Key == key && f(a.Val) {
-				return true
-			}
-		}
-		return false
-	}
-}
-
-// attributeExistsSelector returns a Selector that matches elements that have
-// an attribute named key.
-func attributeExistsSelector(key string) Selector {
-	return attributeSelector(key, func(string) bool { return true })
-}
-
-// attributeEqualsSelector returns a Selector that matches elements where
-// the attribute named key has the value val.
-func attributeEqualsSelector(key, val string) Selector {
-	return attributeSelector(key,
-		func(s string) bool {
-			return s == val
-		})
-}
-
-// attributeNotEqualSelector returns a Selector that matches elements where
-// the attribute named key does not have the value val.
-func attributeNotEqualSelector(key, val string) Selector {
-	key = toLowerASCII(key)
-	return func(n *html.Node) bool {
-		if n.Type != html.ElementNode {
-			return false
-		}
-		for _, a := range n.Attr {
-			if a.Key == key && a.Val == val {
-				return false
-			}
-		}
-		return true
-	}
-}
-
-// attributeIncludesSelector returns a Selector that matches elements where
-// the attribute named key is a whitespace-separated list that includes val.
-func attributeIncludesSelector(key, val string) Selector {
-	return attributeSelector(key,
-		func(s string) bool {
-			for s != "" {
-				i := strings.IndexAny(s, " \t\r\n\f")
-				if i == -1 {
-					return s == val
-				}
-				if s[:i] == val {
-					return true
-				}
-				s = s[i+1:]
-			}
-			return false
-		})
-}
-
-// attributeDashmatchSelector returns a Selector that matches elements where
-// the attribute named key equals val or starts with val plus a hyphen.
-func attributeDashmatchSelector(key, val string) Selector {
-	return attributeSelector(key,
-		func(s string) bool {
-			if s == val {
-				return true
-			}
-			if len(s) <= len(val) {
-				return false
-			}
-			if s[:len(val)] == val && s[len(val)] == '-' {
-				return true
-			}
-			return false
-		})
-}
-
-// attributePrefixSelector returns a Selector that matches elements where
-// the attribute named key starts with val.
-func attributePrefixSelector(key, val string) Selector {
-	return attributeSelector(key,
-		func(s string) bool {
-			if strings.TrimSpace(s) == "" {
-				return false
-			}
-			return strings.HasPrefix(s, val)
-		})
-}
-
-// attributeSuffixSelector returns a Selector that matches elements where
-// the attribute named key ends with val.
-func attributeSuffixSelector(key, val string) Selector {
-	return attributeSelector(key,
-		func(s string) bool {
-			if strings.TrimSpace(s) == "" {
-				return false
-			}
-			return strings.HasSuffix(s, val)
-		})
-}
-
-// attributeSubstringSelector returns a Selector that matches nodes where
-// the attribute named key contains val.
-func attributeSubstringSelector(key, val string) Selector {
-	return attributeSelector(key,
-		func(s string) bool {
-			if strings.TrimSpace(s) == "" {
-				return false
-			}
-			return strings.Contains(s, val)
-		})
-}
-
-// attributeRegexSelector returns a Selector that matches nodes where
-// the attribute named key matches the regular expression rx
-func attributeRegexSelector(key string, rx *regexp.Regexp) Selector {
-	return attributeSelector(key,
-		func(s string) bool {
-			return rx.MatchString(s)
-		})
-}
-
-// intersectionSelector returns a selector that matches nodes that match
-// both a and b.
-func intersectionSelector(a, b Selector) Selector {
-	return func(n *html.Node) bool {
-		return a(n) && b(n)
-	}
-}
-
-// unionSelector returns a selector that matches elements that match
-// either a or b.
-func unionSelector(a, b Selector) Selector {
-	return func(n *html.Node) bool {
-		return a(n) || b(n)
-	}
-}
-
-// negatedSelector returns a selector that matches elements that do not match a.
-func negatedSelector(a Selector) Selector {
-	return func(n *html.Node) bool {
-		if n.Type != html.ElementNode {
-			return false
-		}
-		return !a(n)
-	}
-}
-
-// writeNodeText writes the text contained in n and its descendants to b.
-func writeNodeText(n *html.Node, b *bytes.Buffer) {
-	switch n.Type {
-	case html.TextNode:
-		b.WriteString(n.Data)
-	case html.ElementNode:
-		for c := n.FirstChild; c != nil; c = c.NextSibling {
-			writeNodeText(c, b)
-		}
-	}
-}
-
-// nodeText returns the text contained in n and its descendants.
-func nodeText(n *html.Node) string {
-	var b bytes.Buffer
-	writeNodeText(n, &b)
-	return b.String()
-}
-
-// nodeOwnText returns the contents of the text nodes that are direct
-// children of n.
-func nodeOwnText(n *html.Node) string {
-	var b bytes.Buffer
-	for c := n.FirstChild; c != nil; c = c.NextSibling {
-		if c.Type == html.TextNode {
-			b.WriteString(c.Data)
-		}
-	}
-	return b.String()
-}
-
-// textSubstrSelector returns a selector that matches nodes that
-// contain the given text.
-func textSubstrSelector(val string) Selector {
-	return func(n *html.Node) bool {
-		text := strings.ToLower(nodeText(n))
-		return strings.Contains(text, val)
-	}
-}
-
-// ownTextSubstrSelector returns a selector that matches nodes that
-// directly contain the given text
-func ownTextSubstrSelector(val string) Selector {
-	return func(n *html.Node) bool {
-		text := strings.ToLower(nodeOwnText(n))
-		return strings.Contains(text, val)
-	}
-}
-
-// textRegexSelector returns a selector that matches nodes whose text matches
-// the specified regular expression
-func textRegexSelector(rx *regexp.Regexp) Selector {
-	return func(n *html.Node) bool {
-		return rx.MatchString(nodeText(n))
-	}
-}
-
-// ownTextRegexSelector returns a selector that matches nodes whose text
-// directly matches the specified regular expression
-func ownTextRegexSelector(rx *regexp.Regexp) Selector {
-	return func(n *html.Node) bool {
-		return rx.MatchString(nodeOwnText(n))
-	}
-}
-
-// hasChildSelector returns a selector that matches elements
-// with a child that matches a.
-func hasChildSelector(a Selector) Selector {
-	return func(n *html.Node) bool {
-		if n.Type != html.ElementNode {
-			return false
-		}
-		return hasChildMatch(n, a)
-	}
-}
-
-// hasDescendantSelector returns a selector that matches elements
-// with any descendant that matches a.
-func hasDescendantSelector(a Selector) Selector {
-	return func(n *html.Node) bool {
-		if n.Type != html.ElementNode {
-			return false
-		}
-		return hasDescendantMatch(n, a)
-	}
-}
-
-// nthChildSelector returns a selector that implements :nth-child(an+b).
-// If last is true, implements :nth-last-child instead.
-// If ofType is true, implements :nth-of-type instead.
-func nthChildSelector(a, b int, last, ofType bool) Selector {
-	return func(n *html.Node) bool {
-		if n.Type != html.ElementNode {
-			return false
-		}
-
-		parent := n.Parent
-		if parent == nil {
-			return false
-		}
-
-		if parent.Type == html.DocumentNode {
-			return false
-		}
-
-		i := -1
-		count := 0
-		for c := parent.FirstChild; c != nil; c = c.NextSibling {
-			if (c.Type != html.ElementNode) || (ofType && c.Data != n.Data) {
-				continue
-			}
-			count++
-			if c == n {
-				i = count
-				if !last {
-					break
-				}
-			}
-		}
-
-		if i == -1 {
-			// This shouldn't happen, since n should always be one of its parent's children.
-			return false
-		}
-
-		if last {
-			i = count - i + 1
-		}
-
-		i -= b
-		if a == 0 {
-			return i == 0
-		}
-
-		return i%a == 0 && i/a >= 0
-	}
-}
-
-// simpleNthChildSelector returns a selector that implements :nth-child(b).
-// If ofType is true, implements :nth-of-type instead.
-func simpleNthChildSelector(b int, ofType bool) Selector {
-	return func(n *html.Node) bool {
-		if n.Type != html.ElementNode {
-			return false
-		}
-
-		parent := n.Parent
-		if parent == nil {
-			return false
-		}
-
-		if parent.Type == html.DocumentNode {
-			return false
-		}
-
-		count := 0
-		for c := parent.FirstChild; c != nil; c = c.NextSibling {
-			if c.Type != html.ElementNode || (ofType && c.Data != n.Data) {
-				continue
-			}
-			count++
-			if c == n {
-				return count == b
-			}
-			if count >= b {
-				return false
-			}
-		}
-		return false
-	}
-}
-
-// simpleNthLastChildSelector returns a selector that implements
-// :nth-last-child(b). If ofType is true, implements :nth-last-of-type
-// instead.
-func simpleNthLastChildSelector(b int, ofType bool) Selector {
-	return func(n *html.Node) bool {
-		if n.Type != html.ElementNode {
-			return false
-		}
-
-		parent := n.Parent
-		if parent == nil {
-			return false
-		}
-
-		if parent.Type == html.DocumentNode {
-			return false
-		}
-
-		count := 0
-		for c := parent.LastChild; c != nil; c = c.PrevSibling {
-			if c.Type != html.ElementNode || (ofType && c.Data != n.Data) {
-				continue
-			}
-			count++
-			if c == n {
-				return count == b
-			}
-			if count >= b {
-				return false
-			}
-		}
-		return false
-	}
-}
-
-// onlyChildSelector returns a selector that implements :only-child.
-// If ofType is true, it implements :only-of-type instead.
-func onlyChildSelector(ofType bool) Selector {
-	return func(n *html.Node) bool {
-		if n.Type != html.ElementNode {
-			return false
-		}
-
-		parent := n.Parent
-		if parent == nil {
-			return false
-		}
-
-		if parent.Type == html.DocumentNode {
-			return false
-		}
-
-		count := 0
-		for c := parent.FirstChild; c != nil; c = c.NextSibling {
-			if (c.Type != html.ElementNode) || (ofType && c.Data != n.Data) {
-				continue
-			}
-			count++
-			if count > 1 {
-				return false
-			}
-		}
-
-		return count == 1
-	}
-}
-
-// inputSelector is a Selector that matches input, select, textarea and button elements.
-func inputSelector(n *html.Node) bool {
-	return n.Type == html.ElementNode && (n.Data == "input" || n.Data == "select" || n.Data == "textarea" || n.Data == "button")
-}
-
-// emptyElementSelector is a Selector that matches empty elements.
-func emptyElementSelector(n *html.Node) bool {
-	if n.Type != html.ElementNode {
-		return false
-	}
-
-	for c := n.FirstChild; c != nil; c = c.NextSibling {
-		switch c.Type {
-		case html.ElementNode, html.TextNode:
-			return false
-		}
-	}
-
-	return true
-}
-
-// descendantSelector returns a Selector that matches an element if
-// it matches d and has an ancestor that matches a.
-func descendantSelector(a, d Selector) Selector {
-	return func(n *html.Node) bool {
-		if !d(n) {
-			return false
-		}
-
-		for p := n.Parent; p != nil; p = p.Parent {
-			if a(p) {
-				return true
-			}
-		}
-
-		return false
-	}
-}
-
-// childSelector returns a Selector that matches an element if
-// it matches d and its parent matches a.
-func childSelector(a, d Selector) Selector {
-	return func(n *html.Node) bool {
-		return d(n) && n.Parent != nil && a(n.Parent)
-	}
-}
-
-// siblingSelector returns a Selector that matches an element
-// if it matches s2 and in is preceded by an element that matches s1.
-// If adjacent is true, the sibling must be immediately before the element.
-func siblingSelector(s1, s2 Selector, adjacent bool) Selector {
-	return func(n *html.Node) bool {
-		if !s2(n) {
-			return false
-		}
-
-		if adjacent {
-			for n = n.PrevSibling; n != nil; n = n.PrevSibling {
-				if n.Type == html.TextNode || n.Type == html.CommentNode {
-					continue
-				}
-				return s1(n)
-			}
-			return false
-		}
-
-		// Walk backwards looking for element that matches s1
-		for c := n.PrevSibling; c != nil; c = c.PrevSibling {
-			if s1(c) {
-				return true
-			}
-		}
-
-		return false
-	}
-}
-
-// rootSelector implements :root
-func rootSelector(n *html.Node) bool {
-	if n.Type != html.ElementNode {
-		return false
-	}
-	if n.Parent == nil {
-		return false
-	}
-	return n.Parent.Type == html.DocumentNode
-}
--- a/vendor/github.com/bmatcuk/doublestar/.gitignore
+++ b/vendor/github.com/bmatcuk/doublestar/.gitignore
@@ -1,32 +0,0 @@
-# vi
-*~
-*.swp
-*.swo
-
-# 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
-
-# test directory
-test/
--- a/vendor/github.com/bmatcuk/doublestar/.travis.yml
+++ b/vendor/github.com/bmatcuk/doublestar/.travis.yml
@@ -1,15 +0,0 @@
-language: go
-
-go:
-  - 1.11
-  - 1.12
-
-before_install:
-  - go get -t -v ./...
-
-script:
-  - go test -race -coverprofile=coverage.txt -covermode=atomic
-
-after_success:
-  - bash <(curl -s https://codecov.io/bash)
-
--- a/vendor/github.com/bmatcuk/doublestar/LICENSE
+++ b/vendor/github.com/bmatcuk/doublestar/LICENSE
@@ -1,22 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2014 Bob Matcuk
-
-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.
-
--- a/vendor/github.com/bmatcuk/doublestar/README.md
+++ b/vendor/github.com/bmatcuk/doublestar/README.md
@@ -1,109 +0,0 @@
-![Release](https://img.shields.io/github/release/bmatcuk/doublestar.svg?branch=master)
-[![Build Status](https://travis-ci.org/bmatcuk/doublestar.svg?branch=master)](https://travis-ci.org/bmatcuk/doublestar)
-[![codecov.io](https://img.shields.io/codecov/c/github/bmatcuk/doublestar.svg?branch=master)](https://codecov.io/github/bmatcuk/doublestar?branch=master)
-
-# doublestar
-
-**doublestar** is a [golang](http://golang.org/) implementation of path pattern
-matching and globbing with support for "doublestar" (aka globstar: `**`)
-patterns.
-
-doublestar patterns match files and directories recursively. For example, if
-you had the following directory structure:
-
-```
-grandparent
-`-- parent
-    |-- child1
-    `-- child2
-```
-
-You could find the children with patterns such as: `**/child*`,
-`grandparent/**/child?`, `**/parent/*`, or even just `**` by itself (which will
-return all files and directories recursively).
-
-Bash's globstar is doublestar's inspiration and, as such, works similarly.
-Note that the doublestar must appear as a path component by itself. A pattern
-such as `/path**` is invalid and will be treated the same as `/path*`, but
-`/path*/**` should achieve the desired result. Additionally, `/path/**` will
-match all directories and files under the path directory, but `/path/**/` will
-only match directories.
-
-## Installation
-
-**doublestar** can be installed via `go get`:
-
-```bash
-go get github.com/bmatcuk/doublestar
-```
-
-To use it in your code, you must import it:
-
-```go
-import "github.com/bmatcuk/doublestar"
-```
-
-## Functions
-
-### Match
-```go
-func Match(pattern, name string) (bool, error)
-```
-
-Match returns true if `name` matches the file name `pattern`
-([see below](#patterns)). `name` and `pattern` are split on forward slash (`/`)
-characters and may be relative or absolute.
-
-Note: `Match()` is meant to be a drop-in replacement for `path.Match()`. As
-such, it always uses `/` as the path separator. If you are writing code that
-will run on systems where `/` is not the path separator (such as Windows), you
-want to use `PathMatch()` (below) instead.
-
-
-### PathMatch
-```go
-func PathMatch(pattern, name string) (bool, error)
-```
-
-PathMatch returns true  if `name` matches the file name `pattern`
-([see below](#patterns)). The difference between Match and PathMatch is that
-PathMatch will automatically use your system's path separator to split `name`
-and `pattern`.
-
-`PathMatch()` is meant to be a drop-in replacement for `filepath.Match()`.
-
-### Glob
-```go
-func Glob(pattern string) ([]string, error)
-```
-
-Glob finds all files and directories in the filesystem that match `pattern`
-([see below](#patterns)). `pattern` may be relative (to the current working
-directory), or absolute.
-
-`Glob()` is meant to be a drop-in replacement for `filepath.Glob()`.
-
-## Patterns
-
-**doublestar** supports the following special terms in the patterns:
-
-Special Terms | Meaning
------------- | -------
-`*`           | matches any sequence of non-path-separators
-`**`          | matches any sequence of characters, including path separators
-`?`           | matches any single non-path-separator character
-`[class]`     | matches any single non-path-separator character against a class of characters ([see below](#character-classes))
-`{alt1,...}`  | matches a sequence of characters if one of the comma-separated alternatives matches
-
-Any character with a special meaning can be escaped with a backslash (`\`).
-
-### Character Classes
-
-Character classes support the following:
-
-Class      | Meaning
---------- | -------
-`[abc]`    | matches any single character within the set
-`[a-z]`    | matches any single character in the range
-`[^class]` | matches any single character which does *not* match the class
-
--- a/vendor/github.com/bmatcuk/doublestar/doublestar.go
+++ b/vendor/github.com/bmatcuk/doublestar/doublestar.go
@@ -1,476 +0,0 @@
-package doublestar
-
-import (
-	"fmt"
-	"os"
-	"path"
-	"path/filepath"
-	"strings"
-	"unicode/utf8"
-)
-
-// ErrBadPattern indicates a pattern was malformed.
-var ErrBadPattern = path.ErrBadPattern
-
-// Split a path on the given separator, respecting escaping.
-func splitPathOnSeparator(path string, separator rune) (ret []string) {
-	idx := 0
-	if separator == '\\' {
-		// if the separator is '\\', then we can just split...
-		ret = strings.Split(path, string(separator))
-		idx = len(ret)
-	} else {
-		// otherwise, we need to be careful of situations where the separator was escaped
-		cnt := strings.Count(path, string(separator))
-		if cnt == 0 {
-			return []string{path}
-		}
-
-		ret = make([]string, cnt+1)
-		pathlen := len(path)
-		separatorLen := utf8.RuneLen(separator)
-		emptyEnd := false
-		for start := 0; start < pathlen; {
-			end := indexRuneWithEscaping(path[start:], separator)
-			if end == -1 {
-				emptyEnd = false
-				end = pathlen
-			} else {
-				emptyEnd = true
-				end += start
-			}
-			ret[idx] = path[start:end]
-			start = end + separatorLen
-			idx++
-		}
-
-		// If the last rune is a path separator, we need to append an empty string to
-		// represent the last, empty path component. By default, the strings from
-		// make([]string, ...) will be empty, so we just need to icrement the count
-		if emptyEnd {
-			idx++
-		}
-	}
-
-	return ret[:idx]
-}
-
-// Find the first index of a rune in a string,
-// ignoring any times the rune is escaped using "\".
-func indexRuneWithEscaping(s string, r rune) int {
-	end := strings.IndexRune(s, r)
-	if end == -1 {
-		return -1
-	}
-	if end > 0 && s[end-1] == '\\' {
-		start := end + utf8.RuneLen(r)
-		end = indexRuneWithEscaping(s[start:], r)
-		if end != -1 {
-			end += start
-		}
-	}
-	return end
-}
-
-// Match returns true if name matches the shell file name pattern.
-// The pattern syntax is:
-//
-//  pattern:
-//    { term }
-//  term:
-//    '*'         matches any sequence of non-path-separators
-//    '**'        matches any sequence of characters, including
-//                path separators.
-//    '?'         matches any single non-path-separator character
-//    '[' [ '^' ] { character-range } ']'
-//          character class (must be non-empty)
-//    '{' { term } [ ',' { term } ... ] '}'
-//    c           matches character c (c != '*', '?', '\\', '[')
-//    '\\' c      matches character c
-//
-//  character-range:
-//    c           matches character c (c != '\\', '-', ']')
-//    '\\' c      matches character c
-//    lo '-' hi   matches character c for lo <= c <= hi
-//
-// Match requires pattern to match all of name, not just a substring.
-// The path-separator defaults to the '/' character. The only possible
-// returned error is ErrBadPattern, when pattern is malformed.
-//
-// Note: this is meant as a drop-in replacement for path.Match() which
-// always uses '/' as the path separator. If you want to support systems
-// which use a different path separator (such as Windows), what you want
-// is the PathMatch() function below.
-//
-func Match(pattern, name string) (bool, error) {
-	return matchWithSeparator(pattern, name, '/')
-}
-
-// PathMatch is like Match except that it uses your system's path separator.
-// For most systems, this will be '/'. However, for Windows, it would be '\\'.
-// Note that for systems where the path separator is '\\', escaping is
-// disabled.
-//
-// Note: this is meant as a drop-in replacement for filepath.Match().
-//
-func PathMatch(pattern, name string) (bool, error) {
-	return matchWithSeparator(pattern, name, os.PathSeparator)
-}
-
-// Match returns true if name matches the shell file name pattern.
-// The pattern syntax is:
-//
-//  pattern:
-//    { term }
-//  term:
-//    '*'         matches any sequence of non-path-separators
-//              '**'        matches any sequence of characters, including
-//                          path separators.
-//    '?'         matches any single non-path-separator character
-//    '[' [ '^' ] { character-range } ']'
-//          character class (must be non-empty)
-//    '{' { term } [ ',' { term } ... ] '}'
-//    c           matches character c (c != '*', '?', '\\', '[')
-//    '\\' c      matches character c
-//
-//  character-range:
-//    c           matches character c (c != '\\', '-', ']')
-//    '\\' c      matches character c, unless separator is '\\'
-//    lo '-' hi   matches character c for lo <= c <= hi
-//
-// Match requires pattern to match all of name, not just a substring.
-// The only possible returned error is ErrBadPattern, when pattern
-// is malformed.
-//
-func matchWithSeparator(pattern, name string, separator rune) (bool, error) {
-	patternComponents := splitPathOnSeparator(pattern, separator)
-	nameComponents := splitPathOnSeparator(name, separator)
-	return doMatching(patternComponents, nameComponents)
-}
-
-func doMatching(patternComponents, nameComponents []string) (matched bool, err error) {
-	// check for some base-cases
-	patternLen, nameLen := len(patternComponents), len(nameComponents)
-	if patternLen == 0 && nameLen == 0 {
-		return true, nil
-	}
-	if patternLen == 0 || nameLen == 0 {
-		return false, nil
-	}
-
-	patIdx, nameIdx := 0, 0
-	for patIdx < patternLen && nameIdx < nameLen {
-		if patternComponents[patIdx] == "**" {
-			// if our last pattern component is a doublestar, we're done -
-			// doublestar will match any remaining name components, if any.
-			if patIdx++; patIdx >= patternLen {
-				return true, nil
-			}
-
-			// otherwise, try matching remaining components
-			for ; nameIdx < nameLen; nameIdx++ {
-				if m, _ := doMatching(patternComponents[patIdx:], nameComponents[nameIdx:]); m {
-					return true, nil
-				}
-			}
-			return false, nil
-		}
-
-		// try matching components
-		matched, err = matchComponent(patternComponents[patIdx], nameComponents[nameIdx])
-		if !matched || err != nil {
-			return
-		}
-
-		patIdx++
-		nameIdx++
-	}
-	return patIdx >= patternLen && nameIdx >= nameLen, nil
-}
-
-// Glob returns the names of all files matching pattern or nil
-// if there is no matching file. The syntax of pattern is the same
-// as in Match. The pattern may describe hierarchical names such as
-// /usr/*/bin/ed (assuming the Separator is '/').
-//
-// Glob ignores file system errors such as I/O errors reading directories.
-// The only possible returned error is ErrBadPattern, when pattern
-// is malformed.
-//
-// Your system path separator is automatically used. This means on
-// systems where the separator is '\\' (Windows), escaping will be
-// disabled.
-//
-// Note: this is meant as a drop-in replacement for filepath.Glob().
-//
-func Glob(pattern string) (matches []string, err error) {
-	patternComponents := splitPathOnSeparator(filepath.ToSlash(pattern), '/')
-	if len(patternComponents) == 0 {
-		return nil, nil
-	}
-
-	// On Windows systems, this will return the drive name ('C:') for filesystem
-	// paths, or \\<server>\<share> for UNC paths. On other systems, it will
-	// return an empty string. Since absolute paths on non-Windows systems start
-	// with a slash, patternComponent[0] == volumeName will return true for both
-	// absolute Windows paths and absolute non-Windows paths, but we need a
-	// separate check for UNC paths.
-	volumeName := filepath.VolumeName(pattern)
-	isWindowsUNC := strings.HasPrefix(pattern, `\\`)
-	if isWindowsUNC || patternComponents[0] == volumeName {
-		startComponentIndex := 1
-		if isWindowsUNC {
-			startComponentIndex = 4
-		}
-		return doGlob(fmt.Sprintf("%s%s", volumeName, string(os.PathSeparator)), patternComponents[startComponentIndex:], matches)
-	}
-
-	// otherwise, it's a relative pattern
-	return doGlob(".", patternComponents, matches)
-}
-
-// Perform a glob
-func doGlob(basedir string, components, matches []string) (m []string, e error) {
-	m = matches
-	e = nil
-
-	// figure out how many components we don't need to glob because they're
-	// just names without patterns - we'll use os.Lstat below to check if that
-	// path actually exists
-	patLen := len(components)
-	patIdx := 0
-	for ; patIdx < patLen; patIdx++ {
-		if strings.IndexAny(components[patIdx], "*?[{\\") >= 0 {
-			break
-		}
-	}
-	if patIdx > 0 {
-		basedir = filepath.Join(basedir, filepath.Join(components[0:patIdx]...))
-	}
-
-	// Lstat will return an error if the file/directory doesn't exist
-	fi, err := os.Lstat(basedir)
-	if err != nil {
-		return
-	}
-
-	// if there are no more components, we've found a match
-	if patIdx >= patLen {
-		m = append(m, basedir)
-		return
-	}
-
-	// otherwise, we need to check each item in the directory...
-	// first, if basedir is a symlink, follow it...
-	if (fi.Mode() & os.ModeSymlink) != 0 {
-		fi, err = os.Stat(basedir)
-		if err != nil {
-			return
-		}
-	}
-
-	// confirm it's a directory...
-	if !fi.IsDir() {
-		return
-	}
-
-	// read directory
-	dir, err := os.Open(basedir)
-	if err != nil {
-		return
-	}
-	defer dir.Close()
-
-	files, _ := dir.Readdir(-1)
-	lastComponent := (patIdx + 1) >= patLen
-	if components[patIdx] == "**" {
-		// if the current component is a doublestar, we'll try depth-first
-		for _, file := range files {
-			// if symlink, we may want to follow
-			if (file.Mode() & os.ModeSymlink) != 0 {
-				file, err = os.Stat(filepath.Join(basedir, file.Name()))
-				if err != nil {
-					continue
-				}
-			}
-
-			if file.IsDir() {
-				// recurse into directories
-				if lastComponent {
-					m = append(m, filepath.Join(basedir, file.Name()))
-				}
-				m, e = doGlob(filepath.Join(basedir, file.Name()), components[patIdx:], m)
-			} else if lastComponent {
-				// if the pattern's last component is a doublestar, we match filenames, too
-				m = append(m, filepath.Join(basedir, file.Name()))
-			}
-		}
-		if lastComponent {
-			return // we're done
-		}
-		patIdx++
-		lastComponent = (patIdx + 1) >= patLen
-	}
-
-	// check items in current directory and recurse
-	var match bool
-	for _, file := range files {
-		match, e = matchComponent(components[patIdx], file.Name())
-		if e != nil {
-			return
-		}
-		if match {
-			if lastComponent {
-				m = append(m, filepath.Join(basedir, file.Name()))
-			} else {
-				m, e = doGlob(filepath.Join(basedir, file.Name()), components[patIdx+1:], m)
-			}
-		}
-	}
-	return
-}
-
-// Attempt to match a single pattern component with a path component
-func matchComponent(pattern, name string) (bool, error) {
-	// check some base cases
-	patternLen, nameLen := len(pattern), len(name)
-	if patternLen == 0 && nameLen == 0 {
-		return true, nil
-	}
-	if patternLen == 0 {
-		return false, nil
-	}
-	if nameLen == 0 && pattern != "*" {
-		return false, nil
-	}
-
-	// check for matches one rune at a time
-	patIdx, nameIdx := 0, 0
-	for patIdx < patternLen && nameIdx < nameLen {
-		patRune, patAdj := utf8.DecodeRuneInString(pattern[patIdx:])
-		nameRune, nameAdj := utf8.DecodeRuneInString(name[nameIdx:])
-		if patRune == '\\' {
-			// handle escaped runes
-			patIdx += patAdj
-			patRune, patAdj = utf8.DecodeRuneInString(pattern[patIdx:])
-			if patRune == utf8.RuneError {
-				return false, ErrBadPattern
-			} else if patRune == nameRune {
-				patIdx += patAdj
-				nameIdx += nameAdj
-			} else {
-				return false, nil
-			}
-		} else if patRune == '*' {
-			// handle stars
-			if patIdx += patAdj; patIdx >= patternLen {
-				// a star at the end of a pattern will always
-				// match the rest of the path
-				return true, nil
-			}
-
-			// check if we can make any matches
-			for ; nameIdx < nameLen; nameIdx += nameAdj {
-				if m, _ := matchComponent(pattern[patIdx:], name[nameIdx:]); m {
-					return true, nil
-				}
-			}
-			return false, nil
-		} else if patRune == '[' {
-			// handle character sets
-			patIdx += patAdj
-			endClass := indexRuneWithEscaping(pattern[patIdx:], ']')
-			if endClass == -1 {
-				return false, ErrBadPattern
-			}
-			endClass += patIdx
-			classRunes := []rune(pattern[patIdx:endClass])
-			classRunesLen := len(classRunes)
-			if classRunesLen > 0 {
-				classIdx := 0
-				matchClass := false
-				if classRunes[0] == '^' {
-					classIdx++
-				}
-				for classIdx < classRunesLen {
-					low := classRunes[classIdx]
-					if low == '-' {
-						return false, ErrBadPattern
-					}
-					classIdx++
-					if low == '\\' {
-						if classIdx < classRunesLen {
-							low = classRunes[classIdx]
-							classIdx++
-						} else {
-							return false, ErrBadPattern
-						}
-					}
-					high := low
-					if classIdx < classRunesLen && classRunes[classIdx] == '-' {
-						// we have a range of runes
-						if classIdx++; classIdx >= classRunesLen {
-							return false, ErrBadPattern
-						}
-						high = classRunes[classIdx]
-						if high == '-' {
-							return false, ErrBadPattern
-						}
-						classIdx++
-						if high == '\\' {
-							if classIdx < classRunesLen {
-								high = classRunes[classIdx]
-								classIdx++
-							} else {
-								return false, ErrBadPattern
-							}
-						}
-					}
-					if low <= nameRune && nameRune <= high {
-						matchClass = true
-					}
-				}
-				if matchClass == (classRunes[0] == '^') {
-					return false, nil
-				}
-			} else {
-				return false, ErrBadPattern
-			}
-			patIdx = endClass + 1
-			nameIdx += nameAdj
-		} else if patRune == '{' {
-			// handle alternatives such as {alt1,alt2,...}
-			patIdx += patAdj
-			endOptions := indexRuneWithEscaping(pattern[patIdx:], '}')
-			if endOptions == -1 {
-				return false, ErrBadPattern
-			}
-			endOptions += patIdx
-			options := splitPathOnSeparator(pattern[patIdx:endOptions], ',')
-			patIdx = endOptions + 1
-			for _, o := range options {
-				m, e := matchComponent(o+pattern[patIdx:], name[nameIdx:])
-				if e != nil {
-					return false, e
-				}
-				if m {
-					return true, nil
-				}
-			}
-			return false, nil
-		} else if patRune == '?' || patRune == nameRune {
-			// handle single-rune wildcard
-			patIdx += patAdj
-			nameIdx += nameAdj
-		} else {
-			return false, nil
-		}
-	}
-	if patIdx >= patternLen && nameIdx >= nameLen {
-		return true, nil
-	}
-	if nameIdx >= nameLen && pattern[patIdx:] == "*" || pattern[patIdx:] == "**" {
-		return true, nil
-	}
-	return false, nil
-}
--- a/vendor/github.com/bmatcuk/doublestar/go.mod
+++ b/vendor/github.com/bmatcuk/doublestar/go.mod
@@ -1,3 +0,0 @@
-module github.com/bmatcuk/doublestar
-
-go 1.12
--- a/vendor/github.com/disintegration/imaging/.travis.yml
+++ b/vendor/github.com/disintegration/imaging/.travis.yml
@@ -1,14 +0,0 @@
-language: go
-go:
-  - "1.7.x"
-  - "1.8.x"
-  - "1.9.x"
-  - "1.10.x"
-  - "1.11.x"
-
-before_install:
-  - go get github.com/mattn/goveralls
-
-script:
-  - go test -v -race -cover
-  - $GOPATH/bin/goveralls -service=travis-ci
--- a/vendor/github.com/disintegration/imaging/LICENSE
+++ b/vendor/github.com/disintegration/imaging/LICENSE
@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2012 Grigory Dryapak
-
-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.
--- a/vendor/github.com/disintegration/imaging/README.md
+++ b/vendor/github.com/disintegration/imaging/README.md
@@ -1,197 +0,0 @@
-# Imaging
-
-[![GoDoc](https://godoc.org/github.com/disintegration/imaging?status.svg)](https://godoc.org/github.com/disintegration/imaging)
-[![Build Status](https://travis-ci.org/disintegration/imaging.svg?branch=master)](https://travis-ci.org/disintegration/imaging)
-[![Coverage Status](https://coveralls.io/repos/github/disintegration/imaging/badge.svg?branch=master&service=github)](https://coveralls.io/github/disintegration/imaging?branch=master)
-[![Go Report Card](https://goreportcard.com/badge/github.com/disintegration/imaging)](https://goreportcard.com/report/github.com/disintegration/imaging)
-
-Package imaging provides basic image processing functions (resize, rotate, crop, brightness/contrast adjustments, etc.).
-
-All the image processing functions provided by the package accept any image type that implements `image.Image` interface
-as an input, and return a new image of `*image.NRGBA` type (32bit RGBA colors, non-premultiplied alpha).
-
-## Installation
-
-    go get -u github.com/disintegration/imaging
-
-## Documentation
-
-http://godoc.org/github.com/disintegration/imaging
-
-## Usage examples
-
-A few usage examples can be found below. See the documentation for the full list of supported functions.
-
-### Image resizing
-
-```go
-// Resize srcImage to size = 128x128px using the Lanczos filter.
-dstImage128 := imaging.Resize(srcImage, 128, 128, imaging.Lanczos)
-
-// Resize srcImage to width = 800px preserving the aspect ratio.
-dstImage800 := imaging.Resize(srcImage, 800, 0, imaging.Lanczos)
-
-// Scale down srcImage to fit the 800x600px bounding box.
-dstImageFit := imaging.Fit(srcImage, 800, 600, imaging.Lanczos)
-
-// Resize and crop the srcImage to fill the 100x100px area.
-dstImageFill := imaging.Fill(srcImage, 100, 100, imaging.Center, imaging.Lanczos)
-```
-
-Imaging supports image resizing using various resampling filters. The most notable ones:
- `Lanczos` - A high-quality resampling filter for photographic images yielding sharp results.
- `CatmullRom` - A sharp cubic filter that is faster than Lanczos filter while providing similar results.
- `MitchellNetravali` - A cubic filter that produces smoother results with less ringing artifacts than CatmullRom.
- `Linear` - Bilinear resampling filter, produces smooth output. Faster than cubic filters.
- `Box` - Simple and fast averaging filter appropriate for downscaling. When upscaling it's similar to NearestNeighbor.
- `NearestNeighbor` - Fastest resampling filter, no antialiasing.
-
-The full list of supported filters:  NearestNeighbor, Box, Linear, Hermite, MitchellNetravali, CatmullRom, BSpline, Gaussian, Lanczos, Hann, Hamming, Blackman, Bartlett, Welch, Cosine. Custom filters can be created using ResampleFilter struct.
-
-**Resampling filters comparison**
-
-Original image:
-
-![srcImage](testdata/branches.png)
-
-The same image resized from 600x400px to 150x100px using different resampling filters.
-From faster (lower quality) to slower (higher quality):
-
-Filter                    | Resize result
--------------------------|---------------------------------------------
-`imaging.NearestNeighbor` | ![dstImage](testdata/out_resize_nearest.png)
-`imaging.Linear`          | ![dstImage](testdata/out_resize_linear.png)
-`imaging.CatmullRom`      | ![dstImage](testdata/out_resize_catrom.png)
-`imaging.Lanczos`         | ![dstImage](testdata/out_resize_lanczos.png)
-
-
-### Gaussian Blur
-
-```go
-dstImage := imaging.Blur(srcImage, 0.5)
-```
-
-Sigma parameter allows to control the strength of the blurring effect.
-
-Original image                     | Sigma = 0.5                            | Sigma = 1.5
-----------------------------------|----------------------------------------|---------------------------------------
-![srcImage](testdata/flowers_small.png) | ![dstImage](testdata/out_blur_0.5.png) | ![dstImage](testdata/out_blur_1.5.png)
-
-### Sharpening
-
-```go
-dstImage := imaging.Sharpen(srcImage, 0.5)
-```
-
-`Sharpen` uses gaussian function internally. Sigma parameter allows to control the strength of the sharpening effect.
-
-Original image                     | Sigma = 0.5                               | Sigma = 1.5
-----------------------------------|-------------------------------------------|------------------------------------------
-![srcImage](testdata/flowers_small.png) | ![dstImage](testdata/out_sharpen_0.5.png) | ![dstImage](testdata/out_sharpen_1.5.png)
-
-### Gamma correction
-
-```go
-dstImage := imaging.AdjustGamma(srcImage, 0.75)
-```
-
-Original image                     | Gamma = 0.75                             | Gamma = 1.25
-----------------------------------|------------------------------------------|-----------------------------------------
-![srcImage](testdata/flowers_small.png) | ![dstImage](testdata/out_gamma_0.75.png) | ![dstImage](testdata/out_gamma_1.25.png)
-
-### Contrast adjustment
-
-```go
-dstImage := imaging.AdjustContrast(srcImage, 20)
-```
-
-Original image                     | Contrast = 15                              | Contrast = -15
-----------------------------------|--------------------------------------------|-------------------------------------------
-![srcImage](testdata/flowers_small.png) | ![dstImage](testdata/out_contrast_p15.png) | ![dstImage](testdata/out_contrast_m15.png)
-
-### Brightness adjustment
-
-```go
-dstImage := imaging.AdjustBrightness(srcImage, 20)
-```
-
-Original image                     | Brightness = 10                              | Brightness = -10
-----------------------------------|----------------------------------------------|---------------------------------------------
-![srcImage](testdata/flowers_small.png) | ![dstImage](testdata/out_brightness_p10.png) | ![dstImage](testdata/out_brightness_m10.png)
-
-### Saturation adjustment
-
-```go
-dstImage := imaging.AdjustSaturation(srcImage, 20)
-```
-
-Original image                     | Saturation = 30                              | Saturation = -30
-----------------------------------|----------------------------------------------|---------------------------------------------
-![srcImage](testdata/flowers_small.png) | ![dstImage](testdata/out_saturation_p30.png) | ![dstImage](testdata/out_saturation_m30.png)
-
-## Example code
-
-```go
-package main
-
-import (
-	"image"
-	"image/color"
-	"log"
-
-	"github.com/disintegration/imaging"
-)
-
-func main() {
-	// Open a test image.
-	src, err := imaging.Open("testdata/flowers.png")
-	if err != nil {
-		log.Fatalf("failed to open image: %v", err)
-	}
-
-	// Crop the original image to 300x300px size using the center anchor.
-	src = imaging.CropAnchor(src, 300, 300, imaging.Center)
-
-	// Resize the cropped image to width = 200px preserving the aspect ratio.
-	src = imaging.Resize(src, 200, 0, imaging.Lanczos)
-
-	// Create a blurred version of the image.
-	img1 := imaging.Blur(src, 5)
-
-	// Create a grayscale version of the image with higher contrast and sharpness.
-	img2 := imaging.Grayscale(src)
-	img2 = imaging.AdjustContrast(img2, 20)
-	img2 = imaging.Sharpen(img2, 2)
-
-	// Create an inverted version of the image.
-	img3 := imaging.Invert(src)
-
-	// Create an embossed version of the image using a convolution filter.
-	img4 := imaging.Convolve3x3(
-		src,
-		[9]float64{
-			-1, -1, 0,
-			-1, 1, 1,
-			0, 1, 1,
-		},
-		nil,
-	)
-
-	// Create a new image and paste the four produced images into it.
-	dst := imaging.New(400, 400, color.NRGBA{0, 0, 0, 0})
-	dst = imaging.Paste(dst, img1, image.Pt(0, 0))
-	dst = imaging.Paste(dst, img2, image.Pt(0, 200))
-	dst = imaging.Paste(dst, img3, image.Pt(200, 0))
-	dst = imaging.Paste(dst, img4, image.Pt(200, 200))
-
-	// Save the resulting image as JPEG.
-	err = imaging.Save(dst, "testdata/out_example.jpg")
-	if err != nil {
-		log.Fatalf("failed to save image: %v", err)
-	}
-}
-```
-
-Output:
-
-![dstImage](testdata/out_example.jpg)
--- a/vendor/github.com/disintegration/imaging/adjust.go
+++ b/vendor/github.com/disintegration/imaging/adjust.go
@@ -1,252 +0,0 @@
-package imaging
-
-import (
-	"image"
-	"image/color"
-	"math"
-)
-
-// Grayscale produces a grayscale version of the image.
-func Grayscale(img image.Image) *image.NRGBA {
-	src := newScanner(img)
-	dst := image.NewNRGBA(image.Rect(0, 0, src.w, src.h))
-	parallel(0, src.h, func(ys <-chan int) {
-		for y := range ys {
-			i := y * dst.Stride
-			src.scan(0, y, src.w, y+1, dst.Pix[i:i+src.w*4])
-			for x := 0; x < src.w; x++ {
-				d := dst.Pix[i : i+3 : i+3]
-				r := d[0]
-				g := d[1]
-				b := d[2]
-				f := 0.299*float64(r) + 0.587*float64(g) + 0.114*float64(b)
-				y := uint8(f + 0.5)
-				d[0] = y
-				d[1] = y
-				d[2] = y
-				i += 4
-			}
-		}
-	})
-	return dst
-}
-
-// Invert produces an inverted (negated) version of the image.
-func Invert(img image.Image) *image.NRGBA {
-	src := newScanner(img)
-	dst := image.NewNRGBA(image.Rect(0, 0, src.w, src.h))
-	parallel(0, src.h, func(ys <-chan int) {
-		for y := range ys {
-			i := y * dst.Stride
-			src.scan(0, y, src.w, y+1, dst.Pix[i:i+src.w*4])
-			for x := 0; x < src.w; x++ {
-				d := dst.Pix[i : i+3 : i+3]
-				d[0] = 255 - d[0]
-				d[1] = 255 - d[1]
-				d[2] = 255 - d[2]
-				i += 4
-			}
-		}
-	})
-	return dst
-}
-
-// AdjustSaturation changes the saturation of the image using the percentage parameter and returns the adjusted image.
-// The percentage must be in the range (-100, 100).
-// The percentage = 0 gives the original image.
-// The percentage = 100 gives the image with the saturation value doubled for each pixel.
-// The percentage = -100 gives the image with the saturation value zeroed for each pixel (grayscale).
-//
-// Examples:
-//  dstImage = imaging.AdjustSaturation(srcImage, 25) // Increase image saturation by 25%.
-//  dstImage = imaging.AdjustSaturation(srcImage, -10) // Decrease image saturation by 10%.
-//
-func AdjustSaturation(img image.Image, percentage float64) *image.NRGBA {
-	percentage = math.Min(math.Max(percentage, -100), 100)
-	multiplier := 1 + percentage/100
-
-	return AdjustFunc(img, func(c color.NRGBA) color.NRGBA {
-		h, s, l := rgbToHSL(c.R, c.G, c.B)
-		s *= multiplier
-		if s > 1 {
-			s = 1
-		}
-		r, g, b := hslToRGB(h, s, l)
-		return color.NRGBA{r, g, b, c.A}
-	})
-}
-
-// AdjustContrast changes the contrast of the image using the percentage parameter and returns the adjusted image.
-// The percentage must be in range (-100, 100). The percentage = 0 gives the original image.
-// The percentage = -100 gives solid gray image.
-//
-// Examples:
-//
-//	dstImage = imaging.AdjustContrast(srcImage, -10) // Decrease image contrast by 10%.
-//	dstImage = imaging.AdjustContrast(srcImage, 20) // Increase image contrast by 20%.
-//
-func AdjustContrast(img image.Image, percentage float64) *image.NRGBA {
-	percentage = math.Min(math.Max(percentage, -100.0), 100.0)
-	lut := make([]uint8, 256)
-
-	v := (100.0 + percentage) / 100.0
-	for i := 0; i < 256; i++ {
-		if 0 <= v && v <= 1 {
-			lut[i] = clamp((0.5 + (float64(i)/255.0-0.5)*v) * 255.0)
-		} else if 1 < v && v < 2 {
-			lut[i] = clamp((0.5 + (float64(i)/255.0-0.5)*(1/(2.0-v))) * 255.0)
-		} else {
-			lut[i] = uint8(float64(i)/255.0+0.5) * 255
-		}
-	}
-
-	return adjustLUT(img, lut)
-}
-
-// AdjustBrightness changes the brightness of the image using the percentage parameter and returns the adjusted image.
-// The percentage must be in range (-100, 100). The percentage = 0 gives the original image.
-// The percentage = -100 gives solid black image. The percentage = 100 gives solid white image.
-//
-// Examples:
-//
-//	dstImage = imaging.AdjustBrightness(srcImage, -15) // Decrease image brightness by 15%.
-//	dstImage = imaging.AdjustBrightness(srcImage, 10) // Increase image brightness by 10%.
-//
-func AdjustBrightness(img image.Image, percentage float64) *image.NRGBA {
-	percentage = math.Min(math.Max(percentage, -100.0), 100.0)
-	lut := make([]uint8, 256)
-
-	shift := 255.0 * percentage / 100.0
-	for i := 0; i < 256; i++ {
-		lut[i] = clamp(float64(i) + shift)
-	}
-
-	return adjustLUT(img, lut)
-}
-
-// AdjustGamma performs a gamma correction on the image and returns the adjusted image.
-// Gamma parameter must be positive. Gamma = 1.0 gives the original image.
-// Gamma less than 1.0 darkens the image and gamma greater than 1.0 lightens it.
-//
-// Example:
-//
-//	dstImage = imaging.AdjustGamma(srcImage, 0.7)
-//
-func AdjustGamma(img image.Image, gamma float64) *image.NRGBA {
-	e := 1.0 / math.Max(gamma, 0.0001)
-	lut := make([]uint8, 256)
-
-	for i := 0; i < 256; i++ {
-		lut[i] = clamp(math.Pow(float64(i)/255.0, e) * 255.0)
-	}
-
-	return adjustLUT(img, lut)
-}
-
-// AdjustSigmoid changes the contrast of the image using a sigmoidal function and returns the adjusted image.
-// It's a non-linear contrast change useful for photo adjustments as it preserves highlight and shadow detail.
-// The midpoint parameter is the midpoint of contrast that must be between 0 and 1, typically 0.5.
-// The factor parameter indicates how much to increase or decrease the contrast, typically in range (-10, 10).
-// If the factor parameter is positive the image contrast is increased otherwise the contrast is decreased.
-//
-// Examples:
-//
-//	dstImage = imaging.AdjustSigmoid(srcImage, 0.5, 3.0) // Increase the contrast.
-//	dstImage = imaging.AdjustSigmoid(srcImage, 0.5, -3.0) // Decrease the contrast.
-//
-func AdjustSigmoid(img image.Image, midpoint, factor float64) *image.NRGBA {
-	if factor == 0 {
-		return Clone(img)
-	}
-
-	lut := make([]uint8, 256)
-	a := math.Min(math.Max(midpoint, 0.0), 1.0)
-	b := math.Abs(factor)
-	sig0 := sigmoid(a, b, 0)
-	sig1 := sigmoid(a, b, 1)
-	e := 1.0e-6
-
-	if factor > 0 {
-		for i := 0; i < 256; i++ {
-			x := float64(i) / 255.0
-			sigX := sigmoid(a, b, x)
-			f := (sigX - sig0) / (sig1 - sig0)
-			lut[i] = clamp(f * 255.0)
-		}
-	} else {
-		for i := 0; i < 256; i++ {
-			x := float64(i) / 255.0
-			arg := math.Min(math.Max((sig1-sig0)*x+sig0, e), 1.0-e)
-			f := a - math.Log(1.0/arg-1.0)/b
-			lut[i] = clamp(f * 255.0)
-		}
-	}
-
-	return adjustLUT(img, lut)
-}
-
-func sigmoid(a, b, x float64) float64 {
-	return 1 / (1 + math.Exp(b*(a-x)))
-}
-
-// adjustLUT applies the given lookup table to the colors of the image.
-func adjustLUT(img image.Image, lut []uint8) *image.NRGBA {
-	src := newScanner(img)
-	dst := image.NewNRGBA(image.Rect(0, 0, src.w, src.h))
-	lut = lut[0:256]
-	parallel(0, src.h, func(ys <-chan int) {
-		for y := range ys {
-			i := y * dst.Stride
-			src.scan(0, y, src.w, y+1, dst.Pix[i:i+src.w*4])
-			for x := 0; x < src.w; x++ {
-				d := dst.Pix[i : i+3 : i+3]
-				d[0] = lut[d[0]]
-				d[1] = lut[d[1]]
-				d[2] = lut[d[2]]
-				i += 4
-			}
-		}
-	})
-	return dst
-}
-
-// AdjustFunc applies the fn function to each pixel of the img image and returns the adjusted image.
-//
-// Example:
-//
-//	dstImage = imaging.AdjustFunc(
-//		srcImage,
-//		func(c color.NRGBA) color.NRGBA {
-//			// Shift the red channel by 16.
-//			r := int(c.R) + 16
-//			if r > 255 {
-//				r = 255
-//			}
-//			return color.NRGBA{uint8(r), c.G, c.B, c.A}
-//		}
-//	)
-//
-func AdjustFunc(img image.Image, fn func(c color.NRGBA) color.NRGBA) *image.NRGBA {
-	src := newScanner(img)
-	dst := image.NewNRGBA(image.Rect(0, 0, src.w, src.h))
-	parallel(0, src.h, func(ys <-chan int) {
-		for y := range ys {
-			i := y * dst.Stride
-			src.scan(0, y, src.w, y+1, dst.Pix[i:i+src.w*4])
-			for x := 0; x < src.w; x++ {
-				d := dst.Pix[i : i+4 : i+4]
-				r := d[0]
-				g := d[1]
-				b := d[2]
-				a := d[3]
-				c := fn(color.NRGBA{r, g, b, a})
-				d[0] = c.R
-				d[1] = c.G
-				d[2] = c.B
-				d[3] = c.A
-				i += 4
-			}
-		}
-	})
-	return dst
-}
--- a/vendor/github.com/disintegration/imaging/convolution.go
+++ b/vendor/github.com/disintegration/imaging/convolution.go
@@ -1,148 +0,0 @@
-package imaging
-
-import (
-	"image"
-)
-
-// ConvolveOptions are convolution parameters.
-type ConvolveOptions struct {
-	// If Normalize is true the kernel is normalized before convolution.
-	Normalize bool
-
-	// If Abs is true the absolute value of each color channel is taken after convolution.
-	Abs bool
-
-	// Bias is added to each color channel value after convolution.
-	Bias int
-}
-
-// Convolve3x3 convolves the image with the specified 3x3 convolution kernel.
-// Default parameters are used if a nil *ConvolveOptions is passed.
-func Convolve3x3(img image.Image, kernel [9]float64, options *ConvolveOptions) *image.NRGBA {
-	return convolve(img, kernel[:], options)
-}
-
-// Convolve5x5 convolves the image with the specified 5x5 convolution kernel.
-// Default parameters are used if a nil *ConvolveOptions is passed.
-func Convolve5x5(img image.Image, kernel [25]float64, options *ConvolveOptions) *image.NRGBA {
-	return convolve(img, kernel[:], options)
-}
-
-func convolve(img image.Image, kernel []float64, options *ConvolveOptions) *image.NRGBA {
-	src := toNRGBA(img)
-	w := src.Bounds().Max.X
-	h := src.Bounds().Max.Y
-	dst := image.NewNRGBA(image.Rect(0, 0, w, h))
-
-	if w < 1 || h < 1 {
-		return dst
-	}
-
-	if options == nil {
-		options = &ConvolveOptions{}
-	}
-
-	if options.Normalize {
-		normalizeKernel(kernel)
-	}
-
-	type coef struct {
-		x, y int
-		k    float64
-	}
-	var coefs []coef
-	var m int
-
-	switch len(kernel) {
-	case 9:
-		m = 1
-	case 25:
-		m = 2
-	}
-
-	i := 0
-	for y := -m; y <= m; y++ {
-		for x := -m; x <= m; x++ {
-			if kernel[i] != 0 {
-				coefs = append(coefs, coef{x: x, y: y, k: kernel[i]})
-			}
-			i++
-		}
-	}
-
-	parallel(0, h, func(ys <-chan int) {
-		for y := range ys {
-			for x := 0; x < w; x++ {
-				var r, g, b float64
-				for _, c := range coefs {
-					ix := x + c.x
-					if ix < 0 {
-						ix = 0
-					} else if ix >= w {
-						ix = w - 1
-					}
-
-					iy := y + c.y
-					if iy < 0 {
-						iy = 0
-					} else if iy >= h {
-						iy = h - 1
-					}
-
-					off := iy*src.Stride + ix*4
-					s := src.Pix[off : off+3 : off+3]
-					r += float64(s[0]) * c.k
-					g += float64(s[1]) * c.k
-					b += float64(s[2]) * c.k
-				}
-
-				if options.Abs {
-					if r < 0 {
-						r = -r
-					}
-					if g < 0 {
-						g = -g
-					}
-					if b < 0 {
-						b = -b
-					}
-				}
-
-				if options.Bias != 0 {
-					r += float64(options.Bias)
-					g += float64(options.Bias)
-					b += float64(options.Bias)
-				}
-
-				srcOff := y*src.Stride + x*4
-				dstOff := y*dst.Stride + x*4
-				d := dst.Pix[dstOff : dstOff+4 : dstOff+4]
-				d[0] = clamp(r)
-				d[1] = clamp(g)
-				d[2] = clamp(b)
-				d[3] = src.Pix[srcOff+3]
-			}
-		}
-	})
-
-	return dst
-}
-
-func normalizeKernel(kernel []float64) {
-	var sum, sumpos float64
-	for i := range kernel {
-		sum += kernel[i]
-		if kernel[i] > 0 {
-			sumpos += kernel[i]
-		}
-	}
-	if sum != 0 {
-		for i := range kernel {
-			kernel[i] /= sum
-		}
-	} else if sumpos != 0 {
-		for i := range kernel {
-			kernel[i] /= sumpos
-		}
-	}
-}
--- a/vendor/github.com/disintegration/imaging/doc.go
+++ b/vendor/github.com/disintegration/imaging/doc.go
@@ -1,7 +0,0 @@
-/*
-Package imaging provides basic image processing functions (resize, rotate, crop, brightness/contrast adjustments, etc.).
-
-All the image processing functions provided by the package accept any image type that implements image.Image interface
-as an input, and return a new image of *image.NRGBA type (32bit RGBA colors, non-premultiplied alpha).
-*/
-package imaging
--- a/vendor/github.com/disintegration/imaging/effects.go
+++ b/vendor/github.com/disintegration/imaging/effects.go
@@ -1,169 +0,0 @@
-package imaging
-
-import (
-	"image"
-	"math"
-)
-
-func gaussianBlurKernel(x, sigma float64) float64 {
-	return math.Exp(-(x*x)/(2*sigma*sigma)) / (sigma * math.Sqrt(2*math.Pi))
-}
-
-// Blur produces a blurred version of the image using a Gaussian function.
-// Sigma parameter must be positive and indicates how much the image will be blurred.
-//
-// Example:
-//
-//	dstImage := imaging.Blur(srcImage, 3.5)
-//
-func Blur(img image.Image, sigma float64) *image.NRGBA {
-	if sigma <= 0 {
-		return Clone(img)
-	}
-
-	radius := int(math.Ceil(sigma * 3.0))
-	kernel := make([]float64, radius+1)
-
-	for i := 0; i <= radius; i++ {
-		kernel[i] = gaussianBlurKernel(float64(i), sigma)
-	}
-
-	return blurVertical(blurHorizontal(img, kernel), kernel)
-}
-
-func blurHorizontal(img image.Image, kernel []float64) *image.NRGBA {
-	src := newScanner(img)
-	dst := image.NewNRGBA(image.Rect(0, 0, src.w, src.h))
-	radius := len(kernel) - 1
-
-	parallel(0, src.h, func(ys <-chan int) {
-		scanLine := make([]uint8, src.w*4)
-		scanLineF := make([]float64, len(scanLine))
-		for y := range ys {
-			src.scan(0, y, src.w, y+1, scanLine)
-			for i, v := range scanLine {
-				scanLineF[i] = float64(v)
-			}
-			for x := 0; x < src.w; x++ {
-				min := x - radius
-				if min < 0 {
-					min = 0
-				}
-				max := x + radius
-				if max > src.w-1 {
-					max = src.w - 1
-				}
-				var r, g, b, a, wsum float64
-				for ix := min; ix <= max; ix++ {
-					i := ix * 4
-					weight := kernel[absint(x-ix)]
-					wsum += weight
-					s := scanLineF[i : i+4 : i+4]
-					wa := s[3] * weight
-					r += s[0] * wa
-					g += s[1] * wa
-					b += s[2] * wa
-					a += wa
-				}
-				if a != 0 {
-					aInv := 1 / a
-					j := y*dst.Stride + x*4
-					d := dst.Pix[j : j+4 : j+4]
-					d[0] = clamp(r * aInv)
-					d[1] = clamp(g * aInv)
-					d[2] = clamp(b * aInv)
-					d[3] = clamp(a / wsum)
-				}
-			}
-		}
-	})
-
-	return dst
-}
-
-func blurVertical(img image.Image, kernel []float64) *image.NRGBA {
-	src := newScanner(img)
-	dst := image.NewNRGBA(image.Rect(0, 0, src.w, src.h))
-	radius := len(kernel) - 1
-
-	parallel(0, src.w, func(xs <-chan int) {
-		scanLine := make([]uint8, src.h*4)
-		scanLineF := make([]float64, len(scanLine))
-		for x := range xs {
-			src.scan(x, 0, x+1, src.h, scanLine)
-			for i, v := range scanLine {
-				scanLineF[i] = float64(v)
-			}
-			for y := 0; y < src.h; y++ {
-				min := y - radius
-				if min < 0 {
-					min = 0
-				}
-				max := y + radius
-				if max > src.h-1 {
-					max = src.h - 1
-				}
-				var r, g, b, a, wsum float64
-				for iy := min; iy <= max; iy++ {
-					i := iy * 4
-					weight := kernel[absint(y-iy)]
-					wsum += weight
-					s := scanLineF[i : i+4 : i+4]
-					wa := s[3] * weight
-					r += s[0] * wa
-					g += s[1] * wa
-					b += s[2] * wa
-					a += wa
-				}
-				if a != 0 {
-					aInv := 1 / a
-					j := y*dst.Stride + x*4
-					d := dst.Pix[j : j+4 : j+4]
-					d[0] = clamp(r * aInv)
-					d[1] = clamp(g * aInv)
-					d[2] = clamp(b * aInv)
-					d[3] = clamp(a / wsum)
-				}
-			}
-		}
-	})
-
-	return dst
-}
-
-// Sharpen produces a sharpened version of the image.
-// Sigma parameter must be positive and indicates how much the image will be sharpened.
-//
-// Example:
-//
-//	dstImage := imaging.Sharpen(srcImage, 3.5)
-//
-func Sharpen(img image.Image, sigma float64) *image.NRGBA {
-	if sigma <= 0 {
-		return Clone(img)
-	}
-
-	src := newScanner(img)
-	dst := image.NewNRGBA(image.Rect(0, 0, src.w, src.h))
-	blurred := Blur(img, sigma)
-
-	parallel(0, src.h, func(ys <-chan int) {
-		scanLine := make([]uint8, src.w*4)
-		for y := range ys {
-			src.scan(0, y, src.w, y+1, scanLine)
-			j := y * dst.Stride
-			for i := 0; i < src.w*4; i++ {
-				val := int(scanLine[i])<<1 - int(blurred.Pix[j])
-				if val < 0 {
-					val = 0
-				} else if val > 0xff {
-					val = 0xff
-				}
-				dst.Pix[j] = uint8(val)
-				j++
-			}
-		}
-	})
-
-	return dst
-}
--- a/vendor/github.com/disintegration/imaging/go.mod
+++ b/vendor/github.com/disintegration/imaging/go.mod
@@ -1,3 +0,0 @@
-module github.com/disintegration/imaging
-
-require golang.org/x/image v0.0.0-20180708004352-c73c2afc3b81
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Stash Dev	e13dae6012	Removed vendoring	2019-11-16 08:35:01 -08:00
WithoutPants	6a75d5551f	Use vendor when building (#201 ) * Use vendor code for all go calls * Add missing vendor dependencies * Add travis_retry to yarn install * Fix go test call	2019-11-16 08:03:28 -08:00
				`@@ -1 +0,0 @@`
				`au BufWritePost *.go silent!make tags > /dev/null 2>&1`