updated dependencies

Makefile

@@ -5,7 +5,7 @@ GCFLAGS=-gcflags '-e'
 LDFLAGS=-ldflags '-buildid=$(VERSION) -X main.version=$(VERSION) -s -w'
 PROGRAM=gowiki
 CMD=-o $(PROGRAM) cmd/gowiki/main.go
-ENV=CGO_ENABLED=0 GO111MODULE=on
+ENV=GOGC=0 CGO_ENABLED=0 GO111MODULE=on
 
 all: $(PROGRAM)
 
@@ -36,6 +36,9 @@ codeqa: govet misspell staticcheck test
 govet:
 	$(CC) vet ./...
 
+update:
+	$(ENV) $(CC) get -u ./...
+
 misspell:
 	$(GOPATH)/bin/misspell cmd/* pkg/* Makefile README.md sri.sh
 

go.mod

@@ -1,42 +1,40 @@
 module git.giftfish.de/ston1th/gowiki
 
-go 1.17
+go 1.19
 
 require (
-	git.giftfish.de/ston1th/godrop/v2 v2.1.0
+	git.giftfish.de/ston1th/godrop/v2 v2.1.1
 	git.giftfish.de/ston1th/jwt/v3 v3.2.0
 	github.com/blevesearch/bleve v1.0.14
 	github.com/gorilla/mux v1.8.0
-	github.com/pquerna/otp v1.3.0
+	github.com/pquerna/otp v1.4.0
 	github.com/russross/blackfriday v1.6.0
-	github.com/urfave/cli v1.22.5
+	github.com/urfave/cli v1.22.10
 	go.etcd.io/bbolt v1.3.6
-	golang.org/x/crypto v0.0.0-20210817164053-32db794688a5
+	golang.org/x/crypto v0.5.0
 )
 
 require (
-	github.com/RoaringBitmap/roaring v0.5.5 // indirect
+	github.com/RoaringBitmap/roaring v1.2.1 // indirect
+	github.com/bits-and-blooms/bitset v1.4.0 // indirect
 	github.com/blevesearch/go-porterstemmer v1.0.3 // indirect
-	github.com/blevesearch/mmap-go v1.0.2 // indirect
+	github.com/blevesearch/mmap-go v1.0.4 // indirect
-	github.com/blevesearch/segment v0.9.0 // indirect
+	github.com/blevesearch/segment v0.9.1 // indirect
 	github.com/blevesearch/snowballstem v0.9.0 // indirect
 	github.com/blevesearch/zap/v11 v11.0.14 // indirect
 	github.com/blevesearch/zap/v12 v12.0.14 // indirect
 	github.com/blevesearch/zap/v13 v13.0.6 // indirect
 	github.com/blevesearch/zap/v14 v14.0.5 // indirect
 	github.com/blevesearch/zap/v15 v15.0.3 // indirect
-	github.com/boombuler/barcode v1.0.1-0.20190219062509-6c824513bacc // indirect
+	github.com/boombuler/barcode v1.0.1 // indirect
 	github.com/couchbase/vellum v1.0.2 // indirect
-	github.com/cpuguy83/go-md2man/v2 v2.0.0 // indirect
+	github.com/cpuguy83/go-md2man/v2 v2.0.2 // indirect
-	github.com/glycerine/go-unsnap-stream v0.0.0-20190901134440-81cf024a9e0a // indirect
+	github.com/golang/protobuf v1.5.2 // indirect
-	github.com/golang/protobuf v1.4.3 // indirect
+	github.com/golang/snappy v0.0.4 // indirect
-	github.com/golang/snappy v0.0.2 // indirect
 	github.com/mschoch/smat v0.2.0 // indirect
-	github.com/philhofer/fwd v1.1.0 // indirect
 	github.com/russross/blackfriday/v2 v2.1.0 // indirect
 	github.com/steveyen/gtreap v0.1.0 // indirect
-	github.com/tinylib/msgp v1.1.4 // indirect
 	github.com/willf/bitset v1.1.11 // indirect
-	golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1 // indirect
+	golang.org/x/sys v0.4.0 // indirect
-	google.golang.org/protobuf v1.25.0 // indirect
+	google.golang.org/protobuf v1.28.1 // indirect
 )

go.sum

@@ -1,13 +1,15 @@
-cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+git.giftfish.de/ston1th/godrop/v2 v2.1.1 h1:jCzQPFpRImr2N4kz+4lC7wGZJAWGx9pH5X09nUsRQDU=
-git.giftfish.de/ston1th/godrop/v2 v2.1.0 h1:vR4aWVeMGJ+tHQH0p44esZrSl5dYJzuCmZqhKWP/vwI=
+git.giftfish.de/ston1th/godrop/v2 v2.1.1/go.mod h1:DWC4iM+u/bpdJsauL00h0V9tZ97d6Bzi2RGaFKlvZoQ=
-git.giftfish.de/ston1th/godrop/v2 v2.1.0/go.mod h1:z8KA3HP/vB04wddLXZfYVKURYDxBGau9hlHtV61x9mM=
 git.giftfish.de/ston1th/jwt/v3 v3.2.0 h1:V6Lh7OjXn4D3HPd/LoDf7w5N7cyiSXEPAQCIfSVZ05c=
 git.giftfish.de/ston1th/jwt/v3 v3.2.0/go.mod h1:jDALrW7OKeIaqYuMxs3GWyPRnQZmk/R+Lu9p/Em3Ziw=
 github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
 github.com/RoaringBitmap/roaring v0.4.23/go.mod h1:D0gp8kJQgE1A4LQ5wFLggQEyvDi06Mq5mKs52e1TwOo=
-github.com/RoaringBitmap/roaring v0.5.5 h1:naNqvO1mNnghk2UvcsqnzHDBn9DRbCIRy94GmDTRVTQ=
+github.com/RoaringBitmap/roaring v1.2.1 h1:58/LJlg/81wfEHd5L9qsHduznOIhyv4qb1yWcSvVq9A=
-github.com/RoaringBitmap/roaring v0.5.5/go.mod h1:puNo5VdzwbaIQxSiDIwfXl4Hnc+fbovcX4IW/dSTtUk=
+github.com/RoaringBitmap/roaring v1.2.1/go.mod h1:icnadbWcNyfEHlYdr+tDlOTih1Bf/h+rzPpv4sbomAA=
 github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8=
+github.com/bits-and-blooms/bitset v1.2.0/go.mod h1:gIdJ4wp64HaoK2YrL1Q5/N7Y16edYb8uY+O0FJTyyDA=
+github.com/bits-and-blooms/bitset v1.4.0 h1:+YZ8ePm+He2pU3dZlIZiOeAKfrBkXi1lSrXJ/Xzgbu8=
+github.com/bits-and-blooms/bitset v1.4.0/go.mod h1:gIdJ4wp64HaoK2YrL1Q5/N7Y16edYb8uY+O0FJTyyDA=
 github.com/blevesearch/bleve v1.0.14 h1:Q8r+fHTt35jtGXJUM0ULwM3Tzg+MRfyai4ZkWDy2xO4=
 github.com/blevesearch/bleve v1.0.14/go.mod h1:e/LJTr+E7EaoVdkQZTfoz7dt4KoDNvDbLb8MSKuNTLQ=
 github.com/blevesearch/blevex v1.0.0 h1:pnilj2Qi3YSEGdWgLj1Pn9Io7ukfXPoQcpAI1Bv8n/o=
@@ -15,10 +17,12 @@ github.com/blevesearch/blevex v1.0.0/go.mod h1:2rNVqoG2BZI8t1/P1awgTKnGlx5MP9Zbt
 github.com/blevesearch/cld2 v0.0.0-20200327141045-8b5f551d37f5/go.mod h1:PN0QNTLs9+j1bKy3d/GB/59wsNBFC4sWLWG3k69lWbc=
 github.com/blevesearch/go-porterstemmer v1.0.3 h1:GtmsqID0aZdCSNiY8SkuPJ12pD4jI+DdXTAn4YRcHCo=
 github.com/blevesearch/go-porterstemmer v1.0.3/go.mod h1:angGc5Ht+k2xhJdZi511LtmxuEf0OVpvUUNrwmM1P7M=
-github.com/blevesearch/mmap-go v1.0.2 h1:JtMHb+FgQCTTYIhtMvimw15dJwu1Y5lrZDMOFXVWPk0=
 github.com/blevesearch/mmap-go v1.0.2/go.mod h1:ol2qBqYaOUsGdm7aRMRrYGgPvnwLe6Y+7LMvAB5IbSA=
-github.com/blevesearch/segment v0.9.0 h1:5lG7yBCx98or7gK2cHMKPukPZ/31Kag7nONpoBt22Ac=
+github.com/blevesearch/mmap-go v1.0.4 h1:OVhDhT5B/M1HNPpYPBKIEJaD0F3Si+CrEKULGCDPWmc=
+github.com/blevesearch/mmap-go v1.0.4/go.mod h1:EWmEAOmdAS9z/pi/+Toxu99DnsbhG1TIxUoRmJw/pSs=
 github.com/blevesearch/segment v0.9.0/go.mod h1:9PfHYUdQCgHktBgvtUOF4x+pc4/l8rdH0u5spnW85UQ=
+github.com/blevesearch/segment v0.9.1 h1:+dThDy+Lvgj5JMxhmOVlgFfkUtZV2kw49xax4+jTfSU=
+github.com/blevesearch/segment v0.9.1/go.mod h1:zN21iLm7+GnBHWTao9I+Au/7MBiL8pPFtJBJTsk6kQw=
 github.com/blevesearch/snowballstem v0.9.0 h1:lMQ189YspGP6sXvZQ4WZ+MLawfV8wOmPoD/iWeNXm8s=
 github.com/blevesearch/snowballstem v0.9.0/go.mod h1:PivSj3JMc8WuaFkTSRDW2SlrulNWPl4ABg1tC/hlgLs=
 github.com/blevesearch/zap/v11 v11.0.14 h1:IrDAvtlzDylh6H2QCmS0OGcN9Hpf6mISJlfKjcwJs7k=
@@ -31,10 +35,9 @@ github.com/blevesearch/zap/v14 v14.0.5 h1:NdcT+81Nvmp2zL+NhwSvGSLh7xNgGL8QRVZ67n
 github.com/blevesearch/zap/v14 v14.0.5/go.mod h1:bWe8S7tRrSBTIaZ6cLRbgNH4TUDaC9LZSpRGs85AsGY=
 github.com/blevesearch/zap/v15 v15.0.3 h1:Ylj8Oe+mo0P25tr9iLPp33lN6d4qcztGjaIsP51UxaY=
 github.com/blevesearch/zap/v15 v15.0.3/go.mod h1:iuwQrImsh1WjWJ0Ue2kBqY83a0rFtJTqfa9fp1rbVVU=
-github.com/boombuler/barcode v1.0.1-0.20190219062509-6c824513bacc h1:biVzkmvwrH8WK8raXaxBx6fRVTlJILwEwQGL1I/ByEI=
 github.com/boombuler/barcode v1.0.1-0.20190219062509-6c824513bacc/go.mod h1:paBWMcWSl3LHKBqUq+rly7CNSldXjb2rDl3JlRe0mD8=
-github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
+github.com/boombuler/barcode v1.0.1 h1:NDBbPmhS+EqABEs5Kg3n/5ZNjy73Pz7SIV+KCeqyXcs=
-github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
+github.com/boombuler/barcode v1.0.1/go.mod h1:paBWMcWSl3LHKBqUq+rly7CNSldXjb2rDl3JlRe0mD8=
 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=
 github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
@@ -42,11 +45,10 @@ github.com/couchbase/ghistogram v0.1.0/go.mod h1:s1Jhy76zqfEecpNWJfWUiKZookAFaiG
 github.com/couchbase/moss v0.1.0/go.mod h1:9MaHIaRuy9pvLPUJxB8sh8OrLfyDczECVL37grCIubs=
 github.com/couchbase/vellum v1.0.2 h1:BrbP0NKiyDdndMPec8Jjhy0U47CZ0Lgx3xUC2r9rZqw=
 github.com/couchbase/vellum v1.0.2/go.mod h1:FcwrEivFpNi24R3jLOs3n+fs5RnuQnQqCLBJ1uAg1W4=
-github.com/cpuguy83/go-md2man v1.0.10 h1:BSKMNlYxDvnunlTymqtgONjNnaRV1sTpcovwwjF22jk=
 github.com/cpuguy83/go-md2man v1.0.10/go.mod h1:SmD6nW6nTyfqj6ABTjUi3V3JVMnlJmwcJI5acqYI6dE=
 github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
-github.com/cpuguy83/go-md2man/v2 v2.0.0 h1:EoUDS0afbrsXAZ9YQ9jdu/mZ2sXgT1/2yyNng4PGlyM=
+github.com/cpuguy83/go-md2man/v2 v2.0.2 h1:p1EgwI/C7NhT0JmVkwCD2ZBK8j4aeHQX2pMHHBfMQ6w=
-github.com/cpuguy83/go-md2man/v2 v2.0.0/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
+github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
 github.com/cznic/b v0.0.0-20181122101859-a26611c4d92d h1:SwD98825d6bdB+pEuTxWOXiSjBrHdOl/UVp75eI7JT8=
 github.com/cznic/b v0.0.0-20181122101859-a26611c4d92d/go.mod h1:URriBxXwVq5ijiJ12C7iIZqlA69nTlI+LgI6/pwftG8=
 github.com/cznic/mathutil v0.0.0-20181122101859-297441e03548/go.mod h1:e6NPNENfs9mPDVNRekM7lKScauxd5kXTr1Mfyig6TDM=
@@ -54,40 +56,23 @@ github.com/cznic/strutil v0.0.0-20181122101858-275e90344537/go.mod h1:AHHPPPXTw0
 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/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
-github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
 github.com/facebookgo/ensure v0.0.0-20200202191622-63f1cf65ac4c/go.mod h1:Yg+htXGokKKdzcwhuNDwVvN+uBxDGXJ7G/VN1d8fa64=
 github.com/facebookgo/stack v0.0.0-20160209184415-751773369052/go.mod h1:UbMTZqLaRiH3MsBH8va0n7s1pQYcu3uTb8G4tygF4Zg=
 github.com/facebookgo/subset v0.0.0-20200203212716-c811ad88dec4/go.mod h1:5tD+neXqOorC30/tWg0LCSkrqj/AR6gu8yY8/fpw1q0=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
 github.com/glycerine/go-unsnap-stream v0.0.0-20181221182339-f9677308dec2/go.mod h1:/20jfyN9Y5QPEAprSgKAUr+glWDY39ZiUEAYOEv5dsE=
-github.com/glycerine/go-unsnap-stream v0.0.0-20190901134440-81cf024a9e0a h1:FQqoVvjbiUioBBFUL5up+h+GdCa/AnJsL/1bIs/veSI=
-github.com/glycerine/go-unsnap-stream v0.0.0-20190901134440-81cf024a9e0a/go.mod h1:/20jfyN9Y5QPEAprSgKAUr+glWDY39ZiUEAYOEv5dsE=
-github.com/glycerine/goconvey v0.0.0-20190410193231-58a59202ab31 h1:gclg6gY70GLy3PbkQ1AERPfmLMMagS60DKF78eWwLn8=
 github.com/glycerine/goconvey v0.0.0-20190410193231-58a59202ab31/go.mod h1:Ogl1Tioa0aV7gstGFO7KhffUsb9M4ydbEbbxpcEDc24=
-github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
-github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
 github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
+github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
-github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
+github.com/golang/protobuf v1.5.2 h1:ROPKBNFfQgOUMifHyP+KYbvpjbdoFNs+aK7DXlji0Tw=
-github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
+github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
-github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
-github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
-github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8=
-github.com/golang/protobuf v1.4.3 h1:JjCZWpVbqXDqFVmTfYWEVTMIYrL/NPdPSCHPJ0T/raM=
-github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
 github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
-github.com/golang/snappy v0.0.2 h1:aeE13tS0IiQgFjYdoL8qN3K1N2bXXtI6Vi51/y7BpMw=
+github.com/golang/snappy v0.0.4 h1:yAGX7huGHXlcLOEtBnF4w7FQwA26wojNCwOYAEhLjQM=
-github.com/golang/snappy v0.0.2/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
-github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
+github.com/google/go-cmp v0.5.5 h1:Khx7svrCpmxxtHBq5j2mp/xVjsi8hQMfNLvJFAlrGgU=
-github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
-github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.0 h1:/QaMHBdZ26BB3SSst0Iwl10Epc+xhTquomWX0oZEB6w=
-github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/gopherjs/gopherjs v0.0.0-20190910122728-9d188e94fb99 h1:twflg0XRTjwKpxb/jFExr4HGq6on2dEOmnL6FV+fgPw=
 github.com/gopherjs/gopherjs v0.0.0-20190910122728-9d188e94fb99/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
 github.com/gorilla/mux v1.8.0 h1:i40aqfkR1h2SlN9hojwV5ZA91wcXFOvkdNIeFDP5koI=
 github.com/gorilla/mux v1.8.0/go.mod h1:DVbg23sWSpFRCP0SfiEN6jmj59UnW/n46BH5rLB71So=
@@ -97,7 +82,6 @@ github.com/ikawaha/kagome.ipadic v1.1.2/go.mod h1:DPSBbU0czaJhAb/5uKQZHMc9MTVRpD
 github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
 github.com/jmhodges/levigo v1.0.0 h1:q5EC36kV79HWeTBWsod3mG11EgStG3qArTKcvlksN1U=
 github.com/jmhodges/levigo v1.0.0/go.mod h1:Q6Qx+uH3RAqyK4rFQroq9RL7mdkABMcfhEI+nNuzMJQ=
-github.com/jtolds/gls v4.20.0+incompatible h1:xdiiI2gbIgH/gLH7ADydsJ1uDOEzR8yvV7C0MuV77Wo=
 github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
 github.com/kljensen/snowball v0.6.0/go.mod h1:27N7E8fVU5H68RlUmnWwZCfxgt4POBJfENGMvNRhldw=
 github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
@@ -111,13 +95,10 @@ github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+W
 github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
 github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic=
 github.com/philhofer/fwd v1.0.0/go.mod h1:gk3iGcWd9+svBvR0sR+KPcfE+RNWozjowpeBVG3ZVNU=
-github.com/philhofer/fwd v1.1.0 h1:PAdZw9+/BCf4gc/kA2L/PbGPkFe72Kl2GLZXTG8HpU8=
-github.com/philhofer/fwd v1.1.0/go.mod h1:gk3iGcWd9+svBvR0sR+KPcfE+RNWozjowpeBVG3ZVNU=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/pquerna/otp v1.3.0 h1:oJV/SkzR33anKXwQU3Of42rL4wbrffP4uvUf1SvS5Xs=
+github.com/pquerna/otp v1.4.0 h1:wZvl1TIVxKRThZIBiwOOHOGP/1+nZyWBil9Y2XNEDzg=
-github.com/pquerna/otp v1.3.0/go.mod h1:dkJfzwRKNiegxyNb54X/3fLwhCynbMspSyWKnvi1AEg=
+github.com/pquerna/otp v1.4.0/go.mod h1:dkJfzwRKNiegxyNb54X/3fLwhCynbMspSyWKnvi1AEg=
-github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
 github.com/rcrowley/go-metrics v0.0.0-20190826022208-cac0b30c2563/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4=
 github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
 github.com/russross/blackfriday v1.5.2/go.mod h1:JO/DiYxRf+HjHt06OyowR9PTA263kcR/rfWxYHBV53g=
@@ -146,104 +127,40 @@ github.com/tebeka/snowball v0.4.2/go.mod h1:4IfL14h1lvwZcp1sfXuuc7/7yCsvVffTWxWx
 github.com/tecbot/gorocksdb v0.0.0-20191217155057-f0fad39f321c h1:g+WoO5jjkqGAzHWCjJB1zZfXPIAaDpzXIEJ0eS6B5Ok=
 github.com/tecbot/gorocksdb v0.0.0-20191217155057-f0fad39f321c/go.mod h1:ahpPrc7HpcfEWDQRZEmnXMzHY03mLDYMCxeDzy46i+8=
 github.com/tinylib/msgp v1.1.0/go.mod h1:+d+yLhGm8mzTaHzB+wgMYrodPfmZrzkirds8fDWklFE=
-github.com/tinylib/msgp v1.1.4 h1:LoJjc8YHnBUXK7kR6ocUJ0xHuonGLzpzV3RxMZ/4G4M=
-github.com/tinylib/msgp v1.1.4/go.mod h1:fw0zyanbVLI0CNimiAzGT53nQhEXzCaKYmTfeon9xHc=
-github.com/ttacon/chalk v0.0.0-20160626202418-22c06c80ed31/go.mod h1:onvgF043R+lC5RZ8IT9rBXDaEDnpnw/Cl+HFiw+v/7Q=
 github.com/ugorji/go/codec v0.0.0-20181204163529-d75b2dcb6bc8/go.mod h1:VFNgLljTbGfSG7qAOspJ7OScBnGdDN/yBr0sguwnwf0=
-github.com/urfave/cli v1.22.5 h1:lNq9sAHXK2qfdI8W+GRItjCEkI+2oR4d+MEHy1CKXoU=
+github.com/urfave/cli v1.22.10 h1:p8Fspmz3iTctJstry1PYS3HVdllxnEzTEsgIgtxTrCk=
-github.com/urfave/cli v1.22.5/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0=
+github.com/urfave/cli v1.22.10/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0=
 github.com/willf/bitset v1.1.10/go.mod h1:RjeCKbqT1RxIR/KWY6phxZiaY1IyutSBfGjNPySAYV4=
 github.com/willf/bitset v1.1.11 h1:N7Z7E9UvjW+sGsEl7k/SJrvY2reP1A07MrGuCjIOjRE=
 github.com/willf/bitset v1.1.11/go.mod h1:83CECat5yLh5zVOf4P1ErAgKA5UDvKtgyUABdr3+MjI=
 github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q=
-github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 go.etcd.io/bbolt v1.3.5/go.mod h1:G5EMThwa9y8QZGBClrRx5EY+Yw9kAhnjy3bSjsnlVTQ=
 go.etcd.io/bbolt v1.3.6 h1:/ecaJf0sk1l4l6V4awd65v2C3ILy7MSj+s/x1ADCIMU=
 go.etcd.io/bbolt v1.3.6/go.mod h1:qXsaaIqmgQH0T+OPdb99Bf+PKfBBQVAdyD6TY9G8XM4=
 golang.org/x/crypto v0.0.0-20181203042331-505ab145d0a9/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
-golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.5.0 h1:U/0M97KRkSFvyD/3FSmdP5W5swImpNgle/EHFhOsQPE=
-golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.5.0/go.mod h1:NK/OQwhpMQP3MwtdjgLlYHnH9ebylxKWv3e0fK+mkQU=
-golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.0.0-20210817164053-32db794688a5 h1:HWj/xjIHfjYU5nVXpTM0s39J9CbLn7Cc5a7IC5rwsMQ=
-golang.org/x/crypto v0.0.0-20210817164053-32db794688a5/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
-golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
-golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
-golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
-golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
-golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
-golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
-golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/net v0.0.0-20180724234803-3673e40ba225/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-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
-golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
-golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
-golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/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-20181026144532-2772b66316d2/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20181205085412-a5c9d58dba9a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20181221143128-b4a75ba826a6/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190813064441-fde4db37ae7a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200923182605-d9f96fdee20d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.4.0 h1:Zr2JFtRQNX3BCZ8YtxRE9hNJYC8J6I1MVbMg6owUp18=
-golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1 h1:SrN+KX8Art/Sf4HNj6Zcz06G7VEz+7w9tdXTPOZ7+l4=
+golang.org/x/sys v0.4.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
-golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/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-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
-golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
-golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
-golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200928182047-19e03678916f/go.mod h1:z6u4i615ZeAfBE4XtMziQW1fSVJXACjjbWkB/mvPzlU=
-golang.org/x/tools v0.0.0-20201022035929-9cf592e881e9/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
-golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
+google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
-google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
+google.golang.org/protobuf v1.28.1 h1:d0NfwRgPtno5B1Wa6L2DAG+KivqkdutMf1UhdNx175w=
-google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+google.golang.org/protobuf v1.28.1/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
-google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
-google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
-google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo=
-google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
-google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
-google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
-google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
-google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
-google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
-google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
-google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
-google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
-google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
-google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
-google.golang.org/protobuf v1.25.0 h1:Ejskq+SyPohKW+1uil0JJMtmHCgJPJ/qWTxr8qp+R4c=
-google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
 gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
 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=
-honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
-honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=

vendor/git.giftfish.de/ston1th/godrop/v2/LICENSE

@@ -1,4 +1,4 @@
-Copyright (C) 2017 Marius Schellenberger
+Copyright (C) 2022 Marius Schellenberger
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

vendor/git.giftfish.de/ston1th/godrop/v2/godrop.go

@@ -1,5 +1,6 @@
-// Copyright (C) 2018 Marius Schellenberger
+// Copyright (C) 2022 Marius Schellenberger
 
+//go:build go1.11
 // +build go1.11
 
 // Package godrop provides a simple library to drop privileges on Linux and OpenBSD.

vendor/git.giftfish.de/ston1th/godrop/v2/lookup.go

@@ -1,5 +1,6 @@
-// Copyright (C) 2018 Marius Schellenberger
+// Copyright (C) 2022 Marius Schellenberger
 
+//go:build go1.11
 // +build go1.11
 
 package godrop

vendor/git.giftfish.de/ston1th/godrop/v2/pledge.go

@@ -1,5 +1,6 @@
-// Copyright (C) 2018 Marius Schellenberger
+// Copyright (C) 2022 Marius Schellenberger
 
+//go:build !openbsd
 // +build !openbsd
 
 package godrop

vendor/git.giftfish.de/ston1th/godrop/v2/pledge_openbsd.go

@@ -1,5 +1,6 @@
-// Copyright (C) 2018 Marius Schellenberger
+// Copyright (C) 2022 Marius Schellenberger
 
+//go:build openbsd
 // +build openbsd
 
 package godrop

vendor/git.giftfish.de/ston1th/godrop/v2/unveil.go

@@ -1,5 +1,6 @@
-// Copyright (C) 2018 Marius Schellenberger
+// Copyright (C) 2022 Marius Schellenberger
 
+//go:build !openbsd
 // +build !openbsd
 
 package godrop

vendor/git.giftfish.de/ston1th/godrop/v2/unveil_openbsd.go

@@ -1,5 +1,6 @@
-// Copyright (C) 2018 Marius Schellenberger
+// Copyright (C) 2022 Marius Schellenberger
 
+//go:build openbsd
 // +build openbsd
 
 package godrop

vendor/github.com/RoaringBitmap/roaring/.gitignore

@@ -3,4 +3,3 @@ roaring-fuzz.zip
 workdir
 coverage.out
 testdata/all3.classic
-testdata/all3.msgp.snappy

vendor/github.com/RoaringBitmap/roaring/.travis.yml

@@ -1,32 +0,0 @@
-language: go
-sudo: false
-install:
-- go get -t github.com/RoaringBitmap/roaring
-- go get -t golang.org/x/tools/cmd/cover
-- go get -t github.com/mattn/goveralls
-- go get -t github.com/mschoch/smat
-notifications:
-  email: false
-go:
-- "1.13.x"
-- "1.14.x"
-- tip
-
-# whitelist
-branches:
-  only:
-    - master
-script:
-- goveralls -v -service travis-ci -ignore arraycontainer_gen.go,bitmapcontainer_gen.go,rle16_gen.go,rle_gen.go,roaringarray_gen.go,rle.go || go test
-- go test -race -run TestConcurrent*
-- go build -tags appengine
-- go test -tags appengine
-- GOARCH=arm64 go build
-- GOARCH=386 go build
-- GOARCH=386 go test
-- GOARCH=arm go build
-- GOARCH=arm64 go build
-
-matrix:
-  allow_failures:
-  - go: tip

vendor/github.com/RoaringBitmap/roaring/Makefile

@@ -64,7 +64,7 @@ qa: fmtcheck test vet lint
 # Get the dependencies
 deps:
 	GOPATH=$(GOPATH) go get github.com/stretchr/testify
-	GOPATH=$(GOPATH) go get github.com/willf/bitset
+	GOPATH=$(GOPATH) go get github.com/bits-and-blooms/bitset
 	GOPATH=$(GOPATH) go get github.com/golang/lint/golint
 	GOPATH=$(GOPATH) go get github.com/mschoch/smat
 	GOPATH=$(GOPATH) go get github.com/dvyukov/go-fuzz/go-fuzz
@@ -97,10 +97,6 @@ nuke:
 	rm -rf ./target
 	GOPATH=$(GOPATH) go clean -i ./...
 
-
-ser: 
-	go generate
-
 cover:
 	go test -coverprofile=coverage.out
 	go tool cover -html=coverage.out

vendor/github.com/RoaringBitmap/roaring/README.md

@@ -1,4 +1,4 @@
-roaring [![Build Status](https://travis-ci.org/RoaringBitmap/roaring.png)](https://travis-ci.org/RoaringBitmap/roaring) [![GoDoc](https://godoc.org/github.com/RoaringBitmap/roaring?status.svg)](https://godoc.org/github.com/RoaringBitmap/roaring) [![GoDoc](https://godoc.org/github.com/RoaringBitmap/roaring/roaring64?status.svg)](https://godoc.org/github.com/RoaringBitmap/roaring/roaring64) [![Go Report Card](https://goreportcard.com/badge/RoaringBitmap/roaring)](https://goreportcard.com/report/github.com/RoaringBitmap/roaring)
+roaring [![GoDoc](https://godoc.org/github.com/RoaringBitmap/roaring/roaring64?status.svg)](https://godoc.org/github.com/RoaringBitmap/roaring/roaring64) [![Go Report Card](https://goreportcard.com/badge/RoaringBitmap/roaring)](https://goreportcard.com/report/github.com/RoaringBitmap/roaring)
 [![Build Status](https://cloud.drone.io/api/badges/RoaringBitmap/roaring/status.svg)](https://cloud.drone.io/RoaringBitmap/roaring)
 ![Go-CI](https://github.com/RoaringBitmap/roaring/workflows/Go-CI/badge.svg)
 ![Go-ARM-CI](https://github.com/RoaringBitmap/roaring/workflows/Go-ARM-CI/badge.svg)
@@ -7,10 +7,8 @@ roaring [![Build Status](https://travis-ci.org/RoaringBitmap/roaring.png)](https
 
 This is a go version of the Roaring bitmap data structure. 
 
-
-
 Roaring bitmaps are used by several major systems such as [Apache Lucene][lucene] and derivative systems such as [Solr][solr] and
-[Elasticsearch][elasticsearch], [Apache Druid (Incubating)][druid], [LinkedIn Pinot][pinot], [Netflix Atlas][atlas],  [Apache Spark][spark], [OpenSearchServer][opensearchserver], [Cloud Torrent][cloudtorrent], [Whoosh][whoosh],  [Pilosa][pilosa],  [Microsoft Visual Studio Team Services (VSTS)][vsts], and eBay's [Apache Kylin][kylin]. The YouTube SQL Engine, [Google Procella](https://research.google/pubs/pub48388/), uses Roaring bitmaps for indexing.
+[Elasticsearch][elasticsearch], [Apache Druid (Incubating)][druid], [LinkedIn Pinot][pinot], [Netflix Atlas][atlas],  [Apache Spark][spark], [OpenSearchServer][opensearchserver], [anacrolix/torrent][anacrolix/torrent], [Whoosh][whoosh],  [Pilosa][pilosa],  [Microsoft Visual Studio Team Services (VSTS)][vsts], and eBay's [Apache Kylin][kylin]. The YouTube SQL Engine, [Google Procella](https://research.google/pubs/pub48388/), uses Roaring bitmaps for indexing.
 
 [lucene]: https://lucene.apache.org/
 [solr]: https://lucene.apache.org/solr/
@@ -18,7 +16,7 @@ Roaring bitmaps are used by several major systems such as [Apache Lucene][lucene
 [druid]: https://druid.apache.org/
 [spark]: https://spark.apache.org/
 [opensearchserver]: http://www.opensearchserver.com
-[cloudtorrent]: https://github.com/jpillora/cloud-torrent
+[anacrolix/torrent]: https://github.com/anacrolix/torrent
 [whoosh]: https://bitbucket.org/mchaput/whoosh/wiki/Home
 [pilosa]: https://www.pilosa.com/
 [kylin]: http://kylin.apache.org/
@@ -32,7 +30,7 @@ Roaring bitmaps are found to work well in many important applications:
 
 
 The ``roaring`` Go library is used by
-* [Cloud Torrent](https://github.com/jpillora/cloud-torrent)
+* [anacrolix/torrent]
 * [runv](https://github.com/hyperhq/runv)
 * [InfluxDB](https://www.influxdata.com)
 * [Pilosa](https://www.pilosa.com/)
@@ -42,6 +40,7 @@ The ``roaring`` Go library is used by
 * [SourceGraph](https://github.com/sourcegraph/sourcegraph)
 * [M3](https://github.com/m3db/m3)
 * [trident](https://github.com/NetApp/trident)
+* [Husky](https://www.datadoghq.com/blog/engineering/introducing-husky/)
 
 
 This library is used in production in several systems, it is part of the [Awesome Go collection](https://awesome-go.com).
@@ -84,7 +83,7 @@ When the bitset approach is applicable, it can be orders of
 magnitude faster than other possible implementation of a set (e.g., as a hash set)
 while using several times less memory.
 
-However, a bitset, even a compressed one is not always applicable. For example, if the
+However, a bitset, even a compressed one is not always applicable. For example, if
 you have 1000 random-looking integers, then a simple array might be the best representation.
 We refer to this case as the "sparse" scenario.
 
@@ -158,7 +157,7 @@ http://arxiv.org/abs/1402.6407 This paper used data from http://lemire.me/data/r
 Dependencies are fetched automatically by giving the `-t` flag to `go get`.
 
 they include
-  - github.com/willf/bitset
+  - github.com/bits-and-blooms/bitset
   - github.com/mschoch/smat
   - github.com/glycerine/go-unsnap-stream
   - github.com/philhofer/fwd
@@ -384,12 +383,14 @@ You can help us test further the library with fuzzy testing:
          go get github.com/dvyukov/go-fuzz/go-fuzz-build
          go test -tags=gofuzz -run=TestGenerateSmatCorpus
          go-fuzz-build github.com/RoaringBitmap/roaring
-         go-fuzz -bin=./roaring-fuzz.zip -workdir=workdir/ -timeout=200
+         go-fuzz -bin=./roaring-fuzz.zip -workdir=workdir/ -timeout=200 -func FuzzSmat
 
 Let it run, and if the # of crashers is > 0, check out the reports in
 the workdir where you should be able to find the panic goroutine stack
 traces.
 
+You may also replace `-func FuzzSmat`  by `-func FuzzSerializationBuffer` or `-func FuzzSerializationStream`.
+
 ### Alternative in Go
 
 There is a Go version wrapping the C/C++ implementation https://github.com/RoaringBitmap/gocroaring

vendor/github.com/RoaringBitmap/roaring/arraycontainer.go

@@ -4,8 +4,6 @@ import (
 	"fmt"
 )
 
-//go:generate msgp -unexported
-
 type arrayContainer struct {
 	content []uint16
 }
@@ -18,10 +16,11 @@ func (ac *arrayContainer) String() string {
 	return s + "}"
 }
 
-func (ac *arrayContainer) fillLeastSignificant16bits(x []uint32, i int, mask uint32) {
+func (ac *arrayContainer) fillLeastSignificant16bits(x []uint32, i int, mask uint32) int {
 	for k := 0; k < len(ac.content); k++ {
 		x[k+i] = uint32(ac.content[k]) | mask
 	}
+	return i + len(ac.content)
 }
 
 func (ac *arrayContainer) iterate(cb func(x uint16) bool) bool {
@@ -396,11 +395,19 @@ func (ac *arrayContainer) iorBitmap(bc2 *bitmapContainer) container {
 }
 
 func (ac *arrayContainer) iorRun16(rc *runContainer16) container {
-	bc1 := ac.toBitmapContainer()
+	runCardinality := rc.getCardinality()
-	bc2 := rc.toBitmapContainer()
+	// heuristic for if the container should maybe be an
-	bc1.iorBitmap(bc2)
+	// array container.
-	*ac = *newArrayContainerFromBitmap(bc1)
+	if runCardinality < ac.getCardinality() &&
-	return ac
+		runCardinality+ac.getCardinality() < arrayDefaultMaxSize {
+		var result container
+		result = ac
+		for _, run := range rc.iv {
+			result = result.iaddRange(int(run.start), int(run.start)+int(run.length)+1)
+		}
+		return result
+	}
+	return rc.orArray(ac)
 }
 
 func (ac *arrayContainer) lazyIOR(a container) container {
@@ -485,7 +492,7 @@ func (ac *arrayContainer) orArrayCardinality(value2 *arrayContainer) int {
 func (ac *arrayContainer) lazyorArray(value2 *arrayContainer) container {
 	value1 := ac
 	maxPossibleCardinality := value1.getCardinality() + value2.getCardinality()
-	if maxPossibleCardinality > arrayLazyLowerBound { // it could be a bitmap!^M
+	if maxPossibleCardinality > arrayLazyLowerBound { // it could be a bitmap!
 		bc := newBitmapContainer()
 		for k := 0; k < len(value2.content); k++ {
 			v := value2.content[k]
@@ -845,6 +852,10 @@ func (ac *arrayContainer) getCardinality() int {
 	return len(ac.content)
 }
 
+func (ac *arrayContainer) isEmpty() bool {
+	return len(ac.content) == 0
+}
+
 func (ac *arrayContainer) rank(x uint16) int {
 	answer := binarySearch(ac.content, x)
 	if answer >= 0 {
@@ -884,7 +895,7 @@ func (ac *arrayContainer) resetTo(a container) {
 		x.fillArray(ac.content)
 
 	case *runContainer16:
-		card := int(x.cardinality())
+		card := int(x.getCardinality())
 		ac.realloc(card)
 		cur := 0
 		for _, r := range x.iv {
@@ -958,10 +969,10 @@ func (ac *arrayContainer) numberOfRuns() (nr int) {
 				runlen++
 			} else {
 				if cur < prev {
-					panic("then fundamental arrayContainer assumption of sorted ac.content was broken")
+					panic("the fundamental arrayContainer assumption of sorted ac.content was broken")
 				}
 				if cur == prev {
-					panic("then fundamental arrayContainer assumption of deduplicated content was broken")
+					panic("the fundamental arrayContainer assumption of deduplicated content was broken")
 				} else {
 					nr++
 					runlen = 0
@@ -996,16 +1007,42 @@ func (ac *arrayContainer) containerType() contype {
 	return arrayContype
 }
 
-func (ac *arrayContainer) addOffset(x uint16) []container {
+func (ac *arrayContainer) addOffset(x uint16) (container, container) {
-	low := &arrayContainer{}
+	var low, high *arrayContainer
-	high := &arrayContainer{}
+
+	if len(ac.content) == 0 {
+		return nil, nil
+	}
+
+	if y := uint32(ac.content[0]) + uint32(x); highbits(y) == 0 {
+		// Some elements will fall into low part, allocate a container.
+		// Checking the first one is enough because they are ordered.
+		low = &arrayContainer{}
+	}
+	if y := uint32(ac.content[len(ac.content)-1]) + uint32(x); highbits(y) > 0 {
+		// Some elements will fall into high part, allocate a container.
+		// Checking the last one is enough because they are ordered.
+		high = &arrayContainer{}
+	}
+
 	for _, val := range ac.content {
 		y := uint32(val) + uint32(x)
 		if highbits(y) > 0 {
+			// OK, if high == nil then highbits(y) == 0 for all y.
 			high.content = append(high.content, lowbits(y))
 		} else {
+			// OK, if low == nil then highbits(y) > 0 for all y.
 			low.content = append(low.content, lowbits(y))
 		}
 	}
-	return []container{low, high}
+
+	// Ensure proper nil interface.
+	if low == nil {
+		return nil, high
+	}
+	if high == nil {
+		return low, nil
+	}
+
+	return low, high
 }

vendor/github.com/RoaringBitmap/roaring/arraycontainer_gen.go

@@ -1,134 +0,0 @@
-package roaring
-
-// NOTE: THIS FILE WAS PRODUCED BY THE
-// MSGP CODE GENERATION TOOL (github.com/tinylib/msgp)
-// DO NOT EDIT
-
-import "github.com/tinylib/msgp/msgp"
-
-// Deprecated: DecodeMsg implements msgp.Decodable
-func (z *arrayContainer) DecodeMsg(dc *msgp.Reader) (err error) {
-	var field []byte
-	_ = field
-	var zbzg uint32
-	zbzg, err = dc.ReadMapHeader()
-	if err != nil {
-		return
-	}
-	for zbzg > 0 {
-		zbzg--
-		field, err = dc.ReadMapKeyPtr()
-		if err != nil {
-			return
-		}
-		switch msgp.UnsafeString(field) {
-		case "content":
-			var zbai uint32
-			zbai, err = dc.ReadArrayHeader()
-			if err != nil {
-				return
-			}
-			if cap(z.content) >= int(zbai) {
-				z.content = (z.content)[:zbai]
-			} else {
-				z.content = make([]uint16, zbai)
-			}
-			for zxvk := range z.content {
-				z.content[zxvk], err = dc.ReadUint16()
-				if err != nil {
-					return
-				}
-			}
-		default:
-			err = dc.Skip()
-			if err != nil {
-				return
-			}
-		}
-	}
-	return
-}
-
-// Deprecated: EncodeMsg implements msgp.Encodable
-func (z *arrayContainer) EncodeMsg(en *msgp.Writer) (err error) {
-	// map header, size 1
-	// write "content"
-	err = en.Append(0x81, 0xa7, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74)
-	if err != nil {
-		return err
-	}
-	err = en.WriteArrayHeader(uint32(len(z.content)))
-	if err != nil {
-		return
-	}
-	for zxvk := range z.content {
-		err = en.WriteUint16(z.content[zxvk])
-		if err != nil {
-			return
-		}
-	}
-	return
-}
-
-// Deprecated: MarshalMsg implements msgp.Marshaler
-func (z *arrayContainer) MarshalMsg(b []byte) (o []byte, err error) {
-	o = msgp.Require(b, z.Msgsize())
-	// map header, size 1
-	// string "content"
-	o = append(o, 0x81, 0xa7, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74)
-	o = msgp.AppendArrayHeader(o, uint32(len(z.content)))
-	for zxvk := range z.content {
-		o = msgp.AppendUint16(o, z.content[zxvk])
-	}
-	return
-}
-
-// Deprecated: UnmarshalMsg implements msgp.Unmarshaler
-func (z *arrayContainer) UnmarshalMsg(bts []byte) (o []byte, err error) {
-	var field []byte
-	_ = field
-	var zcmr uint32
-	zcmr, bts, err = msgp.ReadMapHeaderBytes(bts)
-	if err != nil {
-		return
-	}
-	for zcmr > 0 {
-		zcmr--
-		field, bts, err = msgp.ReadMapKeyZC(bts)
-		if err != nil {
-			return
-		}
-		switch msgp.UnsafeString(field) {
-		case "content":
-			var zajw uint32
-			zajw, bts, err = msgp.ReadArrayHeaderBytes(bts)
-			if err != nil {
-				return
-			}
-			if cap(z.content) >= int(zajw) {
-				z.content = (z.content)[:zajw]
-			} else {
-				z.content = make([]uint16, zajw)
-			}
-			for zxvk := range z.content {
-				z.content[zxvk], bts, err = msgp.ReadUint16Bytes(bts)
-				if err != nil {
-					return
-				}
-			}
-		default:
-			bts, err = msgp.Skip(bts)
-			if err != nil {
-				return
-			}
-		}
-	}
-	o = bts
-	return
-}
-
-// Deprecated: Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
-func (z *arrayContainer) Msgsize() (s int) {
-	s = 1 + 8 + msgp.ArrayHeaderSize + (len(z.content) * (msgp.Uint16Size))
-	return
-}

vendor/github.com/RoaringBitmap/roaring/bitmapcontainer.go

@@ -5,8 +5,6 @@ import (
 	"unsafe"
 )
 
-//go:generate msgp -unexported
-
 type bitmapContainer struct {
 	cardinality int
 	bitmap      []uint64
@@ -115,7 +113,7 @@ type bitmapContainerShortIterator struct {
 
 func (bcsi *bitmapContainerShortIterator) next() uint16 {
 	j := bcsi.i
-	bcsi.i = bcsi.ptr.NextSetBit(bcsi.i + 1)
+	bcsi.i = bcsi.ptr.NextSetBit(uint(bcsi.i) + 1)
 	return uint16(j)
 }
 func (bcsi *bitmapContainerShortIterator) hasNext() bool {
@@ -128,7 +126,7 @@ func (bcsi *bitmapContainerShortIterator) peekNext() uint16 {
 
 func (bcsi *bitmapContainerShortIterator) advanceIfNeeded(minval uint16) {
 	if bcsi.hasNext() && bcsi.peekNext() < minval {
-		bcsi.i = bcsi.ptr.NextSetBit(int(minval))
+		bcsi.i = bcsi.ptr.NextSetBit(uint(minval))
 	}
 }
 
@@ -266,7 +264,7 @@ func bitmapEquals(a, b []uint64) bool {
 	return true
 }
 
-func (bc *bitmapContainer) fillLeastSignificant16bits(x []uint32, i int, mask uint32) {
+func (bc *bitmapContainer) fillLeastSignificant16bits(x []uint32, i int, mask uint32) int {
 	// TODO: should be written as optimized assembly
 	pos := i
 	base := mask
@@ -280,6 +278,7 @@ func (bc *bitmapContainer) fillLeastSignificant16bits(x []uint32, i int, mask ui
 		}
 		base += 64
 	}
+	return pos
 }
 
 func (bc *bitmapContainer) equals(o container) bool {
@@ -351,6 +350,10 @@ func (bc *bitmapContainer) getCardinality() int {
 	return bc.cardinality
 }
 
+func (bc *bitmapContainer) isEmpty() bool {
+	return bc.cardinality == 0
+}
+
 func (bc *bitmapContainer) clone() container {
 	ptr := bitmapContainer{bc.cardinality, make([]uint64, len(bc.bitmap))}
 	copy(ptr.bitmap, bc.bitmap[:])
@@ -1009,20 +1012,23 @@ func (bc *bitmapContainer) fillArray(container []uint16) {
 	}
 }
 
-func (bc *bitmapContainer) NextSetBit(i int) int {
+func (bc *bitmapContainer) NextSetBit(i uint) int {
-	x := i / 64
+	var (
-	if x >= len(bc.bitmap) {
+		x      = i / 64
+		length = uint(len(bc.bitmap))
+	)
+	if x >= length {
 		return -1
 	}
 	w := bc.bitmap[x]
 	w = w >> uint(i%64)
 	if w != 0 {
-		return i + countTrailingZeros(w)
+		return int(i) + countTrailingZeros(w)
 	}
 	x++
-	for ; x < len(bc.bitmap); x++ {
+	for ; x < length; x++ {
 		if bc.bitmap[x] != 0 {
-			return (x * 64) + countTrailingZeros(bc.bitmap[x])
+			return int(x*64) + countTrailingZeros(bc.bitmap[x])
 		}
 	}
 	return -1
@@ -1118,34 +1124,60 @@ func (bc *bitmapContainer) containerType() contype {
 	return bitmapContype
 }
 
-func (bc *bitmapContainer) addOffset(x uint16) []container {
+func (bc *bitmapContainer) addOffset(x uint16) (container, container) {
-	low := newBitmapContainer()
+	var low, high *bitmapContainer
-	high := newBitmapContainer()
+
+	if bc.cardinality == 0 {
+		return nil, nil
+	}
+
 	b := uint32(x) >> 6
 	i := uint32(x) % 64
 	end := uint32(1024) - b
+
+	low = newBitmapContainer()
 	if i == 0 {
 		copy(low.bitmap[b:], bc.bitmap[:end])
-		copy(high.bitmap[:b], bc.bitmap[end:])
 	} else {
 		low.bitmap[b] = bc.bitmap[0] << i
 		for k := uint32(1); k < end; k++ {
 			newval := bc.bitmap[k] << i
-			if newval == 0 {
+			newval |= bc.bitmap[k-1] >> (64 - i)
-				newval = bc.bitmap[k-1] >> (64 - i)
-			}
 			low.bitmap[b+k] = newval
 		}
+	}
+	low.computeCardinality()
+
+	if low.cardinality == bc.cardinality {
+		// All elements from bc ended up in low, meaning high will be empty.
+		return low, nil
+	}
+
+	if low.cardinality == 0 {
+		// low is empty, let's reuse the container for high.
+		high = low
+		low = nil
+	} else {
+		// None of the containers will be empty, so allocate both.
+		high = newBitmapContainer()
+	}
+
+	if i == 0 {
+		copy(high.bitmap[:b], bc.bitmap[end:])
+	} else {
 		for k := end; k < 1024; k++ {
 			newval := bc.bitmap[k] << i
-			if newval == 0 {
+			newval |= bc.bitmap[k-1] >> (64 - i)
-				newval = bc.bitmap[k-1] >> (64 - i)
-			}
 			high.bitmap[k-end] = newval
 		}
 		high.bitmap[b] = bc.bitmap[1023] >> (64 - i)
 	}
-	low.computeCardinality()
 	high.computeCardinality()
-	return []container{low, high}
+
+	// Ensure proper nil interface.
+	if low == nil {
+		return nil, high
+	}
+
+	return low, high
 }

vendor/github.com/RoaringBitmap/roaring/bitmapcontainer_gen.go

@@ -1,415 +0,0 @@
-package roaring
-
-// NOTE: THIS FILE WAS PRODUCED BY THE
-// MSGP CODE GENERATION TOOL (github.com/tinylib/msgp)
-// DO NOT EDIT
-
-import "github.com/tinylib/msgp/msgp"
-
-// Deprecated: DecodeMsg implements msgp.Decodable
-func (z *bitmapContainer) DecodeMsg(dc *msgp.Reader) (err error) {
-	var field []byte
-	_ = field
-	var zbzg uint32
-	zbzg, err = dc.ReadMapHeader()
-	if err != nil {
-		return
-	}
-	for zbzg > 0 {
-		zbzg--
-		field, err = dc.ReadMapKeyPtr()
-		if err != nil {
-			return
-		}
-		switch msgp.UnsafeString(field) {
-		case "cardinality":
-			z.cardinality, err = dc.ReadInt()
-			if err != nil {
-				return
-			}
-		case "bitmap":
-			var zbai uint32
-			zbai, err = dc.ReadArrayHeader()
-			if err != nil {
-				return
-			}
-			if cap(z.bitmap) >= int(zbai) {
-				z.bitmap = (z.bitmap)[:zbai]
-			} else {
-				z.bitmap = make([]uint64, zbai)
-			}
-			for zxvk := range z.bitmap {
-				z.bitmap[zxvk], err = dc.ReadUint64()
-				if err != nil {
-					return
-				}
-			}
-		default:
-			err = dc.Skip()
-			if err != nil {
-				return
-			}
-		}
-	}
-	return
-}
-
-// Deprecated: EncodeMsg implements msgp.Encodable
-func (z *bitmapContainer) EncodeMsg(en *msgp.Writer) (err error) {
-	// map header, size 2
-	// write "cardinality"
-	err = en.Append(0x82, 0xab, 0x63, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x74, 0x79)
-	if err != nil {
-		return err
-	}
-	err = en.WriteInt(z.cardinality)
-	if err != nil {
-		return
-	}
-	// write "bitmap"
-	err = en.Append(0xa6, 0x62, 0x69, 0x74, 0x6d, 0x61, 0x70)
-	if err != nil {
-		return err
-	}
-	err = en.WriteArrayHeader(uint32(len(z.bitmap)))
-	if err != nil {
-		return
-	}
-	for zxvk := range z.bitmap {
-		err = en.WriteUint64(z.bitmap[zxvk])
-		if err != nil {
-			return
-		}
-	}
-	return
-}
-
-// Deprecated: MarshalMsg implements msgp.Marshaler
-func (z *bitmapContainer) MarshalMsg(b []byte) (o []byte, err error) {
-	o = msgp.Require(b, z.Msgsize())
-	// map header, size 2
-	// string "cardinality"
-	o = append(o, 0x82, 0xab, 0x63, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x74, 0x79)
-	o = msgp.AppendInt(o, z.cardinality)
-	// string "bitmap"
-	o = append(o, 0xa6, 0x62, 0x69, 0x74, 0x6d, 0x61, 0x70)
-	o = msgp.AppendArrayHeader(o, uint32(len(z.bitmap)))
-	for zxvk := range z.bitmap {
-		o = msgp.AppendUint64(o, z.bitmap[zxvk])
-	}
-	return
-}
-
-// Deprecated: UnmarshalMsg implements msgp.Unmarshaler
-func (z *bitmapContainer) UnmarshalMsg(bts []byte) (o []byte, err error) {
-	var field []byte
-	_ = field
-	var zcmr uint32
-	zcmr, bts, err = msgp.ReadMapHeaderBytes(bts)
-	if err != nil {
-		return
-	}
-	for zcmr > 0 {
-		zcmr--
-		field, bts, err = msgp.ReadMapKeyZC(bts)
-		if err != nil {
-			return
-		}
-		switch msgp.UnsafeString(field) {
-		case "cardinality":
-			z.cardinality, bts, err = msgp.ReadIntBytes(bts)
-			if err != nil {
-				return
-			}
-		case "bitmap":
-			var zajw uint32
-			zajw, bts, err = msgp.ReadArrayHeaderBytes(bts)
-			if err != nil {
-				return
-			}
-			if cap(z.bitmap) >= int(zajw) {
-				z.bitmap = (z.bitmap)[:zajw]
-			} else {
-				z.bitmap = make([]uint64, zajw)
-			}
-			for zxvk := range z.bitmap {
-				z.bitmap[zxvk], bts, err = msgp.ReadUint64Bytes(bts)
-				if err != nil {
-					return
-				}
-			}
-		default:
-			bts, err = msgp.Skip(bts)
-			if err != nil {
-				return
-			}
-		}
-	}
-	o = bts
-	return
-}
-
-// Deprecated: Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
-func (z *bitmapContainer) Msgsize() (s int) {
-	s = 1 + 12 + msgp.IntSize + 7 + msgp.ArrayHeaderSize + (len(z.bitmap) * (msgp.Uint64Size))
-	return
-}
-
-// Deprecated: DecodeMsg implements msgp.Decodable
-func (z *bitmapContainerShortIterator) DecodeMsg(dc *msgp.Reader) (err error) {
-	var field []byte
-	_ = field
-	var zhct uint32
-	zhct, err = dc.ReadMapHeader()
-	if err != nil {
-		return
-	}
-	for zhct > 0 {
-		zhct--
-		field, err = dc.ReadMapKeyPtr()
-		if err != nil {
-			return
-		}
-		switch msgp.UnsafeString(field) {
-		case "ptr":
-			if dc.IsNil() {
-				err = dc.ReadNil()
-				if err != nil {
-					return
-				}
-				z.ptr = nil
-			} else {
-				if z.ptr == nil {
-					z.ptr = new(bitmapContainer)
-				}
-				var zcua uint32
-				zcua, err = dc.ReadMapHeader()
-				if err != nil {
-					return
-				}
-				for zcua > 0 {
-					zcua--
-					field, err = dc.ReadMapKeyPtr()
-					if err != nil {
-						return
-					}
-					switch msgp.UnsafeString(field) {
-					case "cardinality":
-						z.ptr.cardinality, err = dc.ReadInt()
-						if err != nil {
-							return
-						}
-					case "bitmap":
-						var zxhx uint32
-						zxhx, err = dc.ReadArrayHeader()
-						if err != nil {
-							return
-						}
-						if cap(z.ptr.bitmap) >= int(zxhx) {
-							z.ptr.bitmap = (z.ptr.bitmap)[:zxhx]
-						} else {
-							z.ptr.bitmap = make([]uint64, zxhx)
-						}
-						for zwht := range z.ptr.bitmap {
-							z.ptr.bitmap[zwht], err = dc.ReadUint64()
-							if err != nil {
-								return
-							}
-						}
-					default:
-						err = dc.Skip()
-						if err != nil {
-							return
-						}
-					}
-				}
-			}
-		case "i":
-			z.i, err = dc.ReadInt()
-			if err != nil {
-				return
-			}
-		default:
-			err = dc.Skip()
-			if err != nil {
-				return
-			}
-		}
-	}
-	return
-}
-
-// Deprecated: EncodeMsg implements msgp.Encodable
-func (z *bitmapContainerShortIterator) EncodeMsg(en *msgp.Writer) (err error) {
-	// map header, size 2
-	// write "ptr"
-	err = en.Append(0x82, 0xa3, 0x70, 0x74, 0x72)
-	if err != nil {
-		return err
-	}
-	if z.ptr == nil {
-		err = en.WriteNil()
-		if err != nil {
-			return
-		}
-	} else {
-		// map header, size 2
-		// write "cardinality"
-		err = en.Append(0x82, 0xab, 0x63, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x74, 0x79)
-		if err != nil {
-			return err
-		}
-		err = en.WriteInt(z.ptr.cardinality)
-		if err != nil {
-			return
-		}
-		// write "bitmap"
-		err = en.Append(0xa6, 0x62, 0x69, 0x74, 0x6d, 0x61, 0x70)
-		if err != nil {
-			return err
-		}
-		err = en.WriteArrayHeader(uint32(len(z.ptr.bitmap)))
-		if err != nil {
-			return
-		}
-		for zwht := range z.ptr.bitmap {
-			err = en.WriteUint64(z.ptr.bitmap[zwht])
-			if err != nil {
-				return
-			}
-		}
-	}
-	// write "i"
-	err = en.Append(0xa1, 0x69)
-	if err != nil {
-		return err
-	}
-	err = en.WriteInt(z.i)
-	if err != nil {
-		return
-	}
-	return
-}
-
-// Deprecated: MarshalMsg implements msgp.Marshaler
-func (z *bitmapContainerShortIterator) MarshalMsg(b []byte) (o []byte, err error) {
-	o = msgp.Require(b, z.Msgsize())
-	// map header, size 2
-	// string "ptr"
-	o = append(o, 0x82, 0xa3, 0x70, 0x74, 0x72)
-	if z.ptr == nil {
-		o = msgp.AppendNil(o)
-	} else {
-		// map header, size 2
-		// string "cardinality"
-		o = append(o, 0x82, 0xab, 0x63, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x74, 0x79)
-		o = msgp.AppendInt(o, z.ptr.cardinality)
-		// string "bitmap"
-		o = append(o, 0xa6, 0x62, 0x69, 0x74, 0x6d, 0x61, 0x70)
-		o = msgp.AppendArrayHeader(o, uint32(len(z.ptr.bitmap)))
-		for zwht := range z.ptr.bitmap {
-			o = msgp.AppendUint64(o, z.ptr.bitmap[zwht])
-		}
-	}
-	// string "i"
-	o = append(o, 0xa1, 0x69)
-	o = msgp.AppendInt(o, z.i)
-	return
-}
-
-// Deprecated: UnmarshalMsg implements msgp.Unmarshaler
-func (z *bitmapContainerShortIterator) UnmarshalMsg(bts []byte) (o []byte, err error) {
-	var field []byte
-	_ = field
-	var zlqf uint32
-	zlqf, bts, err = msgp.ReadMapHeaderBytes(bts)
-	if err != nil {
-		return
-	}
-	for zlqf > 0 {
-		zlqf--
-		field, bts, err = msgp.ReadMapKeyZC(bts)
-		if err != nil {
-			return
-		}
-		switch msgp.UnsafeString(field) {
-		case "ptr":
-			if msgp.IsNil(bts) {
-				bts, err = msgp.ReadNilBytes(bts)
-				if err != nil {
-					return
-				}
-				z.ptr = nil
-			} else {
-				if z.ptr == nil {
-					z.ptr = new(bitmapContainer)
-				}
-				var zdaf uint32
-				zdaf, bts, err = msgp.ReadMapHeaderBytes(bts)
-				if err != nil {
-					return
-				}
-				for zdaf > 0 {
-					zdaf--
-					field, bts, err = msgp.ReadMapKeyZC(bts)
-					if err != nil {
-						return
-					}
-					switch msgp.UnsafeString(field) {
-					case "cardinality":
-						z.ptr.cardinality, bts, err = msgp.ReadIntBytes(bts)
-						if err != nil {
-							return
-						}
-					case "bitmap":
-						var zpks uint32
-						zpks, bts, err = msgp.ReadArrayHeaderBytes(bts)
-						if err != nil {
-							return
-						}
-						if cap(z.ptr.bitmap) >= int(zpks) {
-							z.ptr.bitmap = (z.ptr.bitmap)[:zpks]
-						} else {
-							z.ptr.bitmap = make([]uint64, zpks)
-						}
-						for zwht := range z.ptr.bitmap {
-							z.ptr.bitmap[zwht], bts, err = msgp.ReadUint64Bytes(bts)
-							if err != nil {
-								return
-							}
-						}
-					default:
-						bts, err = msgp.Skip(bts)
-						if err != nil {
-							return
-						}
-					}
-				}
-			}
-		case "i":
-			z.i, bts, err = msgp.ReadIntBytes(bts)
-			if err != nil {
-				return
-			}
-		default:
-			bts, err = msgp.Skip(bts)
-			if err != nil {
-				return
-			}
-		}
-	}
-	o = bts
-	return
-}
-
-// Deprecated: Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
-func (z *bitmapContainerShortIterator) Msgsize() (s int) {
-	s = 1 + 4
-	if z.ptr == nil {
-		s += msgp.NilSize
-	} else {
-		s += 1 + 12 + msgp.IntSize + 7 + msgp.ArrayHeaderSize + (len(z.ptr.bitmap) * (msgp.Uint64Size))
-	}
-	s += 2 + msgp.IntSize
-	return
-}

vendor/github.com/RoaringBitmap/roaring/byte_input.go

@@ -1,161 +0,0 @@
-package roaring
-
-import (
-	"encoding/binary"
-	"io"
-)
-
-type byteInput interface {
-	// next returns a slice containing the next n bytes from the buffer,
-	// advancing the buffer as if the bytes had been returned by Read.
-	next(n int) ([]byte, error)
-	// readUInt32 reads uint32 with LittleEndian order
-	readUInt32() (uint32, error)
-	// readUInt16 reads uint16 with LittleEndian order
-	readUInt16() (uint16, error)
-	// getReadBytes returns read bytes
-	getReadBytes() int64
-	// skipBytes skips exactly n bytes
-	skipBytes(n int) error
-}
-
-func newByteInputFromReader(reader io.Reader) byteInput {
-	return &byteInputAdapter{
-		r:         reader,
-		readBytes: 0,
-	}
-}
-
-func newByteInput(buf []byte) byteInput {
-	return &byteBuffer{
-		buf: buf,
-		off: 0,
-	}
-}
-
-type byteBuffer struct {
-	buf []byte
-	off int
-}
-
-// next returns a slice containing the next n bytes from the reader
-// If there are fewer bytes than the given n, io.ErrUnexpectedEOF will be returned
-func (b *byteBuffer) next(n int) ([]byte, error) {
-	m := len(b.buf) - b.off
-
-	if n > m {
-		return nil, io.ErrUnexpectedEOF
-	}
-
-	data := b.buf[b.off : b.off+n]
-	b.off += n
-
-	return data, nil
-}
-
-// readUInt32 reads uint32 with LittleEndian order
-func (b *byteBuffer) readUInt32() (uint32, error) {
-	if len(b.buf)-b.off < 4 {
-		return 0, io.ErrUnexpectedEOF
-	}
-
-	v := binary.LittleEndian.Uint32(b.buf[b.off:])
-	b.off += 4
-
-	return v, nil
-}
-
-// readUInt16 reads uint16 with LittleEndian order
-func (b *byteBuffer) readUInt16() (uint16, error) {
-	if len(b.buf)-b.off < 2 {
-		return 0, io.ErrUnexpectedEOF
-	}
-
-	v := binary.LittleEndian.Uint16(b.buf[b.off:])
-	b.off += 2
-
-	return v, nil
-}
-
-// getReadBytes returns read bytes
-func (b *byteBuffer) getReadBytes() int64 {
-	return int64(b.off)
-}
-
-// skipBytes skips exactly n bytes
-func (b *byteBuffer) skipBytes(n int) error {
-	m := len(b.buf) - b.off
-
-	if n > m {
-		return io.ErrUnexpectedEOF
-	}
-
-	b.off += n
-
-	return nil
-}
-
-// reset resets the given buffer with a new byte slice
-func (b *byteBuffer) reset(buf []byte) {
-	b.buf = buf
-	b.off = 0
-}
-
-type byteInputAdapter struct {
-	r         io.Reader
-	readBytes int
-}
-
-// next returns a slice containing the next n bytes from the buffer,
-// advancing the buffer as if the bytes had been returned by Read.
-func (b *byteInputAdapter) next(n int) ([]byte, error) {
-	buf := make([]byte, n)
-	m, err := io.ReadAtLeast(b.r, buf, n)
-	b.readBytes += m
-
-	if err != nil {
-		return nil, err
-	}
-
-	return buf, nil
-}
-
-// readUInt32 reads uint32 with LittleEndian order
-func (b *byteInputAdapter) readUInt32() (uint32, error) {
-	buf, err := b.next(4)
-
-	if err != nil {
-		return 0, err
-	}
-
-	return binary.LittleEndian.Uint32(buf), nil
-}
-
-// readUInt16 reads uint16 with LittleEndian order
-func (b *byteInputAdapter) readUInt16() (uint16, error) {
-	buf, err := b.next(2)
-
-	if err != nil {
-		return 0, err
-	}
-
-	return binary.LittleEndian.Uint16(buf), nil
-}
-
-// getReadBytes returns read bytes
-func (b *byteInputAdapter) getReadBytes() int64 {
-	return int64(b.readBytes)
-}
-
-// skipBytes skips exactly n bytes
-func (b *byteInputAdapter) skipBytes(n int) error {
-	_, err := b.next(n)
-
-	return err
-}
-
-// reset resets the given buffer with a new stream
-func (b *byteInputAdapter) reset(stream io.Reader) {
-	b.r = stream
-	b.readBytes = 0
-}

vendor/github.com/RoaringBitmap/roaring/clz.go

@@ -1,4 +1,6 @@
+//go:build go1.9
 // +build go1.9
+
 // "go1.9", from Go version 1.9 onward
 // See https://golang.org/pkg/go/build/#hdr-Build_Constraints
 

vendor/github.com/RoaringBitmap/roaring/clz_compat.go

@@ -1,3 +1,4 @@
+//go:build !go1.9
 // +build !go1.9
 
 package roaring

vendor/github.com/RoaringBitmap/roaring/ctz.go

@@ -1,4 +1,6 @@
+//go:build go1.9
 // +build go1.9
+
 // "go1.9", from Go version 1.9 onward
 // See https://golang.org/pkg/go/build/#hdr-Build_Constraints
 

vendor/github.com/RoaringBitmap/roaring/ctz_compat.go

@@ -1,3 +1,4 @@
+//go:build !go1.9
 // +build !go1.9
 
 package roaring

vendor/github.com/RoaringBitmap/roaring/fastaggregation.go

@@ -33,15 +33,6 @@ main:
 				s2 = x2.highlowcontainer.getKeyAtIndex(pos2)
 			} else {
 				c1 := x1.highlowcontainer.getContainerAtIndex(pos1)
-				switch t := c1.(type) {
-				case *arrayContainer:
-					c1 = t.toBitmapContainer()
-				case *runContainer16:
-					if !t.isFull() {
-						c1 = t.toBitmapContainer()
-					}
-				}
-
 				answer.highlowcontainer.appendContainer(s1, c1.lazyOR(x2.highlowcontainer.getContainerAtIndex(pos2)), false)
 				pos1++
 				pos2++
@@ -89,18 +80,7 @@ main:
 				}
 				s2 = x2.highlowcontainer.getKeyAtIndex(pos2)
 			} else {
-				c1 := x1.highlowcontainer.getContainerAtIndex(pos1)
+				c1 := x1.highlowcontainer.getWritableContainerAtIndex(pos1)
-				switch t := c1.(type) {
-				case *arrayContainer:
-					c1 = t.toBitmapContainer()
-				case *runContainer16:
-					if !t.isFull() {
-						c1 = t.toBitmapContainer()
-					}
-				case *bitmapContainer:
-					c1 = x1.highlowcontainer.getWritableContainerAtIndex(pos1)
-				}
-
 				x1.highlowcontainer.containers[pos1] = c1.lazyIOR(x2.highlowcontainer.getContainerAtIndex(pos2))
 				x1.highlowcontainer.needCopyOnWrite[pos1] = false
 				pos1++
@@ -301,9 +281,6 @@ func (x1 *Bitmap) AndAny(bitmaps ...*Bitmap) {
 					tmpBitmap = newBitmapContainer()
 				}
 				tmpBitmap.resetTo(keyContainers[0])
-				for _, c := range keyContainers[1:] {
-					tmpBitmap.ior(c)
-				}
 				ored = tmpBitmap
 			} else {
 				if tmpArray == nil {
@@ -311,15 +288,15 @@ func (x1 *Bitmap) AndAny(bitmaps ...*Bitmap) {
 				}
 				tmpArray.realloc(maxPossibleOr)
 				tmpArray.resetTo(keyContainers[0])
-				for _, c := range keyContainers[1:] {
-					tmpArray.ior(c)
-				}
 				ored = tmpArray
 			}
+			for _, c := range keyContainers[1:] {
+				ored = ored.ior(c)
+			}
 		}
 
 		result := x1.highlowcontainer.getWritableContainerAtIndex(basePos).iand(ored)
-		if result.getCardinality() > 0 {
+		if !result.isEmpty() {
 			x1.highlowcontainer.replaceKeyAndContainerAtIndex(intersections, baseKey, result, false)
 			intersections++
 		}

vendor/github.com/RoaringBitmap/roaring/internal/byte_input.go

@@ -0,0 +1,166 @@
+package internal
+
+import (
+	"encoding/binary"
+	"io"
+)
+
+// ByteInput typed interface around io.Reader or raw bytes
+type ByteInput interface {
+	// Next returns a slice containing the next n bytes from the buffer,
+	// advancing the buffer as if the bytes had been returned by Read.
+	Next(n int) ([]byte, error)
+	// ReadUInt32 reads uint32 with LittleEndian order
+	ReadUInt32() (uint32, error)
+	// ReadUInt16 reads uint16 with LittleEndian order
+	ReadUInt16() (uint16, error)
+	// GetReadBytes returns read bytes
+	GetReadBytes() int64
+	// SkipBytes skips exactly n bytes
+	SkipBytes(n int) error
+}
+
+// NewByteInputFromReader creates reader wrapper
+func NewByteInputFromReader(reader io.Reader) ByteInput {
+	return &ByteInputAdapter{
+		r:         reader,
+		readBytes: 0,
+	}
+}
+
+// NewByteInput creates raw bytes wrapper
+func NewByteInput(buf []byte) ByteInput {
+	return &ByteBuffer{
+		buf: buf,
+		off: 0,
+	}
+}
+
+// ByteBuffer raw bytes wrapper
+type ByteBuffer struct {
+	buf []byte
+	off int
+}
+
+// Next returns a slice containing the next n bytes from the reader
+// If there are fewer bytes than the given n, io.ErrUnexpectedEOF will be returned
+func (b *ByteBuffer) Next(n int) ([]byte, error) {
+	m := len(b.buf) - b.off
+
+	if n > m {
+		return nil, io.ErrUnexpectedEOF
+	}
+
+	data := b.buf[b.off : b.off+n]
+	b.off += n
+
+	return data, nil
+}
+
+// ReadUInt32 reads uint32 with LittleEndian order
+func (b *ByteBuffer) ReadUInt32() (uint32, error) {
+	if len(b.buf)-b.off < 4 {
+		return 0, io.ErrUnexpectedEOF
+	}
+
+	v := binary.LittleEndian.Uint32(b.buf[b.off:])
+	b.off += 4
+
+	return v, nil
+}
+
+// ReadUInt16 reads uint16 with LittleEndian order
+func (b *ByteBuffer) ReadUInt16() (uint16, error) {
+	if len(b.buf)-b.off < 2 {
+		return 0, io.ErrUnexpectedEOF
+	}
+
+	v := binary.LittleEndian.Uint16(b.buf[b.off:])
+	b.off += 2
+
+	return v, nil
+}
+
+// GetReadBytes returns read bytes
+func (b *ByteBuffer) GetReadBytes() int64 {
+	return int64(b.off)
+}
+
+// SkipBytes skips exactly n bytes
+func (b *ByteBuffer) SkipBytes(n int) error {
+	m := len(b.buf) - b.off
+
+	if n > m {
+		return io.ErrUnexpectedEOF
+	}
+
+	b.off += n
+
+	return nil
+}
+
+// Reset resets the given buffer with a new byte slice
+func (b *ByteBuffer) Reset(buf []byte) {
+	b.buf = buf
+	b.off = 0
+}
+
+// ByteInputAdapter reader wrapper
+type ByteInputAdapter struct {
+	r         io.Reader
+	readBytes int
+}
+
+// Next returns a slice containing the next n bytes from the buffer,
+// advancing the buffer as if the bytes had been returned by Read.
+func (b *ByteInputAdapter) Next(n int) ([]byte, error) {
+	buf := make([]byte, n)
+	m, err := io.ReadAtLeast(b.r, buf, n)
+	b.readBytes += m
+
+	if err != nil {
+		return nil, err
+	}
+
+	return buf, nil
+}
+
+// ReadUInt32 reads uint32 with LittleEndian order
+func (b *ByteInputAdapter) ReadUInt32() (uint32, error) {
+	buf, err := b.Next(4)
+
+	if err != nil {
+		return 0, err
+	}
+
+	return binary.LittleEndian.Uint32(buf), nil
+}
+
+// ReadUInt16 reads uint16 with LittleEndian order
+func (b *ByteInputAdapter) ReadUInt16() (uint16, error) {
+	buf, err := b.Next(2)
+
+	if err != nil {
+		return 0, err
+	}
+
+	return binary.LittleEndian.Uint16(buf), nil
+}
+
+// GetReadBytes returns read bytes
+func (b *ByteInputAdapter) GetReadBytes() int64 {
+	return int64(b.readBytes)
+}
+
+// SkipBytes skips exactly n bytes
+func (b *ByteInputAdapter) SkipBytes(n int) error {
+	_, err := b.Next(n)
+
+	return err
+}
+
+// Reset resets the given buffer with a new stream
+func (b *ByteInputAdapter) Reset(stream io.Reader) {
+	b.r = stream
+	b.readBytes = 0
+}

vendor/github.com/RoaringBitmap/roaring/internal/pools.go

@@ -0,0 +1,21 @@
+package internal
+
+import (
+	"sync"
+)
+
+var (
+	// ByteInputAdapterPool shared pool
+	ByteInputAdapterPool = sync.Pool{
+		New: func() interface{} {
+			return &ByteInputAdapter{}
+		},
+	}
+
+	// ByteBufferPool shared pool
+	ByteBufferPool = sync.Pool{
+		New: func() interface{} {
+			return &ByteBuffer{}
+		},
+	}
+)

vendor/github.com/RoaringBitmap/roaring/parallel.go

@@ -166,7 +166,6 @@ func appenderRoutine(bitmapChan chan<- *Bitmap, resultChan <-chan keyedContainer
 			make([]container, 0, expectedKeys),
 			make([]bool, 0, expectedKeys),
 			false,
-			nil,
 		},
 	}
 	for i := range keys {
@@ -286,14 +285,14 @@ func ParAnd(parallelism int, bitmaps ...*Bitmap) *Bitmap {
 		for input := range inputChan {
 			c := input.containers[0].and(input.containers[1])
 			for _, next := range input.containers[2:] {
-				if c.getCardinality() == 0 {
+				if c.isEmpty() {
 					break
 				}
 				c = c.iand(next)
 			}
 
 			// Send a nil explicitly if the result of the intersection is an empty container
-			if c.getCardinality() == 0 {
+			if c.isEmpty() {
 				c = nil
 			}
 
@@ -355,10 +354,10 @@ func ParOr(parallelism int, bitmaps ...*Bitmap) *Bitmap {
 	if lKey == MaxUint16 && hKey == 0 {
 		return New()
 	} else if len(bitmaps) == 1 {
-		return bitmaps[0]
+		return bitmaps[0].Clone()
 	}
 
-	keyRange := hKey - lKey + 1
+	keyRange := int(hKey) - int(lKey) + 1
 	if keyRange == 1 {
 		// revert to FastOr. Since the key range is 0
 		// no container-level aggregation parallelism is achievable

vendor/github.com/RoaringBitmap/roaring/popcnt.go

@@ -1,4 +1,6 @@
+//go:build go1.9
 // +build go1.9
+
 // "go1.9", from Go version 1.9 onward
 // See https://golang.org/pkg/go/build/#hdr-Build_Constraints
 

vendor/github.com/RoaringBitmap/roaring/popcnt_asm.go

@@ -1,3 +1,4 @@
+//go:build amd64 && !appengine && !go1.9
 // +build amd64,!appengine,!go1.9
 
 package roaring

vendor/github.com/RoaringBitmap/roaring/popcnt_compat.go

@@ -1,3 +1,4 @@
+//go:build !go1.9
 // +build !go1.9
 
 package roaring

vendor/github.com/RoaringBitmap/roaring/popcnt_generic.go

@@ -1,3 +1,4 @@
+//go:build !amd64 || appengine || go1.9
 // +build !amd64 appengine go1.9
 
 package roaring

vendor/github.com/RoaringBitmap/roaring/roaring.go

@@ -11,7 +11,8 @@ import (
 	"fmt"
 	"io"
 	"strconv"
-	"sync"
+
+	"github.com/RoaringBitmap/roaring/internal"
 )
 
 // Bitmap represents a compressed bitmap where you can add integers.
@@ -52,27 +53,72 @@ func (rb *Bitmap) ToBytes() ([]byte, error) {
 	return rb.highlowcontainer.toBytes()
 }
 
-// Deprecated: WriteToMsgpack writes a msgpack2/snappy-streaming compressed serialized
+// Checksum computes a hash (currently FNV-1a) for a bitmap that is suitable for
-// version of this bitmap to stream. The format is not
+// using bitmaps as elements in hash sets or as keys in hash maps, as well as
-// compatible with the WriteTo() format, and is
+// generally quicker comparisons.
-// experimental: it may produce smaller on disk
+// The implementation is biased towards efficiency in little endian machines, so
-// footprint and/or be faster to read, depending
+// expect some extra CPU cycles and memory to be used if your machine is big endian.
-// on your content. Currently only the Go roaring
+// Likewise, don't use this to verify integrity unless you're certain you'll load
-// implementation supports this format.
+// the bitmap on a machine with the same endianess used to create it.
-func (rb *Bitmap) WriteToMsgpack(stream io.Writer) (int64, error) {
+func (rb *Bitmap) Checksum() uint64 {
-	return 0, rb.highlowcontainer.writeToMsgpack(stream)
+	const (
+		offset = 14695981039346656037
+		prime = 1099511628211
+	)
+
+	var bytes []byte
+
+	hash := uint64(offset)
+
+	bytes = uint16SliceAsByteSlice(rb.highlowcontainer.keys)
+
+	for _, b := range bytes {
+		hash ^= uint64(b)
+		hash *= prime
+	}
+
+	for _, c := range rb.highlowcontainer.containers {
+		// 0 separator
+		hash ^= 0
+		hash *= prime
+
+		switch c := c.(type) {
+		case *bitmapContainer:
+			bytes = uint64SliceAsByteSlice(c.bitmap)
+		case *arrayContainer:
+			bytes = uint16SliceAsByteSlice(c.content)
+		case *runContainer16:
+			bytes = interval16SliceAsByteSlice(c.iv)
+		default:
+			panic("invalid container type")
+		}
+
+		if len(bytes) == 0 {
+			panic("empty containers are not supported")
+		}
+
+		for _, b := range bytes {
+			hash ^= uint64(b)
+			hash *= prime
+		}
+	}
+
+	return hash
 }
 
 // ReadFrom reads a serialized version of this bitmap from stream.
 // The format is compatible with other RoaringBitmap
 // implementations (Java, C) and is documented here:
 // https://github.com/RoaringBitmap/RoaringFormatSpec
-func (rb *Bitmap) ReadFrom(reader io.Reader) (p int64, err error) {
+// Since io.Reader is regarded as a stream and cannot be read twice.
-	stream := byteInputAdapterPool.Get().(*byteInputAdapter)
+// So add cookieHeader to accept the 4-byte data that has been read in roaring64.ReadFrom.
-	stream.reset(reader)
+// It is not necessary to pass cookieHeader when call roaring.ReadFrom to read the roaring32 data directly.
+func (rb *Bitmap) ReadFrom(reader io.Reader, cookieHeader ...byte) (p int64, err error) {
+	stream := internal.ByteInputAdapterPool.Get().(*internal.ByteInputAdapter)
+	stream.Reset(reader)
 
-	p, err = rb.highlowcontainer.readFrom(stream)
+	p, err = rb.highlowcontainer.readFrom(stream, cookieHeader...)
-	byteInputAdapterPool.Put(stream)
+	internal.ByteInputAdapterPool.Put(stream)
 
 	return
 }
@@ -100,29 +146,15 @@ func (rb *Bitmap) ReadFrom(reader io.Reader) (p int64, err error) {
 // call CloneCopyOnWriteContainers on all such bitmaps.
 //
 func (rb *Bitmap) FromBuffer(buf []byte) (p int64, err error) {
-	stream := byteBufferPool.Get().(*byteBuffer)
+	stream := internal.ByteBufferPool.Get().(*internal.ByteBuffer)
-	stream.reset(buf)
+	stream.Reset(buf)
 
 	p, err = rb.highlowcontainer.readFrom(stream)
-	byteBufferPool.Put(stream)
+	internal.ByteBufferPool.Put(stream)
 
 	return
 }
 
-var (
-	byteBufferPool = sync.Pool{
-		New: func() interface{} {
-			return &byteBuffer{}
-		},
-	}
-
-	byteInputAdapterPool = sync.Pool{
-		New: func() interface{} {
-			return &byteInputAdapter{}
-		},
-	}
-)
-
 // RunOptimize attempts to further compress the runs of consecutive values found in the bitmap
 func (rb *Bitmap) RunOptimize() {
 	rb.highlowcontainer.runOptimize()
@@ -133,14 +165,6 @@ func (rb *Bitmap) HasRunCompression() bool {
 	return rb.highlowcontainer.hasRunCompression()
 }
 
-// Deprecated: ReadFromMsgpack reads a msgpack2/snappy-streaming serialized
-// version of this bitmap from stream. The format is
-// expected is that written by the WriteToMsgpack()
-// call; see additional notes there.
-func (rb *Bitmap) ReadFromMsgpack(stream io.Reader) (int64, error) {
-	return 0, rb.highlowcontainer.readFromMsgpack(stream)
-}
-
 // MarshalBinary implements the encoding.BinaryMarshaler interface for the bitmap
 // (same as ToBytes)
 func (rb *Bitmap) MarshalBinary() ([]byte, error) {
@@ -180,8 +204,7 @@ func (rb *Bitmap) ToArray() []uint32 {
 		hs := uint32(rb.highlowcontainer.getKeyAtIndex(pos)) << 16
 		c := rb.highlowcontainer.getContainerAtIndex(pos)
 		pos++
-		c.fillLeastSignificant16bits(array, pos2, hs)
+		pos2 = c.fillLeastSignificant16bits(array, pos2, hs)
-		pos2 += c.getCardinality()
 	}
 	return array
 }
@@ -248,6 +271,14 @@ type intIterator struct {
 	hs               uint32
 	iter             shortPeekable
 	highlowcontainer *roaringArray
+
+	// These embedded iterators per container type help reduce load in the GC.
+	// This way, instead of making up-to 64k allocations per full iteration
+	// we get a single allocation and simply reinitialize the appropriate
+	// iterator and point to it in the generic `iter` member on each key bound.
+	shortIter        shortIterator
+	runIter          runIterator16
+	bitmapIter       bitmapContainerShortIterator
 }
 
 // HasNext returns true if there are more integers to iterate over
@@ -257,8 +288,19 @@ func (ii *intIterator) HasNext() bool {
 
 func (ii *intIterator) init() {
 	if ii.highlowcontainer.size() > ii.pos {
-		ii.iter = ii.highlowcontainer.getContainerAtIndex(ii.pos).getShortIterator()
 		ii.hs = uint32(ii.highlowcontainer.getKeyAtIndex(ii.pos)) << 16
+		c := ii.highlowcontainer.getContainerAtIndex(ii.pos)
+		switch t := c.(type) {
+		case *arrayContainer:
+			ii.shortIter = shortIterator{t.content, 0}
+			ii.iter = &ii.shortIter
+		case *runContainer16:
+			ii.runIter = runIterator16{rc: t, curIndex: 0, curPosInIndex: 0}
+			ii.iter = &ii.runIter
+		case *bitmapContainer:
+			ii.bitmapIter = bitmapContainerShortIterator{t, t.NextSetBit(0)}
+			ii.iter = &ii.bitmapIter
+		}
 	}
 }
 
@@ -279,14 +321,14 @@ func (ii *intIterator) PeekNext() uint32 {
 
 // AdvanceIfNeeded advances as long as the next value is smaller than minval
 func (ii *intIterator) AdvanceIfNeeded(minval uint32) {
-	to := minval >> 16
+	to := minval & 0xffff0000
 
-	for ii.HasNext() && (ii.hs>>16) < to {
+	for ii.HasNext() && ii.hs < to {
 		ii.pos++
 		ii.init()
 	}
 
-	if ii.HasNext() && (ii.hs>>16) == to {
+	if ii.HasNext() && ii.hs == to {
 		ii.iter.advanceIfNeeded(lowbits(minval))
 
 		if !ii.iter.hasNext() {
@@ -296,12 +338,17 @@ func (ii *intIterator) AdvanceIfNeeded(minval uint32) {
 	}
 }
 
-func newIntIterator(a *Bitmap) *intIterator {
+// IntIterator is meant to allow you to iterate through the values of a bitmap, see Initialize(a *Bitmap)
-	p := new(intIterator)
+type IntIterator = intIterator
+
+
+// Initialize configures the existing iterator so that it can iterate through the values of
+// the provided bitmap.
+// The iteration results are undefined if the bitmap is modified (e.g., with Add or Remove).
+func (p *intIterator) Initialize(a *Bitmap) {
 	p.pos = 0
 	p.highlowcontainer = &a.highlowcontainer
 	p.init()
-	return p
 }
 
 type intReverseIterator struct {
@@ -309,6 +356,10 @@ type intReverseIterator struct {
 	hs               uint32
 	iter             shortIterable
 	highlowcontainer *roaringArray
+
+	shortIter        reverseIterator
+	runIter          runReverseIterator16
+	bitmapIter       reverseBitmapContainerShortIterator
 }
 
 // HasNext returns true if there are more integers to iterate over
@@ -318,8 +369,30 @@ func (ii *intReverseIterator) HasNext() bool {
 
 func (ii *intReverseIterator) init() {
 	if ii.pos >= 0 {
-		ii.iter = ii.highlowcontainer.getContainerAtIndex(ii.pos).getReverseIterator()
 		ii.hs = uint32(ii.highlowcontainer.getKeyAtIndex(ii.pos)) << 16
+		c := ii.highlowcontainer.getContainerAtIndex(ii.pos)
+		switch t := c.(type) {
+		case *arrayContainer:
+			ii.shortIter = reverseIterator{t.content, len(t.content) - 1}
+			ii.iter = &ii.shortIter
+		case *runContainer16:
+			index := int(len(t.iv)) - 1
+			pos := uint16(0)
+
+			if index >= 0 {
+				pos = t.iv[index].length
+			}
+
+			ii.runIter = runReverseIterator16{rc: t, curIndex: index, curPosInIndex: pos}
+			ii.iter = &ii.runIter
+		case *bitmapContainer:
+			pos := -1
+			if t.cardinality > 0 {
+				pos = int(t.maximum())
+			}
+			ii.bitmapIter = reverseBitmapContainerShortIterator{t, pos}
+			ii.iter = &ii.bitmapIter
+		}
 	} else {
 		ii.iter = nil
 	}
@@ -335,12 +408,16 @@ func (ii *intReverseIterator) Next() uint32 {
 	return x
 }
 
-func newIntReverseIterator(a *Bitmap) *intReverseIterator {
+// IntReverseIterator is meant to allow you to iterate through the values of a bitmap, see Initialize(a *Bitmap)
-	p := new(intReverseIterator)
+type IntReverseIterator = intReverseIterator
+
+// Initialize configures the existing iterator so that it can iterate through the values of
+// the provided bitmap.
+// The iteration results are undefined if the bitmap is modified (e.g., with Add or Remove).
+func (p *intReverseIterator) Initialize(a *Bitmap) {
 	p.highlowcontainer = &a.highlowcontainer
 	p.pos = a.highlowcontainer.size() - 1
 	p.init()
-	return p
 }
 
 // ManyIntIterable allows you to iterate over the values in a Bitmap
@@ -356,12 +433,27 @@ type manyIntIterator struct {
 	hs               uint32
 	iter             manyIterable
 	highlowcontainer *roaringArray
+
+	shortIter        shortIterator
+	runIter          runIterator16
+	bitmapIter       bitmapContainerManyIterator
 }
 
 func (ii *manyIntIterator) init() {
 	if ii.highlowcontainer.size() > ii.pos {
-		ii.iter = ii.highlowcontainer.getContainerAtIndex(ii.pos).getManyIterator()
 		ii.hs = uint32(ii.highlowcontainer.getKeyAtIndex(ii.pos)) << 16
+		c := ii.highlowcontainer.getContainerAtIndex(ii.pos)
+		switch t := c.(type) {
+		case *arrayContainer:
+			ii.shortIter = shortIterator{t.content, 0}
+			ii.iter = &ii.shortIter
+		case *runContainer16:
+			ii.runIter = runIterator16{rc: t, curIndex: 0, curPosInIndex: 0}
+			ii.iter = &ii.runIter
+		case *bitmapContainer:
+			ii.bitmapIter = bitmapContainerManyIterator{t, -1, 0}
+			ii.iter = &ii.bitmapIter
+		}
 	} else {
 		ii.iter = nil
 	}
@@ -403,12 +495,17 @@ func (ii *manyIntIterator) NextMany64(hs64 uint64, buf []uint64) int {
 	return n
 }
 
-func newManyIntIterator(a *Bitmap) *manyIntIterator {
+
-	p := new(manyIntIterator)
+// ManyIntIterator is meant to allow you to iterate through the values of a bitmap, see Initialize(a *Bitmap)
+type ManyIntIterator = manyIntIterator
+
+// Initialize configures the existing iterator so that it can iterate through the values of
+// the provided bitmap.
+// The iteration results are undefined if the bitmap is modified (e.g., with Add or Remove).
+func (p *manyIntIterator) Initialize(a *Bitmap) {
 	p.pos = 0
 	p.highlowcontainer = &a.highlowcontainer
 	p.init()
-	return p
 }
 
 // String creates a string representation of the Bitmap
@@ -440,7 +537,7 @@ func (rb *Bitmap) String() string {
 // Iterate iterates over the bitmap, calling the given callback with each value in the bitmap.  If the callback returns
 // false, the iteration is halted.
 // The iteration results are undefined if the bitmap is modified (e.g., with Add or Remove).
-// There is no guarantee as to what order the values will be iterated
+// There is no guarantee as to what order the values will be iterated.
 func (rb *Bitmap) Iterate(cb func(x uint32) bool) {
 	for i := 0; i < rb.highlowcontainer.size(); i++ {
 		hs := uint32(rb.highlowcontainer.getKeyAtIndex(i)) << 16
@@ -472,19 +569,25 @@ func (rb *Bitmap) Iterate(cb func(x uint32) bool) {
 // Iterator creates a new IntPeekable to iterate over the integers contained in the bitmap, in sorted order;
 // the iterator becomes invalid if the bitmap is modified (e.g., with Add or Remove).
 func (rb *Bitmap) Iterator() IntPeekable {
-	return newIntIterator(rb)
+    p := new(intIterator)
+	p.Initialize(rb)
+	return p
 }
 
 // ReverseIterator creates a new IntIterable to iterate over the integers contained in the bitmap, in sorted order;
 // the iterator becomes invalid if the bitmap is modified (e.g., with Add or Remove).
 func (rb *Bitmap) ReverseIterator() IntIterable {
-	return newIntReverseIterator(rb)
+	p := new(intReverseIterator)
+	p.Initialize(rb)
+	return p
 }
 
 // ManyIterator creates a new ManyIntIterable to iterate over the integers contained in the bitmap, in sorted order;
 // the iterator becomes invalid if the bitmap is modified (e.g., with Add or Remove).
 func (rb *Bitmap) ManyIterator() ManyIntIterable {
-	return newManyIntIterator(rb)
+	p := new(manyIntIterator)
+	p.Initialize(rb)
+	return p
 }
 
 // Clone creates a copy of the Bitmap
@@ -496,11 +599,17 @@ func (rb *Bitmap) Clone() *Bitmap {
 
 // Minimum get the smallest value stored in this roaring bitmap, assumes that it is not empty
 func (rb *Bitmap) Minimum() uint32 {
+	if len(rb.highlowcontainer.containers) == 0 {
+		panic("Empty bitmap")
+	}
 	return uint32(rb.highlowcontainer.containers[0].minimum()) | (uint32(rb.highlowcontainer.keys[0]) << 16)
 }
 
 // Maximum get the largest value stored in this roaring bitmap, assumes that it is not empty
 func (rb *Bitmap) Maximum() uint32 {
+	if len(rb.highlowcontainer.containers) == 0 {
+		panic("Empty bitmap")
+	}
 	lastindex := len(rb.highlowcontainer.containers) - 1
 	return uint32(rb.highlowcontainer.containers[lastindex].maximum()) | (uint32(rb.highlowcontainer.keys[lastindex]) << 16)
 }
@@ -544,34 +653,38 @@ func AddOffset64(x *Bitmap, offset int64) (answer *Bitmap) {
 		containerOffset64 = offset >> 16
 	}
 
-	if containerOffset64 >= (1<<16) || containerOffset64 <= -(1<<16) {
+	answer = New()
-		return New()
+
+	if containerOffset64 >= (1<<16) || containerOffset64 < -(1<<16) {
+		return answer
 	}
 
 	containerOffset := int32(containerOffset64)
 	inOffset := (uint16)(offset - containerOffset64*(1<<16))
 
 	if inOffset == 0 {
-		answer = x.Clone()
-		for pos := 0; pos < answer.highlowcontainer.size(); pos++ {
-			key := int32(answer.highlowcontainer.getKeyAtIndex(pos))
-			key += containerOffset
-
-			if key >= 0 && key <= MaxUint16 {
-				answer.highlowcontainer.keys[pos] = uint16(key)
-			}
-		}
-	} else {
-		answer = New()
-
 		for pos := 0; pos < x.highlowcontainer.size(); pos++ {
 			key := int32(x.highlowcontainer.getKeyAtIndex(pos))
 			key += containerOffset
 
-			c := x.highlowcontainer.getContainerAtIndex(pos)
+			if key >= 0 && key <= MaxUint16 {
-			offsetted := c.addOffset(inOffset)
+				c := x.highlowcontainer.getContainerAtIndex(pos).clone()
+				answer.highlowcontainer.appendContainer(uint16(key), c, false)
+			}
+		}
+	} else {
+		for pos := 0; pos < x.highlowcontainer.size(); pos++ {
+			key := int32(x.highlowcontainer.getKeyAtIndex(pos))
+			key += containerOffset
 
-			if offsetted[0].getCardinality() > 0 && (key >= 0 && key <= MaxUint16) {
+			if key+1 < 0 || key > MaxUint16 {
+				continue
+			}
+
+			c := x.highlowcontainer.getContainerAtIndex(pos)
+			lo, hi := c.addOffset(inOffset)
+
+			if lo != nil && key >= 0 {
 				curSize := answer.highlowcontainer.size()
 				lastkey := int32(0)
 
@@ -581,15 +694,15 @@ func AddOffset64(x *Bitmap, offset int64) (answer *Bitmap) {
 
 				if curSize > 0 && lastkey == key {
 					prev := answer.highlowcontainer.getContainerAtIndex(curSize - 1)
-					orrseult := prev.ior(offsetted[0])
+					orresult := prev.ior(lo)
-					answer.highlowcontainer.setContainerAtIndex(curSize-1, orrseult)
+					answer.highlowcontainer.setContainerAtIndex(curSize-1, orresult)
 				} else {
-					answer.highlowcontainer.appendContainer(uint16(key), offsetted[0], false)
+					answer.highlowcontainer.appendContainer(uint16(key), lo, false)
 				}
 			}
 
-			if offsetted[1].getCardinality() > 0 && ((key+1) >= 0 && (key+1) <= MaxUint16) {
+			if hi != nil && key+1 <= MaxUint16 {
-				answer.highlowcontainer.appendContainer(uint16(key+1), offsetted[1], false)
+				answer.highlowcontainer.appendContainer(uint16(key+1), hi, false)
 			}
 		}
 	}
@@ -659,13 +772,13 @@ func (rb *Bitmap) Remove(x uint32) {
 	if i >= 0 {
 		c := rb.highlowcontainer.getWritableContainerAtIndex(i).iremoveReturnMinimized(lowbits(x))
 		rb.highlowcontainer.setContainerAtIndex(i, c)
-		if rb.highlowcontainer.getContainerAtIndex(i).getCardinality() == 0 {
+		if rb.highlowcontainer.getContainerAtIndex(i).isEmpty() {
 			rb.highlowcontainer.removeAtIndex(i)
 		}
 	}
 }
 
-// CheckedRemove removes the integer x from the bitmap and return true if the integer was effectively remove (and false if the integer was not present)
+// CheckedRemove removes the integer x from the bitmap and return true if the integer was effectively removed (and false if the integer was not present)
 func (rb *Bitmap) CheckedRemove(x uint32) bool {
 	// TODO: add unit tests for this method
 	hb := highbits(x)
@@ -675,7 +788,7 @@ func (rb *Bitmap) CheckedRemove(x uint32) bool {
 		oldcard := C.getCardinality()
 		C = C.iremoveReturnMinimized(lowbits(x))
 		rb.highlowcontainer.setContainerAtIndex(i, C)
-		if rb.highlowcontainer.getContainerAtIndex(i).getCardinality() == 0 {
+		if rb.highlowcontainer.getContainerAtIndex(i).isEmpty() {
 			rb.highlowcontainer.removeAtIndex(i)
 			return true
 		}
@@ -723,15 +836,12 @@ func (rb *Bitmap) Rank(x uint32) uint64 {
 // the smallest element. Note that this function differs in convention from
 // the Rank function which returns 1 on the smallest value.
 func (rb *Bitmap) Select(x uint32) (uint32, error) {
-	if rb.GetCardinality() <= uint64(x) {
-		return 0, fmt.Errorf("can't find %dth integer in a bitmap with only %d items", x, rb.GetCardinality())
-	}
-
 	remaining := x
 	for i := 0; i < rb.highlowcontainer.size(); i++ {
 		c := rb.highlowcontainer.getContainerAtIndex(i)
-		if remaining >= uint32(c.getCardinality()) {
+		card := uint32(c.getCardinality())
-			remaining -= uint32(c.getCardinality())
+		if remaining >= card {
+			remaining -= card
 		} else {
 			key := rb.highlowcontainer.getKeyAtIndex(i)
 			return uint32(key)<<16 + uint32(c.selectInt(uint16(remaining))), nil
@@ -758,7 +868,7 @@ main:
 					c1 := rb.highlowcontainer.getWritableContainerAtIndex(pos1)
 					c2 := x2.highlowcontainer.getContainerAtIndex(pos2)
 					diff := c1.iand(c2)
-					if diff.getCardinality() > 0 {
+					if !diff.isEmpty() {
 						rb.highlowcontainer.replaceKeyAndContainerAtIndex(intersectionsize, s1, diff, false)
 						intersectionsize++
 					}
@@ -889,6 +999,28 @@ main:
 	return answer
 }
 
+// IntersectsWithInterval checks whether a bitmap 'rb' and an open interval '[x,y)' intersect.
+func (rb *Bitmap) IntersectsWithInterval(x, y uint64) bool {
+	if x >= y {
+		return false
+	}
+	if x > MaxUint32 {
+		return false
+	}
+
+	it := intIterator{}
+	it.Initialize(rb)
+	it.AdvanceIfNeeded(uint32(x))
+	if !it.HasNext() {
+		return false
+	}
+	if uint64(it.Next()) >= y {
+		return false
+	}
+
+	return true
+}
+
 // Intersects checks whether two bitmap intersects, bitmaps are not modified
 func (rb *Bitmap) Intersects(x2 *Bitmap) bool {
 	pos1 := 0
@@ -960,7 +1092,7 @@ func (rb *Bitmap) Xor(x2 *Bitmap) {
 			} else {
 				// TODO: couple be computed in-place for reduced memory usage
 				c := rb.highlowcontainer.getContainerAtIndex(pos1).xor(x2.highlowcontainer.getContainerAtIndex(pos2))
-				if c.getCardinality() > 0 {
+				if !c.isEmpty() {
 					rb.highlowcontainer.setContainerAtIndex(pos1, c)
 					pos1++
 				} else {
@@ -1040,7 +1172,7 @@ main:
 					c1 := rb.highlowcontainer.getWritableContainerAtIndex(pos1)
 					c2 := x2.highlowcontainer.getContainerAtIndex(pos2)
 					diff := c1.iandNot(c2)
-					if diff.getCardinality() > 0 {
+					if !diff.isEmpty() {
 						rb.highlowcontainer.replaceKeyAndContainerAtIndex(intersectionsize, s1, diff, false)
 						intersectionsize++
 					}
@@ -1149,7 +1281,7 @@ main:
 				C := x1.highlowcontainer.getContainerAtIndex(pos1)
 				C = C.and(x2.highlowcontainer.getContainerAtIndex(pos2))
 
-				if C.getCardinality() > 0 {
+				if !C.isEmpty() {
 					answer.highlowcontainer.appendContainer(s1, C, false)
 				}
 				pos1++
@@ -1196,7 +1328,7 @@ func Xor(x1, x2 *Bitmap) *Bitmap {
 				pos2++
 			} else {
 				c := x1.highlowcontainer.getContainerAtIndex(pos1).xor(x2.highlowcontainer.getContainerAtIndex(pos2))
-				if c.getCardinality() > 0 {
+				if !c.isEmpty() {
 					answer.highlowcontainer.appendContainer(s1, c, false)
 				}
 				pos1++
@@ -1239,7 +1371,7 @@ main:
 					c1 := x1.highlowcontainer.getContainerAtIndex(pos1)
 					c2 := x2.highlowcontainer.getContainerAtIndex(pos2)
 					diff := c1.andNot(c2)
-					if diff.getCardinality() > 0 {
+					if !diff.isEmpty() {
 						answer.highlowcontainer.appendContainer(s1, diff, false)
 					}
 					pos1++
@@ -1329,7 +1461,7 @@ func (rb *Bitmap) Flip(rangeStart, rangeEnd uint64) {
 
 		if i >= 0 {
 			c := rb.highlowcontainer.getWritableContainerAtIndex(i).inot(int(containerStart), int(containerLast)+1)
-			if c.getCardinality() > 0 {
+			if !c.isEmpty() {
 				rb.highlowcontainer.setContainerAtIndex(i, c)
 			} else {
 				rb.highlowcontainer.removeAtIndex(i)
@@ -1410,7 +1542,7 @@ func (rb *Bitmap) RemoveRange(rangeStart, rangeEnd uint64) {
 			return
 		}
 		c := rb.highlowcontainer.getWritableContainerAtIndex(i).iremoveRange(int(lbStart), int(lbLast+1))
-		if c.getCardinality() > 0 {
+		if !c.isEmpty() {
 			rb.highlowcontainer.setContainerAtIndex(i, c)
 		} else {
 			rb.highlowcontainer.removeAtIndex(i)
@@ -1423,7 +1555,7 @@ func (rb *Bitmap) RemoveRange(rangeStart, rangeEnd uint64) {
 	if ifirst >= 0 {
 		if lbStart != 0 {
 			c := rb.highlowcontainer.getWritableContainerAtIndex(ifirst).iremoveRange(int(lbStart), int(max+1))
-			if c.getCardinality() > 0 {
+			if !c.isEmpty() {
 				rb.highlowcontainer.setContainerAtIndex(ifirst, c)
 				ifirst++
 			}
@@ -1434,7 +1566,7 @@ func (rb *Bitmap) RemoveRange(rangeStart, rangeEnd uint64) {
 	if ilast >= 0 {
 		if lbLast != max {
 			c := rb.highlowcontainer.getWritableContainerAtIndex(ilast).iremoveRange(int(0), int(lbLast+1))
-			if c.getCardinality() > 0 {
+			if !c.isEmpty() {
 				rb.highlowcontainer.setContainerAtIndex(ilast, c)
 			} else {
 				ilast++
@@ -1490,7 +1622,7 @@ func Flip(bm *Bitmap, rangeStart, rangeEnd uint64) *Bitmap {
 
 		if i >= 0 {
 			c := bm.highlowcontainer.getContainerAtIndex(i).not(int(containerStart), int(containerLast)+1)
-			if c.getCardinality() > 0 {
+			if !c.isEmpty() {
 				answer.highlowcontainer.insertNewKeyValueAt(-j-1, uint16(hb), c)
 			}
 

vendor/github.com/RoaringBitmap/roaring/roaringarray.go

@@ -4,16 +4,15 @@ import (
 	"bytes"
 	"encoding/binary"
 	"fmt"
+	"github.com/RoaringBitmap/roaring/internal"
 	"io"
-
-	snappy "github.com/glycerine/go-unsnap-stream"
-	"github.com/tinylib/msgp/msgp"
 )
 
-//go:generate msgp -unexported
-
 type container interface {
-	addOffset(uint16) []container
+	// addOffset returns the (low, high) parts of the shifted container.
+	// Whenever one of them would be empty, nil will be returned instead to
+	// avoid unnecessary allocations.
+	addOffset(uint16) (container, container)
 
 	clone() container
 	and(container) container
@@ -21,6 +20,7 @@ type container interface {
 	iand(container) container // i stands for inplace
 	andNot(container) container
 	iandNot(container) container // i stands for inplace
+	isEmpty() bool
 	getCardinality() int
 	// rank returns the number of integers that are
 	// smaller or equal to x. rank(infinity) would be getCardinality().
@@ -51,7 +51,7 @@ type container interface {
 	// any of the implementations.
 	equals(r container) bool
 
-	fillLeastSignificant16bits(array []uint32, i int, mask uint32)
+	fillLeastSignificant16bits(array []uint32, i int, mask uint32) int
 	or(r container) container
 	orCardinality(r container) int
 	isFull() bool
@@ -103,18 +103,6 @@ type roaringArray struct {
 	containers      []container `msg:"-"` // don't try to serialize directly.
 	needCopyOnWrite []bool
 	copyOnWrite     bool
-
-	// conserz is used at serialization time
-	// to serialize containers. Otherwise empty.
-	conserz []containerSerz
-}
-
-// containerSerz facilitates serializing container (tricky to
-// serialize because it is an interface) by providing a
-// light wrapper with a type identifier.
-type containerSerz struct {
-	t contype  `msg:"t"` // type
-	r msgp.Raw `msg:"r"` // Raw msgpack of the actual container type
 }
 
 func newRoaringArray() *roaringArray {
@@ -246,7 +234,6 @@ func (ra *roaringArray) resize(newsize int) {
 func (ra *roaringArray) clear() {
 	ra.resize(0)
 	ra.copyOnWrite = false
-	ra.conserz = nil
 }
 
 func (ra *roaringArray) clone() *roaringArray {
@@ -566,51 +553,58 @@ func (ra *roaringArray) toBytes() ([]byte, error) {
 	return buf.Bytes(), err
 }
 
-func (ra *roaringArray) readFrom(stream byteInput) (int64, error) {
+func (ra *roaringArray) readFrom(stream internal.ByteInput, cookieHeader ...byte) (int64, error) {
-	cookie, err := stream.readUInt32()
+	var cookie uint32
-
+	var err error
-	if err != nil {
+	if len(cookieHeader) > 0 && len(cookieHeader) != 4 {
-		return stream.getReadBytes(), fmt.Errorf("error in roaringArray.readFrom: could not read initial cookie: %s", err)
+		return int64(len(cookieHeader)), fmt.Errorf("error in roaringArray.readFrom: could not read initial cookie: incorrect size of cookie header")
+	}
+	if len(cookieHeader) == 4 {
+		cookie = binary.LittleEndian.Uint32(cookieHeader)
+	} else {
+		cookie, err = stream.ReadUInt32()
+		if err != nil {
+			return stream.GetReadBytes(), fmt.Errorf("error in roaringArray.readFrom: could not read initial cookie: %s", err)
+		}
 	}
 
 	var size uint32
 	var isRunBitmap []byte
 
 	if cookie&0x0000FFFF == serialCookie {
-		size = uint32(uint16(cookie>>16) + 1)
+		size = uint32(cookie>>16 + 1)
 		// create is-run-container bitmap
 		isRunBitmapSize := (int(size) + 7) / 8
-		isRunBitmap, err = stream.next(isRunBitmapSize)
+		isRunBitmap, err = stream.Next(isRunBitmapSize)
 
 		if err != nil {
-			return stream.getReadBytes(), fmt.Errorf("malformed bitmap, failed to read is-run bitmap, got: %s", err)
+			return stream.GetReadBytes(), fmt.Errorf("malformed bitmap, failed to read is-run bitmap, got: %s", err)
 		}
 	} else if cookie == serialCookieNoRunContainer {
-		size, err = stream.readUInt32()
+		size, err = stream.ReadUInt32()
-
 		if err != nil {
-			return stream.getReadBytes(), fmt.Errorf("malformed bitmap, failed to read a bitmap size: %s", err)
+			return stream.GetReadBytes(), fmt.Errorf("malformed bitmap, failed to read a bitmap size: %s", err)
 		}
 	} else {
-		return stream.getReadBytes(), fmt.Errorf("error in roaringArray.readFrom: did not find expected serialCookie in header")
+		return stream.GetReadBytes(), fmt.Errorf("error in roaringArray.readFrom: did not find expected serialCookie in header")
 	}
 
 	if size > (1 << 16) {
-		return stream.getReadBytes(), fmt.Errorf("it is logically impossible to have more than (1<<16) containers")
+		return stream.GetReadBytes(), fmt.Errorf("it is logically impossible to have more than (1<<16) containers")
 	}
 
 	// descriptive header
-	buf, err := stream.next(2 * 2 * int(size))
+	buf, err := stream.Next(2 * 2 * int(size))
 
 	if err != nil {
-		return stream.getReadBytes(), fmt.Errorf("failed to read descriptive header: %s", err)
+		return stream.GetReadBytes(), fmt.Errorf("failed to read descriptive header: %s", err)
 	}
 
 	keycard := byteSliceAsUint16Slice(buf)
 
 	if isRunBitmap == nil || size >= noOffsetThreshold {
-		if err := stream.skipBytes(int(size) * 4); err != nil {
+		if err := stream.SkipBytes(int(size) * 4); err != nil {
-			return stream.getReadBytes(), fmt.Errorf("failed to skip bytes: %s", err)
+			return stream.GetReadBytes(), fmt.Errorf("failed to skip bytes: %s", err)
 		}
 	}
 
@@ -641,30 +635,29 @@ func (ra *roaringArray) readFrom(stream byteInput) (int64, error) {
 
 		if isRunBitmap != nil && isRunBitmap[i/8]&(1<<(i%8)) != 0 {
 			// run container
-			nr, err := stream.readUInt16()
+			nr, err := stream.ReadUInt16()
 
 			if err != nil {
 				return 0, fmt.Errorf("failed to read runtime container size: %s", err)
 			}
 
-			buf, err := stream.next(int(nr) * 4)
+			buf, err := stream.Next(int(nr) * 4)
 
 			if err != nil {
-				return stream.getReadBytes(), fmt.Errorf("failed to read runtime container content: %s", err)
+				return stream.GetReadBytes(), fmt.Errorf("failed to read runtime container content: %s", err)
 			}
 
 			nb := runContainer16{
-				iv:   byteSliceAsInterval16Slice(buf),
+				iv: byteSliceAsInterval16Slice(buf),
-				card: int64(card),
 			}
 
 			ra.containers[i] = &nb
 		} else if card > arrayDefaultMaxSize {
 			// bitmap container
-			buf, err := stream.next(arrayDefaultMaxSize * 2)
+			buf, err := stream.Next(arrayDefaultMaxSize * 2)
 
 			if err != nil {
-				return stream.getReadBytes(), fmt.Errorf("failed to read bitmap container: %s", err)
+				return stream.GetReadBytes(), fmt.Errorf("failed to read bitmap container: %s", err)
 			}
 
 			nb := bitmapContainer{
@@ -675,10 +668,10 @@ func (ra *roaringArray) readFrom(stream byteInput) (int64, error) {
 			ra.containers[i] = &nb
 		} else {
 			// array container
-			buf, err := stream.next(card * 2)
+			buf, err := stream.Next(card * 2)
 
 			if err != nil {
-				return stream.getReadBytes(), fmt.Errorf("failed to read array container: %s", err)
+				return stream.GetReadBytes(), fmt.Errorf("failed to read array container: %s", err)
 			}
 
 			nb := arrayContainer{
@@ -689,7 +682,7 @@ func (ra *roaringArray) readFrom(stream byteInput) (int64, error) {
 		}
 	}
 
-	return stream.getReadBytes(), nil
+	return stream.GetReadBytes(), nil
 }
 
 func (ra *roaringArray) hasRunCompression() bool {
@@ -702,84 +695,6 @@ func (ra *roaringArray) hasRunCompression() bool {
 	return false
 }
 
-func (ra *roaringArray) writeToMsgpack(stream io.Writer) error {
-
-	ra.conserz = make([]containerSerz, len(ra.containers))
-	for i, v := range ra.containers {
-		switch cn := v.(type) {
-		case *bitmapContainer:
-			bts, err := cn.MarshalMsg(nil)
-			if err != nil {
-				return err
-			}
-			ra.conserz[i].t = bitmapContype
-			ra.conserz[i].r = bts
-		case *arrayContainer:
-			bts, err := cn.MarshalMsg(nil)
-			if err != nil {
-				return err
-			}
-			ra.conserz[i].t = arrayContype
-			ra.conserz[i].r = bts
-		case *runContainer16:
-			bts, err := cn.MarshalMsg(nil)
-			if err != nil {
-				return err
-			}
-			ra.conserz[i].t = run16Contype
-			ra.conserz[i].r = bts
-		default:
-			panic(fmt.Errorf("Unrecognized container implementation: %T", cn))
-		}
-	}
-	w := snappy.NewWriter(stream)
-	err := msgp.Encode(w, ra)
-	ra.conserz = nil
-	return err
-}
-
-func (ra *roaringArray) readFromMsgpack(stream io.Reader) error {
-	r := snappy.NewReader(stream)
-	err := msgp.Decode(r, ra)
-	if err != nil {
-		return err
-	}
-
-	if len(ra.containers) != len(ra.keys) {
-		ra.containers = make([]container, len(ra.keys))
-	}
-
-	for i, v := range ra.conserz {
-		switch v.t {
-		case bitmapContype:
-			c := &bitmapContainer{}
-			_, err = c.UnmarshalMsg(v.r)
-			if err != nil {
-				return err
-			}
-			ra.containers[i] = c
-		case arrayContype:
-			c := &arrayContainer{}
-			_, err = c.UnmarshalMsg(v.r)
-			if err != nil {
-				return err
-			}
-			ra.containers[i] = c
-		case run16Contype:
-			c := &runContainer16{}
-			_, err = c.UnmarshalMsg(v.r)
-			if err != nil {
-				return err
-			}
-			ra.containers[i] = c
-		default:
-			return fmt.Errorf("unrecognized contype serialization code: '%v'", v.t)
-		}
-	}
-	ra.conserz = nil
-	return nil
-}
-
 func (ra *roaringArray) advanceUntil(min uint16, pos int) int {
 	lower := pos + 1
 

vendor/github.com/RoaringBitmap/roaring/roaringarray_gen.go

@@ -1,529 +0,0 @@
-package roaring
-
-// NOTE: THIS FILE WAS PRODUCED BY THE
-// MSGP CODE GENERATION TOOL (github.com/tinylib/msgp)
-// DO NOT EDIT
-
-import (
-	"github.com/tinylib/msgp/msgp"
-)
-
-// Deprecated: DecodeMsg implements msgp.Decodable
-func (z *containerSerz) DecodeMsg(dc *msgp.Reader) (err error) {
-	var field []byte
-	_ = field
-	var zxvk uint32
-	zxvk, err = dc.ReadMapHeader()
-	if err != nil {
-		return
-	}
-	for zxvk > 0 {
-		zxvk--
-		field, err = dc.ReadMapKeyPtr()
-		if err != nil {
-			return
-		}
-		switch msgp.UnsafeString(field) {
-		case "t":
-			{
-				var zbzg uint8
-				zbzg, err = dc.ReadUint8()
-				z.t = contype(zbzg)
-			}
-			if err != nil {
-				return
-			}
-		case "r":
-			err = z.r.DecodeMsg(dc)
-			if err != nil {
-				return
-			}
-		default:
-			err = dc.Skip()
-			if err != nil {
-				return
-			}
-		}
-	}
-	return
-}
-
-// Deprecated: EncodeMsg implements msgp.Encodable
-func (z *containerSerz) EncodeMsg(en *msgp.Writer) (err error) {
-	// map header, size 2
-	// write "t"
-	err = en.Append(0x82, 0xa1, 0x74)
-	if err != nil {
-		return err
-	}
-	err = en.WriteUint8(uint8(z.t))
-	if err != nil {
-		return
-	}
-	// write "r"
-	err = en.Append(0xa1, 0x72)
-	if err != nil {
-		return err
-	}
-	err = z.r.EncodeMsg(en)
-	if err != nil {
-		return
-	}
-	return
-}
-
-// Deprecated: MarshalMsg implements msgp.Marshaler
-func (z *containerSerz) MarshalMsg(b []byte) (o []byte, err error) {
-	o = msgp.Require(b, z.Msgsize())
-	// map header, size 2
-	// string "t"
-	o = append(o, 0x82, 0xa1, 0x74)
-	o = msgp.AppendUint8(o, uint8(z.t))
-	// string "r"
-	o = append(o, 0xa1, 0x72)
-	o, err = z.r.MarshalMsg(o)
-	if err != nil {
-		return
-	}
-	return
-}
-
-// Deprecated: UnmarshalMsg implements msgp.Unmarshaler
-func (z *containerSerz) UnmarshalMsg(bts []byte) (o []byte, err error) {
-	var field []byte
-	_ = field
-	var zbai uint32
-	zbai, bts, err = msgp.ReadMapHeaderBytes(bts)
-	if err != nil {
-		return
-	}
-	for zbai > 0 {
-		zbai--
-		field, bts, err = msgp.ReadMapKeyZC(bts)
-		if err != nil {
-			return
-		}
-		switch msgp.UnsafeString(field) {
-		case "t":
-			{
-				var zcmr uint8
-				zcmr, bts, err = msgp.ReadUint8Bytes(bts)
-				z.t = contype(zcmr)
-			}
-			if err != nil {
-				return
-			}
-		case "r":
-			bts, err = z.r.UnmarshalMsg(bts)
-			if err != nil {
-				return
-			}
-		default:
-			bts, err = msgp.Skip(bts)
-			if err != nil {
-				return
-			}
-		}
-	}
-	o = bts
-	return
-}
-
-// Deprecated: Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
-func (z *containerSerz) Msgsize() (s int) {
-	s = 1 + 2 + msgp.Uint8Size + 2 + z.r.Msgsize()
-	return
-}
-
-// Deprecated: DecodeMsg implements msgp.Decodable
-func (z *contype) DecodeMsg(dc *msgp.Reader) (err error) {
-	{
-		var zajw uint8
-		zajw, err = dc.ReadUint8()
-		(*z) = contype(zajw)
-	}
-	if err != nil {
-		return
-	}
-	return
-}
-
-// Deprecated: EncodeMsg implements msgp.Encodable
-func (z contype) EncodeMsg(en *msgp.Writer) (err error) {
-	err = en.WriteUint8(uint8(z))
-	if err != nil {
-		return
-	}
-	return
-}
-
-// Deprecated: MarshalMsg implements msgp.Marshaler
-func (z contype) MarshalMsg(b []byte) (o []byte, err error) {
-	o = msgp.Require(b, z.Msgsize())
-	o = msgp.AppendUint8(o, uint8(z))
-	return
-}
-
-// Deprecated: UnmarshalMsg implements msgp.Unmarshaler
-func (z *contype) UnmarshalMsg(bts []byte) (o []byte, err error) {
-	{
-		var zwht uint8
-		zwht, bts, err = msgp.ReadUint8Bytes(bts)
-		(*z) = contype(zwht)
-	}
-	if err != nil {
-		return
-	}
-	o = bts
-	return
-}
-
-// Deprecated: Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
-func (z contype) Msgsize() (s int) {
-	s = msgp.Uint8Size
-	return
-}
-
-// Deprecated: DecodeMsg implements msgp.Decodable
-func (z *roaringArray) DecodeMsg(dc *msgp.Reader) (err error) {
-	var field []byte
-	_ = field
-	var zlqf uint32
-	zlqf, err = dc.ReadMapHeader()
-	if err != nil {
-		return
-	}
-	for zlqf > 0 {
-		zlqf--
-		field, err = dc.ReadMapKeyPtr()
-		if err != nil {
-			return
-		}
-		switch msgp.UnsafeString(field) {
-		case "keys":
-			var zdaf uint32
-			zdaf, err = dc.ReadArrayHeader()
-			if err != nil {
-				return
-			}
-			if cap(z.keys) >= int(zdaf) {
-				z.keys = (z.keys)[:zdaf]
-			} else {
-				z.keys = make([]uint16, zdaf)
-			}
-			for zhct := range z.keys {
-				z.keys[zhct], err = dc.ReadUint16()
-				if err != nil {
-					return
-				}
-			}
-		case "needCopyOnWrite":
-			var zpks uint32
-			zpks, err = dc.ReadArrayHeader()
-			if err != nil {
-				return
-			}
-			if cap(z.needCopyOnWrite) >= int(zpks) {
-				z.needCopyOnWrite = (z.needCopyOnWrite)[:zpks]
-			} else {
-				z.needCopyOnWrite = make([]bool, zpks)
-			}
-			for zcua := range z.needCopyOnWrite {
-				z.needCopyOnWrite[zcua], err = dc.ReadBool()
-				if err != nil {
-					return
-				}
-			}
-		case "copyOnWrite":
-			z.copyOnWrite, err = dc.ReadBool()
-			if err != nil {
-				return
-			}
-		case "conserz":
-			var zjfb uint32
-			zjfb, err = dc.ReadArrayHeader()
-			if err != nil {
-				return
-			}
-			if cap(z.conserz) >= int(zjfb) {
-				z.conserz = (z.conserz)[:zjfb]
-			} else {
-				z.conserz = make([]containerSerz, zjfb)
-			}
-			for zxhx := range z.conserz {
-				var zcxo uint32
-				zcxo, err = dc.ReadMapHeader()
-				if err != nil {
-					return
-				}
-				for zcxo > 0 {
-					zcxo--
-					field, err = dc.ReadMapKeyPtr()
-					if err != nil {
-						return
-					}
-					switch msgp.UnsafeString(field) {
-					case "t":
-						{
-							var zeff uint8
-							zeff, err = dc.ReadUint8()
-							z.conserz[zxhx].t = contype(zeff)
-						}
-						if err != nil {
-							return
-						}
-					case "r":
-						err = z.conserz[zxhx].r.DecodeMsg(dc)
-						if err != nil {
-							return
-						}
-					default:
-						err = dc.Skip()
-						if err != nil {
-							return
-						}
-					}
-				}
-			}
-		default:
-			err = dc.Skip()
-			if err != nil {
-				return
-			}
-		}
-	}
-	return
-}
-
-// Deprecated: EncodeMsg implements msgp.Encodable
-func (z *roaringArray) EncodeMsg(en *msgp.Writer) (err error) {
-	// map header, size 4
-	// write "keys"
-	err = en.Append(0x84, 0xa4, 0x6b, 0x65, 0x79, 0x73)
-	if err != nil {
-		return err
-	}
-	err = en.WriteArrayHeader(uint32(len(z.keys)))
-	if err != nil {
-		return
-	}
-	for zhct := range z.keys {
-		err = en.WriteUint16(z.keys[zhct])
-		if err != nil {
-			return
-		}
-	}
-	// write "needCopyOnWrite"
-	err = en.Append(0xaf, 0x6e, 0x65, 0x65, 0x64, 0x43, 0x6f, 0x70, 0x79, 0x4f, 0x6e, 0x57, 0x72, 0x69, 0x74, 0x65)
-	if err != nil {
-		return err
-	}
-	err = en.WriteArrayHeader(uint32(len(z.needCopyOnWrite)))
-	if err != nil {
-		return
-	}
-	for zcua := range z.needCopyOnWrite {
-		err = en.WriteBool(z.needCopyOnWrite[zcua])
-		if err != nil {
-			return
-		}
-	}
-	// write "copyOnWrite"
-	err = en.Append(0xab, 0x63, 0x6f, 0x70, 0x79, 0x4f, 0x6e, 0x57, 0x72, 0x69, 0x74, 0x65)
-	if err != nil {
-		return err
-	}
-	err = en.WriteBool(z.copyOnWrite)
-	if err != nil {
-		return
-	}
-	// write "conserz"
-	err = en.Append(0xa7, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x72, 0x7a)
-	if err != nil {
-		return err
-	}
-	err = en.WriteArrayHeader(uint32(len(z.conserz)))
-	if err != nil {
-		return
-	}
-	for zxhx := range z.conserz {
-		// map header, size 2
-		// write "t"
-		err = en.Append(0x82, 0xa1, 0x74)
-		if err != nil {
-			return err
-		}
-		err = en.WriteUint8(uint8(z.conserz[zxhx].t))
-		if err != nil {
-			return
-		}
-		// write "r"
-		err = en.Append(0xa1, 0x72)
-		if err != nil {
-			return err
-		}
-		err = z.conserz[zxhx].r.EncodeMsg(en)
-		if err != nil {
-			return
-		}
-	}
-	return
-}
-
-// Deprecated: MarshalMsg implements msgp.Marshaler
-func (z *roaringArray) MarshalMsg(b []byte) (o []byte, err error) {
-	o = msgp.Require(b, z.Msgsize())
-	// map header, size 4
-	// string "keys"
-	o = append(o, 0x84, 0xa4, 0x6b, 0x65, 0x79, 0x73)
-	o = msgp.AppendArrayHeader(o, uint32(len(z.keys)))
-	for zhct := range z.keys {
-		o = msgp.AppendUint16(o, z.keys[zhct])
-	}
-	// string "needCopyOnWrite"
-	o = append(o, 0xaf, 0x6e, 0x65, 0x65, 0x64, 0x43, 0x6f, 0x70, 0x79, 0x4f, 0x6e, 0x57, 0x72, 0x69, 0x74, 0x65)
-	o = msgp.AppendArrayHeader(o, uint32(len(z.needCopyOnWrite)))
-	for zcua := range z.needCopyOnWrite {
-		o = msgp.AppendBool(o, z.needCopyOnWrite[zcua])
-	}
-	// string "copyOnWrite"
-	o = append(o, 0xab, 0x63, 0x6f, 0x70, 0x79, 0x4f, 0x6e, 0x57, 0x72, 0x69, 0x74, 0x65)
-	o = msgp.AppendBool(o, z.copyOnWrite)
-	// string "conserz"
-	o = append(o, 0xa7, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x72, 0x7a)
-	o = msgp.AppendArrayHeader(o, uint32(len(z.conserz)))
-	for zxhx := range z.conserz {
-		// map header, size 2
-		// string "t"
-		o = append(o, 0x82, 0xa1, 0x74)
-		o = msgp.AppendUint8(o, uint8(z.conserz[zxhx].t))
-		// string "r"
-		o = append(o, 0xa1, 0x72)
-		o, err = z.conserz[zxhx].r.MarshalMsg(o)
-		if err != nil {
-			return
-		}
-	}
-	return
-}
-
-// Deprecated: UnmarshalMsg implements msgp.Unmarshaler
-func (z *roaringArray) UnmarshalMsg(bts []byte) (o []byte, err error) {
-	var field []byte
-	_ = field
-	var zrsw uint32
-	zrsw, bts, err = msgp.ReadMapHeaderBytes(bts)
-	if err != nil {
-		return
-	}
-	for zrsw > 0 {
-		zrsw--
-		field, bts, err = msgp.ReadMapKeyZC(bts)
-		if err != nil {
-			return
-		}
-		switch msgp.UnsafeString(field) {
-		case "keys":
-			var zxpk uint32
-			zxpk, bts, err = msgp.ReadArrayHeaderBytes(bts)
-			if err != nil {
-				return
-			}
-			if cap(z.keys) >= int(zxpk) {
-				z.keys = (z.keys)[:zxpk]
-			} else {
-				z.keys = make([]uint16, zxpk)
-			}
-			for zhct := range z.keys {
-				z.keys[zhct], bts, err = msgp.ReadUint16Bytes(bts)
-				if err != nil {
-					return
-				}
-			}
-		case "needCopyOnWrite":
-			var zdnj uint32
-			zdnj, bts, err = msgp.ReadArrayHeaderBytes(bts)
-			if err != nil {
-				return
-			}
-			if cap(z.needCopyOnWrite) >= int(zdnj) {
-				z.needCopyOnWrite = (z.needCopyOnWrite)[:zdnj]
-			} else {
-				z.needCopyOnWrite = make([]bool, zdnj)
-			}
-			for zcua := range z.needCopyOnWrite {
-				z.needCopyOnWrite[zcua], bts, err = msgp.ReadBoolBytes(bts)
-				if err != nil {
-					return
-				}
-			}
-		case "copyOnWrite":
-			z.copyOnWrite, bts, err = msgp.ReadBoolBytes(bts)
-			if err != nil {
-				return
-			}
-		case "conserz":
-			var zobc uint32
-			zobc, bts, err = msgp.ReadArrayHeaderBytes(bts)
-			if err != nil {
-				return
-			}
-			if cap(z.conserz) >= int(zobc) {
-				z.conserz = (z.conserz)[:zobc]
-			} else {
-				z.conserz = make([]containerSerz, zobc)
-			}
-			for zxhx := range z.conserz {
-				var zsnv uint32
-				zsnv, bts, err = msgp.ReadMapHeaderBytes(bts)
-				if err != nil {
-					return
-				}
-				for zsnv > 0 {
-					zsnv--
-					field, bts, err = msgp.ReadMapKeyZC(bts)
-					if err != nil {
-						return
-					}
-					switch msgp.UnsafeString(field) {
-					case "t":
-						{
-							var zkgt uint8
-							zkgt, bts, err = msgp.ReadUint8Bytes(bts)
-							z.conserz[zxhx].t = contype(zkgt)
-						}
-						if err != nil {
-							return
-						}
-					case "r":
-						bts, err = z.conserz[zxhx].r.UnmarshalMsg(bts)
-						if err != nil {
-							return
-						}
-					default:
-						bts, err = msgp.Skip(bts)
-						if err != nil {
-							return
-						}
-					}
-				}
-			}
-		default:
-			bts, err = msgp.Skip(bts)
-			if err != nil {
-				return
-			}
-		}
-	}
-	o = bts
-	return
-}
-
-// Deprecated: Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
-func (z *roaringArray) Msgsize() (s int) {
-	s = 1 + 5 + msgp.ArrayHeaderSize + (len(z.keys) * (msgp.Uint16Size)) + 16 + msgp.ArrayHeaderSize + (len(z.needCopyOnWrite) * (msgp.BoolSize)) + 12 + msgp.BoolSize + 8 + msgp.ArrayHeaderSize
-	for zxhx := range z.conserz {
-		s += 1 + 2 + msgp.Uint8Size + 2 + z.conserz[zxhx].r.Msgsize()
-	}
-	return
-}

vendor/github.com/RoaringBitmap/roaring/serialization.go

@@ -3,8 +3,6 @@ package roaring
 import (
 	"encoding/binary"
 	"io"
-
-	"github.com/tinylib/msgp/msgp"
 )
 
 // writeTo for runContainer16 follows this
@@ -19,16 +17,3 @@ func (b *runContainer16) writeTo(stream io.Writer) (int, error) {
 	}
 	return stream.Write(buf)
 }
-
-func (b *runContainer16) writeToMsgpack(stream io.Writer) (int, error) {
-	bts, err := b.MarshalMsg(nil)
-	if err != nil {
-		return 0, err
-	}
-	return stream.Write(bts)
-}
-
-func (b *runContainer16) readFromMsgpack(stream io.Reader) (int, error) {
-	err := msgp.Decode(stream, b)
-	return 0, err
-}

vendor/github.com/RoaringBitmap/roaring/serialization_generic.go

@@ -1,3 +1,4 @@
+//go:build (!amd64 && !386 && !arm && !arm64 && !ppc64le && !mipsle && !mips64le && !mips64p32le && !wasm) || appengine
 // +build !amd64,!386,!arm,!arm64,!ppc64le,!mipsle,!mips64le,!mips64p32le,!wasm appengine
 
 package roaring
@@ -84,6 +85,17 @@ func uint16SliceAsByteSlice(slice []uint16) []byte {
 	return by
 }
 
+func interval16SliceAsByteSlice(slice []interval16) []byte {
+	by := make([]byte, len(slice)*4)
+
+	for i, v := range slice {
+		binary.LittleEndian.PutUint16(by[i*2:], v.start)
+		binary.LittleEndian.PutUint16(by[i*2+2:], v.length)
+	}
+
+	return by
+}
+
 func byteSliceAsUint16Slice(slice []byte) []uint16 {
 	if len(slice)%2 != 0 {
 		panic("Slice size should be divisible by 2")

vendor/github.com/RoaringBitmap/roaring/serialization_littleendian.go

@@ -1,8 +1,10 @@
+//go:build (386 && !appengine) || (amd64 && !appengine) || (arm && !appengine) || (arm64 && !appengine) || (ppc64le && !appengine) || (mipsle && !appengine) || (mips64le && !appengine) || (mips64p32le && !appengine) || (wasm && !appengine)
 // +build 386,!appengine amd64,!appengine arm,!appengine arm64,!appengine ppc64le,!appengine mipsle,!appengine mips64le,!appengine mips64p32le,!appengine wasm,!appengine
 
 package roaring
 
 import (
+	"encoding/binary"
 	"errors"
 	"io"
 	"reflect"
@@ -55,6 +57,22 @@ func uint16SliceAsByteSlice(slice []uint16) []byte {
 	return result
 }
 
+func interval16SliceAsByteSlice(slice []interval16) []byte {
+	// make a new slice header
+	header := *(*reflect.SliceHeader)(unsafe.Pointer(&slice))
+
+	// update its capacity and length
+	header.Len *= 4
+	header.Cap *= 4
+
+	// instantiate result and use KeepAlive so data isn't unmapped.
+	result := *(*[]byte)(unsafe.Pointer(&header))
+	runtime.KeepAlive(&slice)
+
+	// return it
+	return result
+}
+
 func (bc *bitmapContainer) asLittleEndianByteSlice() []byte {
 	return uint64SliceAsByteSlice(bc.bitmap)
 }
@@ -132,3 +150,503 @@ func byteSliceAsInterval16Slice(slice []byte) (result []interval16) {
 	// return result
 	return
 }
+
+func byteSliceAsContainerSlice(slice []byte) (result []container) {
+	var c container
+	containerSize := int(unsafe.Sizeof(c))
+
+	if len(slice)%containerSize != 0 {
+		panic("Slice size should be divisible by unsafe.Sizeof(container)")
+	}
+	// reference: https://go101.org/article/unsafe.html
+
+	// make a new slice header
+	bHeader := (*reflect.SliceHeader)(unsafe.Pointer(&slice))
+	rHeader := (*reflect.SliceHeader)(unsafe.Pointer(&result))
+
+	// transfer the data from the given slice to a new variable (our result)
+	rHeader.Data = bHeader.Data
+	rHeader.Len = bHeader.Len / containerSize
+	rHeader.Cap = bHeader.Cap / containerSize
+
+	// instantiate result and use KeepAlive so data isn't unmapped.
+	runtime.KeepAlive(&slice) // it is still crucial, GC can free it)
+
+	// return result
+	return
+}
+
+func byteSliceAsBitsetSlice(slice []byte) (result []bitmapContainer) {
+	bitsetSize := int(unsafe.Sizeof(bitmapContainer{}))
+	if len(slice)%bitsetSize != 0 {
+		panic("Slice size should be divisible by unsafe.Sizeof(bitmapContainer)")
+	}
+	// reference: https://go101.org/article/unsafe.html
+
+	// make a new slice header
+	bHeader := (*reflect.SliceHeader)(unsafe.Pointer(&slice))
+	rHeader := (*reflect.SliceHeader)(unsafe.Pointer(&result))
+
+	// transfer the data from the given slice to a new variable (our result)
+	rHeader.Data = bHeader.Data
+	rHeader.Len = bHeader.Len / bitsetSize
+	rHeader.Cap = bHeader.Cap / bitsetSize
+
+	// instantiate result and use KeepAlive so data isn't unmapped.
+	runtime.KeepAlive(&slice) // it is still crucial, GC can free it)
+
+	// return result
+	return
+}
+
+func byteSliceAsArraySlice(slice []byte) (result []arrayContainer) {
+	arraySize := int(unsafe.Sizeof(arrayContainer{}))
+	if len(slice)%arraySize != 0 {
+		panic("Slice size should be divisible by unsafe.Sizeof(arrayContainer)")
+	}
+	// reference: https://go101.org/article/unsafe.html
+
+	// make a new slice header
+	bHeader := (*reflect.SliceHeader)(unsafe.Pointer(&slice))
+	rHeader := (*reflect.SliceHeader)(unsafe.Pointer(&result))
+
+	// transfer the data from the given slice to a new variable (our result)
+	rHeader.Data = bHeader.Data
+	rHeader.Len = bHeader.Len / arraySize
+	rHeader.Cap = bHeader.Cap / arraySize
+
+	// instantiate result and use KeepAlive so data isn't unmapped.
+	runtime.KeepAlive(&slice) // it is still crucial, GC can free it)
+
+	// return result
+	return
+}
+
+func byteSliceAsRun16Slice(slice []byte) (result []runContainer16) {
+	run16Size := int(unsafe.Sizeof(runContainer16{}))
+	if len(slice)%run16Size != 0 {
+		panic("Slice size should be divisible by unsafe.Sizeof(runContainer16)")
+	}
+	// reference: https://go101.org/article/unsafe.html
+
+	// make a new slice header
+	bHeader := (*reflect.SliceHeader)(unsafe.Pointer(&slice))
+	rHeader := (*reflect.SliceHeader)(unsafe.Pointer(&result))
+
+	// transfer the data from the given slice to a new variable (our result)
+	rHeader.Data = bHeader.Data
+	rHeader.Len = bHeader.Len / run16Size
+	rHeader.Cap = bHeader.Cap / run16Size
+
+	// instantiate result and use KeepAlive so data isn't unmapped.
+	runtime.KeepAlive(&slice) // it is still crucial, GC can free it)
+
+	// return result
+	return
+}
+
+func byteSliceAsBoolSlice(slice []byte) (result []bool) {
+	boolSize := int(unsafe.Sizeof(true))
+	if len(slice)%boolSize != 0 {
+		panic("Slice size should be divisible by unsafe.Sizeof(bool)")
+	}
+	// reference: https://go101.org/article/unsafe.html
+
+	// make a new slice header
+	bHeader := (*reflect.SliceHeader)(unsafe.Pointer(&slice))
+	rHeader := (*reflect.SliceHeader)(unsafe.Pointer(&result))
+
+	// transfer the data from the given slice to a new variable (our result)
+	rHeader.Data = bHeader.Data
+	rHeader.Len = bHeader.Len / boolSize
+	rHeader.Cap = bHeader.Cap / boolSize
+
+	// instantiate result and use KeepAlive so data isn't unmapped.
+	runtime.KeepAlive(&slice) // it is still crucial, GC can free it)
+
+	// return result
+	return
+}
+
+// FrozenView creates a static view of a serialized bitmap stored in buf.
+// It uses CRoaring's frozen bitmap format.
+//
+// The format specification is available here:
+// https://github.com/RoaringBitmap/CRoaring/blob/2c867e9f9c9e2a3a7032791f94c4c7ae3013f6e0/src/roaring.c#L2756-L2783
+//
+// The provided byte array (buf) is expected to be a constant.
+// The function makes the best effort attempt not to copy data.
+// Only little endian is supported. The function will err if it detects a big
+// endian serialized file.
+// You should take care not to modify buff as it will likely result in
+// unexpected program behavior.
+// If said buffer comes from a memory map, it's advisable to give it read
+// only permissions, either at creation or by calling Mprotect from the
+// golang.org/x/sys/unix package.
+//
+// Resulting bitmaps are effectively immutable in the following sense:
+// a copy-on-write marker is used so that when you modify the resulting
+// bitmap, copies of selected data (containers) are made.
+// You should *not* change the copy-on-write status of the resulting
+// bitmaps (SetCopyOnWrite).
+//
+// If buf becomes unavailable, then a bitmap created with
+// FromBuffer would be effectively broken. Furthermore, any
+// bitmap derived from this bitmap (e.g., via Or, And) might
+// also be broken. Thus, before making buf unavailable, you should
+// call CloneCopyOnWriteContainers on all such bitmaps.
+//
+func (rb *Bitmap) FrozenView(buf []byte) error {
+	return rb.highlowcontainer.frozenView(buf)
+}
+
+/* Verbatim specification from CRoaring.
+ *
+ * FROZEN SERIALIZATION FORMAT DESCRIPTION
+ *
+ * -- (beginning must be aligned by 32 bytes) --
+ * <bitset_data> uint64_t[BITSET_CONTAINER_SIZE_IN_WORDS * num_bitset_containers]
+ * <run_data>    rle16_t[total number of rle elements in all run containers]
+ * <array_data>  uint16_t[total number of array elements in all array containers]
+ * <keys>        uint16_t[num_containers]
+ * <counts>      uint16_t[num_containers]
+ * <typecodes>   uint8_t[num_containers]
+ * <header>      uint32_t
+ *
+ * <header> is a 4-byte value which is a bit union of FROZEN_COOKIE (15 bits)
+ * and the number of containers (17 bits).
+ *
+ * <counts> stores number of elements for every container.
+ * Its meaning depends on container type.
+ * For array and bitset containers, this value is the container cardinality minus one.
+ * For run container, it is the number of rle_t elements (n_runs).
+ *
+ * <bitset_data>,<array_data>,<run_data> are flat arrays of elements of
+ * all containers of respective type.
+ *
+ * <*_data> and <keys> are kept close together because they are not accessed
+ * during deserilization. This may reduce IO in case of large mmaped bitmaps.
+ * All members have their native alignments during deserilization except <header>,
+ * which is not guaranteed to be aligned by 4 bytes.
+ */
+const FROZEN_COOKIE = 13766
+
+var (
+	FrozenBitmapInvalidCookie   = errors.New("header does not contain the FROZEN_COOKIE")
+	FrozenBitmapBigEndian       = errors.New("loading big endian frozen bitmaps is not supported")
+	FrozenBitmapIncomplete      = errors.New("input buffer too small to contain a frozen bitmap")
+	FrozenBitmapOverpopulated   = errors.New("too many containers")
+	FrozenBitmapUnexpectedData  = errors.New("spurious data in input")
+	FrozenBitmapInvalidTypecode = errors.New("unrecognized typecode")
+	FrozenBitmapBufferTooSmall  = errors.New("buffer too small")
+)
+
+func (ra *roaringArray) frozenView(buf []byte) error {
+	if len(buf) < 4 {
+		return FrozenBitmapIncomplete
+	}
+
+	headerBE := binary.BigEndian.Uint32(buf[len(buf)-4:])
+	if headerBE&0x7fff == FROZEN_COOKIE {
+		return FrozenBitmapBigEndian
+	}
+
+	header := binary.LittleEndian.Uint32(buf[len(buf)-4:])
+	buf = buf[:len(buf)-4]
+
+	if header&0x7fff != FROZEN_COOKIE {
+		return FrozenBitmapInvalidCookie
+	}
+
+	nCont := int(header >> 15)
+	if nCont > (1 << 16) {
+		return FrozenBitmapOverpopulated
+	}
+
+	// 1 byte per type, 2 bytes per key, 2 bytes per count.
+	if len(buf) < 5*nCont {
+		return FrozenBitmapIncomplete
+	}
+
+	types := buf[len(buf)-nCont:]
+	buf = buf[:len(buf)-nCont]
+
+	counts := byteSliceAsUint16Slice(buf[len(buf)-2*nCont:])
+	buf = buf[:len(buf)-2*nCont]
+
+	keys := byteSliceAsUint16Slice(buf[len(buf)-2*nCont:])
+	buf = buf[:len(buf)-2*nCont]
+
+	nBitmap, nArray, nRun := 0, 0, 0
+	nArrayEl, nRunEl := 0, 0
+	for i, t := range types {
+		switch t {
+		case 1:
+			nBitmap++
+		case 2:
+			nArray++
+			nArrayEl += int(counts[i]) + 1
+		case 3:
+			nRun++
+			nRunEl += int(counts[i])
+		default:
+			return FrozenBitmapInvalidTypecode
+		}
+	}
+
+	if len(buf) < (1<<13)*nBitmap+4*nRunEl+2*nArrayEl {
+		return FrozenBitmapIncomplete
+	}
+
+	bitsetsArena := byteSliceAsUint64Slice(buf[:(1<<13)*nBitmap])
+	buf = buf[(1<<13)*nBitmap:]
+
+	runsArena := byteSliceAsInterval16Slice(buf[:4*nRunEl])
+	buf = buf[4*nRunEl:]
+
+	arraysArena := byteSliceAsUint16Slice(buf[:2*nArrayEl])
+	buf = buf[2*nArrayEl:]
+
+	if len(buf) != 0 {
+		return FrozenBitmapUnexpectedData
+	}
+
+	var c container
+	containersSz := int(unsafe.Sizeof(c))*nCont
+	bitsetsSz := int(unsafe.Sizeof(bitmapContainer{}))*nBitmap
+	arraysSz := int(unsafe.Sizeof(arrayContainer{}))*nArray
+	runsSz := int(unsafe.Sizeof(runContainer16{}))*nRun
+	needCOWSz := int(unsafe.Sizeof(true))*nCont
+
+	bitmapArenaSz := containersSz + bitsetsSz + arraysSz + runsSz + needCOWSz
+	bitmapArena := make([]byte, bitmapArenaSz)
+
+	containers := byteSliceAsContainerSlice(bitmapArena[:containersSz])
+	bitmapArena = bitmapArena[containersSz:]
+
+	bitsets := byteSliceAsBitsetSlice(bitmapArena[:bitsetsSz])
+	bitmapArena = bitmapArena[bitsetsSz:]
+
+	arrays := byteSliceAsArraySlice(bitmapArena[:arraysSz])
+	bitmapArena = bitmapArena[arraysSz:]
+
+	runs := byteSliceAsRun16Slice(bitmapArena[:runsSz])
+	bitmapArena = bitmapArena[runsSz:]
+
+	needCOW := byteSliceAsBoolSlice(bitmapArena)
+
+	iBitset, iArray, iRun := 0, 0, 0
+	for i, t := range types {
+		needCOW[i] = true
+
+		switch t {
+		case 1:
+			containers[i] = &bitsets[iBitset]
+			bitsets[iBitset].cardinality = int(counts[i]) + 1
+			bitsets[iBitset].bitmap = bitsetsArena[:1024]
+			bitsetsArena = bitsetsArena[1024:]
+			iBitset++
+		case 2:
+			containers[i] = &arrays[iArray]
+			sz := int(counts[i]) + 1
+			arrays[iArray].content = arraysArena[:sz]
+			arraysArena = arraysArena[sz:]
+			iArray++
+		case 3:
+			containers[i] = &runs[iRun]
+			runs[iRun].iv = runsArena[:counts[i]]
+			runsArena = runsArena[counts[i]:]
+			iRun++
+		}
+	}
+
+	// Not consuming the full input is a bug.
+	if iBitset != nBitmap || len(bitsetsArena) != 0 ||
+		iArray != nArray || len(arraysArena) != 0 ||
+		iRun != nRun || len(runsArena) != 0 {
+		panic("we missed something")
+	}
+
+	ra.keys = keys
+	ra.containers = containers
+	ra.needCopyOnWrite = needCOW
+	ra.copyOnWrite = true
+
+	return nil
+}
+
+func (bm *Bitmap) GetFrozenSizeInBytes() uint64 {
+	nBits, nArrayEl, nRunEl := uint64(0), uint64(0), uint64(0)
+	for _, c := range bm.highlowcontainer.containers {
+		switch v := c.(type) {
+		case *bitmapContainer:
+			nBits++
+		case *arrayContainer:
+			nArrayEl += uint64(len(v.content))
+		case *runContainer16:
+			nRunEl += uint64(len(v.iv))
+		}
+	}
+	return 4 + 5*uint64(len(bm.highlowcontainer.containers)) +
+		(nBits << 13) + 2*nArrayEl + 4*nRunEl
+}
+
+func (bm *Bitmap) Freeze() ([]byte, error) {
+	sz := bm.GetFrozenSizeInBytes()
+	buf := make([]byte, sz)
+	_, err := bm.FreezeTo(buf)
+	return buf, err
+}
+
+func (bm *Bitmap) FreezeTo(buf []byte) (int, error) {
+	containers := bm.highlowcontainer.containers
+	nCont := len(containers)
+
+	nBits, nArrayEl, nRunEl := 0, 0, 0
+	for _, c := range containers {
+		switch v := c.(type) {
+		case *bitmapContainer:
+			nBits++
+		case *arrayContainer:
+			nArrayEl += len(v.content)
+		case *runContainer16:
+			nRunEl += len(v.iv)
+		}
+	}
+
+	serialSize := 4 + 5*nCont + (1<<13)*nBits + 4*nRunEl + 2*nArrayEl
+	if len(buf) < serialSize {
+		return 0, FrozenBitmapBufferTooSmall
+	}
+
+	bitsArena := byteSliceAsUint64Slice(buf[:(1<<13)*nBits])
+	buf = buf[(1<<13)*nBits:]
+
+	runsArena := byteSliceAsInterval16Slice(buf[:4*nRunEl])
+	buf = buf[4*nRunEl:]
+
+	arraysArena := byteSliceAsUint16Slice(buf[:2*nArrayEl])
+	buf = buf[2*nArrayEl:]
+
+	keys := byteSliceAsUint16Slice(buf[:2*nCont])
+	buf = buf[2*nCont:]
+
+	counts := byteSliceAsUint16Slice(buf[:2*nCont])
+	buf = buf[2*nCont:]
+
+	types := buf[:nCont]
+	buf = buf[nCont:]
+
+	header := uint32(FROZEN_COOKIE | (nCont << 15))
+	binary.LittleEndian.PutUint32(buf[:4], header)
+
+	copy(keys, bm.highlowcontainer.keys[:])
+
+	for i, c := range containers {
+		switch v := c.(type) {
+		case *bitmapContainer:
+			copy(bitsArena, v.bitmap)
+			bitsArena = bitsArena[1024:]
+			counts[i] = uint16(v.cardinality - 1)
+			types[i] = 1
+		case *arrayContainer:
+			copy(arraysArena, v.content)
+			arraysArena = arraysArena[len(v.content):]
+			elems := len(v.content)
+			counts[i] = uint16(elems - 1)
+			types[i] = 2
+		case *runContainer16:
+			copy(runsArena, v.iv)
+			runs := len(v.iv)
+			runsArena = runsArena[runs:]
+			counts[i] = uint16(runs)
+			types[i] = 3
+		}
+	}
+
+	return serialSize, nil
+}
+
+func (bm *Bitmap) WriteFrozenTo(wr io.Writer) (int, error) {
+	// FIXME: this is a naive version that iterates 4 times through the
+	// containers and allocates 3*len(containers) bytes; it's quite likely
+	// it can be done more efficiently.
+	containers := bm.highlowcontainer.containers
+	written := 0
+
+	for _, c := range containers {
+		c, ok := c.(*bitmapContainer)
+		if !ok {
+			continue
+		}
+		n, err := wr.Write(uint64SliceAsByteSlice(c.bitmap))
+		written += n
+		if err != nil {
+			return written, err
+		}
+	}
+
+	for _, c := range containers {
+		c, ok := c.(*runContainer16)
+		if !ok {
+			continue
+		}
+		n, err := wr.Write(interval16SliceAsByteSlice(c.iv))
+		written += n
+		if err != nil {
+			return written, err
+		}
+	}
+
+	for _, c := range containers {
+		c, ok := c.(*arrayContainer)
+		if !ok {
+			continue
+		}
+		n, err := wr.Write(uint16SliceAsByteSlice(c.content))
+		written += n
+		if err != nil {
+			return written, err
+		}
+	}
+
+	n, err := wr.Write(uint16SliceAsByteSlice(bm.highlowcontainer.keys))
+	written += n
+	if err != nil {
+		return written, err
+	}
+
+	countTypeBuf := make([]byte, 3*len(containers))
+	counts := byteSliceAsUint16Slice(countTypeBuf[:2*len(containers)])
+	types := countTypeBuf[2*len(containers):]
+
+	for i, c := range containers {
+		switch c := c.(type) {
+		case *bitmapContainer:
+			counts[i] = uint16(c.cardinality - 1)
+			types[i] = 1
+		case *arrayContainer:
+			elems := len(c.content)
+			counts[i] = uint16(elems - 1)
+			types[i] = 2
+		case *runContainer16:
+			runs := len(c.iv)
+			counts[i] = uint16(runs)
+			types[i] = 3
+		}
+	}
+
+	n, err = wr.Write(countTypeBuf)
+	written += n
+	if err != nil {
+		return written, err
+	}
+
+	header := uint32(FROZEN_COOKIE | (len(containers) << 15))
+	if err := binary.Write(wr, binary.LittleEndian, header); err != nil {
+		return written, err
+	}
+	written += 4
+
+	return written, nil
+}

vendor/github.com/RoaringBitmap/roaring/serializationfuzz.go

@@ -1,3 +1,4 @@
+//go:build gofuzz
 // +build gofuzz
 
 package roaring

vendor/github.com/RoaringBitmap/roaring/setutil_arm64.go

@@ -1,3 +1,4 @@
+//go:build arm64 && !gccgo && !appengine
 // +build arm64,!gccgo,!appengine
 
 package roaring

vendor/github.com/RoaringBitmap/roaring/setutil_generic.go

@@ -1,3 +1,4 @@
+//go:build !arm64 || gccgo || appengine
 // +build !arm64 gccgo appengine
 
 package roaring

vendor/github.com/RoaringBitmap/roaring/smat.go

@@ -1,3 +1,4 @@
+//go:build gofuzz
 // +build gofuzz
 
 /*
@@ -62,8 +63,8 @@ import (
 	"fmt"
 	"sort"
 
+	"github.com/bits-and-blooms/bitset"
 	"github.com/mschoch/smat"
-	"github.com/willf/bitset"
 )
 
 // fuzz test using state machine driven by byte stream.

vendor/github.com/bits-and-blooms/bitset/.gitignore

@@ -20,3 +20,7 @@ _cgo_export.*
 _testmain.go
 
 *.exe
+*.test
+*.prof
+
+target

vendor/github.com/bits-and-blooms/bitset/.travis.yml

@@ -0,0 +1,37 @@
+language: go
+
+sudo: false
+
+branches:
+  except:
+    - release
+
+branches:
+  only:
+    - master
+    - travis
+
+go:
+  - "1.11.x"
+  - tip
+
+matrix:
+  allow_failures:
+    - go: tip
+
+before_install:
+  - if [ -n "$GH_USER" ]; then git config --global github.user ${GH_USER}; fi;
+  - if [ -n "$GH_TOKEN" ]; then git config --global github.token ${GH_TOKEN}; fi;
+  - go get github.com/mattn/goveralls
+
+before_script:
+  - make deps
+
+script:
+  - make qa
+
+after_failure:
+  - cat ./target/test/report.xml
+
+after_success:
+  - if [ "$TRAVIS_GO_VERSION" = "1.11.1" ]; then $HOME/gopath/bin/goveralls -covermode=count -coverprofile=target/report/coverage.out -service=travis-ci; fi;

vendor/github.com/bits-and-blooms/bitset/LICENSE

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

vendor/github.com/bits-and-blooms/bitset/README.md

@@ -0,0 +1,93 @@
+# bitset
+
+*Go language library to map between non-negative integers and boolean values*
+
+[![Test](https://github.com/bits-and-blooms/bitset/workflows/Test/badge.svg)](https://github.com/willf/bitset/actions?query=workflow%3ATest)
+[![Go Report Card](https://goreportcard.com/badge/github.com/willf/bitset)](https://goreportcard.com/report/github.com/willf/bitset)
+[![PkgGoDev](https://pkg.go.dev/badge/github.com/bits-and-blooms/bitset?tab=doc)](https://pkg.go.dev/github.com/bits-and-blooms/bitset?tab=doc)
+
+
+## Description
+
+Package bitset implements bitsets, a mapping between non-negative integers and boolean values.
+It should be more efficient than map[uint] bool.
+
+It provides methods for setting, clearing, flipping, and testing individual integers.
+
+But it also provides set intersection, union, difference, complement, and symmetric operations, as well as tests to check whether any, all, or no bits are set, and querying a bitset's current length and number of positive bits.
+
+BitSets are expanded to the size of the largest set bit; the memory allocation is approximately Max bits, where Max is the largest set bit. BitSets are never shrunk. On creation, a hint can be given for the number of bits that will be used.
+
+Many of the methods, including Set, Clear, and Flip, return a BitSet pointer, which allows for chaining.
+
+### Example use:
+
+```go
+package main
+
+import (
+	"fmt"
+	"math/rand"
+
+	"github.com/bits-and-blooms/bitset"
+)
+
+func main() {
+	fmt.Printf("Hello from BitSet!\n")
+	var b bitset.BitSet
+	// play some Go Fish
+	for i := 0; i < 100; i++ {
+		card1 := uint(rand.Intn(52))
+		card2 := uint(rand.Intn(52))
+		b.Set(card1)
+		if b.Test(card2) {
+			fmt.Println("Go Fish!")
+		}
+		b.Clear(card1)
+	}
+
+	// Chaining
+	b.Set(10).Set(11)
+
+	for i, e := b.NextSet(0); e; i, e = b.NextSet(i + 1) {
+		fmt.Println("The following bit is set:", i)
+	}
+	if b.Intersection(bitset.New(100).Set(10)).Count() == 1 {
+		fmt.Println("Intersection works.")
+	} else {
+		fmt.Println("Intersection doesn't work???")
+	}
+}
+```
+
+As an alternative to BitSets, one should check out the 'big' package, which provides a (less set-theoretical) view of bitsets.
+
+Package documentation is at: https://pkg.go.dev/github.com/bits-and-blooms/bitset?tab=doc
+
+## Memory Usage
+
+The memory usage of a bitset using N bits is at least N/8 bytes. The number of bits in a bitset is at least as large as one plus the greatest bit index you have accessed. Thus it is possible to run out of memory while using a bitset. If you have lots of bits, you might prefer compressed bitsets, like the [Roaring bitmaps](http://roaringbitmap.org) and its [Go implementation](https://github.com/RoaringBitmap/roaring).
+
+## Implementation Note
+
+Go 1.9 introduced a native `math/bits` library. We provide backward compatibility to Go 1.7, which might be removed.
+
+It is possible that a later version will match the `math/bits` return signature for counts (which is `int`, rather than our library's `unit64`). If so, the version will be bumped.
+
+## Installation
+
+```bash
+go get github.com/bits-and-blooms/bitset
+```
+
+## Contributing
+
+If you wish to contribute to this project, please branch and issue a pull request against master ("[GitHub Flow](https://guides.github.com/introduction/flow/)")
+
+## Running all tests
+
+Before committing the code, please check if it passes tests, has adequate coverage, etc.
+```bash
+go test
+go test -cover
+```

vendor/github.com/bits-and-blooms/bitset/azure-pipelines.yml

@@ -0,0 +1,39 @@
+# Go
+# Build your Go project.
+# Add steps that test, save build artifacts, deploy, and more:
+# https://docs.microsoft.com/azure/devops/pipelines/languages/go
+
+trigger:
+- master
+
+pool:
+  vmImage: 'Ubuntu-16.04'
+
+variables:
+  GOBIN:  '$(GOPATH)/bin' # Go binaries path
+  GOROOT: '/usr/local/go1.11' # Go installation path
+  GOPATH: '$(system.defaultWorkingDirectory)/gopath' # Go workspace path
+  modulePath: '$(GOPATH)/src/github.com/$(build.repository.name)' # Path to the module's code
+
+steps:
+- script: |
+    mkdir -p '$(GOBIN)'
+    mkdir -p '$(GOPATH)/pkg'
+    mkdir -p '$(modulePath)'
+    shopt -s extglob
+    shopt -s dotglob
+    mv !(gopath) '$(modulePath)'
+    echo '##vso[task.prependpath]$(GOBIN)'
+    echo '##vso[task.prependpath]$(GOROOT)/bin'
+  displayName: 'Set up the Go workspace'
+
+- script: |
+    go version
+    go get -v -t -d ./...
+    if [ -f Gopkg.toml ]; then
+        curl https://raw.githubusercontent.com/golang/dep/master/install.sh | sh
+        dep ensure
+    fi
+    go build -v .
+  workingDirectory: '$(modulePath)'
+  displayName: 'Get dependencies, then build'

vendor/github.com/bits-and-blooms/bitset/popcnt.go

@@ -0,0 +1,53 @@
+package bitset
+
+// bit population count, take from
+// https://code.google.com/p/go/issues/detail?id=4988#c11
+// credit: https://code.google.com/u/arnehormann/
+func popcount(x uint64) (n uint64) {
+	x -= (x >> 1) & 0x5555555555555555
+	x = (x>>2)&0x3333333333333333 + x&0x3333333333333333
+	x += x >> 4
+	x &= 0x0f0f0f0f0f0f0f0f
+	x *= 0x0101010101010101
+	return x >> 56
+}
+
+func popcntSliceGo(s []uint64) uint64 {
+	cnt := uint64(0)
+	for _, x := range s {
+		cnt += popcount(x)
+	}
+	return cnt
+}
+
+func popcntMaskSliceGo(s, m []uint64) uint64 {
+	cnt := uint64(0)
+	for i := range s {
+		cnt += popcount(s[i] &^ m[i])
+	}
+	return cnt
+}
+
+func popcntAndSliceGo(s, m []uint64) uint64 {
+	cnt := uint64(0)
+	for i := range s {
+		cnt += popcount(s[i] & m[i])
+	}
+	return cnt
+}
+
+func popcntOrSliceGo(s, m []uint64) uint64 {
+	cnt := uint64(0)
+	for i := range s {
+		cnt += popcount(s[i] | m[i])
+	}
+	return cnt
+}
+
+func popcntXorSliceGo(s, m []uint64) uint64 {
+	cnt := uint64(0)
+	for i := range s {
+		cnt += popcount(s[i] ^ m[i])
+	}
+	return cnt
+}

vendor/github.com/bits-and-blooms/bitset/popcnt_19.go

@@ -0,0 +1,45 @@
+// +build go1.9
+
+package bitset
+
+import "math/bits"
+
+func popcntSlice(s []uint64) uint64 {
+	var cnt int
+	for _, x := range s {
+		cnt += bits.OnesCount64(x)
+	}
+	return uint64(cnt)
+}
+
+func popcntMaskSlice(s, m []uint64) uint64 {
+	var cnt int
+	for i := range s {
+		cnt += bits.OnesCount64(s[i] &^ m[i])
+	}
+	return uint64(cnt)
+}
+
+func popcntAndSlice(s, m []uint64) uint64 {
+	var cnt int
+	for i := range s {
+		cnt += bits.OnesCount64(s[i] & m[i])
+	}
+	return uint64(cnt)
+}
+
+func popcntOrSlice(s, m []uint64) uint64 {
+	var cnt int
+	for i := range s {
+		cnt += bits.OnesCount64(s[i] | m[i])
+	}
+	return uint64(cnt)
+}
+
+func popcntXorSlice(s, m []uint64) uint64 {
+	var cnt int
+	for i := range s {
+		cnt += bits.OnesCount64(s[i] ^ m[i])
+	}
+	return uint64(cnt)
+}

vendor/github.com/bits-and-blooms/bitset/popcnt_amd64.go

@@ -0,0 +1,68 @@
+// +build !go1.9
+// +build amd64,!appengine
+
+package bitset
+
+// *** the following functions are defined in popcnt_amd64.s
+
+//go:noescape
+
+func hasAsm() bool
+
+// useAsm is a flag used to select the GO or ASM implementation of the popcnt function
+var useAsm = hasAsm()
+
+//go:noescape
+
+func popcntSliceAsm(s []uint64) uint64
+
+//go:noescape
+
+func popcntMaskSliceAsm(s, m []uint64) uint64
+
+//go:noescape
+
+func popcntAndSliceAsm(s, m []uint64) uint64
+
+//go:noescape
+
+func popcntOrSliceAsm(s, m []uint64) uint64
+
+//go:noescape
+
+func popcntXorSliceAsm(s, m []uint64) uint64
+
+func popcntSlice(s []uint64) uint64 {
+	if useAsm {
+		return popcntSliceAsm(s)
+	}
+	return popcntSliceGo(s)
+}
+
+func popcntMaskSlice(s, m []uint64) uint64 {
+	if useAsm {
+		return popcntMaskSliceAsm(s, m)
+	}
+	return popcntMaskSliceGo(s, m)
+}
+
+func popcntAndSlice(s, m []uint64) uint64 {
+	if useAsm {
+		return popcntAndSliceAsm(s, m)
+	}
+	return popcntAndSliceGo(s, m)
+}
+
+func popcntOrSlice(s, m []uint64) uint64 {
+	if useAsm {
+		return popcntOrSliceAsm(s, m)
+	}
+	return popcntOrSliceGo(s, m)
+}
+
+func popcntXorSlice(s, m []uint64) uint64 {
+	if useAsm {
+		return popcntXorSliceAsm(s, m)
+	}
+	return popcntXorSliceGo(s, m)
+}

vendor/github.com/bits-and-blooms/bitset/popcnt_amd64.s

@@ -0,0 +1,104 @@
+// +build !go1.9
+// +build amd64,!appengine
+
+TEXT ·hasAsm(SB),4,$0-1
+MOVQ $1, AX
+CPUID
+SHRQ $23, CX
+ANDQ $1, CX
+MOVB CX, ret+0(FP)
+RET
+
+#define POPCNTQ_DX_DX BYTE $0xf3; BYTE $0x48; BYTE $0x0f; BYTE $0xb8; BYTE $0xd2
+
+TEXT ·popcntSliceAsm(SB),4,$0-32
+XORQ	AX, AX
+MOVQ	s+0(FP), SI
+MOVQ	s_len+8(FP), CX
+TESTQ	CX, CX
+JZ		popcntSliceEnd
+popcntSliceLoop:
+BYTE $0xf3; BYTE $0x48; BYTE $0x0f; BYTE $0xb8; BYTE $0x16 // POPCNTQ (SI), DX
+ADDQ	DX, AX
+ADDQ	$8, SI
+LOOP	popcntSliceLoop
+popcntSliceEnd:
+MOVQ	AX, ret+24(FP)
+RET
+
+TEXT ·popcntMaskSliceAsm(SB),4,$0-56
+XORQ	AX, AX
+MOVQ	s+0(FP), SI
+MOVQ	s_len+8(FP), CX
+TESTQ	CX, CX
+JZ		popcntMaskSliceEnd
+MOVQ	m+24(FP), DI
+popcntMaskSliceLoop:
+MOVQ	(DI), DX
+NOTQ	DX
+ANDQ	(SI), DX
+POPCNTQ_DX_DX
+ADDQ	DX, AX
+ADDQ	$8, SI
+ADDQ	$8, DI
+LOOP	popcntMaskSliceLoop
+popcntMaskSliceEnd:
+MOVQ	AX, ret+48(FP)
+RET
+
+TEXT ·popcntAndSliceAsm(SB),4,$0-56
+XORQ	AX, AX
+MOVQ	s+0(FP), SI
+MOVQ	s_len+8(FP), CX
+TESTQ	CX, CX
+JZ		popcntAndSliceEnd
+MOVQ	m+24(FP), DI
+popcntAndSliceLoop:
+MOVQ	(DI), DX
+ANDQ	(SI), DX
+POPCNTQ_DX_DX
+ADDQ	DX, AX
+ADDQ	$8, SI
+ADDQ	$8, DI
+LOOP	popcntAndSliceLoop
+popcntAndSliceEnd:
+MOVQ	AX, ret+48(FP)
+RET
+
+TEXT ·popcntOrSliceAsm(SB),4,$0-56
+XORQ	AX, AX
+MOVQ	s+0(FP), SI
+MOVQ	s_len+8(FP), CX
+TESTQ	CX, CX
+JZ		popcntOrSliceEnd
+MOVQ	m+24(FP), DI
+popcntOrSliceLoop:
+MOVQ	(DI), DX
+ORQ		(SI), DX
+POPCNTQ_DX_DX
+ADDQ	DX, AX
+ADDQ	$8, SI
+ADDQ	$8, DI
+LOOP	popcntOrSliceLoop
+popcntOrSliceEnd:
+MOVQ	AX, ret+48(FP)
+RET
+
+TEXT ·popcntXorSliceAsm(SB),4,$0-56
+XORQ	AX, AX
+MOVQ	s+0(FP), SI
+MOVQ	s_len+8(FP), CX
+TESTQ	CX, CX
+JZ		popcntXorSliceEnd
+MOVQ	m+24(FP), DI
+popcntXorSliceLoop:
+MOVQ	(DI), DX
+XORQ	(SI), DX
+POPCNTQ_DX_DX
+ADDQ	DX, AX
+ADDQ	$8, SI
+ADDQ	$8, DI
+LOOP	popcntXorSliceLoop
+popcntXorSliceEnd:
+MOVQ	AX, ret+48(FP)
+RET

vendor/github.com/bits-and-blooms/bitset/popcnt_generic.go

@@ -0,0 +1,24 @@
+// +build !go1.9
+// +build !amd64 appengine
+
+package bitset
+
+func popcntSlice(s []uint64) uint64 {
+	return popcntSliceGo(s)
+}
+
+func popcntMaskSlice(s, m []uint64) uint64 {
+	return popcntMaskSliceGo(s, m)
+}
+
+func popcntAndSlice(s, m []uint64) uint64 {
+	return popcntAndSliceGo(s, m)
+}
+
+func popcntOrSlice(s, m []uint64) uint64 {
+	return popcntOrSliceGo(s, m)
+}
+
+func popcntXorSlice(s, m []uint64) uint64 {
+	return popcntXorSliceGo(s, m)
+}

vendor/github.com/bits-and-blooms/bitset/trailing_zeros_18.go

@@ -0,0 +1,14 @@
+// +build !go1.9
+
+package bitset
+
+var deBruijn = [...]byte{
+	0, 1, 56, 2, 57, 49, 28, 3, 61, 58, 42, 50, 38, 29, 17, 4,
+	62, 47, 59, 36, 45, 43, 51, 22, 53, 39, 33, 30, 24, 18, 12, 5,
+	63, 55, 48, 27, 60, 41, 37, 16, 46, 35, 44, 21, 52, 32, 23, 11,
+	54, 26, 40, 15, 34, 20, 31, 10, 25, 14, 19, 9, 13, 8, 7, 6,
+}
+
+func trailingZeroes64(v uint64) uint {
+	return uint(deBruijn[((v&-v)*0x03f79d71b4ca8b09)>>58])
+}

vendor/github.com/bits-and-blooms/bitset/trailing_zeros_19.go

@@ -0,0 +1,9 @@
+// +build go1.9
+
+package bitset
+
+import "math/bits"
+
+func trailingZeroes64(v uint64) uint {
+	return uint(bits.TrailingZeros64(v))
+}

vendor/github.com/blevesearch/segment/.travis.yml

@@ -1,15 +0,0 @@
-language: go
-
-go:
- - 1.7
-
-script:
-  - go get golang.org/x/tools/cmd/cover
-  - go get github.com/mattn/goveralls
-  - go test -v -covermode=count -coverprofile=profile.out
-  - go vet 
-  - goveralls -service drone.io -coverprofile=profile.out -repotoken $COVERALLS
-
-notifications:
-  email:
-    - marty.schoch@gmail.com

vendor/github.com/blevesearch/segment/README.md

@@ -1,5 +1,7 @@
 # segment
 
+[![Tests](https://github.com/blevesearch/segment/workflows/Tests/badge.svg?branch=master&event=push)](https://github.com/blevesearch/segment/actions?query=workflow%3ATests+event%3Apush+branch%3Amaster)
+
 A Go library for performing Unicode Text Segmentation
 as described in [Unicode Standard Annex #29](http://www.unicode.org/reports/tr29/)
 

vendor/github.com/cpuguy83/go-md2man/v2/md2man/roff.go

@@ -15,7 +15,7 @@ type roffRenderer struct {
 	extensions   blackfriday.Extensions
 	listCounters []int
 	firstHeader  bool
-	defineTerm   bool
+	firstDD      bool
 	listDepth    int
 }
 
@@ -42,7 +42,8 @@ const (
 	quoteCloseTag    = "\n.RE\n"
 	listTag          = "\n.RS\n"
 	listCloseTag     = "\n.RE\n"
-	arglistTag       = "\n.TP\n"
+	dtTag            = "\n.TP\n"
+	dd2Tag           = "\n"
 	tableStart       = "\n.TS\nallbox;\n"
 	tableEnd         = ".TE\n"
 	tableCellStart   = "T{\n"
@@ -90,7 +91,7 @@ func (r *roffRenderer) RenderNode(w io.Writer, node *blackfriday.Node, entering
 
 	switch node.Type {
 	case blackfriday.Text:
-		r.handleText(w, node, entering)
+		escapeSpecialChars(w, node.Literal)
 	case blackfriday.Softbreak:
 		out(w, crTag)
 	case blackfriday.Hardbreak:
@@ -150,40 +151,21 @@ func (r *roffRenderer) RenderNode(w io.Writer, node *blackfriday.Node, entering
 		out(w, codeCloseTag)
 	case blackfriday.Table:
 		r.handleTable(w, node, entering)
-	case blackfriday.TableCell:
-		r.handleTableCell(w, node, entering)
 	case blackfriday.TableHead:
 	case blackfriday.TableBody:
 	case blackfriday.TableRow:
 		// no action as cell entries do all the nroff formatting
 		return blackfriday.GoToNext
+	case blackfriday.TableCell:
+		r.handleTableCell(w, node, entering)
+	case blackfriday.HTMLSpan:
+		// ignore other HTML tags
 	default:
 		fmt.Fprintln(os.Stderr, "WARNING: go-md2man does not handle node type "+node.Type.String())
 	}
 	return walkAction
 }
 
-func (r *roffRenderer) handleText(w io.Writer, node *blackfriday.Node, entering bool) {
-	var (
-		start, end string
-	)
-	// handle special roff table cell text encapsulation
-	if node.Parent.Type == blackfriday.TableCell {
-		if len(node.Literal) > 30 {
-			start = tableCellStart
-			end = tableCellEnd
-		} else {
-			// end rows that aren't terminated by "tableCellEnd" with a cr if end of row
-			if node.Parent.Next == nil && !node.Parent.IsHeader {
-				end = crTag
-			}
-		}
-	}
-	out(w, start)
-	escapeSpecialChars(w, node.Literal)
-	out(w, end)
-}
-
 func (r *roffRenderer) handleHeading(w io.Writer, node *blackfriday.Node, entering bool) {
 	if entering {
 		switch node.Level {
@@ -230,15 +212,20 @@ func (r *roffRenderer) handleItem(w io.Writer, node *blackfriday.Node, entering
 		if node.ListFlags&blackfriday.ListTypeOrdered != 0 {
 			out(w, fmt.Sprintf(".IP \"%3d.\" 5\n", r.listCounters[len(r.listCounters)-1]))
 			r.listCounters[len(r.listCounters)-1]++
+		} else if node.ListFlags&blackfriday.ListTypeTerm != 0 {
+			// DT (definition term): line just before DD (see below).
+			out(w, dtTag)
+			r.firstDD = true
 		} else if node.ListFlags&blackfriday.ListTypeDefinition != 0 {
-			// state machine for handling terms and following definitions
+			// DD (definition description): line that starts with ": ".
-			// since blackfriday does not distinguish them properly, nor
+			//
-			// does it seperate them into separate lists as it should
+			// We have to distinguish between the first DD and the
-			if !r.defineTerm {
+			// subsequent ones, as there should be no vertical
-				out(w, arglistTag)
+			// whitespace between the DT and the first DD.
-				r.defineTerm = true
+			if r.firstDD {
+				r.firstDD = false
 			} else {
-				r.defineTerm = false
+				out(w, dd2Tag)
 			}
 		} else {
 			out(w, ".IP \\(bu 2\n")
@@ -251,7 +238,7 @@ func (r *roffRenderer) handleItem(w io.Writer, node *blackfriday.Node, entering
 func (r *roffRenderer) handleTable(w io.Writer, node *blackfriday.Node, entering bool) {
 	if entering {
 		out(w, tableStart)
-		//call walker to count cells (and rows?) so format section can be produced
+		// call walker to count cells (and rows?) so format section can be produced
 		columns := countColumns(node)
 		out(w, strings.Repeat("l ", columns)+"\n")
 		out(w, strings.Repeat("l ", columns)+".\n")
@@ -261,28 +248,41 @@ func (r *roffRenderer) handleTable(w io.Writer, node *blackfriday.Node, entering
 }
 
 func (r *roffRenderer) handleTableCell(w io.Writer, node *blackfriday.Node, entering bool) {
-	var (
-		start, end string
-	)
-	if node.IsHeader {
-		start = codespanTag
-		end = codespanCloseTag
-	}
 	if entering {
+		var start string
 		if node.Prev != nil && node.Prev.Type == blackfriday.TableCell {
-			out(w, "\t"+start)
+			start = "\t"
-		} else {
-			out(w, start)
 		}
+		if node.IsHeader {
+			start += codespanTag
+		} else if nodeLiteralSize(node) > 30 {
+			start += tableCellStart
+		}
+		out(w, start)
 	} else {
-		// need to carriage return if we are at the end of the header row
+		var end string
-		if node.IsHeader && node.Next == nil {
+		if node.IsHeader {
-			end = end + crTag
+			end = codespanCloseTag
+		} else if nodeLiteralSize(node) > 30 {
+			end = tableCellEnd
+		}
+		if node.Next == nil && end != tableCellEnd {
+			// Last cell: need to carriage return if we are at the end of the
+			// header row and content isn't wrapped in a "tablecell"
+			end += crTag
 		}
 		out(w, end)
 	}
 }
 
+func nodeLiteralSize(node *blackfriday.Node) int {
+	total := 0
+	for n := node.FirstChild; n != nil; n = n.FirstChild {
+		total += len(n.Literal)
+	}
+	return total
+}
+
 // because roff format requires knowing the column count before outputting any table
 // data we need to walk a table tree and count the columns
 func countColumns(node *blackfriday.Node) int {
@@ -309,15 +309,6 @@ func out(w io.Writer, output string) {
 	io.WriteString(w, output) // nolint: errcheck
 }
 
-func needsBackslash(c byte) bool {
-	for _, r := range []byte("-_&\\~") {
-		if c == r {
-			return true
-		}
-	}
-	return false
-}
-
 func escapeSpecialChars(w io.Writer, text []byte) {
 	for i := 0; i < len(text); i++ {
 		// escape initial apostrophe or period
@@ -328,7 +319,7 @@ func escapeSpecialChars(w io.Writer, text []byte) {
 		// directly copy normal characters
 		org := i
 
-		for i < len(text) && !needsBackslash(text[i]) {
+		for i < len(text) && text[i] != '\\' {
 			i++
 		}
 		if i > org {

vendor/github.com/glycerine/go-unsnap-stream/LICENSE

@@ -1,21 +0,0 @@
-The MIT license.
-
-Copyright (c) 2014 the go-unsnap-stream 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.
-

vendor/github.com/glycerine/go-unsnap-stream/README.md

@@ -1,22 +0,0 @@
-go-unsnap-stream
-================
-
-This is a small golang library for decoding and encoding the snappy *streaming* format, specified here: https://github.com/google/snappy/blob/master/framing_format.txt
-
-Note that the *streaming or framing format* for snappy is different from snappy itself. Think of it as a train of boxcars: the streaming format breaks your data in chunks, applies snappy to each chunk alone, then puts a thin wrapper around the chunk, and sends it along in turn. You can begin decoding before receiving everything. And memory requirements for decoding are sane.
-
-Strangely, though the streaming format was first proposed in Go[1][2], it was never upated, and I could not locate any other library for Go that would handle the streaming/framed snappy format. Hence this implementation of the spec. There is a command line tool[3] that has a C implementation, but this is the only Go implementation that I am aware of. The reference for the framing/streaming spec seems to be the python implementation[4].
-
-Update to the previous paragraph: Horray! Good news: Thanks to @nigeltao, we have since learned that the [github.com/golang/snappy](https://github.com/golang/snappy) package now provides the snappy streaming format too. Even though the type level descriptions are a little misleading because they don't mention that they are for the stream format, the [snappy package header documentation](https://godoc.org/github.com/golang/snappy) points out that the [snappy.Reader](https://godoc.org/github.com/golang/snappy#Reader) and [snappy.Writer](https://godoc.org/github.com/golang/snappy#Writer) types do indeed provide stream (vs block) handling. Although I have not benchmarked, you should probably prefer that package as it will likely be maintained more than I have time to devote, and also perhaps better integrated with the underlying snappy as they share the same repo.
-
-For binary compatibility with the [python implementation](https://pypi.python.org/pypi/python-snappy) in [4], one could use the C-snappy compressor/decompressor code directly; using github.com/dgryski/go-csnappy. In fact we did this for a while to verify byte-for-byte compatiblity, as the native Go implementation produces slightly different binary compression (still conformant with the standard of course), which made test-diffs harder, and some have complained about it being slower than the C.
-
-However, while the c-snappy was useful for checking compatibility, it introduced dependencies on external C libraries (both the c-snappy library and the C standard library). Our go binary executable that used the go-unsnap-stream library was no longer standalone, and deployment was painful if not impossible if the target had a different C standard library. So we've gone back to using the snappy-go implementation (entirely in Go) for ease of deployment. See the comments at the top of unsnap.go if you wish to use c-snappy instead.
-
-[1] https://groups.google.com/forum/#!msg/snappy-compression/qvLNe2cSH9s/R19oBC-p7g4J
-
-[2] https://codereview.appspot.com/5167058
-
-[3] https://github.com/kubo/snzip
-
-[4] https://pypi.python.org/pypi/python-snappy

vendor/github.com/glycerine/go-unsnap-stream/rbuf.go

@@ -1,375 +0,0 @@
-package unsnap
-
-// copyright (c) 2014, Jason E. Aten
-// license: MIT
-
-// Some text from the Golang standard library doc is adapted and
-// reproduced in fragments below to document the expected behaviors
-// of the interface functions Read()/Write()/ReadFrom()/WriteTo() that
-// are implemented here. Those descriptions (see
-// http://golang.org/pkg/io/#Reader for example) are
-// copyright 2010 The Go Authors.
-
-import "io"
-
-// FixedSizeRingBuf:
-//
-//    a fixed-size circular ring buffer. Yes, just what is says.
-//
-//    We keep a pair of ping/pong buffers so that we can linearize
-//    the circular buffer into a contiguous slice if need be.
-//
-// For efficiency, a FixedSizeRingBuf may be vastly preferred to
-// a bytes.Buffer. The ReadWithoutAdvance(), Advance(), and Adopt()
-// methods are all non-standard methods written for speed.
-//
-// For an I/O heavy application, I have replaced bytes.Buffer with
-// FixedSizeRingBuf and seen memory consumption go from 8GB to 25MB.
-// Yes, that is a 300x reduction in memory footprint. Everything ran
-// faster too.
-//
-// Note that Bytes(), while inescapable at times, is expensive: avoid
-// it if possible. Instead it is better to use the FixedSizeRingBuf.Readable
-// member to get the number of bytes available. Bytes() is expensive because
-// it may copy the back and then the front of a wrapped buffer A[Use]
-// into A[1-Use] in order to get a contiguous slice. If possible use ContigLen()
-// first to get the size that can be read without copying, Read() that
-// amount, and then Read() a second time -- to avoid the copy.
-
-type FixedSizeRingBuf struct {
-	A        [2][]byte // a pair of ping/pong buffers. Only one is active.
-	Use      int       // which A buffer is in active use, 0 or 1
-	N        int       // MaxViewInBytes, the size of A[0] and A[1] in bytes.
-	Beg      int       // start of data in A[Use]
-	Readable int       // number of bytes available to read in A[Use]
-
-	OneMade bool // lazily instantiate the [1] buffer. If we never call Bytes(),
-	// we may never need it. If OneMade is false, the Use must be = 0.
-}
-
-func (b *FixedSizeRingBuf) Make2ndBuffer() {
-	if b.OneMade {
-		return
-	}
-	b.A[1] = make([]byte, b.N, b.N)
-	b.OneMade = true
-}
-
-// get the length of the largest read that we can provide to a contiguous slice
-// without an extra linearizing copy of all bytes internally.
-func (b *FixedSizeRingBuf) ContigLen() int {
-	extent := b.Beg + b.Readable
-	firstContigLen := intMin(extent, b.N) - b.Beg
-	return firstContigLen
-}
-
-func NewFixedSizeRingBuf(maxViewInBytes int) *FixedSizeRingBuf {
-	n := maxViewInBytes
-	r := &FixedSizeRingBuf{
-		Use: 0, // 0 or 1, whichever is actually in use at the moment.
-		// If we are asked for Bytes() and we wrap, linearize into the other.
-
-		N:        n,
-		Beg:      0,
-		Readable: 0,
-		OneMade:  false,
-	}
-	r.A[0] = make([]byte, n, n)
-
-	// r.A[1] initialized lazily now.
-
-	return r
-}
-
-// from the standard library description of Bytes():
-// Bytes() returns a slice of the contents of the unread portion of the buffer.
-// If the caller changes the contents of the
-// returned slice, the contents of the buffer will change provided there
-//  are no intervening method calls on the Buffer.
-//
-func (b *FixedSizeRingBuf) Bytes() []byte {
-
-	extent := b.Beg + b.Readable
-	if extent <= b.N {
-		// we fit contiguously in this buffer without wrapping to the other
-		return b.A[b.Use][b.Beg:(b.Beg + b.Readable)]
-	}
-
-	// wrap into the other buffer
-	b.Make2ndBuffer()
-
-	src := b.Use
-	dest := 1 - b.Use
-
-	n := copy(b.A[dest], b.A[src][b.Beg:])
-	n += copy(b.A[dest][n:], b.A[src][0:(extent%b.N)])
-
-	b.Use = dest
-	b.Beg = 0
-
-	return b.A[b.Use][:n]
-}
-
-// Read():
-//
-// from bytes.Buffer.Read(): Read reads the next len(p) bytes
-// from the buffer or until the buffer is drained. The return
-// value n is the number of bytes read. If the buffer has no data
-// to return, err is io.EOF (unless len(p) is zero); otherwise it is nil.
-//
-//  from the description of the Reader interface,
-//     http://golang.org/pkg/io/#Reader
-//
-/*
-Reader is the interface that wraps the basic Read method.
-
-Read reads up to len(p) bytes into p. It returns the number
-of bytes read (0 <= n <= len(p)) and any error encountered.
-Even if Read returns n < len(p), it may use all of p as scratch
-space during the call. If some data is available but not
-len(p) bytes, Read conventionally returns what is available
-instead of waiting for more.
-
-When Read encounters an error or end-of-file condition after
-successfully reading n > 0 bytes, it returns the number of bytes
-read. It may return the (non-nil) error from the same call or
-return the error (and n == 0) from a subsequent call. An instance
-of this general case is that a Reader returning a non-zero number
-of bytes at the end of the input stream may return
-either err == EOF or err == nil. The next Read should
-return 0, EOF regardless.
-
-Callers should always process the n > 0 bytes returned before
-considering the error err. Doing so correctly handles I/O errors
-that happen after reading some bytes and also both of the
-allowed EOF behaviors.
-
-Implementations of Read are discouraged from returning a zero
-byte count with a nil error, and callers should treat that
-situation as a no-op.
-*/
-//
-
-func (b *FixedSizeRingBuf) Read(p []byte) (n int, err error) {
-	return b.ReadAndMaybeAdvance(p, true)
-}
-
-// if you want to Read the data and leave it in the buffer, so as
-// to peek ahead for example.
-func (b *FixedSizeRingBuf) ReadWithoutAdvance(p []byte) (n int, err error) {
-	return b.ReadAndMaybeAdvance(p, false)
-}
-
-func (b *FixedSizeRingBuf) ReadAndMaybeAdvance(p []byte, doAdvance bool) (n int, err error) {
-	if len(p) == 0 {
-		return 0, nil
-	}
-	if b.Readable == 0 {
-		return 0, io.EOF
-	}
-	extent := b.Beg + b.Readable
-	if extent <= b.N {
-		n += copy(p, b.A[b.Use][b.Beg:extent])
-	} else {
-		n += copy(p, b.A[b.Use][b.Beg:b.N])
-		if n < len(p) {
-			n += copy(p[n:], b.A[b.Use][0:(extent%b.N)])
-		}
-	}
-	if doAdvance {
-		b.Advance(n)
-	}
-	return
-}
-
-//
-// Write writes len(p) bytes from p to the underlying data stream.
-// It returns the number of bytes written from p (0 <= n <= len(p))
-// and any error encountered that caused the write to stop early.
-// Write must return a non-nil error if it returns n < len(p).
-//
-func (b *FixedSizeRingBuf) Write(p []byte) (n int, err error) {
-	for {
-		if len(p) == 0 {
-			// nothing (left) to copy in; notice we shorten our
-			// local copy p (below) as we read from it.
-			return
-		}
-
-		writeCapacity := b.N - b.Readable
-		if writeCapacity <= 0 {
-			// we are all full up already.
-			return n, io.ErrShortWrite
-		}
-		if len(p) > writeCapacity {
-			err = io.ErrShortWrite
-			// leave err set and
-			// keep going, write what we can.
-		}
-
-		writeStart := (b.Beg + b.Readable) % b.N
-
-		upperLim := intMin(writeStart+writeCapacity, b.N)
-
-		k := copy(b.A[b.Use][writeStart:upperLim], p)
-
-		n += k
-		b.Readable += k
-		p = p[k:]
-
-		// we can fill from b.A[b.Use][0:something] from
-		// p's remainder, so loop
-	}
-}
-
-// WriteTo and ReadFrom avoid intermediate allocation and copies.
-
-// WriteTo writes data to w until there's no more data to write
-// or when an error occurs. The return value n is the number of
-// bytes written. Any error encountered during the write is also returned.
-func (b *FixedSizeRingBuf) WriteTo(w io.Writer) (n int64, err error) {
-
-	if b.Readable == 0 {
-		return 0, io.EOF
-	}
-
-	extent := b.Beg + b.Readable
-	firstWriteLen := intMin(extent, b.N) - b.Beg
-	secondWriteLen := b.Readable - firstWriteLen
-	if firstWriteLen > 0 {
-		m, e := w.Write(b.A[b.Use][b.Beg:(b.Beg + firstWriteLen)])
-		n += int64(m)
-		b.Advance(m)
-
-		if e != nil {
-			return n, e
-		}
-		// all bytes should have been written, by definition of
-		// Write method in io.Writer
-		if m != firstWriteLen {
-			return n, io.ErrShortWrite
-		}
-	}
-	if secondWriteLen > 0 {
-		m, e := w.Write(b.A[b.Use][0:secondWriteLen])
-		n += int64(m)
-		b.Advance(m)
-
-		if e != nil {
-			return n, e
-		}
-		// all bytes should have been written, by definition of
-		// Write method in io.Writer
-		if m != secondWriteLen {
-			return n, io.ErrShortWrite
-		}
-	}
-
-	return n, nil
-}
-
-// ReadFrom() reads data from r until EOF or error. The return value n
-// is the number of bytes read. Any error except io.EOF encountered
-// during the read is also returned.
-func (b *FixedSizeRingBuf) ReadFrom(r io.Reader) (n int64, err error) {
-	for {
-		writeCapacity := b.N - b.Readable
-		if writeCapacity <= 0 {
-			// we are all full
-			return n, nil
-		}
-		writeStart := (b.Beg + b.Readable) % b.N
-		upperLim := intMin(writeStart+writeCapacity, b.N)
-
-		m, e := r.Read(b.A[b.Use][writeStart:upperLim])
-		n += int64(m)
-		b.Readable += m
-		if e == io.EOF {
-			return n, nil
-		}
-		if e != nil {
-			return n, e
-		}
-	}
-}
-
-func (b *FixedSizeRingBuf) Reset() {
-	b.Beg = 0
-	b.Readable = 0
-	b.Use = 0
-}
-
-// Advance(): non-standard, but better than Next(),
-// because we don't have to unwrap our buffer and pay the cpu time
-// for the copy that unwrapping may need.
-// Useful in conjuction/after ReadWithoutAdvance() above.
-func (b *FixedSizeRingBuf) Advance(n int) {
-	if n <= 0 {
-		return
-	}
-	if n > b.Readable {
-		n = b.Readable
-	}
-	b.Readable -= n
-	b.Beg = (b.Beg + n) % b.N
-}
-
-// Adopt(): non-standard.
-//
-// For efficiency's sake, (possibly) take ownership of
-// already allocated slice offered in me.
-//
-// If me is large we will adopt it, and we will potentially then
-// write to the me buffer.
-// If we already have a bigger buffer, copy me into the existing
-// buffer instead.
-func (b *FixedSizeRingBuf) Adopt(me []byte) {
-	n := len(me)
-	if n > b.N {
-		b.A[0] = me
-		b.OneMade = false
-		b.N = n
-		b.Use = 0
-		b.Beg = 0
-		b.Readable = n
-	} else {
-		// we already have a larger buffer, reuse it.
-		copy(b.A[0], me)
-		b.Use = 0
-		b.Beg = 0
-		b.Readable = n
-	}
-}
-
-func intMax(a, b int) int {
-	if a > b {
-		return a
-	} else {
-		return b
-	}
-}
-
-func intMin(a, b int) int {
-	if a < b {
-		return a
-	} else {
-		return b
-	}
-}
-
-// Get the (beg, end] indices of the tailing empty buffer of bytes slice that from that is free for writing.
-// Note: not guaranteed to be zeroed. At all.
-func (b *FixedSizeRingBuf) GetEndmostWritable() (beg int, end int) {
-	extent := b.Beg + b.Readable
-	if extent < b.N {
-		return extent, b.N
-	}
-
-	return extent % b.N, b.Beg
-}
-
-// Note: not guaranteed to be zeroed.
-func (b *FixedSizeRingBuf) GetEndmostWritableSlice() []byte {
-	beg, e := b.GetEndmostWritable()
-	return b.A[b.Use][beg:e]
-}

vendor/github.com/glycerine/go-unsnap-stream/snap.go

@@ -1,100 +0,0 @@
-package unsnap
-
-import (
-	"encoding/binary"
-
-	// no c lib dependency
-	snappy "github.com/golang/snappy"
-	// or, use the C wrapper for speed
-	//snappy "github.com/dgryski/go-csnappy"
-)
-
-// add Write() method for SnappyFile (see unsnap.go)
-
-// reference for snappy framing/streaming format:
-//         http://code.google.com/p/snappy/source/browse/trunk/framing_format.txt
-//             ?spec=svn68&r=71
-
-//
-// Write writes len(p) bytes from p to the underlying data stream.
-// It returns the number of bytes written from p (0 <= n <= len(p)) and
-// any error encountered that caused the write to stop early. Write
-// must return a non-nil error if it returns n < len(p).
-//
-func (sf *SnappyFile) Write(p []byte) (n int, err error) {
-
-	if sf.SnappyEncodeDecodeOff {
-		return sf.Writer.Write(p)
-	}
-
-	if !sf.Writing {
-		panic("Writing on a read-only SnappyFile")
-	}
-
-	// encoding in snappy can apparently go beyond the original size, beware.
-	// so our buffers must be sized 2*max snappy chunk => 2 * CHUNK_MAX(65536)
-
-	sf.DecBuf.Reset()
-	sf.EncBuf.Reset()
-
-	if !sf.HeaderChunkWritten {
-		sf.HeaderChunkWritten = true
-		_, err = sf.Writer.Write(SnappyStreamHeaderMagic)
-		if err != nil {
-			return
-		}
-	}
-	var chunk []byte
-	var chunk_type byte
-	var crc uint32
-
-	for len(p) > 0 {
-
-		// chunk points to input p by default, unencoded input.
-		chunk = p[:IntMin(len(p), CHUNK_MAX)]
-		crc = masked_crc32c(chunk)
-
-		writeme := chunk[:]
-
-		// first write to EncBuf, as a temp, in case we want
-		// to discard and send uncompressed instead.
-		compressed_chunk := snappy.Encode(sf.EncBuf.GetEndmostWritableSlice(), chunk)
-
-		if len(compressed_chunk) <= int((1-_COMPRESSION_THRESHOLD)*float64(len(chunk))) {
-			writeme = compressed_chunk
-			chunk_type = _COMPRESSED_CHUNK
-		} else {
-			// keep writeme pointing at original chunk (uncompressed)
-			chunk_type = _UNCOMPRESSED_CHUNK
-		}
-
-		const crc32Sz = 4
-		var tag32 uint32 = uint32(chunk_type) + (uint32(len(writeme)+crc32Sz) << 8)
-
-		err = binary.Write(sf.Writer, binary.LittleEndian, tag32)
-		if err != nil {
-			return
-		}
-
-		err = binary.Write(sf.Writer, binary.LittleEndian, crc)
-		if err != nil {
-			return
-		}
-
-		_, err = sf.Writer.Write(writeme)
-		if err != nil {
-			return
-		}
-
-		n += len(chunk)
-		p = p[len(chunk):]
-	}
-	return n, nil
-}
-
-func IntMin(a int, b int) int {
-	if a < b {
-		return a
-	}
-	return b
-}

vendor/github.com/glycerine/go-unsnap-stream/unenc.txt

@@ -1 +0,0 @@
-hello_snappy

vendor/github.com/glycerine/go-unsnap-stream/unsnap.go

@@ -1,519 +0,0 @@
-package unsnap
-
-import (
-	"bytes"
-	"encoding/binary"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"os"
-	"strings"
-
-	"hash/crc32"
-
-	snappy "github.com/golang/snappy"
-	// The C library can be used, but this makes the binary dependent
-	// lots of extraneous c-libraries; it is no longer stand-alone. Yuck.
-	//
-	// Therefore we comment out the "dgryski/go-csnappy" path and use the
-	// "github.com/golang/snappy/snappy" above instead. If you are
-	// performance limited and can deal with distributing more libraries,
-	// then this is easy to swap.
-	//
-	// If you swap, note that some of the tests won't pass
-	// because snappy-go produces slightly different (but still
-	// conformant) encodings on some data. Here are bindings
-	// to the C-snappy:
-	// snappy "github.com/dgryski/go-csnappy"
-)
-
-// SnappyFile: create a drop-in-replacement/wrapper for an *os.File that handles doing the unsnappification online as more is read from it
-
-type SnappyFile struct {
-	Fname string
-
-	Reader io.Reader
-	Writer io.Writer
-
-	// allow clients to substitute us for an os.File and just switch
-	// off compression if they don't want it.
-	SnappyEncodeDecodeOff bool // if true, we bypass straight to Filep
-
-	EncBuf FixedSizeRingBuf // holds any extra that isn't yet returned, encoded
-	DecBuf FixedSizeRingBuf // holds any extra that isn't yet returned, decoded
-
-	// for writing to stream-framed snappy
-	HeaderChunkWritten bool
-
-	// Sanity check: we can only read, or only write, to one SnappyFile.
-	// EncBuf and DecBuf are used differently in each mode. Verify
-	// that we are consistent with this flag.
-	Writing bool
-}
-
-var total int
-
-// for debugging, show state of buffers
-func (f *SnappyFile) Dump() {
-	fmt.Printf("EncBuf has length %d and contents:\n%s\n", len(f.EncBuf.Bytes()), string(f.EncBuf.Bytes()))
-	fmt.Printf("DecBuf has length %d and contents:\n%s\n", len(f.DecBuf.Bytes()), string(f.DecBuf.Bytes()))
-}
-
-func (f *SnappyFile) Read(p []byte) (n int, err error) {
-
-	if f.SnappyEncodeDecodeOff {
-		return f.Reader.Read(p)
-	}
-
-	if f.Writing {
-		panic("Reading on a write-only SnappyFile")
-	}
-
-	// before we unencrypt more, try to drain the DecBuf first
-	n, _ = f.DecBuf.Read(p)
-	if n > 0 {
-		total += n
-		return n, nil
-	}
-
-	//nEncRead, nDecAdded, err := UnsnapOneFrame(f.Filep, &f.EncBuf, &f.DecBuf, f.Fname)
-	_, _, err = UnsnapOneFrame(f.Reader, &f.EncBuf, &f.DecBuf, f.Fname)
-	if err != nil && err != io.EOF {
-		panic(err)
-	}
-
-	n, _ = f.DecBuf.Read(p)
-
-	if n > 0 {
-		total += n
-		return n, nil
-	}
-	if f.DecBuf.Readable == 0 {
-		if f.DecBuf.Readable == 0 && f.EncBuf.Readable == 0 {
-			// only now (when EncBuf is empty) can we give io.EOF.
-			// Any earlier, and we leave stuff un-decoded!
-			return 0, io.EOF
-		}
-	}
-	return 0, nil
-}
-
-func Open(name string) (file *SnappyFile, err error) {
-	fp, err := os.Open(name)
-	if err != nil {
-		return nil, err
-	}
-	// encoding in snappy can apparently go beyond the original size, so
-	// we make our buffers big enough, 2*max snappy chunk => 2 * CHUNK_MAX(65536)
-
-	snap := NewReader(fp)
-	snap.Fname = name
-	return snap, nil
-}
-
-func NewReader(r io.Reader) *SnappyFile {
-	return &SnappyFile{
-		Reader:  r,
-		EncBuf:  *NewFixedSizeRingBuf(CHUNK_MAX * 2), // buffer of snappy encoded bytes
-		DecBuf:  *NewFixedSizeRingBuf(CHUNK_MAX * 2), // buffer of snapppy decoded bytes
-		Writing: false,
-	}
-}
-
-func NewWriter(w io.Writer) *SnappyFile {
-	return &SnappyFile{
-		Writer:  w,
-		EncBuf:  *NewFixedSizeRingBuf(65536),     // on writing: temp for testing compression
-		DecBuf:  *NewFixedSizeRingBuf(65536 * 2), // on writing: final buffer of snappy framed and encoded bytes
-		Writing: true,
-	}
-}
-
-func Create(name string) (file *SnappyFile, err error) {
-	fp, err := os.Create(name)
-	if err != nil {
-		return nil, err
-	}
-	snap := NewWriter(fp)
-	snap.Fname = name
-	return snap, nil
-}
-
-func (f *SnappyFile) Close() error {
-	if f.Writing {
-		wc, ok := f.Writer.(io.WriteCloser)
-		if ok {
-			return wc.Close()
-		}
-		return nil
-	}
-	rc, ok := f.Reader.(io.ReadCloser)
-	if ok {
-		return rc.Close()
-	}
-	return nil
-}
-
-func (f *SnappyFile) Sync() error {
-	file, ok := f.Writer.(*os.File)
-	if ok {
-		return file.Sync()
-	}
-	return nil
-}
-
-// for an increment of a frame at a time:
-// read from r into encBuf (encBuf is still encoded, thus the name), and write unsnappified frames into outDecodedBuf
-//  the returned n: number of bytes read from the encrypted encBuf
-func UnsnapOneFrame(r io.Reader, encBuf *FixedSizeRingBuf, outDecodedBuf *FixedSizeRingBuf, fname string) (nEnc int64, nDec int64, err error) {
-	//	b, err := ioutil.ReadAll(r)
-	//	if err != nil {
-	//		panic(err)
-	//	}
-
-	nEnc = 0
-	nDec = 0
-
-	// read up to 65536 bytes from r into encBuf, at least a snappy frame
-	nread, err := io.CopyN(encBuf, r, 65536) // returns nwrotebytes, err
-	nEnc += nread
-	if err != nil {
-		if err == io.EOF {
-			if nread == 0 {
-				if encBuf.Readable == 0 {
-					return nEnc, nDec, io.EOF
-				}
-				// else we have bytes in encBuf, so decode them!
-				err = nil
-			} else {
-				// continue below, processing the nread bytes
-				err = nil
-			}
-		} else {
-			// may be an odd already closed... don't panic on that
-			if strings.Contains(err.Error(), "file already closed") {
-				err = nil
-			} else {
-				panic(err)
-			}
-		}
-	}
-
-	// flag for printing chunk size alignment messages
-	verbose := false
-
-	const snappyStreamHeaderSz = 10
-	const headerSz = 4
-	const crc32Sz = 4
-	// the magic 18 bytes accounts for the snappy streaming header and the first chunks size and checksum
-	// http://code.google.com/p/snappy/source/browse/trunk/framing_format.txt
-
-	chunk := (*encBuf).Bytes()
-
-	// however we exit, advance as
-	//	defer func() { (*encBuf).Next(N) }()
-
-	// 65536 is the max size of a snappy framed chunk. See
-	// http://code.google.com/p/snappy/source/browse/trunk/framing_format.txt:91
-	// buf := make([]byte, 65536)
-
-	//	fmt.Printf("read from file, b is len:%d with value: %#v\n", len(b), b)
-	//	fmt.Printf("read from file, bcut is len:%d with value: %#v\n", len(bcut), bcut)
-
-	//fmt.Printf("raw bytes of chunksz are: %v\n", b[11:14])
-
-	fourbytes := make([]byte, 4)
-	chunkCount := 0
-
-	for nDec < 65536 {
-		if len(chunk) == 0 {
-			break
-		}
-		chunkCount++
-		fourbytes[3] = 0
-		copy(fourbytes, chunk[1:4])
-		chunksz := binary.LittleEndian.Uint32(fourbytes)
-		chunk_type := chunk[0]
-
-		switch true {
-		case chunk_type == 0xff:
-			{ // stream identifier
-
-				streamHeader := chunk[:snappyStreamHeaderSz]
-				if 0 != bytes.Compare(streamHeader, []byte{0xff, 0x06, 0x00, 0x00, 0x73, 0x4e, 0x61, 0x50, 0x70, 0x59}) {
-					panic("file had chunk starting with 0xff but then no magic snappy streaming protocol bytes, aborting.")
-				} else {
-					//fmt.Printf("got streaming snappy magic header just fine.\n")
-				}
-				chunk = chunk[snappyStreamHeaderSz:]
-				(*encBuf).Advance(snappyStreamHeaderSz)
-				nEnc += snappyStreamHeaderSz
-				continue
-			}
-		case chunk_type == 0x00:
-			{ // compressed data
-				if verbose {
-					fmt.Fprintf(os.Stderr, "chunksz is %d  while  total bytes avail are: %d\n", int(chunksz), len(chunk)-4)
-				}
-
-				crc := binary.LittleEndian.Uint32(chunk[headerSz:(headerSz + crc32Sz)])
-				section := chunk[(headerSz + crc32Sz):(headerSz + chunksz)]
-
-				dec, ok := snappy.Decode(nil, section)
-				if ok != nil {
-					// we've probably truncated a snappy frame at this point
-					// ok=snappy: corrupt input
-					// len(dec) == 0
-					//
-					panic(fmt.Sprintf("could not decode snappy stream: '%s' and len dec=%d and ok=%v\n", fname, len(dec), ok))
-
-					// get back to caller with what we've got so far
-					return nEnc, nDec, nil
-				}
-				//	fmt.Printf("ok, b is %#v , %#v\n", ok, dec)
-
-				// spit out decoded text
-				// n, err := w.Write(dec)
-				//fmt.Printf("len(dec) = %d,   outDecodedBuf.Readable=%d\n", len(dec), outDecodedBuf.Readable)
-				bnb := bytes.NewBuffer(dec)
-				n, err := io.Copy(outDecodedBuf, bnb)
-				if err != nil {
-					//fmt.Printf("got n=%d, err= %s ; when trying to io.Copy(outDecodedBuf: N=%d, Readable=%d)\n", n, err, outDecodedBuf.N, outDecodedBuf.Readable)
-					panic(err)
-				}
-				if n != int64(len(dec)) {
-					panic("could not write all bytes to outDecodedBuf")
-				}
-				nDec += n
-
-				// verify the crc32 rotated checksum
-				m32 := masked_crc32c(dec)
-				if m32 != crc {
-					panic(fmt.Sprintf("crc32 masked failiure. expected: %v but got: %v", crc, m32))
-				} else {
-					//fmt.Printf("\nchecksums match: %v == %v\n", crc, m32)
-				}
-
-				// move to next header
-				inc := (headerSz + int(chunksz))
-				chunk = chunk[inc:]
-				(*encBuf).Advance(inc)
-				nEnc += int64(inc)
-				continue
-			}
-		case chunk_type == 0x01:
-			{ // uncompressed data
-
-				//n, err := w.Write(chunk[(headerSz+crc32Sz):(headerSz + int(chunksz))])
-				n, err := io.Copy(outDecodedBuf, bytes.NewBuffer(chunk[(headerSz+crc32Sz):(headerSz+int(chunksz))]))
-				if verbose {
-					//fmt.Printf("debug: n=%d  err=%v  chunksz=%d  outDecodedBuf='%v'\n", n, err, chunksz, outDecodedBuf)
-				}
-				if err != nil {
-					panic(err)
-				}
-				if n != int64(chunksz-crc32Sz) {
-					panic("could not write all bytes to stdout")
-				}
-				nDec += n
-
-				inc := (headerSz + int(chunksz))
-				chunk = chunk[inc:]
-				(*encBuf).Advance(inc)
-				nEnc += int64(inc)
-				continue
-			}
-		case chunk_type == 0xfe:
-			fallthrough // padding, just skip it
-		case chunk_type >= 0x80 && chunk_type <= 0xfd:
-			{ //  Reserved skippable chunks
-				//fmt.Printf("\nin reserved skippable chunks, at nEnc=%v\n", nEnc)
-				inc := (headerSz + int(chunksz))
-				chunk = chunk[inc:]
-				nEnc += int64(inc)
-				(*encBuf).Advance(inc)
-				continue
-			}
-
-		default:
-			panic(fmt.Sprintf("unrecognized/unsupported chunk type %#v", chunk_type))
-		}
-
-	} // end for{}
-
-	return nEnc, nDec, err
-	//return int64(N), nil
-}
-
-// for whole file at once:
-//
-// receive on stdin a stream of bytes in the snappy-streaming framed
-//  format, defined here: http://code.google.com/p/snappy/source/browse/trunk/framing_format.txt
-// Grab each frame, run it through the snappy decoder, and spit out
-//  each frame all joined back-to-back on stdout.
-//
-func Unsnappy(r io.Reader, w io.Writer) (err error) {
-	b, err := ioutil.ReadAll(r)
-	if err != nil {
-		panic(err)
-	}
-
-	// flag for printing chunk size alignment messages
-	verbose := false
-
-	const snappyStreamHeaderSz = 10
-	const headerSz = 4
-	const crc32Sz = 4
-	// the magic 18 bytes accounts for the snappy streaming header and the first chunks size and checksum
-	// http://code.google.com/p/snappy/source/browse/trunk/framing_format.txt
-
-	chunk := b[:]
-
-	// 65536 is the max size of a snappy framed chunk. See
-	// http://code.google.com/p/snappy/source/browse/trunk/framing_format.txt:91
-	//buf := make([]byte, 65536)
-
-	//	fmt.Printf("read from file, b is len:%d with value: %#v\n", len(b), b)
-	//	fmt.Printf("read from file, bcut is len:%d with value: %#v\n", len(bcut), bcut)
-
-	//fmt.Printf("raw bytes of chunksz are: %v\n", b[11:14])
-
-	fourbytes := make([]byte, 4)
-	chunkCount := 0
-
-	for {
-		if len(chunk) == 0 {
-			break
-		}
-		chunkCount++
-		fourbytes[3] = 0
-		copy(fourbytes, chunk[1:4])
-		chunksz := binary.LittleEndian.Uint32(fourbytes)
-		chunk_type := chunk[0]
-
-		switch true {
-		case chunk_type == 0xff:
-			{ // stream identifier
-
-				streamHeader := chunk[:snappyStreamHeaderSz]
-				if 0 != bytes.Compare(streamHeader, []byte{0xff, 0x06, 0x00, 0x00, 0x73, 0x4e, 0x61, 0x50, 0x70, 0x59}) {
-					panic("file had chunk starting with 0xff but then no magic snappy streaming protocol bytes, aborting.")
-				} else {
-					//fmt.Printf("got streaming snappy magic header just fine.\n")
-				}
-				chunk = chunk[snappyStreamHeaderSz:]
-				continue
-			}
-		case chunk_type == 0x00:
-			{ // compressed data
-				if verbose {
-					fmt.Fprintf(os.Stderr, "chunksz is %d  while  total bytes avail are: %d\n", int(chunksz), len(chunk)-4)
-				}
-
-				//crc := binary.LittleEndian.Uint32(chunk[headerSz:(headerSz + crc32Sz)])
-				section := chunk[(headerSz + crc32Sz):(headerSz + chunksz)]
-
-				dec, ok := snappy.Decode(nil, section)
-				if ok != nil {
-					panic("could not decode snappy stream")
-				}
-				//	fmt.Printf("ok, b is %#v , %#v\n", ok, dec)
-
-				// spit out decoded text
-				n, err := w.Write(dec)
-				if err != nil {
-					panic(err)
-				}
-				if n != len(dec) {
-					panic("could not write all bytes to stdout")
-				}
-
-				// TODO: verify the crc32 rotated checksum?
-
-				// move to next header
-				chunk = chunk[(headerSz + int(chunksz)):]
-				continue
-			}
-		case chunk_type == 0x01:
-			{ // uncompressed data
-
-				//crc := binary.LittleEndian.Uint32(chunk[headerSz:(headerSz + crc32Sz)])
-				section := chunk[(headerSz + crc32Sz):(headerSz + chunksz)]
-
-				n, err := w.Write(section)
-				if err != nil {
-					panic(err)
-				}
-				if n != int(chunksz-crc32Sz) {
-					panic("could not write all bytes to stdout")
-				}
-
-				chunk = chunk[(headerSz + int(chunksz)):]
-				continue
-			}
-		case chunk_type == 0xfe:
-			fallthrough // padding, just skip it
-		case chunk_type >= 0x80 && chunk_type <= 0xfd:
-			{ //  Reserved skippable chunks
-				chunk = chunk[(headerSz + int(chunksz)):]
-				continue
-			}
-
-		default:
-			panic(fmt.Sprintf("unrecognized/unsupported chunk type %#v", chunk_type))
-		}
-
-	} // end for{}
-
-	return nil
-}
-
-// 0xff 0x06 0x00 0x00 sNaPpY
-var SnappyStreamHeaderMagic = []byte{0xff, 0x06, 0x00, 0x00, 0x73, 0x4e, 0x61, 0x50, 0x70, 0x59}
-
-const CHUNK_MAX = 65536
-const _STREAM_TO_STREAM_BLOCK_SIZE = CHUNK_MAX
-const _STREAM_IDENTIFIER = `sNaPpY`
-const _COMPRESSED_CHUNK = 0x00
-const _UNCOMPRESSED_CHUNK = 0x01
-const _IDENTIFIER_CHUNK = 0xff
-const _RESERVED_UNSKIPPABLE0 = 0x02 // chunk ranges are [inclusive, exclusive)
-const _RESERVED_UNSKIPPABLE1 = 0x80
-const _RESERVED_SKIPPABLE0 = 0x80
-const _RESERVED_SKIPPABLE1 = 0xff
-
-// the minimum percent of bytes compression must save to be enabled in automatic
-// mode
-const _COMPRESSION_THRESHOLD = .125
-
-var crctab *crc32.Table
-
-func init() {
-	crctab = crc32.MakeTable(crc32.Castagnoli) // this is correct table, matches the crc32c.c code used by python
-}
-
-func masked_crc32c(data []byte) uint32 {
-
-	// see the framing format specification, http://code.google.com/p/snappy/source/browse/trunk/framing_format.txt
-	var crc uint32 = crc32.Checksum(data, crctab)
-	return (uint32((crc>>15)|(crc<<17)) + 0xa282ead8)
-}
-
-func ReadSnappyStreamCompressedFile(filename string) ([]byte, error) {
-
-	snappyFile, err := Open(filename)
-	if err != nil {
-		return []byte{}, err
-	}
-
-	var bb bytes.Buffer
-	_, err = bb.ReadFrom(snappyFile)
-	if err == io.EOF {
-		err = nil
-	}
-	if err != nil {
-		panic(err)
-	}
-
-	return bb.Bytes(), err
-}

vendor/github.com/golang/protobuf/proto/registry.go

@@ -13,6 +13,7 @@ import (
 	"strings"
 	"sync"
 
+	"google.golang.org/protobuf/reflect/protodesc"
 	"google.golang.org/protobuf/reflect/protoreflect"
 	"google.golang.org/protobuf/reflect/protoregistry"
 	"google.golang.org/protobuf/runtime/protoimpl"
@@ -62,14 +63,7 @@ func FileDescriptor(s filePath) fileDescGZIP {
 	// Find the descriptor in the v2 registry.
 	var b []byte
 	if fd, _ := protoregistry.GlobalFiles.FindFileByPath(s); fd != nil {
-		if fd, ok := fd.(interface{ ProtoLegacyRawDesc() []byte }); ok {
+		b, _ = Marshal(protodesc.ToFileDescriptorProto(fd))
-			b = fd.ProtoLegacyRawDesc()
-		} else {
-			// TODO: Use protodesc.ToFileDescriptorProto to construct
-			// a descriptorpb.FileDescriptorProto and marshal it.
-			// However, doing so causes the proto package to have a dependency
-			// on descriptorpb, leading to cyclic dependency issues.
-		}
 	}
 
 	// Locally cache the raw descriptor form for the file.

vendor/github.com/golang/snappy/AUTHORS

@@ -10,6 +10,7 @@
 
 Amazon.com, Inc
 Damian Gryski <dgryski@gmail.com>
+Eric Buth <eric@topos.com>
 Google Inc.
 Jan Mercl <0xjnml@gmail.com>
 Klaus Post <klauspost@gmail.com>

vendor/github.com/golang/snappy/CONTRIBUTORS

@@ -26,7 +26,9 @@
 
 # Please keep the list sorted.
 
+Alex Legg <alexlegg@google.com>
 Damian Gryski <dgryski@gmail.com>
+Eric Buth <eric@topos.com>
 Jan Mercl <0xjnml@gmail.com>
 Jonathan Swinney <jswinney@amazon.com>
 Kai Backman <kaib@golang.org>

vendor/github.com/golang/snappy/decode.go

@@ -118,32 +118,23 @@ func (r *Reader) readFull(p []byte, allowEOF bool) (ok bool) {
 	return true
 }
 
-// Read satisfies the io.Reader interface.
+func (r *Reader) fill() error {
-func (r *Reader) Read(p []byte) (int, error) {
+	for r.i >= r.j {
-	if r.err != nil {
-		return 0, r.err
-	}
-	for {
-		if r.i < r.j {
-			n := copy(p, r.decoded[r.i:r.j])
-			r.i += n
-			return n, nil
-		}
 		if !r.readFull(r.buf[:4], true) {
-			return 0, r.err
+			return r.err
 		}
 		chunkType := r.buf[0]
 		if !r.readHeader {
 			if chunkType != chunkTypeStreamIdentifier {
 				r.err = ErrCorrupt
-				return 0, r.err
+				return r.err
 			}
 			r.readHeader = true
 		}
 		chunkLen := int(r.buf[1]) | int(r.buf[2])<<8 | int(r.buf[3])<<16
 		if chunkLen > len(r.buf) {
 			r.err = ErrUnsupported
-			return 0, r.err
+			return r.err
 		}
 
 		// The chunk types are specified at
@@ -153,11 +144,11 @@ func (r *Reader) Read(p []byte) (int, error) {
 			// Section 4.2. Compressed data (chunk type 0x00).
 			if chunkLen < checksumSize {
 				r.err = ErrCorrupt
-				return 0, r.err
+				return r.err
 			}
 			buf := r.buf[:chunkLen]
 			if !r.readFull(buf, false) {
-				return 0, r.err
+				return r.err
 			}
 			checksum := uint32(buf[0]) | uint32(buf[1])<<8 | uint32(buf[2])<<16 | uint32(buf[3])<<24
 			buf = buf[checksumSize:]
@@ -165,19 +156,19 @@ func (r *Reader) Read(p []byte) (int, error) {
 			n, err := DecodedLen(buf)
 			if err != nil {
 				r.err = err
-				return 0, r.err
+				return r.err
 			}
 			if n > len(r.decoded) {
 				r.err = ErrCorrupt
-				return 0, r.err
+				return r.err
 			}
 			if _, err := Decode(r.decoded, buf); err != nil {
 				r.err = err
-				return 0, r.err
+				return r.err
 			}
 			if crc(r.decoded[:n]) != checksum {
 				r.err = ErrCorrupt
-				return 0, r.err
+				return r.err
 			}
 			r.i, r.j = 0, n
 			continue
@@ -186,25 +177,25 @@ func (r *Reader) Read(p []byte) (int, error) {
 			// Section 4.3. Uncompressed data (chunk type 0x01).
 			if chunkLen < checksumSize {
 				r.err = ErrCorrupt
-				return 0, r.err
+				return r.err
 			}
 			buf := r.buf[:checksumSize]
 			if !r.readFull(buf, false) {
-				return 0, r.err
+				return r.err
 			}
 			checksum := uint32(buf[0]) | uint32(buf[1])<<8 | uint32(buf[2])<<16 | uint32(buf[3])<<24
 			// Read directly into r.decoded instead of via r.buf.
 			n := chunkLen - checksumSize
 			if n > len(r.decoded) {
 				r.err = ErrCorrupt
-				return 0, r.err
+				return r.err
 			}
 			if !r.readFull(r.decoded[:n], false) {
-				return 0, r.err
+				return r.err
 			}
 			if crc(r.decoded[:n]) != checksum {
 				r.err = ErrCorrupt
-				return 0, r.err
+				return r.err
 			}
 			r.i, r.j = 0, n
 			continue
@@ -213,15 +204,15 @@ func (r *Reader) Read(p []byte) (int, error) {
 			// Section 4.1. Stream identifier (chunk type 0xff).
 			if chunkLen != len(magicBody) {
 				r.err = ErrCorrupt
-				return 0, r.err
+				return r.err
 			}
 			if !r.readFull(r.buf[:len(magicBody)], false) {
-				return 0, r.err
+				return r.err
 			}
 			for i := 0; i < len(magicBody); i++ {
 				if r.buf[i] != magicBody[i] {
 					r.err = ErrCorrupt
-					return 0, r.err
+					return r.err
 				}
 			}
 			continue
@@ -230,12 +221,44 @@ func (r *Reader) Read(p []byte) (int, error) {
 		if chunkType <= 0x7f {
 			// Section 4.5. Reserved unskippable chunks (chunk types 0x02-0x7f).
 			r.err = ErrUnsupported
-			return 0, r.err
+			return r.err
 		}
 		// Section 4.4 Padding (chunk type 0xfe).
 		// Section 4.6. Reserved skippable chunks (chunk types 0x80-0xfd).
 		if !r.readFull(r.buf[:chunkLen], false) {
-			return 0, r.err
+			return r.err
 		}
 	}
+
+	return nil
+}
+
+// Read satisfies the io.Reader interface.
+func (r *Reader) Read(p []byte) (int, error) {
+	if r.err != nil {
+		return 0, r.err
+	}
+
+	if err := r.fill(); err != nil {
+		return 0, err
+	}
+
+	n := copy(p, r.decoded[r.i:r.j])
+	r.i += n
+	return n, nil
+}
+
+// ReadByte satisfies the io.ByteReader interface.
+func (r *Reader) ReadByte() (byte, error) {
+	if r.err != nil {
+		return 0, r.err
+	}
+
+	if err := r.fill(); err != nil {
+		return 0, err
+	}
+
+	c := r.decoded[r.i]
+	r.i++
+	return c, nil
 }

vendor/github.com/golang/snappy/decode_arm64.s

@@ -70,7 +70,7 @@ loop:
 	// x := uint32(src[s] >> 2)
 	// switch
 	MOVW $60, R1
-	ADD  R4>>2, ZR, R4
+	LSRW $2, R4, R4
 	CMPW R4, R1
 	BLS  tagLit60Plus
 
@@ -111,13 +111,12 @@ doLit:
 	// is contiguous in memory and so it needs to leave enough source bytes to
 	// read the next tag without refilling buffers, but Go's Decode assumes
 	// contiguousness (the src argument is a []byte).
-	MOVD $16, R1
+	CMP $16, R4
-	CMP  R1, R4
+	BGT callMemmove
-	BGT  callMemmove
+	CMP $16, R2
-	CMP  R1, R2
+	BLT callMemmove
-	BLT  callMemmove
+	CMP $16, R3
-	CMP  R1, R3
+	BLT callMemmove
-	BLT  callMemmove
 
 	// !!! Implement the copy from src to dst as a 16-byte load and store.
 	// (Decode's documentation says that dst and src must not overlap.)
@@ -130,9 +129,8 @@ doLit:
 	// Note that on arm64, it is legal and cheap to issue unaligned 8-byte or
 	// 16-byte loads and stores. This technique probably wouldn't be as
 	// effective on architectures that are fussier about alignment.
-
+	LDP 0(R6), (R14, R15)
-	VLD1 0(R6), [V0.B16]
+	STP (R14, R15), 0(R7)
-	VST1 [V0.B16], 0(R7)
 
 	// d += length
 	// s += length
@@ -210,8 +208,7 @@ tagLit61:
 	B     doLit
 
 tagLit62Plus:
-	MOVW $62, R1
+	CMPW $62, R4
-	CMPW R1, R4
 	BHI  tagLit63
 
 	// case x == 62:
@@ -273,10 +270,9 @@ tagCopy:
 	// We have a copy tag. We assume that:
 	//	- R3 == src[s] & 0x03
 	//	- R4 == src[s]
-	MOVD $2, R1
+	CMP $2, R3
-	CMP  R1, R3
+	BEQ tagCopy2
-	BEQ  tagCopy2
+	BGT tagCopy4
-	BGT  tagCopy4
 
 	// case tagCopy1:
 	// s += 2
@@ -346,13 +342,11 @@ doCopy:
 	// }
 	// copy 16 bytes
 	// d += length
-	MOVD $16, R1
+	CMP  $16, R4
-	MOVD $8, R0
-	CMP  R1, R4
 	BGT  slowForwardCopy
-	CMP  R0, R5
+	CMP  $8, R5
 	BLT  slowForwardCopy
-	CMP  R1, R14
+	CMP  $16, R14
 	BLT  slowForwardCopy
 	MOVD 0(R15), R2
 	MOVD R2, 0(R7)
@@ -426,8 +420,7 @@ makeOffsetAtLeast8:
 	//   // The two previous lines together means that d-offset, and therefore
 	//   // R15, is unchanged.
 	// }
-	MOVD $8, R1
+	CMP  $8, R5
-	CMP  R1, R5
 	BGE  fixUpSlowForwardCopy
 	MOVD (R15), R3
 	MOVD R3, (R7)
@@ -477,9 +470,7 @@ verySlowForwardCopy:
 	ADD  $1, R15, R15
 	ADD  $1, R7, R7
 	SUB  $1, R4, R4
-	MOVD $0, R1
+	CBNZ R4, verySlowForwardCopy
-	CMP  R1, R4
-	BNE  verySlowForwardCopy
 	B    loop
 
 	// The code above handles copy tags.

vendor/github.com/golang/snappy/encode_arm64.s

@@ -35,11 +35,9 @@ TEXT ·emitLiteral(SB), NOSPLIT, $32-56
 	MOVW R3, R4
 	SUBW $1, R4, R4
 
-	MOVW $60, R2
+	CMPW $60, R4
-	CMPW R2, R4
 	BLT  oneByte
-	MOVW $256, R2
+	CMPW $256, R4
-	CMPW R2, R4
 	BLT  twoBytes
 
 threeBytes:
@@ -98,8 +96,7 @@ TEXT ·emitCopy(SB), NOSPLIT, $0-48
 
 loop0:
 	// for length >= 68 { etc }
-	MOVW $68, R2
+	CMPW $68, R3
-	CMPW R2, R3
 	BLT  step1
 
 	// Emit a length 64 copy, encoded as 3 bytes.
@@ -112,9 +109,8 @@ loop0:
 
 step1:
 	// if length > 64 { etc }
-	MOVD $64, R2
+	CMP $64, R3
-	CMP  R2, R3
+	BLE step2
-	BLE  step2
 
 	// Emit a length 60 copy, encoded as 3 bytes.
 	MOVD $0xee, R2
@@ -125,11 +121,9 @@ step1:
 
 step2:
 	// if length >= 12 || offset >= 2048 { goto step3 }
-	MOVD $12, R2
+	CMP  $12, R3
-	CMP  R2, R3
 	BGE  step3
-	MOVW $2048, R2
+	CMPW $2048, R11
-	CMPW R2, R11
 	BGE  step3
 
 	// Emit the remaining copy, encoded as 2 bytes.
@@ -295,27 +289,24 @@ varTable:
 	// var table [maxTableSize]uint16
 	//
 	// In the asm code, unlike the Go code, we can zero-initialize only the
-	// first tableSize elements. Each uint16 element is 2 bytes and each VST1
+	// first tableSize elements. Each uint16 element is 2 bytes and each
-	// writes 64 bytes, so we can do only tableSize/32 writes instead of the
+	// iterations writes 64 bytes, so we can do only tableSize/32 writes
-	// 2048 writes that would zero-initialize all of table's 32768 bytes.
+	// instead of the 2048 writes that would zero-initialize all of table's
-	// This clear could overrun the first tableSize elements, but it won't
+	// 32768 bytes. This clear could overrun the first tableSize elements, but
-	// overrun the allocated stack size.
+	// it won't overrun the allocated stack size.
 	ADD  $128, RSP, R17
 	MOVD R17, R4
 
 	// !!! R6 = &src[tableSize]
 	ADD R6<<1, R17, R6
 
-	// zero the SIMD registers
-	VEOR V0.B16, V0.B16, V0.B16
-	VEOR V1.B16, V1.B16, V1.B16
-	VEOR V2.B16, V2.B16, V2.B16
-	VEOR V3.B16, V3.B16, V3.B16
-
 memclr:
-	VST1.P [V0.B16, V1.B16, V2.B16, V3.B16], 64(R4)
+	STP.P (ZR, ZR), 64(R4)
-	CMP    R4, R6
+	STP   (ZR, ZR), -48(R4)
-	BHI    memclr
+	STP   (ZR, ZR), -32(R4)
+	STP   (ZR, ZR), -16(R4)
+	CMP   R4, R6
+	BHI   memclr
 
 	// !!! R6 = &src[0]
 	MOVD R7, R6
@@ -391,7 +382,7 @@ inner0:
 
 	// if load32(src, s) != load32(src, candidate) { continue } break
 	MOVW 0(R7), R3
-	MOVW (R6)(R15*1), R4
+	MOVW (R6)(R15), R4
 	CMPW R4, R3
 	BNE  inner0
 
@@ -404,8 +395,7 @@ fourByteMatch:
 	// on inputMargin in encode.go.
 	MOVD R7, R3
 	SUB  R10, R3, R3
-	MOVD $16, R2
+	CMP  $16, R3
-	CMP  R2, R3
 	BLE  emitLiteralFastPath
 
 	// ----------------------------------------
@@ -454,18 +444,21 @@ inlineEmitLiteralMemmove:
 	MOVD R3, 24(RSP)
 
 	// Finish the "d +=" part of "d += emitLiteral(etc)".
-	ADD  R3, R8, R8
+	ADD   R3, R8, R8
-	MOVD R7, 80(RSP)
+	MOVD  R7, 80(RSP)
-	MOVD R8, 88(RSP)
+	MOVD  R8, 88(RSP)
-	MOVD R15, 120(RSP)
+	MOVD  R15, 120(RSP)
-	CALL runtime·memmove(SB)
+	CALL  runtime·memmove(SB)
-	MOVD 64(RSP), R5
+	MOVD  64(RSP), R5
-	MOVD 72(RSP), R6
+	MOVD  72(RSP), R6
-	MOVD 80(RSP), R7
+	MOVD  80(RSP), R7
-	MOVD 88(RSP), R8
+	MOVD  88(RSP), R8
-	MOVD 96(RSP), R9
+	MOVD  96(RSP), R9
-	MOVD 120(RSP), R15
+	MOVD  120(RSP), R15
-	B    inner1
+	ADD   $128, RSP, R17
+	MOVW  $0xa7bd, R16
+	MOVKW $(0x1e35<<16), R16
+	B     inner1
 
 inlineEmitLiteralEnd:
 	// End inline of the emitLiteral call.
@@ -489,9 +482,9 @@ emitLiteralFastPath:
 	// Note that on arm64, it is legal and cheap to issue unaligned 8-byte or
 	// 16-byte loads and stores. This technique probably wouldn't be as
 	// effective on architectures that are fussier about alignment.
-	VLD1 0(R10), [V0.B16]
+	LDP 0(R10), (R0, R1)
-	VST1 [V0.B16], 0(R8)
+	STP (R0, R1), 0(R8)
-	ADD  R3, R8, R8
+	ADD R3, R8, R8
 
 inner1:
 	// for { etc }
@@ -679,7 +672,7 @@ inlineEmitCopyEnd:
 	MOVHU R3, 0(R17)(R11<<1)
 
 	// if uint32(x>>8) == load32(src, candidate) { continue }
-	MOVW (R6)(R15*1), R4
+	MOVW (R6)(R15), R4
 	CMPW R4, R14
 	BEQ  inner1
 

vendor/github.com/philhofer/fwd/LICENSE.md

@@ -1,7 +0,0 @@
-Copyright (c) 2014-2015, Philip Hofer
-
-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.

vendor/github.com/philhofer/fwd/README.md

@@ -1,315 +0,0 @@
-
-# fwd
-    import "github.com/philhofer/fwd"
-
-The `fwd` package provides a buffered reader
-and writer. Each has methods that help improve
-the encoding/decoding performance of some binary
-protocols.
-
-The `fwd.Writer` and `fwd.Reader` type provide similar
-functionality to their counterparts in `bufio`, plus
-a few extra utility methods that simplify read-ahead
-and write-ahead. I wrote this package to improve serialization
-performance for <a href="http://github.com/tinylib/msgp">http://github.com/tinylib/msgp</a>,
-where it provided about a 2x speedup over `bufio` for certain
-workloads. However, care must be taken to understand the semantics of the
-extra methods provided by this package, as they allow
-the user to access and manipulate the buffer memory
-directly.
-
-The extra methods for `fwd.Reader` are `Peek`, `Skip`
-and `Next`. `(*fwd.Reader).Peek`, unlike `(*bufio.Reader).Peek`,
-will re-allocate the read buffer in order to accommodate arbitrarily
-large read-ahead. `(*fwd.Reader).Skip` skips the next `n` bytes
-in the stream, and uses the `io.Seeker` interface if the underlying
-stream implements it. `(*fwd.Reader).Next` returns a slice pointing
-to the next `n` bytes in the read buffer (like `Peek`), but also
-increments the read position. This allows users to process streams
-in arbitrary block sizes without having to manage appropriately-sized
-slices. Additionally, obviating the need to copy the data from the
-buffer to another location in memory can improve performance dramatically
-in CPU-bound applications.
-
-`fwd.Writer` only has one extra method, which is `(*fwd.Writer).Next`, which
-returns a slice pointing to the next `n` bytes of the writer, and increments
-the write position by the length of the returned slice. This allows users
-to write directly to the end of the buffer.
-
-
-
-
-## Constants
-``` go
-const (
-    // DefaultReaderSize is the default size of the read buffer
-    DefaultReaderSize = 2048
-)
-```
-``` go
-const (
-    // DefaultWriterSize is the
-    // default write buffer size.
-    DefaultWriterSize = 2048
-)
-```
-
-
-
-## type Reader
-``` go
-type Reader struct {
-    // contains filtered or unexported fields
-}
-```
-Reader is a buffered look-ahead reader
-
-
-
-
-
-
-
-
-
-### func NewReader
-``` go
-func NewReader(r io.Reader) *Reader
-```
-NewReader returns a new *Reader that reads from 'r'
-
-
-### func NewReaderSize
-``` go
-func NewReaderSize(r io.Reader, n int) *Reader
-```
-NewReaderSize returns a new *Reader that
-reads from 'r' and has a buffer size 'n'
-
-
-
-
-### func (\*Reader) BufferSize
-``` go
-func (r *Reader) BufferSize() int
-```
-BufferSize returns the total size of the buffer
-
-
-
-### func (\*Reader) Buffered
-``` go
-func (r *Reader) Buffered() int
-```
-Buffered returns the number of bytes currently in the buffer
-
-
-
-### func (\*Reader) Next
-``` go
-func (r *Reader) Next(n int) ([]byte, error)
-```
-Next returns the next 'n' bytes in the stream.
-Unlike Peek, Next advances the reader position.
-The returned bytes point to the same
-data as the buffer, so the slice is
-only valid until the next reader method call.
-An EOF is considered an unexpected error.
-If an the returned slice is less than the
-length asked for, an error will be returned,
-and the reader position will not be incremented.
-
-
-
-### func (\*Reader) Peek
-``` go
-func (r *Reader) Peek(n int) ([]byte, error)
-```
-Peek returns the next 'n' buffered bytes,
-reading from the underlying reader if necessary.
-It will only return a slice shorter than 'n' bytes
-if it also returns an error. Peek does not advance
-the reader. EOF errors are *not* returned as
-io.ErrUnexpectedEOF.
-
-
-
-### func (\*Reader) Read
-``` go
-func (r *Reader) Read(b []byte) (int, error)
-```
-Read implements `io.Reader`
-
-
-
-### func (\*Reader) ReadByte
-``` go
-func (r *Reader) ReadByte() (byte, error)
-```
-ReadByte implements `io.ByteReader`
-
-
-
-### func (\*Reader) ReadFull
-``` go
-func (r *Reader) ReadFull(b []byte) (int, error)
-```
-ReadFull attempts to read len(b) bytes into
-'b'. It returns the number of bytes read into
-'b', and an error if it does not return len(b).
-EOF is considered an unexpected error.
-
-
-
-### func (\*Reader) Reset
-``` go
-func (r *Reader) Reset(rd io.Reader)
-```
-Reset resets the underlying reader
-and the read buffer.
-
-
-
-### func (\*Reader) Skip
-``` go
-func (r *Reader) Skip(n int) (int, error)
-```
-Skip moves the reader forward 'n' bytes.
-Returns the number of bytes skipped and any
-errors encountered. It is analogous to Seek(n, 1).
-If the underlying reader implements io.Seeker, then
-that method will be used to skip forward.
-
-If the reader encounters
-an EOF before skipping 'n' bytes, it
-returns io.ErrUnexpectedEOF. If the
-underlying reader implements io.Seeker, then
-those rules apply instead. (Many implementations
-will not return `io.EOF` until the next call
-to Read.)
-
-
-
-### func (\*Reader) WriteTo
-``` go
-func (r *Reader) WriteTo(w io.Writer) (int64, error)
-```
-WriteTo implements `io.WriterTo`
-
-
-
-## type Writer
-``` go
-type Writer struct {
-    // contains filtered or unexported fields
-}
-```
-Writer is a buffered writer
-
-
-
-
-
-
-
-
-
-### func NewWriter
-``` go
-func NewWriter(w io.Writer) *Writer
-```
-NewWriter returns a new writer
-that writes to 'w' and has a buffer
-that is `DefaultWriterSize` bytes.
-
-
-### func NewWriterSize
-``` go
-func NewWriterSize(w io.Writer, size int) *Writer
-```
-NewWriterSize returns a new writer
-that writes to 'w' and has a buffer
-that is 'size' bytes.
-
-
-
-
-### func (\*Writer) BufferSize
-``` go
-func (w *Writer) BufferSize() int
-```
-BufferSize returns the maximum size of the buffer.
-
-
-
-### func (\*Writer) Buffered
-``` go
-func (w *Writer) Buffered() int
-```
-Buffered returns the number of buffered bytes
-in the reader.
-
-
-
-### func (\*Writer) Flush
-``` go
-func (w *Writer) Flush() error
-```
-Flush flushes any buffered bytes
-to the underlying writer.
-
-
-
-### func (\*Writer) Next
-``` go
-func (w *Writer) Next(n int) ([]byte, error)
-```
-Next returns the next 'n' free bytes
-in the write buffer, flushing the writer
-as necessary. Next will return `io.ErrShortBuffer`
-if 'n' is greater than the size of the write buffer.
-Calls to 'next' increment the write position by
-the size of the returned buffer.
-
-
-
-### func (\*Writer) ReadFrom
-``` go
-func (w *Writer) ReadFrom(r io.Reader) (int64, error)
-```
-ReadFrom implements `io.ReaderFrom`
-
-
-
-### func (\*Writer) Write
-``` go
-func (w *Writer) Write(p []byte) (int, error)
-```
-Write implements `io.Writer`
-
-
-
-### func (\*Writer) WriteByte
-``` go
-func (w *Writer) WriteByte(b byte) error
-```
-WriteByte implements `io.ByteWriter`
-
-
-
-### func (\*Writer) WriteString
-``` go
-func (w *Writer) WriteString(s string) (int, error)
-```
-WriteString is analogous to Write, but it takes a string.
-
-
-
-
-
-
-
-
-
-- - -
-Generated by [godoc2md](http://godoc.org/github.com/davecheney/godoc2md)

vendor/github.com/philhofer/fwd/reader.go

@@ -1,396 +0,0 @@
-// The `fwd` package provides a buffered reader
-// and writer. Each has methods that help improve
-// the encoding/decoding performance of some binary
-// protocols.
-//
-// The `fwd.Writer` and `fwd.Reader` type provide similar
-// functionality to their counterparts in `bufio`, plus
-// a few extra utility methods that simplify read-ahead
-// and write-ahead. I wrote this package to improve serialization
-// performance for http://github.com/tinylib/msgp,
-// where it provided about a 2x speedup over `bufio` for certain
-// workloads. However, care must be taken to understand the semantics of the
-// extra methods provided by this package, as they allow
-// the user to access and manipulate the buffer memory
-// directly.
-//
-// The extra methods for `fwd.Reader` are `Peek`, `Skip`
-// and `Next`. `(*fwd.Reader).Peek`, unlike `(*bufio.Reader).Peek`,
-// will re-allocate the read buffer in order to accommodate arbitrarily
-// large read-ahead. `(*fwd.Reader).Skip` skips the next `n` bytes
-// in the stream, and uses the `io.Seeker` interface if the underlying
-// stream implements it. `(*fwd.Reader).Next` returns a slice pointing
-// to the next `n` bytes in the read buffer (like `Peek`), but also
-// increments the read position. This allows users to process streams
-// in arbitrary block sizes without having to manage appropriately-sized
-// slices. Additionally, obviating the need to copy the data from the
-// buffer to another location in memory can improve performance dramatically
-// in CPU-bound applications.
-//
-// `fwd.Writer` only has one extra method, which is `(*fwd.Writer).Next`, which
-// returns a slice pointing to the next `n` bytes of the writer, and increments
-// the write position by the length of the returned slice. This allows users
-// to write directly to the end of the buffer.
-//
-package fwd
-
-import "io"
-
-const (
-	// DefaultReaderSize is the default size of the read buffer
-	DefaultReaderSize = 2048
-
-	// minimum read buffer; straight from bufio
-	minReaderSize = 16
-)
-
-// NewReader returns a new *Reader that reads from 'r'
-func NewReader(r io.Reader) *Reader {
-	return NewReaderSize(r, DefaultReaderSize)
-}
-
-// NewReaderSize returns a new *Reader that
-// reads from 'r' and has a buffer size 'n'.
-func NewReaderSize(r io.Reader, n int) *Reader {
-	buf := make([]byte, 0, max(n, minReaderSize))
-	return NewReaderBuf(r, buf)
-}
-
-// NewReaderBuf returns a new *Reader that
-// reads from 'r' and uses 'buf' as a buffer.
-// 'buf' is not used when has smaller capacity than 16,
-// custom buffer is allocated instead.
-func NewReaderBuf(r io.Reader, buf []byte) *Reader {
-	if cap(buf) < minReaderSize {
-		buf = make([]byte, 0, minReaderSize)
-	}
-	buf = buf[:0]
-	rd := &Reader{
-		r:    r,
-		data: buf,
-	}
-	if s, ok := r.(io.Seeker); ok {
-		rd.rs = s
-	}
-	return rd
-}
-
-// Reader is a buffered look-ahead reader
-type Reader struct {
-	r io.Reader // underlying reader
-
-	// data[n:len(data)] is buffered data; data[len(data):cap(data)] is free buffer space
-	data  []byte // data
-	n     int    // read offset
-	state error  // last read error
-
-	// if the reader past to NewReader was
-	// also an io.Seeker, this is non-nil
-	rs io.Seeker
-}
-
-// Reset resets the underlying reader
-// and the read buffer.
-func (r *Reader) Reset(rd io.Reader) {
-	r.r = rd
-	r.data = r.data[0:0]
-	r.n = 0
-	r.state = nil
-	if s, ok := rd.(io.Seeker); ok {
-		r.rs = s
-	} else {
-		r.rs = nil
-	}
-}
-
-// more() does one read on the underlying reader
-func (r *Reader) more() {
-	// move data backwards so that
-	// the read offset is 0; this way
-	// we can supply the maximum number of
-	// bytes to the reader
-	if r.n != 0 {
-		if r.n < len(r.data) {
-			r.data = r.data[:copy(r.data[0:], r.data[r.n:])]
-		} else {
-			r.data = r.data[:0]
-		}
-		r.n = 0
-	}
-	var a int
-	a, r.state = r.r.Read(r.data[len(r.data):cap(r.data)])
-	if a == 0 && r.state == nil {
-		r.state = io.ErrNoProgress
-		return
-	} else if a > 0 && r.state == io.EOF {
-		// discard the io.EOF if we read more than 0 bytes.
-		// the next call to Read should return io.EOF again.
-		r.state = nil
-	}
-	r.data = r.data[:len(r.data)+a]
-}
-
-// pop error
-func (r *Reader) err() (e error) {
-	e, r.state = r.state, nil
-	return
-}
-
-// pop error; EOF -> io.ErrUnexpectedEOF
-func (r *Reader) noEOF() (e error) {
-	e, r.state = r.state, nil
-	if e == io.EOF {
-		e = io.ErrUnexpectedEOF
-	}
-	return
-}
-
-// buffered bytes
-func (r *Reader) buffered() int { return len(r.data) - r.n }
-
-// Buffered returns the number of bytes currently in the buffer
-func (r *Reader) Buffered() int { return len(r.data) - r.n }
-
-// BufferSize returns the total size of the buffer
-func (r *Reader) BufferSize() int { return cap(r.data) }
-
-// Peek returns the next 'n' buffered bytes,
-// reading from the underlying reader if necessary.
-// It will only return a slice shorter than 'n' bytes
-// if it also returns an error. Peek does not advance
-// the reader. EOF errors are *not* returned as
-// io.ErrUnexpectedEOF.
-func (r *Reader) Peek(n int) ([]byte, error) {
-	// in the degenerate case,
-	// we may need to realloc
-	// (the caller asked for more
-	// bytes than the size of the buffer)
-	if cap(r.data) < n {
-		old := r.data[r.n:]
-		r.data = make([]byte, n+r.buffered())
-		r.data = r.data[:copy(r.data, old)]
-		r.n = 0
-	}
-
-	// keep filling until
-	// we hit an error or
-	// read enough bytes
-	for r.buffered() < n && r.state == nil {
-		r.more()
-	}
-
-	// we must have hit an error
-	if r.buffered() < n {
-		return r.data[r.n:], r.err()
-	}
-
-	return r.data[r.n : r.n+n], nil
-}
-
-// Skip moves the reader forward 'n' bytes.
-// Returns the number of bytes skipped and any
-// errors encountered. It is analogous to Seek(n, 1).
-// If the underlying reader implements io.Seeker, then
-// that method will be used to skip forward.
-//
-// If the reader encounters
-// an EOF before skipping 'n' bytes, it
-// returns io.ErrUnexpectedEOF. If the
-// underlying reader implements io.Seeker, then
-// those rules apply instead. (Many implementations
-// will not return `io.EOF` until the next call
-// to Read.)
-func (r *Reader) Skip(n int) (int, error) {
-
-	// fast path
-	if r.buffered() >= n {
-		r.n += n
-		return n, nil
-	}
-
-	// use seeker implementation
-	// if we can
-	if r.rs != nil {
-		return r.skipSeek(n)
-	}
-
-	// loop on filling
-	// and then erasing
-	o := n
-	for r.buffered() < n && r.state == nil {
-		r.more()
-		// we can skip forward
-		// up to r.buffered() bytes
-		step := min(r.buffered(), n)
-		r.n += step
-		n -= step
-	}
-	// at this point, n should be
-	// 0 if everything went smoothly
-	return o - n, r.noEOF()
-}
-
-// Next returns the next 'n' bytes in the stream.
-// Unlike Peek, Next advances the reader position.
-// The returned bytes point to the same
-// data as the buffer, so the slice is
-// only valid until the next reader method call.
-// An EOF is considered an unexpected error.
-// If an the returned slice is less than the
-// length asked for, an error will be returned,
-// and the reader position will not be incremented.
-func (r *Reader) Next(n int) ([]byte, error) {
-
-	// in case the buffer is too small
-	if cap(r.data) < n {
-		old := r.data[r.n:]
-		r.data = make([]byte, n+r.buffered())
-		r.data = r.data[:copy(r.data, old)]
-		r.n = 0
-	}
-
-	// fill at least 'n' bytes
-	for r.buffered() < n && r.state == nil {
-		r.more()
-	}
-
-	if r.buffered() < n {
-		return r.data[r.n:], r.noEOF()
-	}
-	out := r.data[r.n : r.n+n]
-	r.n += n
-	return out, nil
-}
-
-// skipSeek uses the io.Seeker to seek forward.
-// only call this function when n > r.buffered()
-func (r *Reader) skipSeek(n int) (int, error) {
-	o := r.buffered()
-	// first, clear buffer
-	n -= o
-	r.n = 0
-	r.data = r.data[:0]
-
-	// then seek forward remaning bytes
-	i, err := r.rs.Seek(int64(n), 1)
-	return int(i) + o, err
-}
-
-// Read implements `io.Reader`
-func (r *Reader) Read(b []byte) (int, error) {
-	// if we have data in the buffer, just
-	// return that.
-	if r.buffered() != 0 {
-		x := copy(b, r.data[r.n:])
-		r.n += x
-		return x, nil
-	}
-	var n int
-	// we have no buffered data; determine
-	// whether or not to buffer or call
-	// the underlying reader directly
-	if len(b) >= cap(r.data) {
-		n, r.state = r.r.Read(b)
-	} else {
-		r.more()
-		n = copy(b, r.data)
-		r.n = n
-	}
-	if n == 0 {
-		return 0, r.err()
-	}
-	return n, nil
-}
-
-// ReadFull attempts to read len(b) bytes into
-// 'b'. It returns the number of bytes read into
-// 'b', and an error if it does not return len(b).
-// EOF is considered an unexpected error.
-func (r *Reader) ReadFull(b []byte) (int, error) {
-	var n int  // read into b
-	var nn int // scratch
-	l := len(b)
-	// either read buffered data,
-	// or read directly for the underlying
-	// buffer, or fetch more buffered data.
-	for n < l && r.state == nil {
-		if r.buffered() != 0 {
-			nn = copy(b[n:], r.data[r.n:])
-			n += nn
-			r.n += nn
-		} else if l-n > cap(r.data) {
-			nn, r.state = r.r.Read(b[n:])
-			n += nn
-		} else {
-			r.more()
-		}
-	}
-	if n < l {
-		return n, r.noEOF()
-	}
-	return n, nil
-}
-
-// ReadByte implements `io.ByteReader`
-func (r *Reader) ReadByte() (byte, error) {
-	for r.buffered() < 1 && r.state == nil {
-		r.more()
-	}
-	if r.buffered() < 1 {
-		return 0, r.err()
-	}
-	b := r.data[r.n]
-	r.n++
-	return b, nil
-}
-
-// WriteTo implements `io.WriterTo`
-func (r *Reader) WriteTo(w io.Writer) (int64, error) {
-	var (
-		i   int64
-		ii  int
-		err error
-	)
-	// first, clear buffer
-	if r.buffered() > 0 {
-		ii, err = w.Write(r.data[r.n:])
-		i += int64(ii)
-		if err != nil {
-			return i, err
-		}
-		r.data = r.data[0:0]
-		r.n = 0
-	}
-	for r.state == nil {
-		// here we just do
-		// 1:1 reads and writes
-		r.more()
-		if r.buffered() > 0 {
-			ii, err = w.Write(r.data)
-			i += int64(ii)
-			if err != nil {
-				return i, err
-			}
-			r.data = r.data[0:0]
-			r.n = 0
-		}
-	}
-	if r.state != io.EOF {
-		return i, r.err()
-	}
-	return i, nil
-}
-
-func min(a int, b int) int {
-	if a < b {
-		return a
-	}
-	return b
-}
-
-func max(a int, b int) int {
-	if a < b {
-		return b
-	}
-	return a
-}

vendor/github.com/philhofer/fwd/writer.go

@@ -1,236 +0,0 @@
-package fwd
-
-import "io"
-
-const (
-	// DefaultWriterSize is the
-	// default write buffer size.
-	DefaultWriterSize = 2048
-
-	minWriterSize = minReaderSize
-)
-
-// Writer is a buffered writer
-type Writer struct {
-	w   io.Writer // writer
-	buf []byte    // 0:len(buf) is bufered data
-}
-
-// NewWriter returns a new writer
-// that writes to 'w' and has a buffer
-// that is `DefaultWriterSize` bytes.
-func NewWriter(w io.Writer) *Writer {
-	if wr, ok := w.(*Writer); ok {
-		return wr
-	}
-	return &Writer{
-		w:   w,
-		buf: make([]byte, 0, DefaultWriterSize),
-	}
-}
-
-// NewWriterSize returns a new writer that
-// writes to 'w' and has a buffer size 'n'.
-func NewWriterSize(w io.Writer, n int) *Writer {
-	if wr, ok := w.(*Writer); ok && cap(wr.buf) >= n {
-		return wr
-	}
-	buf := make([]byte, 0, max(n, minWriterSize))
-	return NewWriterBuf(w, buf)
-}
-
-// NewWriterBuf returns a new writer
-// that writes to 'w' and has 'buf' as a buffer.
-// 'buf' is not used when has smaller capacity than 18,
-// custom buffer is allocated instead.
-func NewWriterBuf(w io.Writer, buf []byte) *Writer {
-	if cap(buf) < minWriterSize {
-		buf = make([]byte, 0, minWriterSize)
-	}
-	buf = buf[:0]
-	return &Writer{
-		w:   w,
-		buf: buf,
-	}
-}
-
-// Buffered returns the number of buffered bytes
-// in the reader.
-func (w *Writer) Buffered() int { return len(w.buf) }
-
-// BufferSize returns the maximum size of the buffer.
-func (w *Writer) BufferSize() int { return cap(w.buf) }
-
-// Flush flushes any buffered bytes
-// to the underlying writer.
-func (w *Writer) Flush() error {
-	l := len(w.buf)
-	if l > 0 {
-		n, err := w.w.Write(w.buf)
-
-		// if we didn't write the whole
-		// thing, copy the unwritten
-		// bytes to the beginnning of the
-		// buffer.
-		if n < l && n > 0 {
-			w.pushback(n)
-			if err == nil {
-				err = io.ErrShortWrite
-			}
-		}
-		if err != nil {
-			return err
-		}
-		w.buf = w.buf[:0]
-		return nil
-	}
-	return nil
-}
-
-// Write implements `io.Writer`
-func (w *Writer) Write(p []byte) (int, error) {
-	c, l, ln := cap(w.buf), len(w.buf), len(p)
-	avail := c - l
-
-	// requires flush
-	if avail < ln {
-		if err := w.Flush(); err != nil {
-			return 0, err
-		}
-		l = len(w.buf)
-	}
-	// too big to fit in buffer;
-	// write directly to w.w
-	if c < ln {
-		return w.w.Write(p)
-	}
-
-	// grow buf slice; copy; return
-	w.buf = w.buf[:l+ln]
-	return copy(w.buf[l:], p), nil
-}
-
-// WriteString is analogous to Write, but it takes a string.
-func (w *Writer) WriteString(s string) (int, error) {
-	c, l, ln := cap(w.buf), len(w.buf), len(s)
-	avail := c - l
-
-	// requires flush
-	if avail < ln {
-		if err := w.Flush(); err != nil {
-			return 0, err
-		}
-		l = len(w.buf)
-	}
-	// too big to fit in buffer;
-	// write directly to w.w
-	//
-	// yes, this is unsafe. *but*
-	// io.Writer is not allowed
-	// to mutate its input or
-	// maintain a reference to it,
-	// per the spec in package io.
-	//
-	// plus, if the string is really
-	// too big to fit in the buffer, then
-	// creating a copy to write it is
-	// expensive (and, strictly speaking,
-	// unnecessary)
-	if c < ln {
-		return w.w.Write(unsafestr(s))
-	}
-
-	// grow buf slice; copy; return
-	w.buf = w.buf[:l+ln]
-	return copy(w.buf[l:], s), nil
-}
-
-// WriteByte implements `io.ByteWriter`
-func (w *Writer) WriteByte(b byte) error {
-	if len(w.buf) == cap(w.buf) {
-		if err := w.Flush(); err != nil {
-			return err
-		}
-	}
-	w.buf = append(w.buf, b)
-	return nil
-}
-
-// Next returns the next 'n' free bytes
-// in the write buffer, flushing the writer
-// as necessary. Next will return `io.ErrShortBuffer`
-// if 'n' is greater than the size of the write buffer.
-// Calls to 'next' increment the write position by
-// the size of the returned buffer.
-func (w *Writer) Next(n int) ([]byte, error) {
-	c, l := cap(w.buf), len(w.buf)
-	if n > c {
-		return nil, io.ErrShortBuffer
-	}
-	avail := c - l
-	if avail < n {
-		if err := w.Flush(); err != nil {
-			return nil, err
-		}
-		l = len(w.buf)
-	}
-	w.buf = w.buf[:l+n]
-	return w.buf[l:], nil
-}
-
-// take the bytes from w.buf[n:len(w.buf)]
-// and put them at the beginning of w.buf,
-// and resize to the length of the copied segment.
-func (w *Writer) pushback(n int) {
-	w.buf = w.buf[:copy(w.buf, w.buf[n:])]
-}
-
-// ReadFrom implements `io.ReaderFrom`
-func (w *Writer) ReadFrom(r io.Reader) (int64, error) {
-	// anticipatory flush
-	if err := w.Flush(); err != nil {
-		return 0, err
-	}
-
-	w.buf = w.buf[0:cap(w.buf)] // expand buffer
-
-	var nn int64  // written
-	var err error // error
-	var x int     // read
-
-	// 1:1 reads and writes
-	for err == nil {
-		x, err = r.Read(w.buf)
-		if x > 0 {
-			n, werr := w.w.Write(w.buf[:x])
-			nn += int64(n)
-
-			if err != nil {
-				if n < x && n > 0 {
-					w.pushback(n - x)
-				}
-				return nn, werr
-			}
-			if n < x {
-				w.pushback(n - x)
-				return nn, io.ErrShortWrite
-			}
-		} else if err == nil {
-			err = io.ErrNoProgress
-			break
-		}
-	}
-	if err != io.EOF {
-		return nn, err
-	}
-
-	// we only clear here
-	// because we are sure
-	// the writes have
-	// succeeded. otherwise,
-	// we retain the data in case
-	// future writes succeed.
-	w.buf = w.buf[0:0]
-
-	return nn, nil
-}

vendor/github.com/philhofer/fwd/writer_appengine.go

@@ -1,5 +0,0 @@
-// +build appengine
-
-package fwd
-
-func unsafestr(s string) []byte { return []byte(s) }

vendor/github.com/philhofer/fwd/writer_unsafe.go

@@ -1,18 +0,0 @@
-// +build !appengine
-
-package fwd
-
-import (
-	"reflect"
-	"unsafe"
-)
-
-// unsafe cast string as []byte
-func unsafestr(b string) []byte {
-	l := len(b)
-	return *(*[]byte)(unsafe.Pointer(&reflect.SliceHeader{
-		Len:  l,
-		Cap:  l,
-		Data: (*reflect.StringHeader)(unsafe.Pointer(&b)).Data,
-	}))
-}

vendor/github.com/pquerna/otp/README.md

@@ -4,7 +4,7 @@
 
 # Why One Time Passwords?
 
-One Time Passwords (OTPs) are an mechanism to  improve security over passwords alone. When a Time-based OTP (TOTP) is stored on a user's phone, and combined with something the user knows (Password), you have an easy on-ramp to [Multi-factor authentication](http://en.wikipedia.org/wiki/Multi-factor_authentication) without adding a dependency on a SMS provider.  This Password and TOTP combination is used by many popular websites including Google, Github, Facebook, Salesforce and many others.
+One Time Passwords (OTPs) are an mechanism to  improve security over passwords alone. When a Time-based OTP (TOTP) is stored on a user's phone, and combined with something the user knows (Password), you have an easy on-ramp to [Multi-factor authentication](http://en.wikipedia.org/wiki/Multi-factor_authentication) without adding a dependency on a SMS provider.  This Password and TOTP combination is used by many popular websites including Google, GitHub, Facebook, Salesforce and many others.
 
 The `otp` library enables you to easily add TOTPs to your own application, increasing your user's security against mass-password breaches and malware.
 
@@ -21,7 +21,7 @@ Because TOTP is standardized and widely deployed, there are many [mobile clients
 
 ### User Enrollment
 
-For an example of a working enrollment work flow, [Github has documented theirs](https://help.github.com/articles/configuring-two-factor-authentication-via-a-totp-mobile-app/
+For an example of a working enrollment work flow, [GitHub has documented theirs](https://help.github.com/articles/configuring-two-factor-authentication-via-a-totp-mobile-app/
 ),  but the basics are:
 
 1. Generate new TOTP Key for a User. `key,_ := totp.Generate(...)`.

vendor/github.com/pquerna/otp/doc.go

@@ -19,7 +19,7 @@
 // one time passcodes in a Google Authenticator compatible manner.
 //
 // When adding a TOTP for a user, you must store the "secret" value
-// persistently. It is recommend to store the secret in an encrypted field in your
+// persistently. It is recommended to store the secret in an encrypted field in your
 // datastore.  Due to how TOTP works, it is not possible to store a hash
 // for the secret value like you would a password.
 //
@@ -57,6 +57,7 @@
 //
 // Validating a TOTP passcode is very easy, just prompt the user for a passcode
 // and retrieve the associated user's previously stored secret.
+//
 //	import "github.com/pquerna/otp/totp"
 //
 //	passcode := promptForPasscode()

vendor/github.com/pquerna/otp/hotp/hotp.go

@@ -19,6 +19,7 @@ package hotp
 
 import (
 	"github.com/pquerna/otp"
+	"github.com/pquerna/otp/internal"
 	"io"
 
 	"crypto/hmac"
@@ -71,6 +72,10 @@ func GenerateCode(secret string, counter uint64) (string, error) {
 // GenerateCodeCustom uses a counter and secret value and options struct to
 // create a passcode.
 func GenerateCodeCustom(secret string, counter uint64, opts ValidateOpts) (passcode string, err error) {
+	//Set default value
+	if opts.Digits == 0 {
+		opts.Digits = otp.DigitsSix
+	}
 	// As noted in issue #10 and #17 this adds support for TOTP secrets that are
 	// missing their padding.
 	secret = strings.TrimSpace(secret)
@@ -182,7 +187,7 @@ func Generate(opts GenerateOpts) (*otp.Key, error) {
 		opts.Rand = rand.Reader
 	}
 
-	// otpauth://totp/Example:alice@google.com?secret=JBSWY3DPEHPK3PXP&issuer=Example
+	// otpauth://hotp/Example:alice@google.com?secret=JBSWY3DPEHPK3PXP&issuer=Example
 
 	v := url.Values{}
 	if len(opts.Secret) != 0 {
@@ -204,7 +209,7 @@ func Generate(opts GenerateOpts) (*otp.Key, error) {
 		Scheme:   "otpauth",
 		Host:     "hotp",
 		Path:     "/" + opts.Issuer + ":" + opts.AccountName,
-		RawQuery: v.Encode(),
+		RawQuery: internal.EncodeQuery(v),
 	}
 
 	return otp.NewKeyFromURL(u.String())

vendor/github.com/pquerna/otp/internal/encode.go

@@ -0,0 +1,35 @@
+package internal
+
+import (
+	"net/url"
+	"sort"
+	"strings"
+)
+
+// EncodeQuery is a copy-paste of url.Values.Encode, except it uses %20 instead
+// of + to encode spaces. This is necessary to correctly render spaces in some
+// authenticator apps, like Google Authenticator.
+func EncodeQuery(v url.Values) string {
+	if v == nil {
+		return ""
+	}
+	var buf strings.Builder
+	keys := make([]string, 0, len(v))
+	for k := range v {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+	for _, k := range keys {
+		vs := v[k]
+		keyEscaped := url.PathEscape(k) // changed from url.QueryEscape
+		for _, v := range vs {
+			if buf.Len() > 0 {
+				buf.WriteByte('&')
+			}
+			buf.WriteString(keyEscaped)
+			buf.WriteByte('=')
+			buf.WriteString(url.PathEscape(v)) // changed from url.QueryEscape
+		}
+	}
+	return buf.String()
+}

vendor/github.com/pquerna/otp/otp.go

@@ -18,9 +18,6 @@
 package otp
 
 import (
-	"github.com/boombuler/barcode"
-	"github.com/boombuler/barcode/qr"
-
 	"crypto/md5"
 	"crypto/sha1"
 	"crypto/sha256"
@@ -30,8 +27,11 @@ import (
 	"hash"
 	"image"
 	"net/url"
-	"strings"
 	"strconv"
+	"strings"
+
+	"github.com/boombuler/barcode"
+	"github.com/boombuler/barcode/qr"
 )
 
 // Error when attempting to convert the secret from base32 to raw bytes.
@@ -61,7 +61,6 @@ func NewKeyFromURL(orig string) (*Key, error) {
 	s := strings.TrimSpace(orig)
 
 	u, err := url.Parse(s)
-
 	if err != nil {
 		return nil, err
 	}
@@ -81,7 +80,6 @@ func (k *Key) String() string {
 // to enroll a user's TOTP/HOTP key.
 func (k *Key) Image(width int, height int) (image.Image, error) {
 	b, err := qr.Encode(k.orig, qr.M, qr.Auto)
-
 	if err != nil {
 		return nil, err
 	}
@@ -146,11 +144,45 @@ func (k *Key) Period() uint64 {
 	if u, err := strconv.ParseUint(q.Get("period"), 10, 64); err == nil {
 		return u
 	}
-	
+
 	// If no period is defined 30 seconds is the default per (rfc6238)
 	return 30
 }
 
+// Digits returns a tiny int representing the number of OTP digits.
+func (k *Key) Digits() Digits {
+	q := k.url.Query()
+
+	if u, err := strconv.ParseUint(q.Get("digits"), 10, 64); err == nil {
+		switch u {
+		case 8:
+			return DigitsEight
+		default:
+			return DigitsSix
+		}
+	}
+
+	// Six is the most common value.
+	return DigitsSix
+}
+
+// Algorithm returns the algorithm used or the default (SHA1).
+func (k *Key) Algorithm() Algorithm {
+	q := k.url.Query()
+
+	a := strings.ToLower(q.Get("algorithm"))
+	switch a {
+	case "md5":
+		return AlgorithmMD5
+	case "sha256":
+		return AlgorithmSHA256
+	case "sha512":
+		return AlgorithmSHA512
+	default:
+		return AlgorithmSHA1
+	}
+}
+
 // URL returns the OTP URL as a string
 func (k *Key) URL() string {
 	return k.url.String()

vendor/github.com/pquerna/otp/totp/totp.go

@@ -20,6 +20,7 @@ package totp
 import (
 	"github.com/pquerna/otp"
 	"github.com/pquerna/otp/hotp"
+	"github.com/pquerna/otp/internal"
 	"io"
 
 	"crypto/rand"
@@ -199,7 +200,7 @@ func Generate(opts GenerateOpts) (*otp.Key, error) {
 		Scheme:   "otpauth",
 		Host:     "totp",
 		Path:     "/" + opts.Issuer + ":" + opts.AccountName,
-		RawQuery: v.Encode(),
+		RawQuery: internal.EncodeQuery(v),
 	}
 
 	return otp.NewKeyFromURL(u.String())

vendor/github.com/tinylib/msgp/LICENSE

@@ -1,8 +0,0 @@
-Copyright (c) 2014 Philip Hofer
-Portions Copyright (c) 2009 The Go Authors (license at http://golang.org) where indicated
-
-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.

vendor/github.com/tinylib/msgp/msgp/advise_linux.go

@@ -1,24 +0,0 @@
-// +build linux,!appengine
-
-package msgp
-
-import (
-	"os"
-	"syscall"
-)
-
-func adviseRead(mem []byte) {
-	syscall.Madvise(mem, syscall.MADV_SEQUENTIAL|syscall.MADV_WILLNEED)
-}
-
-func adviseWrite(mem []byte) {
-	syscall.Madvise(mem, syscall.MADV_SEQUENTIAL)
-}
-
-func fallocate(f *os.File, sz int64) error {
-	err := syscall.Fallocate(int(f.Fd()), 0, 0, sz)
-	if err == syscall.ENOTSUP {
-		return f.Truncate(sz)
-	}
-	return err
-}

vendor/github.com/tinylib/msgp/msgp/advise_other.go

@@ -1,17 +0,0 @@
-// +build !linux appengine
-
-package msgp
-
-import (
-	"os"
-)
-
-// TODO: darwin, BSD support
-
-func adviseRead(mem []byte) {}
-
-func adviseWrite(mem []byte) {}
-
-func fallocate(f *os.File, sz int64) error {
-	return f.Truncate(sz)
-}

vendor/github.com/tinylib/msgp/msgp/circular.go

@@ -1,39 +0,0 @@
-package msgp
-
-type timer interface {
-	StartTimer()
-	StopTimer()
-}
-
-// EndlessReader is an io.Reader
-// that loops over the same data
-// endlessly. It is used for benchmarking.
-type EndlessReader struct {
-	tb     timer
-	data   []byte
-	offset int
-}
-
-// NewEndlessReader returns a new endless reader
-func NewEndlessReader(b []byte, tb timer) *EndlessReader {
-	return &EndlessReader{tb: tb, data: b, offset: 0}
-}
-
-// Read implements io.Reader. In practice, it
-// always returns (len(p), nil), although it
-// fills the supplied slice while the benchmark
-// timer is stopped.
-func (c *EndlessReader) Read(p []byte) (int, error) {
-	c.tb.StopTimer()
-	var n int
-	l := len(p)
-	m := len(c.data)
-	for n < l {
-		nn := copy(p[n:], c.data[c.offset:])
-		n += nn
-		c.offset += nn
-		c.offset %= m
-	}
-	c.tb.StartTimer()
-	return n, nil
-}

vendor/github.com/tinylib/msgp/msgp/defs.go

@@ -1,142 +0,0 @@
-// This package is the support library for the msgp code generator (http://github.com/tinylib/msgp).
-//
-// This package defines the utilites used by the msgp code generator for encoding and decoding MessagePack
-// from []byte and io.Reader/io.Writer types. Much of this package is devoted to helping the msgp code
-// generator implement the Marshaler/Unmarshaler and Encodable/Decodable interfaces.
-//
-// This package defines four "families" of functions:
-// 	- AppendXxxx() appends an object to a []byte in MessagePack encoding.
-// 	- ReadXxxxBytes() reads an object from a []byte and returns the remaining bytes.
-// 	- (*Writer).WriteXxxx() writes an object to the buffered *Writer type.
-// 	- (*Reader).ReadXxxx() reads an object from a buffered *Reader type.
-//
-// Once a type has satisfied the `Encodable` and `Decodable` interfaces,
-// it can be written and read from arbitrary `io.Writer`s and `io.Reader`s using
-// 		msgp.Encode(io.Writer, msgp.Encodable)
-// and
-//		msgp.Decode(io.Reader, msgp.Decodable)
-//
-// There are also methods for converting MessagePack to JSON without
-// an explicit de-serialization step.
-//
-// For additional tips, tricks, and gotchas, please visit
-// the wiki at http://github.com/tinylib/msgp
-package msgp
-
-const last4 = 0x0f
-const first4 = 0xf0
-const last5 = 0x1f
-const first3 = 0xe0
-const last7 = 0x7f
-
-func isfixint(b byte) bool {
-	return b>>7 == 0
-}
-
-func isnfixint(b byte) bool {
-	return b&first3 == mnfixint
-}
-
-func isfixmap(b byte) bool {
-	return b&first4 == mfixmap
-}
-
-func isfixarray(b byte) bool {
-	return b&first4 == mfixarray
-}
-
-func isfixstr(b byte) bool {
-	return b&first3 == mfixstr
-}
-
-func wfixint(u uint8) byte {
-	return u & last7
-}
-
-func rfixint(b byte) uint8 {
-	return b
-}
-
-func wnfixint(i int8) byte {
-	return byte(i) | mnfixint
-}
-
-func rnfixint(b byte) int8 {
-	return int8(b)
-}
-
-func rfixmap(b byte) uint8 {
-	return b & last4
-}
-
-func wfixmap(u uint8) byte {
-	return mfixmap | (u & last4)
-}
-
-func rfixstr(b byte) uint8 {
-	return b & last5
-}
-
-func wfixstr(u uint8) byte {
-	return (u & last5) | mfixstr
-}
-
-func rfixarray(b byte) uint8 {
-	return (b & last4)
-}
-
-func wfixarray(u uint8) byte {
-	return (u & last4) | mfixarray
-}
-
-// These are all the byte
-// prefixes defined by the
-// msgpack standard
-const (
-	// 0XXXXXXX
-	mfixint uint8 = 0x00
-
-	// 111XXXXX
-	mnfixint uint8 = 0xe0
-
-	// 1000XXXX
-	mfixmap uint8 = 0x80
-
-	// 1001XXXX
-	mfixarray uint8 = 0x90
-
-	// 101XXXXX
-	mfixstr uint8 = 0xa0
-
-	mnil      uint8 = 0xc0
-	mfalse    uint8 = 0xc2
-	mtrue     uint8 = 0xc3
-	mbin8     uint8 = 0xc4
-	mbin16    uint8 = 0xc5
-	mbin32    uint8 = 0xc6
-	mext8     uint8 = 0xc7
-	mext16    uint8 = 0xc8
-	mext32    uint8 = 0xc9
-	mfloat32  uint8 = 0xca
-	mfloat64  uint8 = 0xcb
-	muint8    uint8 = 0xcc
-	muint16   uint8 = 0xcd
-	muint32   uint8 = 0xce
-	muint64   uint8 = 0xcf
-	mint8     uint8 = 0xd0
-	mint16    uint8 = 0xd1
-	mint32    uint8 = 0xd2
-	mint64    uint8 = 0xd3
-	mfixext1  uint8 = 0xd4
-	mfixext2  uint8 = 0xd5
-	mfixext4  uint8 = 0xd6
-	mfixext8  uint8 = 0xd7
-	mfixext16 uint8 = 0xd8
-	mstr8     uint8 = 0xd9
-	mstr16    uint8 = 0xda
-	mstr32    uint8 = 0xdb
-	marray16  uint8 = 0xdc
-	marray32  uint8 = 0xdd
-	mmap16    uint8 = 0xde
-	mmap32    uint8 = 0xdf
-)

vendor/github.com/tinylib/msgp/msgp/edit.go

@@ -1,242 +0,0 @@
-package msgp
-
-import (
-	"math"
-)
-
-// Locate returns a []byte pointing to the field
-// in a messagepack map with the provided key. (The returned []byte
-// points to a sub-slice of 'raw'; Locate does no allocations.) If the
-// key doesn't exist in the map, a zero-length []byte will be returned.
-func Locate(key string, raw []byte) []byte {
-	s, n := locate(raw, key)
-	return raw[s:n]
-}
-
-// Replace takes a key ("key") in a messagepack map ("raw")
-// and replaces its value with the one provided and returns
-// the new []byte. The returned []byte may point to the same
-// memory as "raw". Replace makes no effort to evaluate the validity
-// of the contents of 'val'. It may use up to the full capacity of 'raw.'
-// Replace returns 'nil' if the field doesn't exist or if the object in 'raw'
-// is not a map.
-func Replace(key string, raw []byte, val []byte) []byte {
-	start, end := locate(raw, key)
-	if start == end {
-		return nil
-	}
-	return replace(raw, start, end, val, true)
-}
-
-// CopyReplace works similarly to Replace except that the returned
-// byte slice does not point to the same memory as 'raw'. CopyReplace
-// returns 'nil' if the field doesn't exist or 'raw' isn't a map.
-func CopyReplace(key string, raw []byte, val []byte) []byte {
-	start, end := locate(raw, key)
-	if start == end {
-		return nil
-	}
-	return replace(raw, start, end, val, false)
-}
-
-// Remove removes a key-value pair from 'raw'. It returns
-// 'raw' unchanged if the key didn't exist.
-func Remove(key string, raw []byte) []byte {
-	start, end := locateKV(raw, key)
-	if start == end {
-		return raw
-	}
-	raw = raw[:start+copy(raw[start:], raw[end:])]
-	return resizeMap(raw, -1)
-}
-
-// HasKey returns whether the map in 'raw' has
-// a field with key 'key'
-func HasKey(key string, raw []byte) bool {
-	sz, bts, err := ReadMapHeaderBytes(raw)
-	if err != nil {
-		return false
-	}
-	var field []byte
-	for i := uint32(0); i < sz; i++ {
-		field, bts, err = ReadStringZC(bts)
-		if err != nil {
-			return false
-		}
-		if UnsafeString(field) == key {
-			return true
-		}
-	}
-	return false
-}
-
-func replace(raw []byte, start int, end int, val []byte, inplace bool) []byte {
-	ll := end - start // length of segment to replace
-	lv := len(val)
-
-	if inplace {
-		extra := lv - ll
-
-		// fastest case: we're doing
-		// a 1:1 replacement
-		if extra == 0 {
-			copy(raw[start:], val)
-			return raw
-
-		} else if extra < 0 {
-			// 'val' smaller than replaced value
-			// copy in place and shift back
-
-			x := copy(raw[start:], val)
-			y := copy(raw[start+x:], raw[end:])
-			return raw[:start+x+y]
-
-		} else if extra < cap(raw)-len(raw) {
-			// 'val' less than (cap-len) extra bytes
-			// copy in place and shift forward
-			raw = raw[0 : len(raw)+extra]
-			// shift end forward
-			copy(raw[end+extra:], raw[end:])
-			copy(raw[start:], val)
-			return raw
-		}
-	}
-
-	// we have to allocate new space
-	out := make([]byte, len(raw)+len(val)-ll)
-	x := copy(out, raw[:start])
-	y := copy(out[x:], val)
-	copy(out[x+y:], raw[end:])
-	return out
-}
-
-// locate does a naive O(n) search for the map key; returns start, end
-// (returns 0,0 on error)
-func locate(raw []byte, key string) (start int, end int) {
-	var (
-		sz    uint32
-		bts   []byte
-		field []byte
-		err   error
-	)
-	sz, bts, err = ReadMapHeaderBytes(raw)
-	if err != nil {
-		return
-	}
-
-	// loop and locate field
-	for i := uint32(0); i < sz; i++ {
-		field, bts, err = ReadStringZC(bts)
-		if err != nil {
-			return 0, 0
-		}
-		if UnsafeString(field) == key {
-			// start location
-			l := len(raw)
-			start = l - len(bts)
-			bts, err = Skip(bts)
-			if err != nil {
-				return 0, 0
-			}
-			end = l - len(bts)
-			return
-		}
-		bts, err = Skip(bts)
-		if err != nil {
-			return 0, 0
-		}
-	}
-	return 0, 0
-}
-
-// locate key AND value
-func locateKV(raw []byte, key string) (start int, end int) {
-	var (
-		sz    uint32
-		bts   []byte
-		field []byte
-		err   error
-	)
-	sz, bts, err = ReadMapHeaderBytes(raw)
-	if err != nil {
-		return 0, 0
-	}
-
-	for i := uint32(0); i < sz; i++ {
-		tmp := len(bts)
-		field, bts, err = ReadStringZC(bts)
-		if err != nil {
-			return 0, 0
-		}
-		if UnsafeString(field) == key {
-			start = len(raw) - tmp
-			bts, err = Skip(bts)
-			if err != nil {
-				return 0, 0
-			}
-			end = len(raw) - len(bts)
-			return
-		}
-		bts, err = Skip(bts)
-		if err != nil {
-			return 0, 0
-		}
-	}
-	return 0, 0
-}
-
-// delta is delta on map size
-func resizeMap(raw []byte, delta int64) []byte {
-	var sz int64
-	switch raw[0] {
-	case mmap16:
-		sz = int64(big.Uint16(raw[1:]))
-		if sz+delta <= math.MaxUint16 {
-			big.PutUint16(raw[1:], uint16(sz+delta))
-			return raw
-		}
-		if cap(raw)-len(raw) >= 2 {
-			raw = raw[0 : len(raw)+2]
-			copy(raw[5:], raw[3:])
-			raw[0] = mmap32
-			big.PutUint32(raw[1:], uint32(sz+delta))
-			return raw
-		}
-		n := make([]byte, 0, len(raw)+5)
-		n = AppendMapHeader(n, uint32(sz+delta))
-		return append(n, raw[3:]...)
-
-	case mmap32:
-		sz = int64(big.Uint32(raw[1:]))
-		big.PutUint32(raw[1:], uint32(sz+delta))
-		return raw
-
-	default:
-		sz = int64(rfixmap(raw[0]))
-		if sz+delta < 16 {
-			raw[0] = wfixmap(uint8(sz + delta))
-			return raw
-		} else if sz+delta <= math.MaxUint16 {
-			if cap(raw)-len(raw) >= 2 {
-				raw = raw[0 : len(raw)+2]
-				copy(raw[3:], raw[1:])
-				raw[0] = mmap16
-				big.PutUint16(raw[1:], uint16(sz+delta))
-				return raw
-			}
-			n := make([]byte, 0, len(raw)+5)
-			n = AppendMapHeader(n, uint32(sz+delta))
-			return append(n, raw[1:]...)
-		}
-		if cap(raw)-len(raw) >= 4 {
-			raw = raw[0 : len(raw)+4]
-			copy(raw[5:], raw[1:])
-			raw[0] = mmap32
-			big.PutUint32(raw[1:], uint32(sz+delta))
-			return raw
-		}
-		n := make([]byte, 0, len(raw)+5)
-		n = AppendMapHeader(n, uint32(sz+delta))
-		return append(n, raw[1:]...)
-	}
-}

vendor/github.com/tinylib/msgp/msgp/elsize.go

@@ -1,99 +0,0 @@
-package msgp
-
-// size of every object on the wire,
-// plus type information. gives us
-// constant-time type information
-// for traversing composite objects.
-//
-var sizes = [256]bytespec{
-	mnil:      {size: 1, extra: constsize, typ: NilType},
-	mfalse:    {size: 1, extra: constsize, typ: BoolType},
-	mtrue:     {size: 1, extra: constsize, typ: BoolType},
-	mbin8:     {size: 2, extra: extra8, typ: BinType},
-	mbin16:    {size: 3, extra: extra16, typ: BinType},
-	mbin32:    {size: 5, extra: extra32, typ: BinType},
-	mext8:     {size: 3, extra: extra8, typ: ExtensionType},
-	mext16:    {size: 4, extra: extra16, typ: ExtensionType},
-	mext32:    {size: 6, extra: extra32, typ: ExtensionType},
-	mfloat32:  {size: 5, extra: constsize, typ: Float32Type},
-	mfloat64:  {size: 9, extra: constsize, typ: Float64Type},
-	muint8:    {size: 2, extra: constsize, typ: UintType},
-	muint16:   {size: 3, extra: constsize, typ: UintType},
-	muint32:   {size: 5, extra: constsize, typ: UintType},
-	muint64:   {size: 9, extra: constsize, typ: UintType},
-	mint8:     {size: 2, extra: constsize, typ: IntType},
-	mint16:    {size: 3, extra: constsize, typ: IntType},
-	mint32:    {size: 5, extra: constsize, typ: IntType},
-	mint64:    {size: 9, extra: constsize, typ: IntType},
-	mfixext1:  {size: 3, extra: constsize, typ: ExtensionType},
-	mfixext2:  {size: 4, extra: constsize, typ: ExtensionType},
-	mfixext4:  {size: 6, extra: constsize, typ: ExtensionType},
-	mfixext8:  {size: 10, extra: constsize, typ: ExtensionType},
-	mfixext16: {size: 18, extra: constsize, typ: ExtensionType},
-	mstr8:     {size: 2, extra: extra8, typ: StrType},
-	mstr16:    {size: 3, extra: extra16, typ: StrType},
-	mstr32:    {size: 5, extra: extra32, typ: StrType},
-	marray16:  {size: 3, extra: array16v, typ: ArrayType},
-	marray32:  {size: 5, extra: array32v, typ: ArrayType},
-	mmap16:    {size: 3, extra: map16v, typ: MapType},
-	mmap32:    {size: 5, extra: map32v, typ: MapType},
-}
-
-func init() {
-	// set up fixed fields
-
-	// fixint
-	for i := mfixint; i < 0x80; i++ {
-		sizes[i] = bytespec{size: 1, extra: constsize, typ: IntType}
-	}
-
-	// nfixint
-	for i := uint16(mnfixint); i < 0x100; i++ {
-		sizes[uint8(i)] = bytespec{size: 1, extra: constsize, typ: IntType}
-	}
-
-	// fixstr gets constsize,
-	// since the prefix yields the size
-	for i := mfixstr; i < 0xc0; i++ {
-		sizes[i] = bytespec{size: 1 + rfixstr(i), extra: constsize, typ: StrType}
-	}
-
-	// fixmap
-	for i := mfixmap; i < 0x90; i++ {
-		sizes[i] = bytespec{size: 1, extra: varmode(2 * rfixmap(i)), typ: MapType}
-	}
-
-	// fixarray
-	for i := mfixarray; i < 0xa0; i++ {
-		sizes[i] = bytespec{size: 1, extra: varmode(rfixarray(i)), typ: ArrayType}
-	}
-}
-
-// a valid bytespsec has
-// non-zero 'size' and
-// non-zero 'typ'
-type bytespec struct {
-	size  uint8   // prefix size information
-	extra varmode // extra size information
-	typ   Type    // type
-	_     byte    // makes bytespec 4 bytes (yes, this matters)
-}
-
-// size mode
-// if positive, # elements for composites
-type varmode int8
-
-const (
-	constsize varmode = 0  // constant size (size bytes + uint8(varmode) objects)
-	extra8            = -1 // has uint8(p[1]) extra bytes
-	extra16           = -2 // has be16(p[1:]) extra bytes
-	extra32           = -3 // has be32(p[1:]) extra bytes
-	map16v            = -4 // use map16
-	map32v            = -5 // use map32
-	array16v          = -6 // use array16
-	array32v          = -7 // use array32
-)
-
-func getType(v byte) Type {
-	return sizes[v].typ
-}

vendor/github.com/tinylib/msgp/msgp/errors.go

@@ -1,317 +0,0 @@
-package msgp
-
-import (
-	"fmt"
-	"reflect"
-)
-
-const resumableDefault = false
-
-var (
-	// ErrShortBytes is returned when the
-	// slice being decoded is too short to
-	// contain the contents of the message
-	ErrShortBytes error = errShort{}
-
-	// this error is only returned
-	// if we reach code that should
-	// be unreachable
-	fatal error = errFatal{}
-)
-
-// Error is the interface satisfied
-// by all of the errors that originate
-// from this package.
-type Error interface {
-	error
-
-	// Resumable returns whether
-	// or not the error means that
-	// the stream of data is malformed
-	// and the information is unrecoverable.
-	Resumable() bool
-}
-
-// contextError allows msgp Error instances to be enhanced with additional
-// context about their origin.
-type contextError interface {
-	Error
-
-	// withContext must not modify the error instance - it must clone and
-	// return a new error with the context added.
-	withContext(ctx string) error
-}
-
-// Cause returns the underlying cause of an error that has been wrapped
-// with additional context.
-func Cause(e error) error {
-	out := e
-	if e, ok := e.(errWrapped); ok && e.cause != nil {
-		out = e.cause
-	}
-	return out
-}
-
-// Resumable returns whether or not the error means that the stream of data is
-// malformed and the information is unrecoverable.
-func Resumable(e error) bool {
-	if e, ok := e.(Error); ok {
-		return e.Resumable()
-	}
-	return resumableDefault
-}
-
-// WrapError wraps an error with additional context that allows the part of the
-// serialized type that caused the problem to be identified. Underlying errors
-// can be retrieved using Cause()
-//
-// The input error is not modified - a new error should be returned.
-//
-// ErrShortBytes is not wrapped with any context due to backward compatibility
-// issues with the public API.
-//
-func WrapError(err error, ctx ...interface{}) error {
-	switch e := err.(type) {
-	case errShort:
-		return e
-	case contextError:
-		return e.withContext(ctxString(ctx))
-	default:
-		return errWrapped{cause: err, ctx: ctxString(ctx)}
-	}
-}
-
-// ctxString converts the incoming interface{} slice into a single string.
-func ctxString(ctx []interface{}) string {
-	out := ""
-	for idx, cv := range ctx {
-		if idx > 0 {
-			out += "/"
-		}
-		out += fmt.Sprintf("%v", cv)
-	}
-	return out
-}
-
-func addCtx(ctx, add string) string {
-	if ctx != "" {
-		return add + "/" + ctx
-	} else {
-		return add
-	}
-}
-
-// errWrapped allows arbitrary errors passed to WrapError to be enhanced with
-// context and unwrapped with Cause()
-type errWrapped struct {
-	cause error
-	ctx   string
-}
-
-func (e errWrapped) Error() string {
-	if e.ctx != "" {
-		return fmt.Sprintf("%s at %s", e.cause, e.ctx)
-	} else {
-		return e.cause.Error()
-	}
-}
-
-func (e errWrapped) Resumable() bool {
-	if e, ok := e.cause.(Error); ok {
-		return e.Resumable()
-	}
-	return resumableDefault
-}
-
-// Unwrap returns the cause.
-func (e errWrapped) Unwrap() error { return e.cause }
-
-type errShort struct{}
-
-func (e errShort) Error() string   { return "msgp: too few bytes left to read object" }
-func (e errShort) Resumable() bool { return false }
-
-type errFatal struct {
-	ctx string
-}
-
-func (f errFatal) Error() string {
-	out := "msgp: fatal decoding error (unreachable code)"
-	if f.ctx != "" {
-		out += " at " + f.ctx
-	}
-	return out
-}
-
-func (f errFatal) Resumable() bool { return false }
-
-func (f errFatal) withContext(ctx string) error { f.ctx = addCtx(f.ctx, ctx); return f }
-
-// ArrayError is an error returned
-// when decoding a fix-sized array
-// of the wrong size
-type ArrayError struct {
-	Wanted uint32
-	Got    uint32
-	ctx    string
-}
-
-// Error implements the error interface
-func (a ArrayError) Error() string {
-	out := fmt.Sprintf("msgp: wanted array of size %d; got %d", a.Wanted, a.Got)
-	if a.ctx != "" {
-		out += " at " + a.ctx
-	}
-	return out
-}
-
-// Resumable is always 'true' for ArrayErrors
-func (a ArrayError) Resumable() bool { return true }
-
-func (a ArrayError) withContext(ctx string) error { a.ctx = addCtx(a.ctx, ctx); return a }
-
-// IntOverflow is returned when a call
-// would downcast an integer to a type
-// with too few bits to hold its value.
-type IntOverflow struct {
-	Value         int64 // the value of the integer
-	FailedBitsize int   // the bit size that the int64 could not fit into
-	ctx           string
-}
-
-// Error implements the error interface
-func (i IntOverflow) Error() string {
-	str := fmt.Sprintf("msgp: %d overflows int%d", i.Value, i.FailedBitsize)
-	if i.ctx != "" {
-		str += " at " + i.ctx
-	}
-	return str
-}
-
-// Resumable is always 'true' for overflows
-func (i IntOverflow) Resumable() bool { return true }
-
-func (i IntOverflow) withContext(ctx string) error { i.ctx = addCtx(i.ctx, ctx); return i }
-
-// UintOverflow is returned when a call
-// would downcast an unsigned integer to a type
-// with too few bits to hold its value
-type UintOverflow struct {
-	Value         uint64 // value of the uint
-	FailedBitsize int    // the bit size that couldn't fit the value
-	ctx           string
-}
-
-// Error implements the error interface
-func (u UintOverflow) Error() string {
-	str := fmt.Sprintf("msgp: %d overflows uint%d", u.Value, u.FailedBitsize)
-	if u.ctx != "" {
-		str += " at " + u.ctx
-	}
-	return str
-}
-
-// Resumable is always 'true' for overflows
-func (u UintOverflow) Resumable() bool { return true }
-
-func (u UintOverflow) withContext(ctx string) error { u.ctx = addCtx(u.ctx, ctx); return u }
-
-// UintBelowZero is returned when a call
-// would cast a signed integer below zero
-// to an unsigned integer.
-type UintBelowZero struct {
-	Value int64 // value of the incoming int
-	ctx   string
-}
-
-// Error implements the error interface
-func (u UintBelowZero) Error() string {
-	str := fmt.Sprintf("msgp: attempted to cast int %d to unsigned", u.Value)
-	if u.ctx != "" {
-		str += " at " + u.ctx
-	}
-	return str
-}
-
-// Resumable is always 'true' for overflows
-func (u UintBelowZero) Resumable() bool { return true }
-
-func (u UintBelowZero) withContext(ctx string) error {
-	u.ctx = ctx
-	return u
-}
-
-// A TypeError is returned when a particular
-// decoding method is unsuitable for decoding
-// a particular MessagePack value.
-type TypeError struct {
-	Method  Type // Type expected by method
-	Encoded Type // Type actually encoded
-
-	ctx string
-}
-
-// Error implements the error interface
-func (t TypeError) Error() string {
-	out := fmt.Sprintf("msgp: attempted to decode type %q with method for %q", t.Encoded, t.Method)
-	if t.ctx != "" {
-		out += " at " + t.ctx
-	}
-	return out
-}
-
-// Resumable returns 'true' for TypeErrors
-func (t TypeError) Resumable() bool { return true }
-
-func (t TypeError) withContext(ctx string) error { t.ctx = addCtx(t.ctx, ctx); return t }
-
-// returns either InvalidPrefixError or
-// TypeError depending on whether or not
-// the prefix is recognized
-func badPrefix(want Type, lead byte) error {
-	t := sizes[lead].typ
-	if t == InvalidType {
-		return InvalidPrefixError(lead)
-	}
-	return TypeError{Method: want, Encoded: t}
-}
-
-// InvalidPrefixError is returned when a bad encoding
-// uses a prefix that is not recognized in the MessagePack standard.
-// This kind of error is unrecoverable.
-type InvalidPrefixError byte
-
-// Error implements the error interface
-func (i InvalidPrefixError) Error() string {
-	return fmt.Sprintf("msgp: unrecognized type prefix 0x%x", byte(i))
-}
-
-// Resumable returns 'false' for InvalidPrefixErrors
-func (i InvalidPrefixError) Resumable() bool { return false }
-
-// ErrUnsupportedType is returned
-// when a bad argument is supplied
-// to a function that takes `interface{}`.
-type ErrUnsupportedType struct {
-	T reflect.Type
-
-	ctx string
-}
-
-// Error implements error
-func (e *ErrUnsupportedType) Error() string {
-	out := fmt.Sprintf("msgp: type %q not supported", e.T)
-	if e.ctx != "" {
-		out += " at " + e.ctx
-	}
-	return out
-}
-
-// Resumable returns 'true' for ErrUnsupportedType
-func (e *ErrUnsupportedType) Resumable() bool { return true }
-
-func (e *ErrUnsupportedType) withContext(ctx string) error {
-	o := *e
-	o.ctx = addCtx(o.ctx, ctx)
-	return &o
-}

vendor/github.com/tinylib/msgp/msgp/extension.go

@@ -1,549 +0,0 @@
-package msgp
-
-import (
-	"fmt"
-	"math"
-)
-
-const (
-	// Complex64Extension is the extension number used for complex64
-	Complex64Extension = 3
-
-	// Complex128Extension is the extension number used for complex128
-	Complex128Extension = 4
-
-	// TimeExtension is the extension number used for time.Time
-	TimeExtension = 5
-)
-
-// our extensions live here
-var extensionReg = make(map[int8]func() Extension)
-
-// RegisterExtension registers extensions so that they
-// can be initialized and returned by methods that
-// decode `interface{}` values. This should only
-// be called during initialization. f() should return
-// a newly-initialized zero value of the extension. Keep in
-// mind that extensions 3, 4, and 5 are reserved for
-// complex64, complex128, and time.Time, respectively,
-// and that MessagePack reserves extension types from -127 to -1.
-//
-// For example, if you wanted to register a user-defined struct:
-//
-//  msgp.RegisterExtension(10, func() msgp.Extension { &MyExtension{} })
-//
-// RegisterExtension will panic if you call it multiple times
-// with the same 'typ' argument, or if you use a reserved
-// type (3, 4, or 5).
-func RegisterExtension(typ int8, f func() Extension) {
-	switch typ {
-	case Complex64Extension, Complex128Extension, TimeExtension:
-		panic(fmt.Sprint("msgp: forbidden extension type:", typ))
-	}
-	if _, ok := extensionReg[typ]; ok {
-		panic(fmt.Sprint("msgp: RegisterExtension() called with typ", typ, "more than once"))
-	}
-	extensionReg[typ] = f
-}
-
-// ExtensionTypeError is an error type returned
-// when there is a mis-match between an extension type
-// and the type encoded on the wire
-type ExtensionTypeError struct {
-	Got  int8
-	Want int8
-}
-
-// Error implements the error interface
-func (e ExtensionTypeError) Error() string {
-	return fmt.Sprintf("msgp: error decoding extension: wanted type %d; got type %d", e.Want, e.Got)
-}
-
-// Resumable returns 'true' for ExtensionTypeErrors
-func (e ExtensionTypeError) Resumable() bool { return true }
-
-func errExt(got int8, wanted int8) error {
-	return ExtensionTypeError{Got: got, Want: wanted}
-}
-
-// Extension is the interface fulfilled
-// by types that want to define their
-// own binary encoding.
-type Extension interface {
-	// ExtensionType should return
-	// a int8 that identifies the concrete
-	// type of the extension. (Types <0 are
-	// officially reserved by the MessagePack
-	// specifications.)
-	ExtensionType() int8
-
-	// Len should return the length
-	// of the data to be encoded
-	Len() int
-
-	// MarshalBinaryTo should copy
-	// the data into the supplied slice,
-	// assuming that the slice has length Len()
-	MarshalBinaryTo([]byte) error
-
-	UnmarshalBinary([]byte) error
-}
-
-// RawExtension implements the Extension interface
-type RawExtension struct {
-	Data []byte
-	Type int8
-}
-
-// ExtensionType implements Extension.ExtensionType, and returns r.Type
-func (r *RawExtension) ExtensionType() int8 { return r.Type }
-
-// Len implements Extension.Len, and returns len(r.Data)
-func (r *RawExtension) Len() int { return len(r.Data) }
-
-// MarshalBinaryTo implements Extension.MarshalBinaryTo,
-// and returns a copy of r.Data
-func (r *RawExtension) MarshalBinaryTo(d []byte) error {
-	copy(d, r.Data)
-	return nil
-}
-
-// UnmarshalBinary implements Extension.UnmarshalBinary,
-// and sets r.Data to the contents of the provided slice
-func (r *RawExtension) UnmarshalBinary(b []byte) error {
-	if cap(r.Data) >= len(b) {
-		r.Data = r.Data[0:len(b)]
-	} else {
-		r.Data = make([]byte, len(b))
-	}
-	copy(r.Data, b)
-	return nil
-}
-
-// WriteExtension writes an extension type to the writer
-func (mw *Writer) WriteExtension(e Extension) error {
-	l := e.Len()
-	var err error
-	switch l {
-	case 0:
-		o, err := mw.require(3)
-		if err != nil {
-			return err
-		}
-		mw.buf[o] = mext8
-		mw.buf[o+1] = 0
-		mw.buf[o+2] = byte(e.ExtensionType())
-	case 1:
-		o, err := mw.require(2)
-		if err != nil {
-			return err
-		}
-		mw.buf[o] = mfixext1
-		mw.buf[o+1] = byte(e.ExtensionType())
-	case 2:
-		o, err := mw.require(2)
-		if err != nil {
-			return err
-		}
-		mw.buf[o] = mfixext2
-		mw.buf[o+1] = byte(e.ExtensionType())
-	case 4:
-		o, err := mw.require(2)
-		if err != nil {
-			return err
-		}
-		mw.buf[o] = mfixext4
-		mw.buf[o+1] = byte(e.ExtensionType())
-	case 8:
-		o, err := mw.require(2)
-		if err != nil {
-			return err
-		}
-		mw.buf[o] = mfixext8
-		mw.buf[o+1] = byte(e.ExtensionType())
-	case 16:
-		o, err := mw.require(2)
-		if err != nil {
-			return err
-		}
-		mw.buf[o] = mfixext16
-		mw.buf[o+1] = byte(e.ExtensionType())
-	default:
-		switch {
-		case l < math.MaxUint8:
-			o, err := mw.require(3)
-			if err != nil {
-				return err
-			}
-			mw.buf[o] = mext8
-			mw.buf[o+1] = byte(uint8(l))
-			mw.buf[o+2] = byte(e.ExtensionType())
-		case l < math.MaxUint16:
-			o, err := mw.require(4)
-			if err != nil {
-				return err
-			}
-			mw.buf[o] = mext16
-			big.PutUint16(mw.buf[o+1:], uint16(l))
-			mw.buf[o+3] = byte(e.ExtensionType())
-		default:
-			o, err := mw.require(6)
-			if err != nil {
-				return err
-			}
-			mw.buf[o] = mext32
-			big.PutUint32(mw.buf[o+1:], uint32(l))
-			mw.buf[o+5] = byte(e.ExtensionType())
-		}
-	}
-	// we can only write directly to the
-	// buffer if we're sure that it
-	// fits the object
-	if l <= mw.bufsize() {
-		o, err := mw.require(l)
-		if err != nil {
-			return err
-		}
-		return e.MarshalBinaryTo(mw.buf[o:])
-	}
-	// here we create a new buffer
-	// just large enough for the body
-	// and save it as the write buffer
-	err = mw.flush()
-	if err != nil {
-		return err
-	}
-	buf := make([]byte, l)
-	err = e.MarshalBinaryTo(buf)
-	if err != nil {
-		return err
-	}
-	mw.buf = buf
-	mw.wloc = l
-	return nil
-}
-
-// peek at the extension type, assuming the next
-// kind to be read is Extension
-func (m *Reader) peekExtensionType() (int8, error) {
-	p, err := m.R.Peek(2)
-	if err != nil {
-		return 0, err
-	}
-	spec := sizes[p[0]]
-	if spec.typ != ExtensionType {
-		return 0, badPrefix(ExtensionType, p[0])
-	}
-	if spec.extra == constsize {
-		return int8(p[1]), nil
-	}
-	size := spec.size
-	p, err = m.R.Peek(int(size))
-	if err != nil {
-		return 0, err
-	}
-	return int8(p[size-1]), nil
-}
-
-// peekExtension peeks at the extension encoding type
-// (must guarantee at least 1 byte in 'b')
-func peekExtension(b []byte) (int8, error) {
-	spec := sizes[b[0]]
-	size := spec.size
-	if spec.typ != ExtensionType {
-		return 0, badPrefix(ExtensionType, b[0])
-	}
-	if len(b) < int(size) {
-		return 0, ErrShortBytes
-	}
-	// for fixed extensions,
-	// the type information is in
-	// the second byte
-	if spec.extra == constsize {
-		return int8(b[1]), nil
-	}
-	// otherwise, it's in the last
-	// part of the prefix
-	return int8(b[size-1]), nil
-}
-
-// ReadExtension reads the next object from the reader
-// as an extension. ReadExtension will fail if the next
-// object in the stream is not an extension, or if
-// e.Type() is not the same as the wire type.
-func (m *Reader) ReadExtension(e Extension) (err error) {
-	var p []byte
-	p, err = m.R.Peek(2)
-	if err != nil {
-		return
-	}
-	lead := p[0]
-	var read int
-	var off int
-	switch lead {
-	case mfixext1:
-		if int8(p[1]) != e.ExtensionType() {
-			err = errExt(int8(p[1]), e.ExtensionType())
-			return
-		}
-		p, err = m.R.Peek(3)
-		if err != nil {
-			return
-		}
-		err = e.UnmarshalBinary(p[2:])
-		if err == nil {
-			_, err = m.R.Skip(3)
-		}
-		return
-
-	case mfixext2:
-		if int8(p[1]) != e.ExtensionType() {
-			err = errExt(int8(p[1]), e.ExtensionType())
-			return
-		}
-		p, err = m.R.Peek(4)
-		if err != nil {
-			return
-		}
-		err = e.UnmarshalBinary(p[2:])
-		if err == nil {
-			_, err = m.R.Skip(4)
-		}
-		return
-
-	case mfixext4:
-		if int8(p[1]) != e.ExtensionType() {
-			err = errExt(int8(p[1]), e.ExtensionType())
-			return
-		}
-		p, err = m.R.Peek(6)
-		if err != nil {
-			return
-		}
-		err = e.UnmarshalBinary(p[2:])
-		if err == nil {
-			_, err = m.R.Skip(6)
-		}
-		return
-
-	case mfixext8:
-		if int8(p[1]) != e.ExtensionType() {
-			err = errExt(int8(p[1]), e.ExtensionType())
-			return
-		}
-		p, err = m.R.Peek(10)
-		if err != nil {
-			return
-		}
-		err = e.UnmarshalBinary(p[2:])
-		if err == nil {
-			_, err = m.R.Skip(10)
-		}
-		return
-
-	case mfixext16:
-		if int8(p[1]) != e.ExtensionType() {
-			err = errExt(int8(p[1]), e.ExtensionType())
-			return
-		}
-		p, err = m.R.Peek(18)
-		if err != nil {
-			return
-		}
-		err = e.UnmarshalBinary(p[2:])
-		if err == nil {
-			_, err = m.R.Skip(18)
-		}
-		return
-
-	case mext8:
-		p, err = m.R.Peek(3)
-		if err != nil {
-			return
-		}
-		if int8(p[2]) != e.ExtensionType() {
-			err = errExt(int8(p[2]), e.ExtensionType())
-			return
-		}
-		read = int(uint8(p[1]))
-		off = 3
-
-	case mext16:
-		p, err = m.R.Peek(4)
-		if err != nil {
-			return
-		}
-		if int8(p[3]) != e.ExtensionType() {
-			err = errExt(int8(p[3]), e.ExtensionType())
-			return
-		}
-		read = int(big.Uint16(p[1:]))
-		off = 4
-
-	case mext32:
-		p, err = m.R.Peek(6)
-		if err != nil {
-			return
-		}
-		if int8(p[5]) != e.ExtensionType() {
-			err = errExt(int8(p[5]), e.ExtensionType())
-			return
-		}
-		read = int(big.Uint32(p[1:]))
-		off = 6
-
-	default:
-		err = badPrefix(ExtensionType, lead)
-		return
-	}
-
-	p, err = m.R.Peek(read + off)
-	if err != nil {
-		return
-	}
-	err = e.UnmarshalBinary(p[off:])
-	if err == nil {
-		_, err = m.R.Skip(read + off)
-	}
-	return
-}
-
-// AppendExtension appends a MessagePack extension to the provided slice
-func AppendExtension(b []byte, e Extension) ([]byte, error) {
-	l := e.Len()
-	var o []byte
-	var n int
-	switch l {
-	case 0:
-		o, n = ensure(b, 3)
-		o[n] = mext8
-		o[n+1] = 0
-		o[n+2] = byte(e.ExtensionType())
-		return o[:n+3], nil
-	case 1:
-		o, n = ensure(b, 3)
-		o[n] = mfixext1
-		o[n+1] = byte(e.ExtensionType())
-		n += 2
-	case 2:
-		o, n = ensure(b, 4)
-		o[n] = mfixext2
-		o[n+1] = byte(e.ExtensionType())
-		n += 2
-	case 4:
-		o, n = ensure(b, 6)
-		o[n] = mfixext4
-		o[n+1] = byte(e.ExtensionType())
-		n += 2
-	case 8:
-		o, n = ensure(b, 10)
-		o[n] = mfixext8
-		o[n+1] = byte(e.ExtensionType())
-		n += 2
-	case 16:
-		o, n = ensure(b, 18)
-		o[n] = mfixext16
-		o[n+1] = byte(e.ExtensionType())
-		n += 2
-	default:
-		switch {
-		case l < math.MaxUint8:
-			o, n = ensure(b, l+3)
-			o[n] = mext8
-			o[n+1] = byte(uint8(l))
-			o[n+2] = byte(e.ExtensionType())
-			n += 3
-		case l < math.MaxUint16:
-			o, n = ensure(b, l+4)
-			o[n] = mext16
-			big.PutUint16(o[n+1:], uint16(l))
-			o[n+3] = byte(e.ExtensionType())
-			n += 4
-		default:
-			o, n = ensure(b, l+6)
-			o[n] = mext32
-			big.PutUint32(o[n+1:], uint32(l))
-			o[n+5] = byte(e.ExtensionType())
-			n += 6
-		}
-	}
-	return o, e.MarshalBinaryTo(o[n:])
-}
-
-// ReadExtensionBytes reads an extension from 'b' into 'e'
-// and returns any remaining bytes.
-// Possible errors:
-// - ErrShortBytes ('b' not long enough)
-// - ExtensionTypeError{} (wire type not the same as e.Type())
-// - TypeError{} (next object not an extension)
-// - InvalidPrefixError
-// - An umarshal error returned from e.UnmarshalBinary
-func ReadExtensionBytes(b []byte, e Extension) ([]byte, error) {
-	l := len(b)
-	if l < 3 {
-		return b, ErrShortBytes
-	}
-	lead := b[0]
-	var (
-		sz  int // size of 'data'
-		off int // offset of 'data'
-		typ int8
-	)
-	switch lead {
-	case mfixext1:
-		typ = int8(b[1])
-		sz = 1
-		off = 2
-	case mfixext2:
-		typ = int8(b[1])
-		sz = 2
-		off = 2
-	case mfixext4:
-		typ = int8(b[1])
-		sz = 4
-		off = 2
-	case mfixext8:
-		typ = int8(b[1])
-		sz = 8
-		off = 2
-	case mfixext16:
-		typ = int8(b[1])
-		sz = 16
-		off = 2
-	case mext8:
-		sz = int(uint8(b[1]))
-		typ = int8(b[2])
-		off = 3
-		if sz == 0 {
-			return b[3:], e.UnmarshalBinary(b[3:3])
-		}
-	case mext16:
-		if l < 4 {
-			return b, ErrShortBytes
-		}
-		sz = int(big.Uint16(b[1:]))
-		typ = int8(b[3])
-		off = 4
-	case mext32:
-		if l < 6 {
-			return b, ErrShortBytes
-		}
-		sz = int(big.Uint32(b[1:]))
-		typ = int8(b[5])
-		off = 6
-	default:
-		return b, badPrefix(ExtensionType, lead)
-	}
-
-	if typ != e.ExtensionType() {
-		return b, errExt(typ, e.ExtensionType())
-	}
-
-	// the data of the extension starts
-	// at 'off' and is 'sz' bytes long
-	if len(b[off:]) < sz {
-		return b, ErrShortBytes
-	}
-	tot := off + sz
-	return b[tot:], e.UnmarshalBinary(b[off:tot])
-}

vendor/github.com/tinylib/msgp/msgp/file.go

@@ -1,92 +0,0 @@
-// +build linux darwin dragonfly freebsd netbsd openbsd
-// +build !appengine
-
-package msgp
-
-import (
-	"os"
-	"syscall"
-)
-
-// ReadFile reads a file into 'dst' using
-// a read-only memory mapping. Consequently,
-// the file must be mmap-able, and the
-// Unmarshaler should never write to
-// the source memory. (Methods generated
-// by the msgp tool obey that constraint, but
-// user-defined implementations may not.)
-//
-// Reading and writing through file mappings
-// is only efficient for large files; small
-// files are best read and written using
-// the ordinary streaming interfaces.
-//
-func ReadFile(dst Unmarshaler, file *os.File) error {
-	stat, err := file.Stat()
-	if err != nil {
-		return err
-	}
-	data, err := syscall.Mmap(int(file.Fd()), 0, int(stat.Size()), syscall.PROT_READ, syscall.MAP_SHARED)
-	if err != nil {
-		return err
-	}
-	adviseRead(data)
-	_, err = dst.UnmarshalMsg(data)
-	uerr := syscall.Munmap(data)
-	if err == nil {
-		err = uerr
-	}
-	return err
-}
-
-// MarshalSizer is the combination
-// of the Marshaler and Sizer
-// interfaces.
-type MarshalSizer interface {
-	Marshaler
-	Sizer
-}
-
-// WriteFile writes a file from 'src' using
-// memory mapping. It overwrites the entire
-// contents of the previous file.
-// The mapping size is calculated
-// using the `Msgsize()` method
-// of 'src', so it must produce a result
-// equal to or greater than the actual encoded
-// size of the object. Otherwise,
-// a fault (SIGBUS) will occur.
-//
-// Reading and writing through file mappings
-// is only efficient for large files; small
-// files are best read and written using
-// the ordinary streaming interfaces.
-//
-// NOTE: The performance of this call
-// is highly OS- and filesystem-dependent.
-// Users should take care to test that this
-// performs as expected in a production environment.
-// (Linux users should run a kernel and filesystem
-// that support fallocate(2) for the best results.)
-func WriteFile(src MarshalSizer, file *os.File) error {
-	sz := src.Msgsize()
-	err := fallocate(file, int64(sz))
-	if err != nil {
-		return err
-	}
-	data, err := syscall.Mmap(int(file.Fd()), 0, sz, syscall.PROT_READ|syscall.PROT_WRITE, syscall.MAP_SHARED)
-	if err != nil {
-		return err
-	}
-	adviseWrite(data)
-	chunk := data[:0]
-	chunk, err = src.MarshalMsg(chunk)
-	if err != nil {
-		return err
-	}
-	uerr := syscall.Munmap(data)
-	if uerr != nil {
-		return uerr
-	}
-	return file.Truncate(int64(len(chunk)))
-}

vendor/github.com/tinylib/msgp/msgp/file_port.go

@@ -1,47 +0,0 @@
-// +build windows appengine
-
-package msgp
-
-import (
-	"io/ioutil"
-	"os"
-)
-
-// MarshalSizer is the combination
-// of the Marshaler and Sizer
-// interfaces.
-type MarshalSizer interface {
-	Marshaler
-	Sizer
-}
-
-func ReadFile(dst Unmarshaler, file *os.File) error {
-	if u, ok := dst.(Decodable); ok {
-		return u.DecodeMsg(NewReader(file))
-	}
-
-	data, err := ioutil.ReadAll(file)
-	if err != nil {
-		return err
-	}
-	_, err = dst.UnmarshalMsg(data)
-	return err
-}
-
-func WriteFile(src MarshalSizer, file *os.File) error {
-	if e, ok := src.(Encodable); ok {
-		w := NewWriter(file)
-		err := e.EncodeMsg(w)
-		if err == nil {
-			err = w.Flush()
-		}
-		return err
-	}
-
-	raw, err := src.MarshalMsg(nil)
-	if err != nil {
-		return err
-	}
-	_, err = file.Write(raw)
-	return err
-}

vendor/github.com/tinylib/msgp/msgp/integers.go

@@ -1,174 +0,0 @@
-package msgp
-
-/* ----------------------------------
-	integer encoding utilities
-	(inline-able)
-
-	TODO(tinylib): there are faster,
-	albeit non-portable solutions
-	to the code below. implement
-	byteswap?
-   ---------------------------------- */
-
-func putMint64(b []byte, i int64) {
-	b[0] = mint64
-	b[1] = byte(i >> 56)
-	b[2] = byte(i >> 48)
-	b[3] = byte(i >> 40)
-	b[4] = byte(i >> 32)
-	b[5] = byte(i >> 24)
-	b[6] = byte(i >> 16)
-	b[7] = byte(i >> 8)
-	b[8] = byte(i)
-}
-
-func getMint64(b []byte) int64 {
-	return (int64(b[1]) << 56) | (int64(b[2]) << 48) |
-		(int64(b[3]) << 40) | (int64(b[4]) << 32) |
-		(int64(b[5]) << 24) | (int64(b[6]) << 16) |
-		(int64(b[7]) << 8) | (int64(b[8]))
-}
-
-func putMint32(b []byte, i int32) {
-	b[0] = mint32
-	b[1] = byte(i >> 24)
-	b[2] = byte(i >> 16)
-	b[3] = byte(i >> 8)
-	b[4] = byte(i)
-}
-
-func getMint32(b []byte) int32 {
-	return (int32(b[1]) << 24) | (int32(b[2]) << 16) | (int32(b[3]) << 8) | (int32(b[4]))
-}
-
-func putMint16(b []byte, i int16) {
-	b[0] = mint16
-	b[1] = byte(i >> 8)
-	b[2] = byte(i)
-}
-
-func getMint16(b []byte) (i int16) {
-	return (int16(b[1]) << 8) | int16(b[2])
-}
-
-func putMint8(b []byte, i int8) {
-	b[0] = mint8
-	b[1] = byte(i)
-}
-
-func getMint8(b []byte) (i int8) {
-	return int8(b[1])
-}
-
-func putMuint64(b []byte, u uint64) {
-	b[0] = muint64
-	b[1] = byte(u >> 56)
-	b[2] = byte(u >> 48)
-	b[3] = byte(u >> 40)
-	b[4] = byte(u >> 32)
-	b[5] = byte(u >> 24)
-	b[6] = byte(u >> 16)
-	b[7] = byte(u >> 8)
-	b[8] = byte(u)
-}
-
-func getMuint64(b []byte) uint64 {
-	return (uint64(b[1]) << 56) | (uint64(b[2]) << 48) |
-		(uint64(b[3]) << 40) | (uint64(b[4]) << 32) |
-		(uint64(b[5]) << 24) | (uint64(b[6]) << 16) |
-		(uint64(b[7]) << 8) | (uint64(b[8]))
-}
-
-func putMuint32(b []byte, u uint32) {
-	b[0] = muint32
-	b[1] = byte(u >> 24)
-	b[2] = byte(u >> 16)
-	b[3] = byte(u >> 8)
-	b[4] = byte(u)
-}
-
-func getMuint32(b []byte) uint32 {
-	return (uint32(b[1]) << 24) | (uint32(b[2]) << 16) | (uint32(b[3]) << 8) | (uint32(b[4]))
-}
-
-func putMuint16(b []byte, u uint16) {
-	b[0] = muint16
-	b[1] = byte(u >> 8)
-	b[2] = byte(u)
-}
-
-func getMuint16(b []byte) uint16 {
-	return (uint16(b[1]) << 8) | uint16(b[2])
-}
-
-func putMuint8(b []byte, u uint8) {
-	b[0] = muint8
-	b[1] = byte(u)
-}
-
-func getMuint8(b []byte) uint8 {
-	return uint8(b[1])
-}
-
-func getUnix(b []byte) (sec int64, nsec int32) {
-	sec = (int64(b[0]) << 56) | (int64(b[1]) << 48) |
-		(int64(b[2]) << 40) | (int64(b[3]) << 32) |
-		(int64(b[4]) << 24) | (int64(b[5]) << 16) |
-		(int64(b[6]) << 8) | (int64(b[7]))
-
-	nsec = (int32(b[8]) << 24) | (int32(b[9]) << 16) | (int32(b[10]) << 8) | (int32(b[11]))
-	return
-}
-
-func putUnix(b []byte, sec int64, nsec int32) {
-	b[0] = byte(sec >> 56)
-	b[1] = byte(sec >> 48)
-	b[2] = byte(sec >> 40)
-	b[3] = byte(sec >> 32)
-	b[4] = byte(sec >> 24)
-	b[5] = byte(sec >> 16)
-	b[6] = byte(sec >> 8)
-	b[7] = byte(sec)
-	b[8] = byte(nsec >> 24)
-	b[9] = byte(nsec >> 16)
-	b[10] = byte(nsec >> 8)
-	b[11] = byte(nsec)
-}
-
-/* -----------------------------
-		prefix utilities
-   ----------------------------- */
-
-// write prefix and uint8
-func prefixu8(b []byte, pre byte, sz uint8) {
-	b[0] = pre
-	b[1] = byte(sz)
-}
-
-// write prefix and big-endian uint16
-func prefixu16(b []byte, pre byte, sz uint16) {
-	b[0] = pre
-	b[1] = byte(sz >> 8)
-	b[2] = byte(sz)
-}
-
-// write prefix and big-endian uint32
-func prefixu32(b []byte, pre byte, sz uint32) {
-	b[0] = pre
-	b[1] = byte(sz >> 24)
-	b[2] = byte(sz >> 16)
-	b[3] = byte(sz >> 8)
-	b[4] = byte(sz)
-}
-
-func prefixu64(b []byte, pre byte, sz uint64) {
-	b[0] = pre
-	b[1] = byte(sz >> 56)
-	b[2] = byte(sz >> 48)
-	b[3] = byte(sz >> 40)
-	b[4] = byte(sz >> 32)
-	b[5] = byte(sz >> 24)
-	b[6] = byte(sz >> 16)
-	b[7] = byte(sz >> 8)
-	b[8] = byte(sz)
-}

vendor/github.com/tinylib/msgp/msgp/json.go

@@ -1,568 +0,0 @@
-package msgp
-
-import (
-	"bufio"
-	"encoding/base64"
-	"encoding/json"
-	"io"
-	"strconv"
-	"unicode/utf8"
-)
-
-var (
-	null = []byte("null")
-	hex  = []byte("0123456789abcdef")
-)
-
-var defuns [_maxtype]func(jsWriter, *Reader) (int, error)
-
-// note: there is an initialization loop if
-// this isn't set up during init()
-func init() {
-	// since none of these functions are inline-able,
-	// there is not much of a penalty to the indirect
-	// call. however, this is best expressed as a jump-table...
-	defuns = [_maxtype]func(jsWriter, *Reader) (int, error){
-		StrType:        rwString,
-		BinType:        rwBytes,
-		MapType:        rwMap,
-		ArrayType:      rwArray,
-		Float64Type:    rwFloat64,
-		Float32Type:    rwFloat32,
-		BoolType:       rwBool,
-		IntType:        rwInt,
-		UintType:       rwUint,
-		NilType:        rwNil,
-		ExtensionType:  rwExtension,
-		Complex64Type:  rwExtension,
-		Complex128Type: rwExtension,
-		TimeType:       rwTime,
-	}
-}
-
-// this is the interface
-// used to write json
-type jsWriter interface {
-	io.Writer
-	io.ByteWriter
-	WriteString(string) (int, error)
-}
-
-// CopyToJSON reads MessagePack from 'src' and copies it
-// as JSON to 'dst' until EOF.
-func CopyToJSON(dst io.Writer, src io.Reader) (n int64, err error) {
-	r := NewReader(src)
-	n, err = r.WriteToJSON(dst)
-	freeR(r)
-	return
-}
-
-// WriteToJSON translates MessagePack from 'r' and writes it as
-// JSON to 'w' until the underlying reader returns io.EOF. It returns
-// the number of bytes written, and an error if it stopped before EOF.
-func (r *Reader) WriteToJSON(w io.Writer) (n int64, err error) {
-	var j jsWriter
-	var bf *bufio.Writer
-	if jsw, ok := w.(jsWriter); ok {
-		j = jsw
-	} else {
-		bf = bufio.NewWriter(w)
-		j = bf
-	}
-	var nn int
-	for err == nil {
-		nn, err = rwNext(j, r)
-		n += int64(nn)
-	}
-	if err != io.EOF {
-		if bf != nil {
-			bf.Flush()
-		}
-		return
-	}
-	err = nil
-	if bf != nil {
-		err = bf.Flush()
-	}
-	return
-}
-
-func rwNext(w jsWriter, src *Reader) (int, error) {
-	t, err := src.NextType()
-	if err != nil {
-		return 0, err
-	}
-	return defuns[t](w, src)
-}
-
-func rwMap(dst jsWriter, src *Reader) (n int, err error) {
-	var comma bool
-	var sz uint32
-	var field []byte
-
-	sz, err = src.ReadMapHeader()
-	if err != nil {
-		return
-	}
-
-	if sz == 0 {
-		return dst.WriteString("{}")
-	}
-
-	err = dst.WriteByte('{')
-	if err != nil {
-		return
-	}
-	n++
-	var nn int
-	for i := uint32(0); i < sz; i++ {
-		if comma {
-			err = dst.WriteByte(',')
-			if err != nil {
-				return
-			}
-			n++
-		}
-
-		field, err = src.ReadMapKeyPtr()
-		if err != nil {
-			return
-		}
-		nn, err = rwquoted(dst, field)
-		n += nn
-		if err != nil {
-			return
-		}
-
-		err = dst.WriteByte(':')
-		if err != nil {
-			return
-		}
-		n++
-		nn, err = rwNext(dst, src)
-		n += nn
-		if err != nil {
-			return
-		}
-		if !comma {
-			comma = true
-		}
-	}
-
-	err = dst.WriteByte('}')
-	if err != nil {
-		return
-	}
-	n++
-	return
-}
-
-func rwArray(dst jsWriter, src *Reader) (n int, err error) {
-	err = dst.WriteByte('[')
-	if err != nil {
-		return
-	}
-	var sz uint32
-	var nn int
-	sz, err = src.ReadArrayHeader()
-	if err != nil {
-		return
-	}
-	comma := false
-	for i := uint32(0); i < sz; i++ {
-		if comma {
-			err = dst.WriteByte(',')
-			if err != nil {
-				return
-			}
-			n++
-		}
-		nn, err = rwNext(dst, src)
-		n += nn
-		if err != nil {
-			return
-		}
-		comma = true
-	}
-
-	err = dst.WriteByte(']')
-	if err != nil {
-		return
-	}
-	n++
-	return
-}
-
-func rwNil(dst jsWriter, src *Reader) (int, error) {
-	err := src.ReadNil()
-	if err != nil {
-		return 0, err
-	}
-	return dst.Write(null)
-}
-
-func rwFloat32(dst jsWriter, src *Reader) (int, error) {
-	f, err := src.ReadFloat32()
-	if err != nil {
-		return 0, err
-	}
-	src.scratch = strconv.AppendFloat(src.scratch[:0], float64(f), 'f', -1, 32)
-	return dst.Write(src.scratch)
-}
-
-func rwFloat64(dst jsWriter, src *Reader) (int, error) {
-	f, err := src.ReadFloat64()
-	if err != nil {
-		return 0, err
-	}
-	src.scratch = strconv.AppendFloat(src.scratch[:0], f, 'f', -1, 64)
-	return dst.Write(src.scratch)
-}
-
-func rwInt(dst jsWriter, src *Reader) (int, error) {
-	i, err := src.ReadInt64()
-	if err != nil {
-		return 0, err
-	}
-	src.scratch = strconv.AppendInt(src.scratch[:0], i, 10)
-	return dst.Write(src.scratch)
-}
-
-func rwUint(dst jsWriter, src *Reader) (int, error) {
-	u, err := src.ReadUint64()
-	if err != nil {
-		return 0, err
-	}
-	src.scratch = strconv.AppendUint(src.scratch[:0], u, 10)
-	return dst.Write(src.scratch)
-}
-
-func rwBool(dst jsWriter, src *Reader) (int, error) {
-	b, err := src.ReadBool()
-	if err != nil {
-		return 0, err
-	}
-	if b {
-		return dst.WriteString("true")
-	}
-	return dst.WriteString("false")
-}
-
-func rwTime(dst jsWriter, src *Reader) (int, error) {
-	t, err := src.ReadTime()
-	if err != nil {
-		return 0, err
-	}
-	bts, err := t.MarshalJSON()
-	if err != nil {
-		return 0, err
-	}
-	return dst.Write(bts)
-}
-
-func rwExtension(dst jsWriter, src *Reader) (n int, err error) {
-	et, err := src.peekExtensionType()
-	if err != nil {
-		return 0, err
-	}
-
-	// registered extensions can override
-	// the JSON encoding
-	if j, ok := extensionReg[et]; ok {
-		var bts []byte
-		e := j()
-		err = src.ReadExtension(e)
-		if err != nil {
-			return
-		}
-		bts, err = json.Marshal(e)
-		if err != nil {
-			return
-		}
-		return dst.Write(bts)
-	}
-
-	e := RawExtension{}
-	e.Type = et
-	err = src.ReadExtension(&e)
-	if err != nil {
-		return
-	}
-
-	var nn int
-	err = dst.WriteByte('{')
-	if err != nil {
-		return
-	}
-	n++
-
-	nn, err = dst.WriteString(`"type:"`)
-	n += nn
-	if err != nil {
-		return
-	}
-
-	src.scratch = strconv.AppendInt(src.scratch[0:0], int64(e.Type), 10)
-	nn, err = dst.Write(src.scratch)
-	n += nn
-	if err != nil {
-		return
-	}
-
-	nn, err = dst.WriteString(`,"data":"`)
-	n += nn
-	if err != nil {
-		return
-	}
-
-	enc := base64.NewEncoder(base64.StdEncoding, dst)
-
-	nn, err = enc.Write(e.Data)
-	n += nn
-	if err != nil {
-		return
-	}
-	err = enc.Close()
-	if err != nil {
-		return
-	}
-	nn, err = dst.WriteString(`"}`)
-	n += nn
-	return
-}
-
-func rwString(dst jsWriter, src *Reader) (n int, err error) {
-	var p []byte
-	p, err = src.R.Peek(1)
-	if err != nil {
-		return
-	}
-	lead := p[0]
-	var read int
-
-	if isfixstr(lead) {
-		read = int(rfixstr(lead))
-		src.R.Skip(1)
-		goto write
-	}
-
-	switch lead {
-	case mstr8:
-		p, err = src.R.Next(2)
-		if err != nil {
-			return
-		}
-		read = int(uint8(p[1]))
-	case mstr16:
-		p, err = src.R.Next(3)
-		if err != nil {
-			return
-		}
-		read = int(big.Uint16(p[1:]))
-	case mstr32:
-		p, err = src.R.Next(5)
-		if err != nil {
-			return
-		}
-		read = int(big.Uint32(p[1:]))
-	default:
-		err = badPrefix(StrType, lead)
-		return
-	}
-write:
-	p, err = src.R.Next(read)
-	if err != nil {
-		return
-	}
-	n, err = rwquoted(dst, p)
-	return
-}
-
-func rwBytes(dst jsWriter, src *Reader) (n int, err error) {
-	var nn int
-	err = dst.WriteByte('"')
-	if err != nil {
-		return
-	}
-	n++
-	src.scratch, err = src.ReadBytes(src.scratch[:0])
-	if err != nil {
-		return
-	}
-	enc := base64.NewEncoder(base64.StdEncoding, dst)
-	nn, err = enc.Write(src.scratch)
-	n += nn
-	if err != nil {
-		return
-	}
-	err = enc.Close()
-	if err != nil {
-		return
-	}
-	err = dst.WriteByte('"')
-	if err != nil {
-		return
-	}
-	n++
-	return
-}
-
-// Below (c) The Go Authors, 2009-2014
-// Subject to the BSD-style license found at http://golang.org
-//
-// see: encoding/json/encode.go:(*encodeState).stringbytes()
-func rwquoted(dst jsWriter, s []byte) (n int, err error) {
-	var nn int
-	err = dst.WriteByte('"')
-	if err != nil {
-		return
-	}
-	n++
-	start := 0
-	for i := 0; i < len(s); {
-		if b := s[i]; b < utf8.RuneSelf {
-			if 0x20 <= b && b != '\\' && b != '"' && b != '<' && b != '>' && b != '&' {
-				i++
-				continue
-			}
-			if start < i {
-				nn, err = dst.Write(s[start:i])
-				n += nn
-				if err != nil {
-					return
-				}
-			}
-			switch b {
-			case '\\', '"':
-				err = dst.WriteByte('\\')
-				if err != nil {
-					return
-				}
-				n++
-				err = dst.WriteByte(b)
-				if err != nil {
-					return
-				}
-				n++
-			case '\n':
-				err = dst.WriteByte('\\')
-				if err != nil {
-					return
-				}
-				n++
-				err = dst.WriteByte('n')
-				if err != nil {
-					return
-				}
-				n++
-			case '\r':
-				err = dst.WriteByte('\\')
-				if err != nil {
-					return
-				}
-				n++
-				err = dst.WriteByte('r')
-				if err != nil {
-					return
-				}
-				n++
-			case '\t':
-				err = dst.WriteByte('\\')
-				if err != nil {
-					return
-				}
-				n++
-				err = dst.WriteByte('t')
-				if err != nil {
-					return
-				}
-				n++
-			default:
-				// This encodes bytes < 0x20 except for \t, \n and \r.
-				// It also escapes <, >, and &
-				// because they can lead to security holes when
-				// user-controlled strings are rendered into JSON
-				// and served to some browsers.
-				nn, err = dst.WriteString(`\u00`)
-				n += nn
-				if err != nil {
-					return
-				}
-				err = dst.WriteByte(hex[b>>4])
-				if err != nil {
-					return
-				}
-				n++
-				err = dst.WriteByte(hex[b&0xF])
-				if err != nil {
-					return
-				}
-				n++
-			}
-			i++
-			start = i
-			continue
-		}
-		c, size := utf8.DecodeRune(s[i:])
-		if c == utf8.RuneError && size == 1 {
-			if start < i {
-				nn, err = dst.Write(s[start:i])
-				n += nn
-				if err != nil {
-					return
-				}
-			}
-			nn, err = dst.WriteString(`\ufffd`)
-			n += nn
-			if err != nil {
-				return
-			}
-			i += size
-			start = i
-			continue
-		}
-		// U+2028 is LINE SEPARATOR.
-		// U+2029 is PARAGRAPH SEPARATOR.
-		// They are both technically valid characters in JSON strings,
-		// but don't work in JSONP, which has to be evaluated as JavaScript,
-		// and can lead to security holes there. It is valid JSON to
-		// escape them, so we do so unconditionally.
-		// See http://timelessrepo.com/json-isnt-a-javascript-subset for discussion.
-		if c == '\u2028' || c == '\u2029' {
-			if start < i {
-				nn, err = dst.Write(s[start:i])
-				n += nn
-				if err != nil {
-					return
-				}
-			}
-			nn, err = dst.WriteString(`\u202`)
-			n += nn
-			if err != nil {
-				return
-			}
-			err = dst.WriteByte(hex[c&0xF])
-			if err != nil {
-				return
-			}
-			n++
-			i += size
-			start = i
-			continue
-		}
-		i += size
-	}
-	if start < len(s) {
-		nn, err = dst.Write(s[start:])
-		n += nn
-		if err != nil {
-			return
-		}
-	}
-	err = dst.WriteByte('"')
-	if err != nil {
-		return
-	}
-	n++
-	return
-}

vendor/github.com/tinylib/msgp/msgp/json_bytes.go

@@ -1,363 +0,0 @@
-package msgp
-
-import (
-	"bufio"
-	"encoding/base64"
-	"encoding/json"
-	"io"
-	"strconv"
-	"time"
-)
-
-var unfuns [_maxtype]func(jsWriter, []byte, []byte) ([]byte, []byte, error)
-
-func init() {
-
-	// NOTE(pmh): this is best expressed as a jump table,
-	// but gc doesn't do that yet. revisit post-go1.5.
-	unfuns = [_maxtype]func(jsWriter, []byte, []byte) ([]byte, []byte, error){
-		StrType:        rwStringBytes,
-		BinType:        rwBytesBytes,
-		MapType:        rwMapBytes,
-		ArrayType:      rwArrayBytes,
-		Float64Type:    rwFloat64Bytes,
-		Float32Type:    rwFloat32Bytes,
-		BoolType:       rwBoolBytes,
-		IntType:        rwIntBytes,
-		UintType:       rwUintBytes,
-		NilType:        rwNullBytes,
-		ExtensionType:  rwExtensionBytes,
-		Complex64Type:  rwExtensionBytes,
-		Complex128Type: rwExtensionBytes,
-		TimeType:       rwTimeBytes,
-	}
-}
-
-// UnmarshalAsJSON takes raw messagepack and writes
-// it as JSON to 'w'. If an error is returned, the
-// bytes not translated will also be returned. If
-// no errors are encountered, the length of the returned
-// slice will be zero.
-func UnmarshalAsJSON(w io.Writer, msg []byte) ([]byte, error) {
-	var (
-		scratch []byte
-		cast    bool
-		dst     jsWriter
-		err     error
-	)
-	if jsw, ok := w.(jsWriter); ok {
-		dst = jsw
-		cast = true
-	} else {
-		dst = bufio.NewWriterSize(w, 512)
-	}
-	for len(msg) > 0 && err == nil {
-		msg, scratch, err = writeNext(dst, msg, scratch)
-	}
-	if !cast && err == nil {
-		err = dst.(*bufio.Writer).Flush()
-	}
-	return msg, err
-}
-
-func writeNext(w jsWriter, msg []byte, scratch []byte) ([]byte, []byte, error) {
-	if len(msg) < 1 {
-		return msg, scratch, ErrShortBytes
-	}
-	t := getType(msg[0])
-	if t == InvalidType {
-		return msg, scratch, InvalidPrefixError(msg[0])
-	}
-	if t == ExtensionType {
-		et, err := peekExtension(msg)
-		if err != nil {
-			return nil, scratch, err
-		}
-		if et == TimeExtension {
-			t = TimeType
-		}
-	}
-	return unfuns[t](w, msg, scratch)
-}
-
-func rwArrayBytes(w jsWriter, msg []byte, scratch []byte) ([]byte, []byte, error) {
-	sz, msg, err := ReadArrayHeaderBytes(msg)
-	if err != nil {
-		return msg, scratch, err
-	}
-	err = w.WriteByte('[')
-	if err != nil {
-		return msg, scratch, err
-	}
-	for i := uint32(0); i < sz; i++ {
-		if i != 0 {
-			err = w.WriteByte(',')
-			if err != nil {
-				return msg, scratch, err
-			}
-		}
-		msg, scratch, err = writeNext(w, msg, scratch)
-		if err != nil {
-			return msg, scratch, err
-		}
-	}
-	err = w.WriteByte(']')
-	return msg, scratch, err
-}
-
-func rwMapBytes(w jsWriter, msg []byte, scratch []byte) ([]byte, []byte, error) {
-	sz, msg, err := ReadMapHeaderBytes(msg)
-	if err != nil {
-		return msg, scratch, err
-	}
-	err = w.WriteByte('{')
-	if err != nil {
-		return msg, scratch, err
-	}
-	for i := uint32(0); i < sz; i++ {
-		if i != 0 {
-			err = w.WriteByte(',')
-			if err != nil {
-				return msg, scratch, err
-			}
-		}
-		msg, scratch, err = rwMapKeyBytes(w, msg, scratch)
-		if err != nil {
-			return msg, scratch, err
-		}
-		err = w.WriteByte(':')
-		if err != nil {
-			return msg, scratch, err
-		}
-		msg, scratch, err = writeNext(w, msg, scratch)
-		if err != nil {
-			return msg, scratch, err
-		}
-	}
-	err = w.WriteByte('}')
-	return msg, scratch, err
-}
-
-func rwMapKeyBytes(w jsWriter, msg []byte, scratch []byte) ([]byte, []byte, error) {
-	msg, scratch, err := rwStringBytes(w, msg, scratch)
-	if err != nil {
-		if tperr, ok := err.(TypeError); ok && tperr.Encoded == BinType {
-			return rwBytesBytes(w, msg, scratch)
-		}
-	}
-	return msg, scratch, err
-}
-
-func rwStringBytes(w jsWriter, msg []byte, scratch []byte) ([]byte, []byte, error) {
-	str, msg, err := ReadStringZC(msg)
-	if err != nil {
-		return msg, scratch, err
-	}
-	_, err = rwquoted(w, str)
-	return msg, scratch, err
-}
-
-func rwBytesBytes(w jsWriter, msg []byte, scratch []byte) ([]byte, []byte, error) {
-	bts, msg, err := ReadBytesZC(msg)
-	if err != nil {
-		return msg, scratch, err
-	}
-	l := base64.StdEncoding.EncodedLen(len(bts))
-	if cap(scratch) >= l {
-		scratch = scratch[0:l]
-	} else {
-		scratch = make([]byte, l)
-	}
-	base64.StdEncoding.Encode(scratch, bts)
-	err = w.WriteByte('"')
-	if err != nil {
-		return msg, scratch, err
-	}
-	_, err = w.Write(scratch)
-	if err != nil {
-		return msg, scratch, err
-	}
-	err = w.WriteByte('"')
-	return msg, scratch, err
-}
-
-func rwNullBytes(w jsWriter, msg []byte, scratch []byte) ([]byte, []byte, error) {
-	msg, err := ReadNilBytes(msg)
-	if err != nil {
-		return msg, scratch, err
-	}
-	_, err = w.Write(null)
-	return msg, scratch, err
-}
-
-func rwBoolBytes(w jsWriter, msg []byte, scratch []byte) ([]byte, []byte, error) {
-	b, msg, err := ReadBoolBytes(msg)
-	if err != nil {
-		return msg, scratch, err
-	}
-	if b {
-		_, err = w.WriteString("true")
-		return msg, scratch, err
-	}
-	_, err = w.WriteString("false")
-	return msg, scratch, err
-}
-
-func rwIntBytes(w jsWriter, msg []byte, scratch []byte) ([]byte, []byte, error) {
-	i, msg, err := ReadInt64Bytes(msg)
-	if err != nil {
-		return msg, scratch, err
-	}
-	scratch = strconv.AppendInt(scratch[0:0], i, 10)
-	_, err = w.Write(scratch)
-	return msg, scratch, err
-}
-
-func rwUintBytes(w jsWriter, msg []byte, scratch []byte) ([]byte, []byte, error) {
-	u, msg, err := ReadUint64Bytes(msg)
-	if err != nil {
-		return msg, scratch, err
-	}
-	scratch = strconv.AppendUint(scratch[0:0], u, 10)
-	_, err = w.Write(scratch)
-	return msg, scratch, err
-}
-
-func rwFloatBytes(w jsWriter, msg []byte, f64 bool, scratch []byte) ([]byte, []byte, error) {
-	var f float64
-	var err error
-	var sz int
-	if f64 {
-		sz = 64
-		f, msg, err = ReadFloat64Bytes(msg)
-	} else {
-		sz = 32
-		var v float32
-		v, msg, err = ReadFloat32Bytes(msg)
-		f = float64(v)
-	}
-	if err != nil {
-		return msg, scratch, err
-	}
-	scratch = strconv.AppendFloat(scratch, f, 'f', -1, sz)
-	_, err = w.Write(scratch)
-	return msg, scratch, err
-}
-
-func rwFloat32Bytes(w jsWriter, msg []byte, scratch []byte) ([]byte, []byte, error) {
-	var f float32
-	var err error
-	f, msg, err = ReadFloat32Bytes(msg)
-	if err != nil {
-		return msg, scratch, err
-	}
-	scratch = strconv.AppendFloat(scratch[:0], float64(f), 'f', -1, 32)
-	_, err = w.Write(scratch)
-	return msg, scratch, err
-}
-
-func rwFloat64Bytes(w jsWriter, msg []byte, scratch []byte) ([]byte, []byte, error) {
-	var f float64
-	var err error
-	f, msg, err = ReadFloat64Bytes(msg)
-	if err != nil {
-		return msg, scratch, err
-	}
-	scratch = strconv.AppendFloat(scratch[:0], f, 'f', -1, 64)
-	_, err = w.Write(scratch)
-	return msg, scratch, err
-}
-
-func rwTimeBytes(w jsWriter, msg []byte, scratch []byte) ([]byte, []byte, error) {
-	var t time.Time
-	var err error
-	t, msg, err = ReadTimeBytes(msg)
-	if err != nil {
-		return msg, scratch, err
-	}
-	bts, err := t.MarshalJSON()
-	if err != nil {
-		return msg, scratch, err
-	}
-	_, err = w.Write(bts)
-	return msg, scratch, err
-}
-
-func rwExtensionBytes(w jsWriter, msg []byte, scratch []byte) ([]byte, []byte, error) {
-	var err error
-	var et int8
-	et, err = peekExtension(msg)
-	if err != nil {
-		return msg, scratch, err
-	}
-
-	// if it's time.Time
-	if et == TimeExtension {
-		var tm time.Time
-		tm, msg, err = ReadTimeBytes(msg)
-		if err != nil {
-			return msg, scratch, err
-		}
-		bts, err := tm.MarshalJSON()
-		if err != nil {
-			return msg, scratch, err
-		}
-		_, err = w.Write(bts)
-		return msg, scratch, err
-	}
-
-	// if the extension is registered,
-	// use its canonical JSON form
-	if f, ok := extensionReg[et]; ok {
-		e := f()
-		msg, err = ReadExtensionBytes(msg, e)
-		if err != nil {
-			return msg, scratch, err
-		}
-		bts, err := json.Marshal(e)
-		if err != nil {
-			return msg, scratch, err
-		}
-		_, err = w.Write(bts)
-		return msg, scratch, err
-	}
-
-	// otherwise, write `{"type": <num>, "data": "<base64data>"}`
-	r := RawExtension{}
-	r.Type = et
-	msg, err = ReadExtensionBytes(msg, &r)
-	if err != nil {
-		return msg, scratch, err
-	}
-	scratch, err = writeExt(w, r, scratch)
-	return msg, scratch, err
-}
-
-func writeExt(w jsWriter, r RawExtension, scratch []byte) ([]byte, error) {
-	_, err := w.WriteString(`{"type":`)
-	if err != nil {
-		return scratch, err
-	}
-	scratch = strconv.AppendInt(scratch[0:0], int64(r.Type), 10)
-	_, err = w.Write(scratch)
-	if err != nil {
-		return scratch, err
-	}
-	_, err = w.WriteString(`,"data":"`)
-	if err != nil {
-		return scratch, err
-	}
-	l := base64.StdEncoding.EncodedLen(len(r.Data))
-	if cap(scratch) >= l {
-		scratch = scratch[0:l]
-	} else {
-		scratch = make([]byte, l)
-	}
-	base64.StdEncoding.Encode(scratch, r.Data)
-	_, err = w.Write(scratch)
-	if err != nil {
-		return scratch, err
-	}
-	_, err = w.WriteString(`"}`)
-	return scratch, err
-}