Update chi/middleware to chi/v5/middleware (#17888)

Fix #17880


Co-authored-by: Lauris BH <lauris@nix.lv>

42 files changed, 128 insertions, 2572 deletions

diff --git a/go.mod b/go.mod
index 4c156b1957..a597958b5b 100644
--- a/go.mod
+++ b/go.mod
@@ -36,7 +36,6 @@ require (
 	github.com/ethantkoenig/rupture v1.0.0
 	github.com/gliderlabs/ssh v0.3.3
 	github.com/go-asn1-ber/asn1-ber v1.5.3 // indirect
-	github.com/go-chi/chi v1.5.4
 	github.com/go-chi/chi/v5 v5.0.4
 	github.com/go-chi/cors v1.2.0
 	github.com/go-enry/go-enry/v2 v2.7.1
diff --git a/go.sum b/go.sum
index bdbf33eddc..6891abd6b3 100644
--- a/go.sum
+++ b/go.sum
@@ -319,8 +319,6 @@ github.com/glycerine/goconvey v0.0.0-20190410193231-58a59202ab31/go.mod h1:Ogl1T
 github.com/go-asn1-ber/asn1-ber v1.5.1/go.mod h1:hEBeB/ic+5LoWskz+yKT7vGhhPYkProFKoKdwZRWMe0=
 github.com/go-asn1-ber/asn1-ber v1.5.3 h1:u7utq56RUFiynqUzgVMFDymapcOtQ/MZkh3H4QYkxag=
 github.com/go-asn1-ber/asn1-ber v1.5.3/go.mod h1:hEBeB/ic+5LoWskz+yKT7vGhhPYkProFKoKdwZRWMe0=
-github.com/go-chi/chi v1.5.4 h1:QHdzF2szwjqVV4wmByUnTcsbIg7UGaQ0tPF2t5GcAIs=
-github.com/go-chi/chi v1.5.4/go.mod h1:uaf8YgoFazUOkPBG7fxPftUylNumIev9awIWOENIuEg=
 github.com/go-chi/chi/v5 v5.0.1/go.mod h1:DslCQbL2OYiznFReuXYUmQ2hGd1aDpCnlMNITLSKoi8=
 github.com/go-chi/chi/v5 v5.0.4 h1:5e494iHzsYBiyXQAHHuI4tyJS9M3V84OuX3ufIIGHFo=
 github.com/go-chi/chi/v5 v5.0.4/go.mod h1:DslCQbL2OYiznFReuXYUmQ2hGd1aDpCnlMNITLSKoi8=
diff --git a/routers/common/middleware.go b/routers/common/middleware.go
index 75d3777e49..7da05d2ae4 100644
--- a/routers/common/middleware.go
+++ b/routers/common/middleware.go
@@ -15,7 +15,7 @@ import (
 	"code.gitea.io/gitea/modules/setting"
 
 	"github.com/chi-middleware/proxy"
-	"github.com/go-chi/chi/middleware"
+	"github.com/go-chi/chi/v5/middleware"
 )
 
 // Middlewares returns common middlewares
diff --git a/routers/web/web.go b/routers/web/web.go
index a642fdea5e..c52d3483f0 100644
--- a/routers/web/web.go
+++ b/routers/web/web.go
@@ -40,7 +40,7 @@ import (
 
 	"gitea.com/go-chi/captcha"
 	"github.com/NYTimes/gziphandler"
-	"github.com/go-chi/chi/middleware"
+	"github.com/go-chi/chi/v5/middleware"
 	"github.com/go-chi/cors"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/tstranex/u2f"
diff --git a/vendor/github.com/go-chi/chi/.gitignore b/vendor/github.com/go-chi/chi/.gitignore
deleted file mode 100644
index ba22c99a99..0000000000
--- a/vendor/github.com/go-chi/chi/.gitignore
+++ /dev/null
@@ -1,3 +0,0 @@
-.idea
-*.sw?
-.vscode
diff --git a/vendor/github.com/go-chi/chi/CHANGELOG.md b/vendor/github.com/go-chi/chi/CHANGELOG.md
deleted file mode 100644
index 7dd079157f..0000000000
--- a/vendor/github.com/go-chi/chi/CHANGELOG.md
+++ /dev/null
@@ -1,269 +0,0 @@
-# Changelog
-
-## v1.5.4 (2021-02-27)
-
-- Undo prior retraction in v1.5.3 as we prepare for v5.0.0 release
-- History of changes: see https://github.com/go-chi/chi/compare/v1.5.3...v1.5.4
-
-
-## v1.5.3 (2021-02-21)
-
-- Update go.mod to go 1.16 with new retract directive marking all versions without prior go.mod support
-- History of changes: see https://github.com/go-chi/chi/compare/v1.5.2...v1.5.3
-
-
-## v1.5.2 (2021-02-10)
-
-- Reverting allocation optimization as a precaution as go test -race fails.
-- Minor improvements, see history below
-- History of changes: see https://github.com/go-chi/chi/compare/v1.5.1...v1.5.2
-
-
-## v1.5.1 (2020-12-06)
-
-- Performance improvement: removing 1 allocation by foregoing context.WithValue, thank you @bouk for
-  your contribution (https://github.com/go-chi/chi/pull/555). Note: new benchmarks posted in README.
-- `middleware.CleanPath`: new middleware that clean's request path of double slashes
-- deprecate & remove `chi.ServerBaseContext` in favour of stdlib `http.Server#BaseContext`
-- plus other tiny improvements, see full commit history below
-- History of changes: see https://github.com/go-chi/chi/compare/v4.1.2...v1.5.1
-
-
-## v1.5.0 (2020-11-12) - now with go.mod support
-
-`chi` dates back to 2016 with it's original implementation as one of the first routers to adopt the newly introduced
-context.Context api to the stdlib -- set out to design a router that is faster, more modular and simpler than anything
-else out there -- while not introducing any custom handler types or dependencies. Today, `chi` still has zero dependencies,
-and in many ways is future proofed from changes, given it's minimal nature. Between versions, chi's iterations have been very
-incremental, with the architecture and api being the same today as it was originally designed in 2016. For this reason it 
-makes chi a pretty easy project to maintain, as well thanks to the many amazing community contributions over the years
-to who all help make chi better (total of 86 contributors to date -- thanks all!).
-
-Chi has been an labour of love, art and engineering, with the goals to offer beautiful ergonomics, flexibility, performance
-and simplicity when building HTTP services with Go. I've strived to keep the router very minimal in surface area / code size,
-and always improving the code wherever possible -- and as of today the `chi` package is just 1082 lines of code (not counting
-middlewares, which are all optional). As well, I don't have the exact metrics, but from my analysis and email exchanges from
-companies and developers, chi is used by thousands of projects around the world -- thank you all as there is no better form of
-joy for me than to have art I had started be helpful and enjoyed by others. And of course I use chi in all of my own projects too :)
-
-For me, the asthetics of chi's code and usage are very important. With the introduction of Go's module support 
-(which I'm a big fan of), chi's past versioning scheme choice to v2, v3 and v4 would mean I'd require the import path
-of "github.com/go-chi/chi/v4", leading to the lengthy discussion at https://github.com/go-chi/chi/issues/462.
-Haha, to some, you may be scratching your head why I've spent > 1 year stalling to adopt "/vXX" convention in the import
-path -- which isn't horrible in general -- but for chi, I'm unable to accept it as I strive for perfection in it's API design,
-aesthetics and simplicity. It just doesn't feel good to me given chi's simple nature -- I do not foresee a "v5" or "v6",
-and upgrading between versions in the future will also be just incremental.
-
-I do understand versioning is a part of the API design as well, which is why the solution for a while has been to "do nothing",
-as Go supports both old and new import paths with/out go.mod. However, now that Go module support has had time to iron out kinks and
-is adopted everywhere, it's time for chi to get with the times. Luckily, I've discovered a path forward that will make me happy,
-while also not breaking anyone's app who adopted a prior versioning from tags in v2/v3/v4. I've made an experimental release of
-v1.5.0 with go.mod silently, and tested it with new and old projects, to ensure the developer experience is preserved, and it's
-largely unnoticed. Fortunately, Go's toolchain will check the tags of a repo and consider the "latest" tag the one with go.mod.
-However, you can still request a specific older tag such as v4.1.2, and everything will "just work". But new users can just
-`go get github.com/go-chi/chi` or `go get github.com/go-chi/chi@latest` and they will get the latest version which contains
-go.mod support, which is v1.5.0+. `chi` will not change very much over the years, just like it hasn't changed much from 4 years ago.
-Therefore, we will stay on v1.x from here on, starting from v1.5.0. Any breaking changes will bump a "minor" release and
-backwards-compatible improvements/fixes will bump a "tiny" release.
-
-For existing projects who want to upgrade to the latest go.mod version, run: `go get -u github.com/go-chi/chi@v1.5.0`,
-which will get you on the go.mod version line (as Go's mod cache may still remember v4.x). Brand new systems can run
-`go get -u github.com/go-chi/chi` or `go get -u github.com/go-chi/chi@latest` to install chi, which will install v1.5.0+
-built with go.mod support.
-
-My apologies to the developers who will disagree with the decisions above, but, hope you'll try it and see it's a very
-minor request which is backwards compatible and won't break your existing installations.
-
-Cheers all, happy coding!
-
-
----
-
-
-## v4.1.2 (2020-06-02)
-
-- fix that handles MethodNotAllowed with path variables, thank you @caseyhadden for your contribution
-- fix to replace nested wildcards correctly in RoutePattern, thank you @@unmultimedio for your contribution
-- History of changes: see https://github.com/go-chi/chi/compare/v4.1.1...v4.1.2
-
-
-## v4.1.1 (2020-04-16)
-
-- fix for issue https://github.com/go-chi/chi/issues/411 which allows for overlapping regexp
-  route to the correct handler through a recursive tree search, thanks to @Jahaja for the PR/fix!
-- new middleware.RouteHeaders as a simple router for request headers with wildcard support
-- History of changes: see https://github.com/go-chi/chi/compare/v4.1.0...v4.1.1
-
-
-## v4.1.0 (2020-04-1)
-
-- middleware.LogEntry: Write method on interface now passes the response header
-  and an extra interface type useful for custom logger implementations.
-- middleware.WrapResponseWriter: minor fix
-- middleware.Recoverer: a bit prettier
-- History of changes: see https://github.com/go-chi/chi/compare/v4.0.4...v4.1.0
-
-## v4.0.4 (2020-03-24)
-
-- middleware.Recoverer: new pretty stack trace printing (https://github.com/go-chi/chi/pull/496)
-- a few minor improvements and fixes
-- History of changes: see https://github.com/go-chi/chi/compare/v4.0.3...v4.0.4
-
-
-## v4.0.3 (2020-01-09)
-
-- core: fix regexp routing to include default value when param is not matched
-- middleware: rewrite of middleware.Compress
-- middleware: suppress http.ErrAbortHandler in middleware.Recoverer
-- History of changes: see https://github.com/go-chi/chi/compare/v4.0.2...v4.0.3
-
-
-## v4.0.2 (2019-02-26)
-
-- Minor fixes
-- History of changes: see https://github.com/go-chi/chi/compare/v4.0.1...v4.0.2
-
-
-## v4.0.1 (2019-01-21)
-
-- Fixes issue with compress middleware: #382 #385
-- History of changes: see https://github.com/go-chi/chi/compare/v4.0.0...v4.0.1
-
-
-## v4.0.0 (2019-01-10)
-
-- chi v4 requires Go 1.10.3+ (or Go 1.9.7+) - we have deprecated support for Go 1.7 and 1.8
-- router: respond with 404 on router with no routes (#362)
-- router: additional check to ensure wildcard is at the end of a url pattern (#333)
-- middleware: deprecate use of http.CloseNotifier (#347)
-- middleware: fix RedirectSlashes to include query params on redirect (#334)
-- History of changes: see https://github.com/go-chi/chi/compare/v3.3.4...v4.0.0
-
-
-## v3.3.4 (2019-01-07)
-
-- Minor middleware improvements. No changes to core library/router. Moving v3 into its
-- own branch as a version of chi for Go 1.7, 1.8, 1.9, 1.10, 1.11
-- History of changes: see https://github.com/go-chi/chi/compare/v3.3.3...v3.3.4
-
-
-## v3.3.3 (2018-08-27)
-
-- Minor release
-- See https://github.com/go-chi/chi/compare/v3.3.2...v3.3.3
-
-
-## v3.3.2 (2017-12-22)
-
-- Support to route trailing slashes on mounted sub-routers (#281)
-- middleware: new `ContentCharset` to check matching charsets. Thank you
-  @csucu for your community contribution!
-
-
-## v3.3.1 (2017-11-20)
-
-- middleware: new `AllowContentType` handler for explicit whitelist of accepted request Content-Types
-- middleware: new `SetHeader` handler for short-hand middleware to set a response header key/value
-- Minor bug fixes
-
-
-## v3.3.0 (2017-10-10)
-
-- New chi.RegisterMethod(method) to add support for custom HTTP methods, see _examples/custom-method for usage
-- Deprecated LINK and UNLINK methods from the default list, please use `chi.RegisterMethod("LINK")` and `chi.RegisterMethod("UNLINK")` in an `init()` function
-
-
-## v3.2.1 (2017-08-31)
-
-- Add new `Match(rctx *Context, method, path string) bool` method to `Routes` interface
-  and `Mux`. Match searches the mux's routing tree for a handler that matches the method/path
-- Add new `RouteMethod` to `*Context`
-- Add new `Routes` pointer to `*Context`
-- Add new `middleware.GetHead` to route missing HEAD requests to GET handler
-- Updated benchmarks (see README)
-
-
-## v3.1.5 (2017-08-02)
-
-- Setup golint and go vet for the project
-- As per golint, we've redefined `func ServerBaseContext(h http.Handler, baseCtx context.Context) http.Handler`
-  to `func ServerBaseContext(baseCtx context.Context, h http.Handler) http.Handler`
-
-
-## v3.1.0 (2017-07-10)
-
-- Fix a few minor issues after v3 release
-- Move `docgen` sub-pkg to https://github.com/go-chi/docgen
-- Move `render` sub-pkg to https://github.com/go-chi/render
-- Add new `URLFormat` handler to chi/middleware sub-pkg to make working with url mime 
-  suffixes easier, ie. parsing `/articles/1.json` and `/articles/1.xml`. See comments in
-  https://github.com/go-chi/chi/blob/master/middleware/url_format.go for example usage.
-
-
-## v3.0.0 (2017-06-21)
-
-- Major update to chi library with many exciting updates, but also some *breaking changes*
-- URL parameter syntax changed from `/:id` to `/{id}` for even more flexible routing, such as
-  `/articles/{month}-{day}-{year}-{slug}`, `/articles/{id}`, and `/articles/{id}.{ext}` on the
-  same router
-- Support for regexp for routing patterns, in the form of `/{paramKey:regExp}` for example:
-  `r.Get("/articles/{name:[a-z]+}", h)` and `chi.URLParam(r, "name")`
-- Add `Method` and `MethodFunc` to `chi.Router` to allow routing definitions such as
-  `r.Method("GET", "/", h)` which provides a cleaner interface for custom handlers like
-  in `_examples/custom-handler`
-- Deprecating `mux#FileServer` helper function. Instead, we encourage users to create their
-  own using file handler with the stdlib, see `_examples/fileserver` for an example
-- Add support for LINK/UNLINK http methods via `r.Method()` and `r.MethodFunc()`
-- Moved the chi project to its own organization, to allow chi-related community packages to
-  be easily discovered and supported, at: https://github.com/go-chi
-- *NOTE:* please update your import paths to `"github.com/go-chi/chi"`
-- *NOTE:* chi v2 is still available at https://github.com/go-chi/chi/tree/v2
-
-
-## v2.1.0 (2017-03-30)
-
-- Minor improvements and update to the chi core library
-- Introduced a brand new `chi/render` sub-package to complete the story of building
-  APIs to offer a pattern for managing well-defined request / response payloads. Please
-  check out the updated `_examples/rest` example for how it works.
-- Added `MethodNotAllowed(h http.HandlerFunc)` to chi.Router interface
-
-
-## v2.0.0 (2017-01-06)
-
-- After many months of v2 being in an RC state with many companies and users running it in
-  production, the inclusion of some improvements to the middlewares, we are very pleased to
-  announce v2.0.0 of chi.
-
-
-## v2.0.0-rc1 (2016-07-26)
-
-- Huge update! chi v2 is a large refactor targetting Go 1.7+. As of Go 1.7, the popular
-  community `"net/context"` package has been included in the standard library as `"context"` and
-  utilized by `"net/http"` and `http.Request` to managing deadlines, cancelation signals and other
-  request-scoped values. We're very excited about the new context addition and are proud to
-  introduce chi v2, a minimal and powerful routing package for building large HTTP services,
-  with zero external dependencies. Chi focuses on idiomatic design and encourages the use of 
-  stdlib HTTP handlers and middlwares.
-- chi v2 deprecates its `chi.Handler` interface and requires `http.Handler` or `http.HandlerFunc`
-- chi v2 stores URL routing parameters and patterns in the standard request context: `r.Context()`
-- chi v2 lower-level routing context is accessible by `chi.RouteContext(r.Context()) *chi.Context`,
-  which provides direct access to URL routing parameters, the routing path and the matching
-  routing patterns.
-- Users upgrading from chi v1 to v2, need to:
-  1. Update the old chi.Handler signature, `func(ctx context.Context, w http.ResponseWriter, r *http.Request)` to
-     the standard http.Handler: `func(w http.ResponseWriter, r *http.Request)`
-  2. Use `chi.URLParam(r *http.Request, paramKey string) string`
-     or `URLParamFromCtx(ctx context.Context, paramKey string) string` to access a url parameter value
-
-
-## v1.0.0 (2016-07-01)
-
-- Released chi v1 stable https://github.com/go-chi/chi/tree/v1.0.0 for Go 1.6 and older.
-
-
-## v0.9.0 (2016-03-31)
-
-- Reuse context objects via sync.Pool for zero-allocation routing [#33](https://github.com/go-chi/chi/pull/33)
-- BREAKING NOTE: due to subtle API changes, previously `chi.URLParams(ctx)["id"]` used to access url parameters
-  has changed to: `chi.URLParam(ctx, "id")`
diff --git a/vendor/github.com/go-chi/chi/CONTRIBUTING.md b/vendor/github.com/go-chi/chi/CONTRIBUTING.md
deleted file mode 100644
index c0ac2dfe85..0000000000
--- a/vendor/github.com/go-chi/chi/CONTRIBUTING.md
+++ /dev/null
@@ -1,31 +0,0 @@
-# Contributing
-
-## Prerequisites
-
-1. [Install Go][go-install].
-2. Download the sources and switch the working directory:
-
-    ```bash
-    go get -u -d github.com/go-chi/chi
-    cd $GOPATH/src/github.com/go-chi/chi
-    ```
-
-## Submitting a Pull Request
-
-A typical workflow is:
-
-1. [Fork the repository.][fork] [This tip maybe also helpful.][go-fork-tip]
-2. [Create a topic branch.][branch]
-3. Add tests for your change.
-4. Run `go test`. If your tests pass, return to the step 3.
-5. Implement the change and ensure the steps from the previous step pass.
-6. Run `goimports -w .`, to ensure the new code conforms to Go formatting guideline.
-7. [Add, commit and push your changes.][git-help]
-8. [Submit a pull request.][pull-req]
-
-[go-install]: https://golang.org/doc/install
-[go-fork-tip]: http://blog.campoy.cat/2014/03/github-and-go-forking-pull-requests-and.html
-[fork]: https://help.github.com/articles/fork-a-repo
-[branch]: http://learn.github.com/p/branching.html
-[git-help]: https://guides.github.com
-[pull-req]: https://help.github.com/articles/using-pull-requests
diff --git a/vendor/github.com/go-chi/chi/LICENSE b/vendor/github.com/go-chi/chi/LICENSE
deleted file mode 100644
index d99f02ffac..0000000000
--- a/vendor/github.com/go-chi/chi/LICENSE
+++ /dev/null
@@ -1,20 +0,0 @@
-Copyright (c) 2015-present Peter Kieltyka (https://github.com/pkieltyka), Google Inc.
-
-MIT License
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software is furnished to do so,
-subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
-COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
-IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/vendor/github.com/go-chi/chi/Makefile b/vendor/github.com/go-chi/chi/Makefile
deleted file mode 100644
index b96c92dd21..0000000000
--- a/vendor/github.com/go-chi/chi/Makefile
+++ /dev/null
@@ -1,14 +0,0 @@
-all:
-	@echo "**********************************************************"
-	@echo "**                    chi build tool                    **"
-	@echo "**********************************************************"
-
-
-test:
-	go clean -testcache && $(MAKE) test-router && $(MAKE) test-middleware
-
-test-router:
-	go test -race -v .
-
-test-middleware:
-	go test -race -v ./middleware
diff --git a/vendor/github.com/go-chi/chi/README.md b/vendor/github.com/go-chi/chi/README.md
deleted file mode 100644
index 1b96d360d7..0000000000
--- a/vendor/github.com/go-chi/chi/README.md
+++ /dev/null
@@ -1,511 +0,0 @@
-# <img alt="chi" src="https://cdn.rawgit.com/go-chi/chi/master/_examples/chi.svg" width="220" />
-
-
-[![GoDoc Widget]][GoDoc] [![Travis Widget]][Travis]
-
-`chi` is a lightweight, idiomatic and composable router for building Go HTTP services. It's
-especially good at helping you write large REST API services that are kept maintainable as your
-project grows and changes. `chi` is built on the new `context` package introduced in Go 1.7 to
-handle signaling, cancelation and request-scoped values across a handler chain.
-
-The focus of the project has been to seek out an elegant and comfortable design for writing
-REST API servers, written during the development of the Pressly API service that powers our
-public API service, which in turn powers all of our client-side applications.
-
-The key considerations of chi's design are: project structure, maintainability, standard http
-handlers (stdlib-only), developer productivity, and deconstructing a large system into many small
-parts. The core router `github.com/go-chi/chi` is quite small (less than 1000 LOC), but we've also
-included some useful/optional subpackages: [middleware](/middleware), [render](https://github.com/go-chi/render)
-and [docgen](https://github.com/go-chi/docgen). We hope you enjoy it too!
-
-## Install
-
-`go get -u github.com/go-chi/chi`
-
-
-## Features
-
-* **Lightweight** - cloc'd in ~1000 LOC for the chi router
-* **Fast** - yes, see [benchmarks](#benchmarks)
-* **100% compatible with net/http** - use any http or middleware pkg in the ecosystem that is also compatible with `net/http`
-* **Designed for modular/composable APIs** - middlewares, inline middlewares, route groups and sub-router mounting
-* **Context control** - built on new `context` package, providing value chaining, cancellations and timeouts
-* **Robust** - in production at Pressly, CloudFlare, Heroku, 99Designs, and many others (see [discussion](https://github.com/go-chi/chi/issues/91))
-* **Doc generation** - `docgen` auto-generates routing documentation from your source to JSON or Markdown
-* **Go.mod support** - v1.x of chi (starting from v1.5.0), now has go.mod support (see [CHANGELOG](https://github.com/go-chi/chi/blob/master/CHANGELOG.md#v150-2020-11-12---now-with-gomod-support))
-* **No external dependencies** - plain ol' Go stdlib + net/http
-
-
-## Examples
-
-See [_examples/](https://github.com/go-chi/chi/blob/master/_examples/) for a variety of examples.
-
-
-**As easy as:**
-
-```go
-package main
-
-import (
-	"net/http"
-
-	"github.com/go-chi/chi"
-	"github.com/go-chi/chi/middleware"
-)
-
-func main() {
-	r := chi.NewRouter()
-	r.Use(middleware.Logger)
-	r.Get("/", func(w http.ResponseWriter, r *http.Request) {
-		w.Write([]byte("welcome"))
-	})
-	http.ListenAndServe(":3000", r)
-}
-```
-
-**REST Preview:**
-
-Here is a little preview of how routing looks like with chi. Also take a look at the generated routing docs
-in JSON ([routes.json](https://github.com/go-chi/chi/blob/master/_examples/rest/routes.json)) and in
-Markdown ([routes.md](https://github.com/go-chi/chi/blob/master/_examples/rest/routes.md)).
-
-I highly recommend reading the source of the [examples](https://github.com/go-chi/chi/blob/master/_examples/) listed
-above, they will show you all the features of chi and serve as a good form of documentation.
-
-```go
-import (
-  //...
-  "context"
-  "github.com/go-chi/chi"
-  "github.com/go-chi/chi/middleware"
-)
-
-func main() {
-  r := chi.NewRouter()
-
-  // A good base middleware stack
-  r.Use(middleware.RequestID)
-  r.Use(middleware.RealIP)
-  r.Use(middleware.Logger)
-  r.Use(middleware.Recoverer)
-
-  // Set a timeout value on the request context (ctx), that will signal
-  // through ctx.Done() that the request has timed out and further
-  // processing should be stopped.
-  r.Use(middleware.Timeout(60 * time.Second))
-
-  r.Get("/", func(w http.ResponseWriter, r *http.Request) {
-    w.Write([]byte("hi"))
-  })
-
-  // RESTy routes for "articles" resource
-  r.Route("/articles", func(r chi.Router) {
-    r.With(paginate).Get("/", listArticles)                           // GET /articles
-    r.With(paginate).Get("/{month}-{day}-{year}", listArticlesByDate) // GET /articles/01-16-2017
-
-    r.Post("/", createArticle)                                        // POST /articles
-    r.Get("/search", searchArticles)                                  // GET /articles/search
-
-    // Regexp url parameters:
-    r.Get("/{articleSlug:[a-z-]+}", getArticleBySlug)                // GET /articles/home-is-toronto
-
-    // Subrouters:
-    r.Route("/{articleID}", func(r chi.Router) {
-      r.Use(ArticleCtx)
-      r.Get("/", getArticle)                                          // GET /articles/123
-      r.Put("/", updateArticle)                                       // PUT /articles/123
-      r.Delete("/", deleteArticle)                                    // DELETE /articles/123
-    })
-  })
-
-  // Mount the admin sub-router
-  r.Mount("/admin", adminRouter())
-
-  http.ListenAndServe(":3333", r)
-}
-
-func ArticleCtx(next http.Handler) http.Handler {
-  return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-    articleID := chi.URLParam(r, "articleID")
-    article, err := dbGetArticle(articleID)
-    if err != nil {
-      http.Error(w, http.StatusText(404), 404)
-      return
-    }
-    ctx := context.WithValue(r.Context(), "article", article)
-    next.ServeHTTP(w, r.WithContext(ctx))
-  })
-}
-
-func getArticle(w http.ResponseWriter, r *http.Request) {
-  ctx := r.Context()
-  article, ok := ctx.Value("article").(*Article)
-  if !ok {
-    http.Error(w, http.StatusText(422), 422)
-    return
-  }
-  w.Write([]byte(fmt.Sprintf("title:%s", article.Title)))
-}
-
-// A completely separate router for administrator routes
-func adminRouter() http.Handler {
-  r := chi.NewRouter()
-  r.Use(AdminOnly)
-  r.Get("/", adminIndex)
-  r.Get("/accounts", adminListAccounts)
-  return r
-}
-
-func AdminOnly(next http.Handler) http.Handler {
-  return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-    ctx := r.Context()
-    perm, ok := ctx.Value("acl.permission").(YourPermissionType)
-    if !ok || !perm.IsAdmin() {
-      http.Error(w, http.StatusText(403), 403)
-      return
-    }
-    next.ServeHTTP(w, r)
-  })
-}
-```
-
-
-## Router interface
-
-chi's router is based on a kind of [Patricia Radix trie](https://en.wikipedia.org/wiki/Radix_tree).
-The router is fully compatible with `net/http`.
-
-Built on top of the tree is the `Router` interface:
-
-```go
-// Router consisting of the core routing methods used by chi's Mux,
-// using only the standard net/http.
-type Router interface {
-	http.Handler
-	Routes
-
-	// Use appends one or more middlewares onto the Router stack.
-	Use(middlewares ...func(http.Handler) http.Handler)
-
-	// With adds inline middlewares for an endpoint handler.
-	With(middlewares ...func(http.Handler) http.Handler) Router
-
-	// Group adds a new inline-Router along the current routing
-	// path, with a fresh middleware stack for the inline-Router.
-	Group(fn func(r Router)) Router
-
-	// Route mounts a sub-Router along a `pattern`` string.
-	Route(pattern string, fn func(r Router)) Router
-
-	// Mount attaches another http.Handler along ./pattern/*
-	Mount(pattern string, h http.Handler)
-
-	// Handle and HandleFunc adds routes for `pattern` that matches
-	// all HTTP methods.
-	Handle(pattern string, h http.Handler)
-	HandleFunc(pattern string, h http.HandlerFunc)
-
-	// Method and MethodFunc adds routes for `pattern` that matches
-	// the `method` HTTP method.
-	Method(method, pattern string, h http.Handler)
-	MethodFunc(method, pattern string, h http.HandlerFunc)
-
-	// HTTP-method routing along `pattern`
-	Connect(pattern string, h http.HandlerFunc)
-	Delete(pattern string, h http.HandlerFunc)
-	Get(pattern string, h http.HandlerFunc)
-	Head(pattern string, h http.HandlerFunc)
-	Options(pattern string, h http.HandlerFunc)
-	Patch(pattern string, h http.HandlerFunc)
-	Post(pattern string, h http.HandlerFunc)
-	Put(pattern string, h http.HandlerFunc)
-	Trace(pattern string, h http.HandlerFunc)
-
-	// NotFound defines a handler to respond whenever a route could
-	// not be found.
-	NotFound(h http.HandlerFunc)
-
-	// MethodNotAllowed defines a handler to respond whenever a method is
-	// not allowed.
-	MethodNotAllowed(h http.HandlerFunc)
-}
-
-// Routes interface adds two methods for router traversal, which is also
-// used by the github.com/go-chi/docgen package to generate documentation for Routers.
-type Routes interface {
-	// Routes returns the routing tree in an easily traversable structure.
-	Routes() []Route
-
-	// Middlewares returns the list of middlewares in use by the router.
-	Middlewares() Middlewares
-
-	// Match searches the routing tree for a handler that matches
-	// the method/path - similar to routing a http request, but without
-	// executing the handler thereafter.
-	Match(rctx *Context, method, path string) bool
-}
-```
-
-Each routing method accepts a URL `pattern` and chain of `handlers`. The URL pattern
-supports named params (ie. `/users/{userID}`) and wildcards (ie. `/admin/*`). URL parameters
-can be fetched at runtime by calling `chi.URLParam(r, "userID")` for named parameters
-and `chi.URLParam(r, "*")` for a wildcard parameter.
-
-
-### Middleware handlers
-
-chi's middlewares are just stdlib net/http middleware handlers. There is nothing special
-about them, which means the router and all the tooling is designed to be compatible and
-friendly with any middleware in the community. This offers much better extensibility and reuse
-of packages and is at the heart of chi's purpose.
-
-Here is an example of a standard net/http middleware where we assign a context key `"user"`
-the value of `"123"`. This middleware sets a hypothetical user identifier on the request
-context and calls the next handler in the chain.
-
-```go
-// HTTP middleware setting a value on the request context
-func MyMiddleware(next http.Handler) http.Handler {
-  return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-    // create new context from `r` request context, and assign key `"user"`
-    // to value of `"123"`
-    ctx := context.WithValue(r.Context(), "user", "123")
-
-    // call the next handler in the chain, passing the response writer and
-    // the updated request object with the new context value.
-    //
-    // note: context.Context values are nested, so any previously set
-    // values will be accessible as well, and the new `"user"` key
-    // will be accessible from this point forward.
-    next.ServeHTTP(w, r.WithContext(ctx))
-  })
-}
-```
-
-
-### Request handlers
-
-chi uses standard net/http request handlers. This little snippet is an example of a http.Handler
-func that reads a user identifier from the request context - hypothetically, identifying
-the user sending an authenticated request, validated+set by a previous middleware handler.
-
-```go
-// HTTP handler accessing data from the request context.
-func MyRequestHandler(w http.ResponseWriter, r *http.Request) {
-  // here we read from the request context and fetch out `"user"` key set in
-  // the MyMiddleware example above.
-  user := r.Context().Value("user").(string)
-
-  // respond to the client
-  w.Write([]byte(fmt.Sprintf("hi %s", user)))
-}
-```
-
-
-### URL parameters
-
-chi's router parses and stores URL parameters right onto the request context. Here is
-an example of how to access URL params in your net/http handlers. And of course, middlewares
-are able to access the same information.
-
-```go
-// HTTP handler accessing the url routing parameters.
-func MyRequestHandler(w http.ResponseWriter, r *http.Request) {
-  // fetch the url parameter `"userID"` from the request of a matching
-  // routing pattern. An example routing pattern could be: /users/{userID}
-  userID := chi.URLParam(r, "userID")
-
-  // fetch `"key"` from the request context
-  ctx := r.Context()
-  key := ctx.Value("key").(string)
-
-  // respond to the client
-  w.Write([]byte(fmt.Sprintf("hi %v, %v", userID, key)))
-}
-```
-
-
-## Middlewares
-
-chi comes equipped with an optional `middleware` package, providing a suite of standard
-`net/http` middlewares. Please note, any middleware in the ecosystem that is also compatible
-with `net/http` can be used with chi's mux.
-
-### Core middlewares
-
-----------------------------------------------------------------------------------------------------
-| chi/middleware Handler | description                                                             |
-| :--------------------- | :---------------------------------------------------------------------- |
-| [AllowContentEncoding] | Enforces a whitelist of request Content-Encoding headers                |
-| [AllowContentType]     | Explicit whitelist of accepted request Content-Types                    |
-| [BasicAuth]            | Basic HTTP authentication                                               |
-| [Compress]             | Gzip compression for clients that accept compressed responses           |
-| [ContentCharset]       | Ensure charset for Content-Type request headers                         |
-| [CleanPath]            | Clean double slashes from request path                                  |
-| [GetHead]              | Automatically route undefined HEAD requests to GET handlers             |
-| [Heartbeat]            | Monitoring endpoint to check the servers pulse                          |
-| [Logger]               | Logs the start and end of each request with the elapsed processing time |
-| [NoCache]              | Sets response headers to prevent clients from caching                   |
-| [Profiler]             | Easily attach net/http/pprof to your routers                            |
-| [RealIP]               | Sets a http.Request's RemoteAddr to either X-Forwarded-For or X-Real-IP |
-| [Recoverer]            | Gracefully absorb panics and prints the stack trace                     |
-| [RequestID]            | Injects a request ID into the context of each request                   |
-| [RedirectSlashes]      | Redirect slashes on routing paths                                       |
-| [RouteHeaders]         | Route handling for request headers                                      |
-| [SetHeader]            | Short-hand middleware to set a response header key/value                |
-| [StripSlashes]         | Strip slashes on routing paths                                          |
-| [Throttle]             | Puts a ceiling on the number of concurrent requests                     |
-| [Timeout]              | Signals to the request context when the timeout deadline is reached     |
-| [URLFormat]            | Parse extension from url and put it on request context                  |
-| [WithValue]            | Short-hand middleware to set a key/value on the request context         |
-----------------------------------------------------------------------------------------------------
-
-[AllowContentEncoding]: https://pkg.go.dev/github.com/go-chi/chi/middleware#AllowContentEncoding
-[AllowContentType]: https://pkg.go.dev/github.com/go-chi/chi/middleware#AllowContentType
-[BasicAuth]: https://pkg.go.dev/github.com/go-chi/chi/middleware#BasicAuth
-[Compress]: https://pkg.go.dev/github.com/go-chi/chi/middleware#Compress
-[ContentCharset]: https://pkg.go.dev/github.com/go-chi/chi/middleware#ContentCharset
-[CleanPath]: https://pkg.go.dev/github.com/go-chi/chi/middleware#CleanPath
-[GetHead]: https://pkg.go.dev/github.com/go-chi/chi/middleware#GetHead
-[GetReqID]: https://pkg.go.dev/github.com/go-chi/chi/middleware#GetReqID
-[Heartbeat]: https://pkg.go.dev/github.com/go-chi/chi/middleware#Heartbeat
-[Logger]: https://pkg.go.dev/github.com/go-chi/chi/middleware#Logger
-[NoCache]: https://pkg.go.dev/github.com/go-chi/chi/middleware#NoCache
-[Profiler]: https://pkg.go.dev/github.com/go-chi/chi/middleware#Profiler
-[RealIP]: https://pkg.go.dev/github.com/go-chi/chi/middleware#RealIP
-[Recoverer]: https://pkg.go.dev/github.com/go-chi/chi/middleware#Recoverer
-[RedirectSlashes]: https://pkg.go.dev/github.com/go-chi/chi/middleware#RedirectSlashes
-[RequestLogger]: https://pkg.go.dev/github.com/go-chi/chi/middleware#RequestLogger
-[RequestID]: https://pkg.go.dev/github.com/go-chi/chi/middleware#RequestID
-[RouteHeaders]: https://pkg.go.dev/github.com/go-chi/chi/middleware#RouteHeaders
-[SetHeader]: https://pkg.go.dev/github.com/go-chi/chi/middleware#SetHeader
-[StripSlashes]: https://pkg.go.dev/github.com/go-chi/chi/middleware#StripSlashes
-[Throttle]: https://pkg.go.dev/github.com/go-chi/chi/middleware#Throttle
-[ThrottleBacklog]: https://pkg.go.dev/github.com/go-chi/chi/middleware#ThrottleBacklog
-[ThrottleWithOpts]: https://pkg.go.dev/github.com/go-chi/chi/middleware#ThrottleWithOpts
-[Timeout]: https://pkg.go.dev/github.com/go-chi/chi/middleware#Timeout
-[URLFormat]: https://pkg.go.dev/github.com/go-chi/chi/middleware#URLFormat
-[WithLogEntry]: https://pkg.go.dev/github.com/go-chi/chi/middleware#WithLogEntry
-[WithValue]: https://pkg.go.dev/github.com/go-chi/chi/middleware#WithValue
-[Compressor]: https://pkg.go.dev/github.com/go-chi/chi/middleware#Compressor
-[DefaultLogFormatter]: https://pkg.go.dev/github.com/go-chi/chi/middleware#DefaultLogFormatter
-[EncoderFunc]: https://pkg.go.dev/github.com/go-chi/chi/middleware#EncoderFunc
-[HeaderRoute]: https://pkg.go.dev/github.com/go-chi/chi/middleware#HeaderRoute
-[HeaderRouter]: https://pkg.go.dev/github.com/go-chi/chi/middleware#HeaderRouter
-[LogEntry]: https://pkg.go.dev/github.com/go-chi/chi/middleware#LogEntry
-[LogFormatter]: https://pkg.go.dev/github.com/go-chi/chi/middleware#LogFormatter
-[LoggerInterface]: https://pkg.go.dev/github.com/go-chi/chi/middleware#LoggerInterface
-[ThrottleOpts]: https://pkg.go.dev/github.com/go-chi/chi/middleware#ThrottleOpts
-[WrapResponseWriter]: https://pkg.go.dev/github.com/go-chi/chi/middleware#WrapResponseWriter
-
-### Extra middlewares & packages
-
-Please see https://github.com/go-chi for additional packages.
-
---------------------------------------------------------------------------------------------------------------------
-| package                                            | description                                                 |
-|:---------------------------------------------------|:-------------------------------------------------------------
-| [cors](https://github.com/go-chi/cors)             | Cross-origin resource sharing (CORS)                        |
-| [docgen](https://github.com/go-chi/docgen)         | Print chi.Router routes at runtime                          |
-| [jwtauth](https://github.com/go-chi/jwtauth)       | JWT authentication                                          |
-| [hostrouter](https://github.com/go-chi/hostrouter) | Domain/host based request routing                           |
-| [httplog](https://github.com/go-chi/httplog)       | Small but powerful structured HTTP request logging          |
-| [httprate](https://github.com/go-chi/httprate)     | HTTP request rate limiter                                   |
-| [httptracer](https://github.com/go-chi/httptracer) | HTTP request performance tracing library                    |
-| [httpvcr](https://github.com/go-chi/httpvcr)       | Write deterministic tests for external sources              |
-| [stampede](https://github.com/go-chi/stampede)     | HTTP request coalescer                                      |
---------------------------------------------------------------------------------------------------------------------
-
-
-## context?
-
-`context` is a tiny pkg that provides simple interface to signal context across call stacks
-and goroutines. It was originally written by [Sameer Ajmani](https://github.com/Sajmani)
-and is available in stdlib since go1.7.
-
-Learn more at https://blog.golang.org/context
-
-and..
-* Docs: https://golang.org/pkg/context
-* Source: https://github.com/golang/go/tree/master/src/context
-
-
-## Benchmarks
-
-The benchmark suite: https://github.com/pkieltyka/go-http-routing-benchmark
-
-Results as of Nov 29, 2020 with Go 1.15.5 on Linux AMD 3950x
-
-```shell
-BenchmarkChi_Param          	3075895	        384 ns/op	      400 B/op      2 allocs/op
-BenchmarkChi_Param5         	2116603	        566 ns/op	      400 B/op      2 allocs/op
-BenchmarkChi_Param20        	 964117	       1227 ns/op	      400 B/op      2 allocs/op
-BenchmarkChi_ParamWrite     	2863413	        420 ns/op	      400 B/op      2 allocs/op
-BenchmarkChi_GithubStatic   	3045488	        395 ns/op	      400 B/op      2 allocs/op
-BenchmarkChi_GithubParam    	2204115	        540 ns/op	      400 B/op      2 allocs/op
-BenchmarkChi_GithubAll      	  10000	     113811 ns/op	    81203 B/op    406 allocs/op
-BenchmarkChi_GPlusStatic    	3337485	        359 ns/op	      400 B/op      2 allocs/op
-BenchmarkChi_GPlusParam     	2825853	        423 ns/op	      400 B/op      2 allocs/op
-BenchmarkChi_GPlus2Params   	2471697	        483 ns/op	      400 B/op      2 allocs/op
-BenchmarkChi_GPlusAll       	 194220	       5950 ns/op	     5200 B/op     26 allocs/op
-BenchmarkChi_ParseStatic    	3365324	        356 ns/op	      400 B/op      2 allocs/op
-BenchmarkChi_ParseParam     	2976614	        404 ns/op	      400 B/op      2 allocs/op
-BenchmarkChi_Parse2Params   	2638084	        439 ns/op	      400 B/op      2 allocs/op
-BenchmarkChi_ParseAll       	 109567	      11295 ns/op	    10400 B/op     52 allocs/op
-BenchmarkChi_StaticAll      	  16846	      71308 ns/op	    62802 B/op    314 allocs/op
-```
-
-Comparison with other routers: https://gist.github.com/pkieltyka/123032f12052520aaccab752bd3e78cc
-
-NOTE: the allocs in the benchmark above are from the calls to http.Request's
-`WithContext(context.Context)` method that clones the http.Request, sets the `Context()`
-on the duplicated (alloc'd) request and returns it the new request object. This is just
-how setting context on a request in Go works.
-
-
-## Go module support & note on chi's versioning
-
-* Go.mod support means we reset our versioning starting from v1.5 (see [CHANGELOG](https://github.com/go-chi/chi/blob/master/CHANGELOG.md#v150-2020-11-12---now-with-gomod-support))
-* All older tags are preserved, are backwards-compatible and will "just work" as they
-* Brand new systems can run `go get -u github.com/go-chi/chi` as normal, or `go get -u github.com/go-chi/chi@latest`
-to install chi, which will install v1.x+ built with go.mod support, starting from v1.5.0.
-* For existing projects who want to upgrade to the latest go.mod version, run: `go get -u github.com/go-chi/chi@v1.5.0`,
-which will get you on the go.mod version line (as Go's mod cache may still remember v4.x).
-* Any breaking changes will bump a "minor" release and backwards-compatible improvements/fixes will bump a "tiny" release.
-
-
-## Credits
-
-* Carl Jackson for https://github.com/zenazn/goji
-  * Parts of chi's thinking comes from goji, and chi's middleware package
-    sources from goji.
-* Armon Dadgar for https://github.com/armon/go-radix
-* Contributions: [@VojtechVitek](https://github.com/VojtechVitek)
-
-We'll be more than happy to see [your contributions](./CONTRIBUTING.md)!
-
-
-## Beyond REST
-
-chi is just a http router that lets you decompose request handling into many smaller layers.
-Many companies use chi to write REST services for their public APIs. But, REST is just a convention
-for managing state via HTTP, and there's a lot of other pieces required to write a complete client-server
-system or network of microservices.
-
-Looking beyond REST, I also recommend some newer works in the field:
-* [webrpc](https://github.com/webrpc/webrpc) - Web-focused RPC client+server framework with code-gen
-* [gRPC](https://github.com/grpc/grpc-go) - Google's RPC framework via protobufs
-* [graphql](https://github.com/99designs/gqlgen) - Declarative query language
-* [NATS](https://nats.io) - lightweight pub-sub
-
-
-## License
-
-Copyright (c) 2015-present [Peter Kieltyka](https://github.com/pkieltyka)
-
-Licensed under [MIT License](./LICENSE)
-
-[GoDoc]: https://pkg.go.dev/github.com/go-chi/chi?tab=versions
-[GoDoc Widget]: https://godoc.org/github.com/go-chi/chi?status.svg
-[Travis]: https://travis-ci.org/go-chi/chi
-[Travis Widget]: https://travis-ci.org/go-chi/chi.svg?branch=master
diff --git a/vendor/github.com/go-chi/chi/chain.go b/vendor/github.com/go-chi/chi/chain.go
deleted file mode 100644
index 88e6846138..0000000000
--- a/vendor/github.com/go-chi/chi/chain.go
+++ /dev/null
@@ -1,49 +0,0 @@
-package chi
-
-import "net/http"
-
-// Chain returns a Middlewares type from a slice of middleware handlers.
-func Chain(middlewares ...func(http.Handler) http.Handler) Middlewares {
-	return Middlewares(middlewares)
-}
-
-// Handler builds and returns a http.Handler from the chain of middlewares,
-// with `h http.Handler` as the final handler.
-func (mws Middlewares) Handler(h http.Handler) http.Handler {
-	return &ChainHandler{mws, h, chain(mws, h)}
-}
-
-// HandlerFunc builds and returns a http.Handler from the chain of middlewares,
-// with `h http.Handler` as the final handler.
-func (mws Middlewares) HandlerFunc(h http.HandlerFunc) http.Handler {
-	return &ChainHandler{mws, h, chain(mws, h)}
-}
-
-// ChainHandler is a http.Handler with support for handler composition and
-// execution.
-type ChainHandler struct {
-	Middlewares Middlewares
-	Endpoint    http.Handler
-	chain       http.Handler
-}
-
-func (c *ChainHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	c.chain.ServeHTTP(w, r)
-}
-
-// chain builds a http.Handler composed of an inline middleware stack and endpoint
-// handler in the order they are passed.
-func chain(middlewares []func(http.Handler) http.Handler, endpoint http.Handler) http.Handler {
-	// Return ahead of time if there aren't any middlewares for the chain
-	if len(middlewares) == 0 {
-		return endpoint
-	}
-
-	// Wrap the end handler with the middleware chain
-	h := middlewares[len(middlewares)-1](endpoint)
-	for i := len(middlewares) - 2; i >= 0; i-- {
-		h = middlewares[i](h)
-	}
-
-	return h
-}
diff --git a/vendor/github.com/go-chi/chi/chi.go b/vendor/github.com/go-chi/chi/chi.go
deleted file mode 100644
index b7063dc297..0000000000
--- a/vendor/github.com/go-chi/chi/chi.go
+++ /dev/null
@@ -1,134 +0,0 @@
-//
-// Package chi is a small, idiomatic and composable router for building HTTP services.
-//
-// chi requires Go 1.10 or newer.
-//
-// Example:
-//  package main
-//
-//  import (
-//  	"net/http"
-//
-//  	"github.com/go-chi/chi"
-//  	"github.com/go-chi/chi/middleware"
-//  )
-//
-//  func main() {
-//  	r := chi.NewRouter()
-//  	r.Use(middleware.Logger)
-//  	r.Use(middleware.Recoverer)
-//
-//  	r.Get("/", func(w http.ResponseWriter, r *http.Request) {
-//  		w.Write([]byte("root."))
-//  	})
-//
-//  	http.ListenAndServe(":3333", r)
-//  }
-//
-// See github.com/go-chi/chi/_examples/ for more in-depth examples.
-//
-// URL patterns allow for easy matching of path components in HTTP
-// requests. The matching components can then be accessed using
-// chi.URLParam(). All patterns must begin with a slash.
-//
-// A simple named placeholder {name} matches any sequence of characters
-// up to the next / or the end of the URL. Trailing slashes on paths must
-// be handled explicitly.
-//
-// A placeholder with a name followed by a colon allows a regular
-// expression match, for example {number:\\d+}. The regular expression
-// syntax is Go's normal regexp RE2 syntax, except that regular expressions
-// including { or } are not supported, and / will never be
-// matched. An anonymous regexp pattern is allowed, using an empty string
-// before the colon in the placeholder, such as {:\\d+}
-//
-// The special placeholder of asterisk matches the rest of the requested
-// URL. Any trailing characters in the pattern are ignored. This is the only
-// placeholder which will match / characters.
-//
-// Examples:
-//  "/user/{name}" matches "/user/jsmith" but not "/user/jsmith/info" or "/user/jsmith/"
-//  "/user/{name}/info" matches "/user/jsmith/info"
-//  "/page/*" matches "/page/intro/latest"
-//  "/page/*/index" also matches "/page/intro/latest"
-//  "/date/{yyyy:\\d\\d\\d\\d}/{mm:\\d\\d}/{dd:\\d\\d}" matches "/date/2017/04/01"
-//
-package chi
-
-import "net/http"
-
-// NewRouter returns a new Mux object that implements the Router interface.
-func NewRouter() *Mux {
-	return NewMux()
-}
-
-// Router consisting of the core routing methods used by chi's Mux,
-// using only the standard net/http.
-type Router interface {
-	http.Handler
-	Routes
-
-	// Use appends one or more middlewares onto the Router stack.
-	Use(middlewares ...func(http.Handler) http.Handler)
-
-	// With adds inline middlewares for an endpoint handler.
-	With(middlewares ...func(http.Handler) http.Handler) Router
-
-	// Group adds a new inline-Router along the current routing
-	// path, with a fresh middleware stack for the inline-Router.
-	Group(fn func(r Router)) Router
-
-	// Route mounts a sub-Router along a `pattern`` string.
-	Route(pattern string, fn func(r Router)) Router
-
-	// Mount attaches another http.Handler along ./pattern/*
-	Mount(pattern string, h http.Handler)
-
-	// Handle and HandleFunc adds routes for `pattern` that matches
-	// all HTTP methods.
-	Handle(pattern string, h http.Handler)
-	HandleFunc(pattern string, h http.HandlerFunc)
-
-	// Method and MethodFunc adds routes for `pattern` that matches
-	// the `method` HTTP method.
-	Method(method, pattern string, h http.Handler)
-	MethodFunc(method, pattern string, h http.HandlerFunc)
-
-	// HTTP-method routing along `pattern`
-	Connect(pattern string, h http.HandlerFunc)
-	Delete(pattern string, h http.HandlerFunc)
-	Get(pattern string, h http.HandlerFunc)
-	Head(pattern string, h http.HandlerFunc)
-	Options(pattern string, h http.HandlerFunc)
-	Patch(pattern string, h http.HandlerFunc)
-	Post(pattern string, h http.HandlerFunc)
-	Put(pattern string, h http.HandlerFunc)
-	Trace(pattern string, h http.HandlerFunc)
-
-	// NotFound defines a handler to respond whenever a route could
-	// not be found.
-	NotFound(h http.HandlerFunc)
-
-	// MethodNotAllowed defines a handler to respond whenever a method is
-	// not allowed.
-	MethodNotAllowed(h http.HandlerFunc)
-}
-
-// Routes interface adds two methods for router traversal, which is also
-// used by the `docgen` subpackage to generation documentation for Routers.
-type Routes interface {
-	// Routes returns the routing tree in an easily traversable structure.
-	Routes() []Route
-
-	// Middlewares returns the list of middlewares in use by the router.
-	Middlewares() Middlewares
-
-	// Match searches the routing tree for a handler that matches
-	// the method/path - similar to routing a http request, but without
-	// executing the handler thereafter.
-	Match(rctx *Context, method, path string) bool
-}
-
-// Middlewares type is a slice of standard middleware handlers with methods
-// to compose middleware chains and http.Handler's.
-type Middlewares []func(http.Handler) http.Handler
diff --git a/vendor/github.com/go-chi/chi/context.go b/vendor/github.com/go-chi/chi/context.go
deleted file mode 100644
index 8c97f214a9..0000000000
--- a/vendor/github.com/go-chi/chi/context.go
+++ /dev/null
@@ -1,157 +0,0 @@
-package chi
-
-import (
-	"context"
-	"net/http"
-	"strings"
-)
-
-// URLParam returns the url parameter from a http.Request object.
-func URLParam(r *http.Request, key string) string {
-	if rctx := RouteContext(r.Context()); rctx != nil {
-		return rctx.URLParam(key)
-	}
-	return ""
-}
-
-// URLParamFromCtx returns the url parameter from a http.Request Context.
-func URLParamFromCtx(ctx context.Context, key string) string {
-	if rctx := RouteContext(ctx); rctx != nil {
-		return rctx.URLParam(key)
-	}
-	return ""
-}
-
-// RouteContext returns chi's routing Context object from a
-// http.Request Context.
-func RouteContext(ctx context.Context) *Context {
-	val, _ := ctx.Value(RouteCtxKey).(*Context)
-	return val
-}
-
-// NewRouteContext returns a new routing Context object.
-func NewRouteContext() *Context {
-	return &Context{}
-}
-
-var (
-	// RouteCtxKey is the context.Context key to store the request context.
-	RouteCtxKey = &contextKey{"RouteContext"}
-)
-
-// Context is the default routing context set on the root node of a
-// request context to track route patterns, URL parameters and
-// an optional routing path.
-type Context struct {
-	Routes Routes
-
-	// Routing path/method override used during the route search.
-	// See Mux#routeHTTP method.
-	RoutePath   string
-	RouteMethod string
-
-	// Routing pattern stack throughout the lifecycle of the request,
-	// across all connected routers. It is a record of all matching
-	// patterns across a stack of sub-routers.
-	RoutePatterns []string
-
-	// URLParams are the stack of routeParams captured during the
-	// routing lifecycle across a stack of sub-routers.
-	URLParams RouteParams
-
-	// The endpoint routing pattern that matched the request URI path
-	// or `RoutePath` of the current sub-router. This value will update
-	// during the lifecycle of a request passing through a stack of
-	// sub-routers.
-	routePattern string
-
-	// Route parameters matched for the current sub-router. It is
-	// intentionally unexported so it cant be tampered.
-	routeParams RouteParams
-
-	// methodNotAllowed hint
-	methodNotAllowed bool
-
-	// parentCtx is the parent of this one, for using Context as a
-	// context.Context directly. This is an optimization that saves
-	// 1 allocation.
-	parentCtx context.Context
-}
-
-// Reset a routing context to its initial state.
-func (x *Context) Reset() {
-	x.Routes = nil
-	x.RoutePath = ""
-	x.RouteMethod = ""
-	x.RoutePatterns = x.RoutePatterns[:0]
-	x.URLParams.Keys = x.URLParams.Keys[:0]
-	x.URLParams.Values = x.URLParams.Values[:0]
-
-	x.routePattern = ""
-	x.routeParams.Keys = x.routeParams.Keys[:0]
-	x.routeParams.Values = x.routeParams.Values[:0]
-	x.methodNotAllowed = false
-	x.parentCtx = nil
-}
-
-// URLParam returns the corresponding URL parameter value from the request
-// routing context.
-func (x *Context) URLParam(key string) string {
-	for k := len(x.URLParams.Keys) - 1; k >= 0; k-- {
-		if x.URLParams.Keys[k] == key {
-			return x.URLParams.Values[k]
-		}
-	}
-	return ""
-}
-
-// RoutePattern builds the routing pattern string for the particular
-// request, at the particular point during routing. This means, the value
-// will change throughout the execution of a request in a router. That is
-// why its advised to only use this value after calling the next handler.
-//
-// For example,
-//
-//   func Instrument(next http.Handler) http.Handler {
-//     return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-//       next.ServeHTTP(w, r)
-//       routePattern := chi.RouteContext(r.Context()).RoutePattern()
-//       measure(w, r, routePattern)
-//   	 })
-//   }
-func (x *Context) RoutePattern() string {
-	routePattern := strings.Join(x.RoutePatterns, "")
-	return replaceWildcards(routePattern)
-}
-
-// replaceWildcards takes a route pattern and recursively replaces all
-// occurrences of "/*/" to "/".
-func replaceWildcards(p string) string {
-	if strings.Contains(p, "/*/") {
-		return replaceWildcards(strings.Replace(p, "/*/", "/", -1))
-	}
-
-	return p
-}
-
-// RouteParams is a structure to track URL routing parameters efficiently.
-type RouteParams struct {
-	Keys, Values []string
-}
-
-// Add will append a URL parameter to the end of the route param
-func (s *RouteParams) Add(key, value string) {
-	s.Keys = append(s.Keys, key)
-	s.Values = append(s.Values, value)
-}
-
-// contextKey is a value for use with context.WithValue. It's used as
-// a pointer so it fits in an interface{} without allocation. This technique
-// for defining context keys was copied from Go 1.7's new use of context in net/http.
-type contextKey struct {
-	name string
-}
-
-func (k *contextKey) String() string {
-	return "chi context value " + k.name
-}
diff --git a/vendor/github.com/go-chi/chi/go.mod b/vendor/github.com/go-chi/chi/go.mod
deleted file mode 100644
index 769b90190a..0000000000
--- a/vendor/github.com/go-chi/chi/go.mod
+++ /dev/null
@@ -1,3 +0,0 @@
-module github.com/go-chi/chi
-
-go 1.16
diff --git a/vendor/github.com/go-chi/chi/mux.go b/vendor/github.com/go-chi/chi/mux.go
deleted file mode 100644
index 146643b04c..0000000000
--- a/vendor/github.com/go-chi/chi/mux.go
+++ /dev/null
@@ -1,479 +0,0 @@
-package chi
-
-import (
-	"context"
-	"fmt"
-	"net/http"
-	"strings"
-	"sync"
-)
-
-var _ Router = &Mux{}
-
-// Mux is a simple HTTP route multiplexer that parses a request path,
-// records any URL params, and executes an end handler. It implements
-// the http.Handler interface and is friendly with the standard library.
-//
-// Mux is designed to be fast, minimal and offer a powerful API for building
-// modular and composable HTTP services with a large set of handlers. It's
-// particularly useful for writing large REST API services that break a handler
-// into many smaller parts composed of middlewares and end handlers.
-type Mux struct {
-	// The radix trie router
-	tree *node
-
-	// The middleware stack
-	middlewares []func(http.Handler) http.Handler
-
-	// Controls the behaviour of middleware chain generation when a mux
-	// is registered as an inline group inside another mux.
-	inline bool
-	parent *Mux
-
-	// The computed mux handler made of the chained middleware stack and
-	// the tree router
-	handler http.Handler
-
-	// Routing context pool
-	pool *sync.Pool
-
-	// Custom route not found handler
-	notFoundHandler http.HandlerFunc
-
-	// Custom method not allowed handler
-	methodNotAllowedHandler http.HandlerFunc
-}
-
-// NewMux returns a newly initialized Mux object that implements the Router
-// interface.
-func NewMux() *Mux {
-	mux := &Mux{tree: &node{}, pool: &sync.Pool{}}
-	mux.pool.New = func() interface{} {
-		return NewRouteContext()
-	}
-	return mux
-}
-
-// ServeHTTP is the single method of the http.Handler interface that makes
-// Mux interoperable with the standard library. It uses a sync.Pool to get and
-// reuse routing contexts for each request.
-func (mx *Mux) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	// Ensure the mux has some routes defined on the mux
-	if mx.handler == nil {
-		mx.NotFoundHandler().ServeHTTP(w, r)
-		return
-	}
-
-	// Check if a routing context already exists from a parent router.
-	rctx, _ := r.Context().Value(RouteCtxKey).(*Context)
-	if rctx != nil {
-		mx.handler.ServeHTTP(w, r)
-		return
-	}
-
-	// Fetch a RouteContext object from the sync pool, and call the computed
-	// mx.handler that is comprised of mx.middlewares + mx.routeHTTP.
-	// Once the request is finished, reset the routing context and put it back
-	// into the pool for reuse from another request.
-	rctx = mx.pool.Get().(*Context)
-	rctx.Reset()
-	rctx.Routes = mx
-	rctx.parentCtx = r.Context()
-
-	// NOTE: r.WithContext() causes 2 allocations and context.WithValue() causes 1 allocation
-	r = r.WithContext(context.WithValue(r.Context(), RouteCtxKey, rctx))
-
-	// Serve the request and once its done, put the request context back in the sync pool
-	mx.handler.ServeHTTP(w, r)
-	mx.pool.Put(rctx)
-}
-
-// Use appends a middleware handler to the Mux middleware stack.
-//
-// The middleware stack for any Mux will execute before searching for a matching
-// route to a specific handler, which provides opportunity to respond early,
-// change the course of the request execution, or set request-scoped values for
-// the next http.Handler.
-func (mx *Mux) Use(middlewares ...func(http.Handler) http.Handler) {
-	if mx.handler != nil {
-		panic("chi: all middlewares must be defined before routes on a mux")
-	}
-	mx.middlewares = append(mx.middlewares, middlewares...)
-}
-
-// Handle adds the route `pattern` that matches any http method to
-// execute the `handler` http.Handler.
-func (mx *Mux) Handle(pattern string, handler http.Handler) {
-	mx.handle(mALL, pattern, handler)
-}
-
-// HandleFunc adds the route `pattern` that matches any http method to
-// execute the `handlerFn` http.HandlerFunc.
-func (mx *Mux) HandleFunc(pattern string, handlerFn http.HandlerFunc) {
-	mx.handle(mALL, pattern, handlerFn)
-}
-
-// Method adds the route `pattern` that matches `method` http method to
-// execute the `handler` http.Handler.
-func (mx *Mux) Method(method, pattern string, handler http.Handler) {
-	m, ok := methodMap[strings.ToUpper(method)]
-	if !ok {
-		panic(fmt.Sprintf("chi: '%s' http method is not supported.", method))
-	}
-	mx.handle(m, pattern, handler)
-}
-
-// MethodFunc adds the route `pattern` that matches `method` http method to
-// execute the `handlerFn` http.HandlerFunc.
-func (mx *Mux) MethodFunc(method, pattern string, handlerFn http.HandlerFunc) {
-	mx.Method(method, pattern, handlerFn)
-}
-
-// Connect adds the route `pattern` that matches a CONNECT http method to
-// execute the `handlerFn` http.HandlerFunc.
-func (mx *Mux) Connect(pattern string, handlerFn http.HandlerFunc) {
-	mx.handle(mCONNECT, pattern, handlerFn)
-}
-
-// Delete adds the route `pattern` that matches a DELETE http method to
-// execute the `handlerFn` http.HandlerFunc.
-func (mx *Mux) Delete(pattern string, handlerFn http.HandlerFunc) {
-	mx.handle(mDELETE, pattern, handlerFn)
-}
-
-// Get adds the route `pattern` that matches a GET http method to
-// execute the `handlerFn` http.HandlerFunc.
-func (mx *Mux) Get(pattern string, handlerFn http.HandlerFunc) {
-	mx.handle(mGET, pattern, handlerFn)
-}
-
-// Head adds the route `pattern` that matches a HEAD http method to
-// execute the `handlerFn` http.HandlerFunc.
-func (mx *Mux) Head(pattern string, handlerFn http.HandlerFunc) {
-	mx.handle(mHEAD, pattern, handlerFn)
-}
-
-// Options adds the route `pattern` that matches a OPTIONS http method to
-// execute the `handlerFn` http.HandlerFunc.
-func (mx *Mux) Options(pattern string, handlerFn http.HandlerFunc) {
-	mx.handle(mOPTIONS, pattern, handlerFn)
-}
-
-// Patch adds the route `pattern` that matches a PATCH http method to
-// execute the `handlerFn` http.HandlerFunc.
-func (mx *Mux) Patch(pattern string, handlerFn http.HandlerFunc) {
-	mx.handle(mPATCH, pattern, handlerFn)
-}
-
-// Post adds the route `pattern` that matches a POST http method to
-// execute the `handlerFn` http.HandlerFunc.
-func (mx *Mux) Post(pattern string, handlerFn http.HandlerFunc) {
-	mx.handle(mPOST, pattern, handlerFn)
-}
-
-// Put adds the route `pattern` that matches a PUT http method to
-// execute the `handlerFn` http.HandlerFunc.
-func (mx *Mux) Put(pattern string, handlerFn http.HandlerFunc) {
-	mx.handle(mPUT, pattern, handlerFn)
-}
-
-// Trace adds the route `pattern` that matches a TRACE http method to
-// execute the `handlerFn` http.HandlerFunc.
-func (mx *Mux) Trace(pattern string, handlerFn http.HandlerFunc) {
-	mx.handle(mTRACE, pattern, handlerFn)
-}
-
-// NotFound sets a custom http.HandlerFunc for routing paths that could
-// not be found. The default 404 handler is `http.NotFound`.
-func (mx *Mux) NotFound(handlerFn http.HandlerFunc) {
-	// Build NotFound handler chain
-	m := mx
-	h := Chain(mx.middlewares...).HandlerFunc(handlerFn).ServeHTTP
-	if mx.inline && mx.parent != nil {
-		m = mx.parent
-	}
-
-	// Update the notFoundHandler from this point forward
-	m.notFoundHandler = h
-	m.updateSubRoutes(func(subMux *Mux) {
-		if subMux.notFoundHandler == nil {
-			subMux.NotFound(h)
-		}
-	})
-}
-
-// MethodNotAllowed sets a custom http.HandlerFunc for routing paths where the
-// method is unresolved. The default handler returns a 405 with an empty body.
-func (mx *Mux) MethodNotAllowed(handlerFn http.HandlerFunc) {
-	// Build MethodNotAllowed handler chain
-	m := mx
-	h := Chain(mx.middlewares...).HandlerFunc(handlerFn).ServeHTTP
-	if mx.inline && mx.parent != nil {
-		m = mx.parent
-	}
-
-	// Update the methodNotAllowedHandler from this point forward
-	m.methodNotAllowedHandler = h
-	m.updateSubRoutes(func(subMux *Mux) {
-		if subMux.methodNotAllowedHandler == nil {
-			subMux.MethodNotAllowed(h)
-		}
-	})
-}
-
-// With adds inline middlewares for an endpoint handler.
-func (mx *Mux) With(middlewares ...func(http.Handler) http.Handler) Router {
-	// Similarly as in handle(), we must build the mux handler once additional
-	// middleware registration isn't allowed for this stack, like now.
-	if !mx.inline && mx.handler == nil {
-		mx.updateRouteHandler()
-	}
-
-	// Copy middlewares from parent inline muxs
-	var mws Middlewares
-	if mx.inline {
-		mws = make(Middlewares, len(mx.middlewares))
-		copy(mws, mx.middlewares)
-	}
-	mws = append(mws, middlewares...)
-
-	im := &Mux{
-		pool: mx.pool, inline: true, parent: mx, tree: mx.tree, middlewares: mws,
-		notFoundHandler: mx.notFoundHandler, methodNotAllowedHandler: mx.methodNotAllowedHandler,
-	}
-
-	return im
-}
-
-// Group creates a new inline-Mux with a fresh middleware stack. It's useful
-// for a group of handlers along the same routing path that use an additional
-// set of middlewares. See _examples/.
-func (mx *Mux) Group(fn func(r Router)) Router {
-	im := mx.With().(*Mux)
-	if fn != nil {
-		fn(im)
-	}
-	return im
-}
-
-// Route creates a new Mux with a fresh middleware stack and mounts it
-// along the `pattern` as a subrouter. Effectively, this is a short-hand
-// call to Mount. See _examples/.
-func (mx *Mux) Route(pattern string, fn func(r Router)) Router {
-	if fn == nil {
-		panic(fmt.Sprintf("chi: attempting to Route() a nil subrouter on '%s'", pattern))
-	}
-	subRouter := NewRouter()
-	fn(subRouter)
-	mx.Mount(pattern, subRouter)
-	return subRouter
-}
-
-// Mount attaches another http.Handler or chi Router as a subrouter along a routing
-// path. It's very useful to split up a large API as many independent routers and
-// compose them as a single service using Mount. See _examples/.
-//
-// Note that Mount() simply sets a wildcard along the `pattern` that will continue
-// routing at the `handler`, which in most cases is another chi.Router. As a result,
-// if you define two Mount() routes on the exact same pattern the mount will panic.
-func (mx *Mux) Mount(pattern string, handler http.Handler) {
-	if handler == nil {
-		panic(fmt.Sprintf("chi: attempting to Mount() a nil handler on '%s'", pattern))
-	}
-
-	// Provide runtime safety for ensuring a pattern isn't mounted on an existing
-	// routing pattern.
-	if mx.tree.findPattern(pattern+"*") || mx.tree.findPattern(pattern+"/*") {
-		panic(fmt.Sprintf("chi: attempting to Mount() a handler on an existing path, '%s'", pattern))
-	}
-
-	// Assign sub-Router's with the parent not found & method not allowed handler if not specified.
-	subr, ok := handler.(*Mux)
-	if ok && subr.notFoundHandler == nil && mx.notFoundHandler != nil {
-		subr.NotFound(mx.notFoundHandler)
-	}
-	if ok && subr.methodNotAllowedHandler == nil && mx.methodNotAllowedHandler != nil {
-		subr.MethodNotAllowed(mx.methodNotAllowedHandler)
-	}
-
-	mountHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		rctx := RouteContext(r.Context())
-
-		// shift the url path past the previous subrouter
-		rctx.RoutePath = mx.nextRoutePath(rctx)
-
-		// reset the wildcard URLParam which connects the subrouter
-		n := len(rctx.URLParams.Keys) - 1
-		if n >= 0 && rctx.URLParams.Keys[n] == "*" && len(rctx.URLParams.Values) > n {
-			rctx.URLParams.Values[n] = ""
-		}
-
-		handler.ServeHTTP(w, r)
-	})
-
-	if pattern == "" || pattern[len(pattern)-1] != '/' {
-		mx.handle(mALL|mSTUB, pattern, mountHandler)
-		mx.handle(mALL|mSTUB, pattern+"/", mountHandler)
-		pattern += "/"
-	}
-
-	method := mALL
-	subroutes, _ := handler.(Routes)
-	if subroutes != nil {
-		method |= mSTUB
-	}
-	n := mx.handle(method, pattern+"*", mountHandler)
-
-	if subroutes != nil {
-		n.subroutes = subroutes
-	}
-}
-
-// Routes returns a slice of routing information from the tree,
-// useful for traversing available routes of a router.
-func (mx *Mux) Routes() []Route {
-	return mx.tree.routes()
-}
-
-// Middlewares returns a slice of middleware handler functions.
-func (mx *Mux) Middlewares() Middlewares {
-	return mx.middlewares
-}
-
-// Match searches the routing tree for a handler that matches the method/path.
-// It's similar to routing a http request, but without executing the handler
-// thereafter.
-//
-// Note: the *Context state is updated during execution, so manage
-// the state carefully or make a NewRouteContext().
-func (mx *Mux) Match(rctx *Context, method, path string) bool {
-	m, ok := methodMap[method]
-	if !ok {
-		return false
-	}
-
-	node, _, h := mx.tree.FindRoute(rctx, m, path)
-
-	if node != nil && node.subroutes != nil {
-		rctx.RoutePath = mx.nextRoutePath(rctx)
-		return node.subroutes.Match(rctx, method, rctx.RoutePath)
-	}
-
-	return h != nil
-}
-
-// NotFoundHandler returns the default Mux 404 responder whenever a route
-// cannot be found.
-func (mx *Mux) NotFoundHandler() http.HandlerFunc {
-	if mx.notFoundHandler != nil {
-		return mx.notFoundHandler
-	}
-	return http.NotFound
-}
-
-// MethodNotAllowedHandler returns the default Mux 405 responder whenever
-// a method cannot be resolved for a route.
-func (mx *Mux) MethodNotAllowedHandler() http.HandlerFunc {
-	if mx.methodNotAllowedHandler != nil {
-		return mx.methodNotAllowedHandler
-	}
-	return methodNotAllowedHandler
-}
-
-// handle registers a http.Handler in the routing tree for a particular http method
-// and routing pattern.
-func (mx *Mux) handle(method methodTyp, pattern string, handler http.Handler) *node {
-	if len(pattern) == 0 || pattern[0] != '/' {
-		panic(fmt.Sprintf("chi: routing pattern must begin with '/' in '%s'", pattern))
-	}
-
-	// Build the computed routing handler for this routing pattern.
-	if !mx.inline && mx.handler == nil {
-		mx.updateRouteHandler()
-	}
-
-	// Build endpoint handler with inline middlewares for the route
-	var h http.Handler
-	if mx.inline {
-		mx.handler = http.HandlerFunc(mx.routeHTTP)
-		h = Chain(mx.middlewares...).Handler(handler)
-	} else {
-		h = handler
-	}
-
-	// Add the endpoint to the tree and return the node
-	return mx.tree.InsertRoute(method, pattern, h)
-}
-
-// routeHTTP routes a http.Request through the Mux routing tree to serve
-// the matching handler for a particular http method.
-func (mx *Mux) routeHTTP(w http.ResponseWriter, r *http.Request) {
-	// Grab the route context object
-	rctx := r.Context().Value(RouteCtxKey).(*Context)
-
-	// The request routing path
-	routePath := rctx.RoutePath
-	if routePath == "" {
-		if r.URL.RawPath != "" {
-			routePath = r.URL.RawPath
-		} else {
-			routePath = r.URL.Path
-		}
-	}
-
-	// Check if method is supported by chi
-	if rctx.RouteMethod == "" {
-		rctx.RouteMethod = r.Method
-	}
-	method, ok := methodMap[rctx.RouteMethod]
-	if !ok {
-		mx.MethodNotAllowedHandler().ServeHTTP(w, r)
-		return
-	}
-
-	// Find the route
-	if _, _, h := mx.tree.FindRoute(rctx, method, routePath); h != nil {
-		h.ServeHTTP(w, r)
-		return
-	}
-	if rctx.methodNotAllowed {
-		mx.MethodNotAllowedHandler().ServeHTTP(w, r)
-	} else {
-		mx.NotFoundHandler().ServeHTTP(w, r)
-	}
-}
-
-func (mx *Mux) nextRoutePath(rctx *Context) string {
-	routePath := "/"
-	nx := len(rctx.routeParams.Keys) - 1 // index of last param in list
-	if nx >= 0 && rctx.routeParams.Keys[nx] == "*" && len(rctx.routeParams.Values) > nx {
-		routePath = "/" + rctx.routeParams.Values[nx]
-	}
-	return routePath
-}
-
-// Recursively update data on child routers.
-func (mx *Mux) updateSubRoutes(fn func(subMux *Mux)) {
-	for _, r := range mx.tree.routes() {
-		subMux, ok := r.SubRoutes.(*Mux)
-		if !ok {
-			continue
-		}
-		fn(subMux)
-	}
-}
-
-// updateRouteHandler builds the single mux handler that is a chain of the middleware
-// stack, as defined by calls to Use(), and the tree router (Mux) itself. After this
-// point, no other middlewares can be registered on this Mux's stack. But you can still
-// compose additional middlewares via Group()'s or using a chained middleware handler.
-func (mx *Mux) updateRouteHandler() {
-	mx.handler = chain(mx.middlewares, http.HandlerFunc(mx.routeHTTP))
-}
-
-// methodNotAllowedHandler is a helper function to respond with a 405,
-// method not allowed.
-func methodNotAllowedHandler(w http.ResponseWriter, r *http.Request) {
-	w.WriteHeader(405)
-	w.Write(nil)
-}
diff --git a/vendor/github.com/go-chi/chi/tree.go b/vendor/github.com/go-chi/chi/tree.go
deleted file mode 100644
index 8057c52813..0000000000
--- a/vendor/github.com/go-chi/chi/tree.go
+++ /dev/null
@@ -1,866 +0,0 @@
-package chi
-
-// Radix tree implementation below is a based on the original work by
-// Armon Dadgar in https://github.com/armon/go-radix/blob/master/radix.go
-// (MIT licensed). It's been heavily modified for use as a HTTP routing tree.
-
-import (
-	"fmt"
-	"net/http"
-	"regexp"
-	"sort"
-	"strconv"
-	"strings"
-)
-
-type methodTyp int
-
-const (
-	mSTUB methodTyp = 1 << iota
-	mCONNECT
-	mDELETE
-	mGET
-	mHEAD
-	mOPTIONS
-	mPATCH
-	mPOST
-	mPUT
-	mTRACE
-)
-
-var mALL = mCONNECT | mDELETE | mGET | mHEAD |
-	mOPTIONS | mPATCH | mPOST | mPUT | mTRACE
-
-var methodMap = map[string]methodTyp{
-	http.MethodConnect: mCONNECT,
-	http.MethodDelete:  mDELETE,
-	http.MethodGet:     mGET,
-	http.MethodHead:    mHEAD,
-	http.MethodOptions: mOPTIONS,
-	http.MethodPatch:   mPATCH,
-	http.MethodPost:    mPOST,
-	http.MethodPut:     mPUT,
-	http.MethodTrace:   mTRACE,
-}
-
-// RegisterMethod adds support for custom HTTP method handlers, available
-// via Router#Method and Router#MethodFunc
-func RegisterMethod(method string) {
-	if method == "" {
-		return
-	}
-	method = strings.ToUpper(method)
-	if _, ok := methodMap[method]; ok {
-		return
-	}
-	n := len(methodMap)
-	if n > strconv.IntSize-2 {
-		panic(fmt.Sprintf("chi: max number of methods reached (%d)", strconv.IntSize))
-	}
-	mt := methodTyp(2 << n)
-	methodMap[method] = mt
-	mALL |= mt
-}
-
-type nodeTyp uint8
-
-const (
-	ntStatic   nodeTyp = iota // /home
-	ntRegexp                  // /{id:[0-9]+}
-	ntParam                   // /{user}
-	ntCatchAll                // /api/v1/*
-)
-
-type node struct {
-	// node type: static, regexp, param, catchAll
-	typ nodeTyp
-
-	// first byte of the prefix
-	label byte
-
-	// first byte of the child prefix
-	tail byte
-
-	// prefix is the common prefix we ignore
-	prefix string
-
-	// regexp matcher for regexp nodes
-	rex *regexp.Regexp
-
-	// HTTP handler endpoints on the leaf node
-	endpoints endpoints
-
-	// subroutes on the leaf node
-	subroutes Routes
-
-	// child nodes should be stored in-order for iteration,
-	// in groups of the node type.
-	children [ntCatchAll + 1]nodes
-}
-
-// endpoints is a mapping of http method constants to handlers
-// for a given route.
-type endpoints map[methodTyp]*endpoint
-
-type endpoint struct {
-	// endpoint handler
-	handler http.Handler
-
-	// pattern is the routing pattern for handler nodes
-	pattern string
-
-	// parameter keys recorded on handler nodes
-	paramKeys []string
-}
-
-func (s endpoints) Value(method methodTyp) *endpoint {
-	mh, ok := s[method]
-	if !ok {
-		mh = &endpoint{}
-		s[method] = mh
-	}
-	return mh
-}
-
-func (n *node) InsertRoute(method methodTyp, pattern string, handler http.Handler) *node {
-	var parent *node
-	search := pattern
-
-	for {
-		// Handle key exhaustion
-		if len(search) == 0 {
-			// Insert or update the node's leaf handler
-			n.setEndpoint(method, handler, pattern)
-			return n
-		}
-
-		// We're going to be searching for a wild node next,
-		// in this case, we need to get the tail
-		var label = search[0]
-		var segTail byte
-		var segEndIdx int
-		var segTyp nodeTyp
-		var segRexpat string
-		if label == '{' || label == '*' {
-			segTyp, _, segRexpat, segTail, _, segEndIdx = patNextSegment(search)
-		}
-
-		var prefix string
-		if segTyp == ntRegexp {
-			prefix = segRexpat
-		}
-
-		// Look for the edge to attach to
-		parent = n
-		n = n.getEdge(segTyp, label, segTail, prefix)
-
-		// No edge, create one
-		if n == nil {
-			child := &node{label: label, tail: segTail, prefix: search}
-			hn := parent.addChild(child, search)
-			hn.setEndpoint(method, handler, pattern)
-
-			return hn
-		}
-
-		// Found an edge to match the pattern
-
-		if n.typ > ntStatic {
-			// We found a param node, trim the param from the search path and continue.
-			// This param/wild pattern segment would already be on the tree from a previous
-			// call to addChild when creating a new node.
-			search = search[segEndIdx:]
-			continue
-		}
-
-		// Static nodes fall below here.
-		// Determine longest prefix of the search key on match.
-		commonPrefix := longestPrefix(search, n.prefix)
-		if commonPrefix == len(n.prefix) {
-			// the common prefix is as long as the current node's prefix we're attempting to insert.
-			// keep the search going.
-			search = search[commonPrefix:]
-			continue
-		}
-
-		// Split the node
-		child := &node{
-			typ:    ntStatic,
-			prefix: search[:commonPrefix],
-		}
-		parent.replaceChild(search[0], segTail, child)
-
-		// Restore the existing node
-		n.label = n.prefix[commonPrefix]
-		n.prefix = n.prefix[commonPrefix:]
-		child.addChild(n, n.prefix)
-
-		// If the new key is a subset, set the method/handler on this node and finish.
-		search = search[commonPrefix:]
-		if len(search) == 0 {
-			child.setEndpoint(method, handler, pattern)
-			return child
-		}
-
-		// Create a new edge for the node
-		subchild := &node{
-			typ:    ntStatic,
-			label:  search[0],
-			prefix: search,
-		}
-		hn := child.addChild(subchild, search)
-		hn.setEndpoint(method, handler, pattern)
-		return hn
-	}
-}
-
-// addChild appends the new `child` node to the tree using the `pattern` as the trie key.
-// For a URL router like chi's, we split the static, param, regexp and wildcard segments
-// into different nodes. In addition, addChild will recursively call itself until every
-// pattern segment is added to the url pattern tree as individual nodes, depending on type.
-func (n *node) addChild(child *node, prefix string) *node {
-	search := prefix
-
-	// handler leaf node added to the tree is the child.
-	// this may be overridden later down the flow
-	hn := child
-
-	// Parse next segment
-	segTyp, _, segRexpat, segTail, segStartIdx, segEndIdx := patNextSegment(search)
-
-	// Add child depending on next up segment
-	switch segTyp {
-
-	case ntStatic:
-		// Search prefix is all static (that is, has no params in path)
-		// noop
-
-	default:
-		// Search prefix contains a param, regexp or wildcard
-
-		if segTyp == ntRegexp {
-			rex, err := regexp.Compile(segRexpat)
-			if err != nil {
-				panic(fmt.Sprintf("chi: invalid regexp pattern '%s' in route param", segRexpat))
-			}
-			child.prefix = segRexpat
-			child.rex = rex
-		}
-
-		if segStartIdx == 0 {
-			// Route starts with a param
-			child.typ = segTyp
-
-			if segTyp == ntCatchAll {
-				segStartIdx = -1
-			} else {
-				segStartIdx = segEndIdx
-			}
-			if segStartIdx < 0 {
-				segStartIdx = len(search)
-			}
-			child.tail = segTail // for params, we set the tail
-
-			if segStartIdx != len(search) {
-				// add static edge for the remaining part, split the end.
-				// its not possible to have adjacent param nodes, so its certainly
-				// going to be a static node next.
-
-				search = search[segStartIdx:] // advance search position
-
-				nn := &node{
-					typ:    ntStatic,
-					label:  search[0],
-					prefix: search,
-				}
-				hn = child.addChild(nn, search)
-			}
-
-		} else if segStartIdx > 0 {
-			// Route has some param
-
-			// starts with a static segment
-			child.typ = ntStatic
-			child.prefix = search[:segStartIdx]
-			child.rex = nil
-
-			// add the param edge node
-			search = search[segStartIdx:]
-
-			nn := &node{
-				typ:   segTyp,
-				label: search[0],
-				tail:  segTail,
-			}
-			hn = child.addChild(nn, search)
-
-		}
-	}
-
-	n.children[child.typ] = append(n.children[child.typ], child)
-	n.children[child.typ].Sort()
-	return hn
-}
-
-func (n *node) replaceChild(label, tail byte, child *node) {
-	for i := 0; i < len(n.children[child.typ]); i++ {
-		if n.children[child.typ][i].label == label && n.children[child.typ][i].tail == tail {
-			n.children[child.typ][i] = child
-			n.children[child.typ][i].label = label
-			n.children[child.typ][i].tail = tail
-			return
-		}
-	}
-	panic("chi: replacing missing child")
-}
-
-func (n *node) getEdge(ntyp nodeTyp, label, tail byte, prefix string) *node {
-	nds := n.children[ntyp]
-	for i := 0; i < len(nds); i++ {
-		if nds[i].label == label && nds[i].tail == tail {
-			if ntyp == ntRegexp && nds[i].prefix != prefix {
-				continue
-			}
-			return nds[i]
-		}
-	}
-	return nil
-}
-
-func (n *node) setEndpoint(method methodTyp, handler http.Handler, pattern string) {
-	// Set the handler for the method type on the node
-	if n.endpoints == nil {
-		n.endpoints = make(endpoints)
-	}
-
-	paramKeys := patParamKeys(pattern)
-
-	if method&mSTUB == mSTUB {
-		n.endpoints.Value(mSTUB).handler = handler
-	}
-	if method&mALL == mALL {
-		h := n.endpoints.Value(mALL)
-		h.handler = handler
-		h.pattern = pattern
-		h.paramKeys = paramKeys
-		for _, m := range methodMap {
-			h := n.endpoints.Value(m)
-			h.handler = handler
-			h.pattern = pattern
-			h.paramKeys = paramKeys
-		}
-	} else {
-		h := n.endpoints.Value(method)
-		h.handler = handler
-		h.pattern = pattern
-		h.paramKeys = paramKeys
-	}
-}
-
-func (n *node) FindRoute(rctx *Context, method methodTyp, path string) (*node, endpoints, http.Handler) {
-	// Reset the context routing pattern and params
-	rctx.routePattern = ""
-	rctx.routeParams.Keys = rctx.routeParams.Keys[:0]
-	rctx.routeParams.Values = rctx.routeParams.Values[:0]
-
-	// Find the routing handlers for the path
-	rn := n.findRoute(rctx, method, path)
-	if rn == nil {
-		return nil, nil, nil
-	}
-
-	// Record the routing params in the request lifecycle
-	rctx.URLParams.Keys = append(rctx.URLParams.Keys, rctx.routeParams.Keys...)
-	rctx.URLParams.Values = append(rctx.URLParams.Values, rctx.routeParams.Values...)
-
-	// Record the routing pattern in the request lifecycle
-	if rn.endpoints[method].pattern != "" {
-		rctx.routePattern = rn.endpoints[method].pattern
-		rctx.RoutePatterns = append(rctx.RoutePatterns, rctx.routePattern)
-	}
-
-	return rn, rn.endpoints, rn.endpoints[method].handler
-}
-
-// Recursive edge traversal by checking all nodeTyp groups along the way.
-// It's like searching through a multi-dimensional radix trie.
-func (n *node) findRoute(rctx *Context, method methodTyp, path string) *node {
-	nn := n
-	search := path
-
-	for t, nds := range nn.children {
-		ntyp := nodeTyp(t)
-		if len(nds) == 0 {
-			continue
-		}
-
-		var xn *node
-		xsearch := search
-
-		var label byte
-		if search != "" {
-			label = search[0]
-		}
-
-		switch ntyp {
-		case ntStatic:
-			xn = nds.findEdge(label)
-			if xn == nil || !strings.HasPrefix(xsearch, xn.prefix) {
-				continue
-			}
-			xsearch = xsearch[len(xn.prefix):]
-
-		case ntParam, ntRegexp:
-			// short-circuit and return no matching route for empty param values
-			if xsearch == "" {
-				continue
-			}
-
-			// serially loop through each node grouped by the tail delimiter
-			for idx := 0; idx < len(nds); idx++ {
-				xn = nds[idx]
-
-				// label for param nodes is the delimiter byte
-				p := strings.IndexByte(xsearch, xn.tail)
-
-				if p < 0 {
-					if xn.tail == '/' {
-						p = len(xsearch)
-					} else {
-						continue
-					}
-				} else if ntyp == ntRegexp && p == 0 {
-					continue
-				}
-
-				if ntyp == ntRegexp && xn.rex != nil {
-					if !xn.rex.MatchString(xsearch[:p]) {
-						continue
-					}
-				} else if strings.IndexByte(xsearch[:p], '/') != -1 {
-					// avoid a match across path segments
-					continue
-				}
-
-				prevlen := len(rctx.routeParams.Values)
-				rctx.routeParams.Values = append(rctx.routeParams.Values, xsearch[:p])
-				xsearch = xsearch[p:]
-
-				if len(xsearch) == 0 {
-					if xn.isLeaf() {
-						h := xn.endpoints[method]
-						if h != nil && h.handler != nil {
-							rctx.routeParams.Keys = append(rctx.routeParams.Keys, h.paramKeys...)
-							return xn
-						}
-
-						// flag that the routing context found a route, but not a corresponding
-						// supported method
-						rctx.methodNotAllowed = true
-					}
-				}
-
-				// recursively find the next node on this branch
-				fin := xn.findRoute(rctx, method, xsearch)
-				if fin != nil {
-					return fin
-				}
-
-				// not found on this branch, reset vars
-				rctx.routeParams.Values = rctx.routeParams.Values[:prevlen]
-				xsearch = search
-			}
-
-			rctx.routeParams.Values = append(rctx.routeParams.Values, "")
-
-		default:
-			// catch-all nodes
-			rctx.routeParams.Values = append(rctx.routeParams.Values, search)
-			xn = nds[0]
-			xsearch = ""
-		}
-
-		if xn == nil {
-			continue
-		}
-
-		// did we find it yet?
-		if len(xsearch) == 0 {
-			if xn.isLeaf() {
-				h := xn.endpoints[method]
-				if h != nil && h.handler != nil {
-					rctx.routeParams.Keys = append(rctx.routeParams.Keys, h.paramKeys...)
-					return xn
-				}
-
-				// flag that the routing context found a route, but not a corresponding
-				// supported method
-				rctx.methodNotAllowed = true
-			}
-		}
-
-		// recursively find the next node..
-		fin := xn.findRoute(rctx, method, xsearch)
-		if fin != nil {
-			return fin
-		}
-
-		// Did not find final handler, let's remove the param here if it was set
-		if xn.typ > ntStatic {
-			if len(rctx.routeParams.Values) > 0 {
-				rctx.routeParams.Values = rctx.routeParams.Values[:len(rctx.routeParams.Values)-1]
-			}
-		}
-
-	}
-
-	return nil
-}
-
-func (n *node) findEdge(ntyp nodeTyp, label byte) *node {
-	nds := n.children[ntyp]
-	num := len(nds)
-	idx := 0
-
-	switch ntyp {
-	case ntStatic, ntParam, ntRegexp:
-		i, j := 0, num-1
-		for i <= j {
-			idx = i + (j-i)/2
-			if label > nds[idx].label {
-				i = idx + 1
-			} else if label < nds[idx].label {
-				j = idx - 1
-			} else {
-				i = num // breaks cond
-			}
-		}
-		if nds[idx].label != label {
-			return nil
-		}
-		return nds[idx]
-
-	default: // catch all
-		return nds[idx]
-	}
-}
-
-func (n *node) isLeaf() bool {
-	return n.endpoints != nil
-}
-
-func (n *node) findPattern(pattern string) bool {
-	nn := n
-	for _, nds := range nn.children {
-		if len(nds) == 0 {
-			continue
-		}
-
-		n = nn.findEdge(nds[0].typ, pattern[0])
-		if n == nil {
-			continue
-		}
-
-		var idx int
-		var xpattern string
-
-		switch n.typ {
-		case ntStatic:
-			idx = longestPrefix(pattern, n.prefix)
-			if idx < len(n.prefix) {
-				continue
-			}
-
-		case ntParam, ntRegexp:
-			idx = strings.IndexByte(pattern, '}') + 1
-
-		case ntCatchAll:
-			idx = longestPrefix(pattern, "*")
-
-		default:
-			panic("chi: unknown node type")
-		}
-
-		xpattern = pattern[idx:]
-		if len(xpattern) == 0 {
-			return true
-		}
-
-		return n.findPattern(xpattern)
-	}
-	return false
-}
-
-func (n *node) routes() []Route {
-	rts := []Route{}
-
-	n.walk(func(eps endpoints, subroutes Routes) bool {
-		if eps[mSTUB] != nil && eps[mSTUB].handler != nil && subroutes == nil {
-			return false
-		}
-
-		// Group methodHandlers by unique patterns
-		pats := make(map[string]endpoints)
-
-		for mt, h := range eps {
-			if h.pattern == "" {
-				continue
-			}
-			p, ok := pats[h.pattern]
-			if !ok {
-				p = endpoints{}
-				pats[h.pattern] = p
-			}
-			p[mt] = h
-		}
-
-		for p, mh := range pats {
-			hs := make(map[string]http.Handler)
-			if mh[mALL] != nil && mh[mALL].handler != nil {
-				hs["*"] = mh[mALL].handler
-			}
-
-			for mt, h := range mh {
-				if h.handler == nil {
-					continue
-				}
-				m := methodTypString(mt)
-				if m == "" {
-					continue
-				}
-				hs[m] = h.handler
-			}
-
-			rt := Route{p, hs, subroutes}
-			rts = append(rts, rt)
-		}
-
-		return false
-	})
-
-	return rts
-}
-
-func (n *node) walk(fn func(eps endpoints, subroutes Routes) bool) bool {
-	// Visit the leaf values if any
-	if (n.endpoints != nil || n.subroutes != nil) && fn(n.endpoints, n.subroutes) {
-		return true
-	}
-
-	// Recurse on the children
-	for _, ns := range n.children {
-		for _, cn := range ns {
-			if cn.walk(fn) {
-				return true
-			}
-		}
-	}
-	return false
-}
-
-// patNextSegment returns the next segment details from a pattern:
-// node type, param key, regexp string, param tail byte, param starting index, param ending index
-func patNextSegment(pattern string) (nodeTyp, string, string, byte, int, int) {
-	ps := strings.Index(pattern, "{")
-	ws := strings.Index(pattern, "*")
-
-	if ps < 0 && ws < 0 {
-		return ntStatic, "", "", 0, 0, len(pattern) // we return the entire thing
-	}
-
-	// Sanity check
-	if ps >= 0 && ws >= 0 && ws < ps {
-		panic("chi: wildcard '*' must be the last pattern in a route, otherwise use a '{param}'")
-	}
-
-	var tail byte = '/' // Default endpoint tail to / byte
-
-	if ps >= 0 {
-		// Param/Regexp pattern is next
-		nt := ntParam
-
-		// Read to closing } taking into account opens and closes in curl count (cc)
-		cc := 0
-		pe := ps
-		for i, c := range pattern[ps:] {
-			if c == '{' {
-				cc++
-			} else if c == '}' {
-				cc--
-				if cc == 0 {
-					pe = ps + i
-					break
-				}
-			}
-		}
-		if pe == ps {
-			panic("chi: route param closing delimiter '}' is missing")
-		}
-
-		key := pattern[ps+1 : pe]
-		pe++ // set end to next position
-
-		if pe < len(pattern) {
-			tail = pattern[pe]
-		}
-
-		var rexpat string
-		if idx := strings.Index(key, ":"); idx >= 0 {
-			nt = ntRegexp
-			rexpat = key[idx+1:]
-			key = key[:idx]
-		}
-
-		if len(rexpat) > 0 {
-			if rexpat[0] != '^' {
-				rexpat = "^" + rexpat
-			}
-			if rexpat[len(rexpat)-1] != '$' {
-				rexpat += "$"
-			}
-		}
-
-		return nt, key, rexpat, tail, ps, pe
-	}
-
-	// Wildcard pattern as finale
-	if ws < len(pattern)-1 {
-		panic("chi: wildcard '*' must be the last value in a route. trim trailing text or use a '{param}' instead")
-	}
-	return ntCatchAll, "*", "", 0, ws, len(pattern)
-}
-
-func patParamKeys(pattern string) []string {
-	pat := pattern
-	paramKeys := []string{}
-	for {
-		ptyp, paramKey, _, _, _, e := patNextSegment(pat)
-		if ptyp == ntStatic {
-			return paramKeys
-		}
-		for i := 0; i < len(paramKeys); i++ {
-			if paramKeys[i] == paramKey {
-				panic(fmt.Sprintf("chi: routing pattern '%s' contains duplicate param key, '%s'", pattern, paramKey))
-			}
-		}
-		paramKeys = append(paramKeys, paramKey)
-		pat = pat[e:]
-	}
-}
-
-// longestPrefix finds the length of the shared prefix
-// of two strings
-func longestPrefix(k1, k2 string) int {
-	max := len(k1)
-	if l := len(k2); l < max {
-		max = l
-	}
-	var i int
-	for i = 0; i < max; i++ {
-		if k1[i] != k2[i] {
-			break
-		}
-	}
-	return i
-}
-
-func methodTypString(method methodTyp) string {
-	for s, t := range methodMap {
-		if method == t {
-			return s
-		}
-	}
-	return ""
-}
-
-type nodes []*node
-
-// Sort the list of nodes by label
-func (ns nodes) Sort()              { sort.Sort(ns); ns.tailSort() }
-func (ns nodes) Len() int           { return len(ns) }
-func (ns nodes) Swap(i, j int)      { ns[i], ns[j] = ns[j], ns[i] }
-func (ns nodes) Less(i, j int) bool { return ns[i].label < ns[j].label }
-
-// tailSort pushes nodes with '/' as the tail to the end of the list for param nodes.
-// The list order determines the traversal order.
-func (ns nodes) tailSort() {
-	for i := len(ns) - 1; i >= 0; i-- {
-		if ns[i].typ > ntStatic && ns[i].tail == '/' {
-			ns.Swap(i, len(ns)-1)
-			return
-		}
-	}
-}
-
-func (ns nodes) findEdge(label byte) *node {
-	num := len(ns)
-	idx := 0
-	i, j := 0, num-1
-	for i <= j {
-		idx = i + (j-i)/2
-		if label > ns[idx].label {
-			i = idx + 1
-		} else if label < ns[idx].label {
-			j = idx - 1
-		} else {
-			i = num // breaks cond
-		}
-	}
-	if ns[idx].label != label {
-		return nil
-	}
-	return ns[idx]
-}
-
-// Route describes the details of a routing handler.
-// Handlers map key is an HTTP method
-type Route struct {
-	Pattern   string
-	Handlers  map[string]http.Handler
-	SubRoutes Routes
-}
-
-// WalkFunc is the type of the function called for each method and route visited by Walk.
-type WalkFunc func(method string, route string, handler http.Handler, middlewares ...func(http.Handler) http.Handler) error
-
-// Walk walks any router tree that implements Routes interface.
-func Walk(r Routes, walkFn WalkFunc) error {
-	return walk(r, walkFn, "")
-}
-
-func walk(r Routes, walkFn WalkFunc, parentRoute string, parentMw ...func(http.Handler) http.Handler) error {
-	for _, route := range r.Routes() {
-		mws := make([]func(http.Handler) http.Handler, len(parentMw))
-		copy(mws, parentMw)
-		mws = append(mws, r.Middlewares()...)
-
-		if route.SubRoutes != nil {
-			if err := walk(route.SubRoutes, walkFn, parentRoute+route.Pattern, mws...); err != nil {
-				return err
-			}
-			continue
-		}
-
-		for method, handler := range route.Handlers {
-			if method == "*" {
-				// Ignore a "catchAll" method, since we pass down all the specific methods for each route.
-				continue
-			}
-
-			fullRoute := parentRoute + route.Pattern
-			fullRoute = strings.Replace(fullRoute, "/*/", "/", -1)
-
-			if chain, ok := handler.(*ChainHandler); ok {
-				if err := walkFn(method, fullRoute, chain.Endpoint, append(mws, chain.Middlewares...)...); err != nil {
-					return err
-				}
-			} else {
-				if err := walkFn(method, fullRoute, handler, mws...); err != nil {
-					return err
-				}
-			}
-		}
-	}
-
-	return nil
-}
diff --git a/vendor/github.com/go-chi/chi/middleware/basic_auth.go b/vendor/github.com/go-chi/chi/v5/middleware/basic_auth.go
index a546c9e9e8..a546c9e9e8 100644
--- a/vendor/github.com/go-chi/chi/middleware/basic_auth.go
+++ b/vendor/github.com/go-chi/chi/v5/middleware/basic_auth.go
diff --git a/vendor/github.com/go-chi/chi/middleware/clean_path.go b/vendor/github.com/go-chi/chi/v5/middleware/clean_path.go
index d42bf28457..adeba42951 100644
--- a/vendor/github.com/go-chi/chi/middleware/clean_path.go
+++ b/vendor/github.com/go-chi/chi/v5/middleware/clean_path.go
@@ -4,7 +4,7 @@ import (
 	"net/http"
 	"path"
 
-	"github.com/go-chi/chi"
+	"github.com/go-chi/chi/v5"
 )
 
 // CleanPath middleware will clean out double slash mistakes from a user's request path.
diff --git a/vendor/github.com/go-chi/chi/middleware/compress.go b/vendor/github.com/go-chi/chi/v5/middleware/compress.go
index 2f40cc15af..75b56fd17e 100644
--- a/vendor/github.com/go-chi/chi/middleware/compress.go
+++ b/vendor/github.com/go-chi/chi/v5/middleware/compress.go
@@ -45,7 +45,6 @@ func Compress(level int, types ...string) func(next http.Handler) http.Handler {
 
 // Compressor represents a set of encoding configurations.
 type Compressor struct {
-	level int // The compression level.
 	// The mapping of encoder names to encoder functions.
 	encoders map[string]EncoderFunc
 	// The mapping of pooled encoders to pools.
@@ -55,6 +54,7 @@ type Compressor struct {
 	allowedWildcards map[string]struct{}
 	// The list of encoders in order of decreasing precedence.
 	encodingPrecedence []string
+	level              int // The compression level.
 }
 
 // NewCompressor creates a new Compressor that will handle encoding responses.
@@ -271,9 +271,9 @@ type compressResponseWriter struct {
 	// The streaming encoder writer to be used if there is one. Otherwise,
 	// this is just the normal writer.
 	w                io.Writer
-	encoding         string
 	contentTypes     map[string]struct{}
 	contentWildcards map[string]struct{}
+	encoding         string
 	wroteHeader      bool
 	compressable     bool
 }
diff --git a/vendor/github.com/go-chi/chi/middleware/content_charset.go b/vendor/github.com/go-chi/chi/v5/middleware/content_charset.go
index 07b5ce6f66..07b5ce6f66 100644
--- a/vendor/github.com/go-chi/chi/middleware/content_charset.go
+++ b/vendor/github.com/go-chi/chi/v5/middleware/content_charset.go
diff --git a/vendor/github.com/go-chi/chi/middleware/content_encoding.go b/vendor/github.com/go-chi/chi/v5/middleware/content_encoding.go
index e0b9ccc08a..e0b9ccc08a 100644
--- a/vendor/github.com/go-chi/chi/middleware/content_encoding.go
+++ b/vendor/github.com/go-chi/chi/v5/middleware/content_encoding.go
diff --git a/vendor/github.com/go-chi/chi/middleware/content_type.go b/vendor/github.com/go-chi/chi/v5/middleware/content_type.go
index 023978fac0..023978fac0 100644
--- a/vendor/github.com/go-chi/chi/middleware/content_type.go
+++ b/vendor/github.com/go-chi/chi/v5/middleware/content_type.go
diff --git a/vendor/github.com/go-chi/chi/middleware/get_head.go b/vendor/github.com/go-chi/chi/v5/middleware/get_head.go
index 86068a96db..d4606d8be6 100644
--- a/vendor/github.com/go-chi/chi/middleware/get_head.go
+++ b/vendor/github.com/go-chi/chi/v5/middleware/get_head.go
@@ -3,7 +3,7 @@ package middleware
 import (
 	"net/http"
 
-	"github.com/go-chi/chi"
+	"github.com/go-chi/chi/v5"
 )
 
 // GetHead automatically route undefined HEAD requests to GET handlers.
diff --git a/vendor/github.com/go-chi/chi/middleware/heartbeat.go b/vendor/github.com/go-chi/chi/v5/middleware/heartbeat.go
index fe822fb536..fe822fb536 100644
--- a/vendor/github.com/go-chi/chi/middleware/heartbeat.go
+++ b/vendor/github.com/go-chi/chi/v5/middleware/heartbeat.go
diff --git a/vendor/github.com/go-chi/chi/middleware/logger.go b/vendor/github.com/go-chi/chi/v5/middleware/logger.go
index 66edc3dda8..66edc3dda8 100644
--- a/vendor/github.com/go-chi/chi/middleware/logger.go
+++ b/vendor/github.com/go-chi/chi/v5/middleware/logger.go
diff --git a/vendor/github.com/go-chi/chi/middleware/middleware.go b/vendor/github.com/go-chi/chi/v5/middleware/middleware.go
index cc371e00a8..cc371e00a8 100644
--- a/vendor/github.com/go-chi/chi/middleware/middleware.go
+++ b/vendor/github.com/go-chi/chi/v5/middleware/middleware.go
diff --git a/vendor/github.com/go-chi/chi/middleware/nocache.go b/vendor/github.com/go-chi/chi/v5/middleware/nocache.go
index 2412829e1b..2412829e1b 100644
--- a/vendor/github.com/go-chi/chi/middleware/nocache.go
+++ b/vendor/github.com/go-chi/chi/v5/middleware/nocache.go
diff --git a/vendor/github.com/go-chi/chi/v5/middleware/page_route.go b/vendor/github.com/go-chi/chi/v5/middleware/page_route.go
new file mode 100644
index 0000000000..32871b7e40
--- /dev/null
+++ b/vendor/github.com/go-chi/chi/v5/middleware/page_route.go
@@ -0,0 +1,20 @@
+package middleware
+
+import (
+	"net/http"
+	"strings"
+)
+
+// PageRoute is a simple middleware which allows you to route a static GET request
+// at the middleware stack level.
+func PageRoute(path string, handler http.Handler) func(http.Handler) http.Handler {
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			if r.Method == "GET" && strings.EqualFold(r.URL.Path, path) {
+				handler.ServeHTTP(w, r)
+				return
+			}
+			next.ServeHTTP(w, r)
+		})
+	}
+}
diff --git a/vendor/github.com/go-chi/chi/v5/middleware/path_rewrite.go b/vendor/github.com/go-chi/chi/v5/middleware/path_rewrite.go
new file mode 100644
index 0000000000..99af62c0c3
--- /dev/null
+++ b/vendor/github.com/go-chi/chi/v5/middleware/path_rewrite.go
@@ -0,0 +1,16 @@
+package middleware
+
+import (
+	"net/http"
+	"strings"
+)
+
+// PathRewrite is a simple middleware which allows you to rewrite the request URL path.
+func PathRewrite(old, new string) func(http.Handler) http.Handler {
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			r.URL.Path = strings.Replace(r.URL.Path, old, new, 1)
+			next.ServeHTTP(w, r)
+		})
+	}
+}
diff --git a/vendor/github.com/go-chi/chi/middleware/profiler.go b/vendor/github.com/go-chi/chi/v5/middleware/profiler.go
index f5b62f7c32..3c36f878f5 100644
--- a/vendor/github.com/go-chi/chi/middleware/profiler.go
+++ b/vendor/github.com/go-chi/chi/v5/middleware/profiler.go
@@ -6,7 +6,7 @@ import (
 	"net/http"
 	"net/http/pprof"
 
-	"github.com/go-chi/chi"
+	"github.com/go-chi/chi/v5"
 )
 
 // Profiler is a convenient subrouter used for mounting net/http/pprof. ie.
@@ -36,6 +36,13 @@ func Profiler() http.Handler {
 	r.HandleFunc("/pprof/trace", pprof.Trace)
 	r.HandleFunc("/vars", expVars)
 
+	r.Handle("/pprof/goroutine", pprof.Handler("goroutine"))
+	r.Handle("/pprof/threadcreate", pprof.Handler("threadcreate"))
+	r.Handle("/pprof/mutex", pprof.Handler("mutex"))
+	r.Handle("/pprof/heap", pprof.Handler("heap"))
+	r.Handle("/pprof/block", pprof.Handler("block"))
+	r.Handle("/pprof/allocs", pprof.Handler("allocs"))
+
 	return r
 }
 
diff --git a/vendor/github.com/go-chi/chi/middleware/realip.go b/vendor/github.com/go-chi/chi/v5/middleware/realip.go
index 72db6ca9f5..034b30d0d9 100644
--- a/vendor/github.com/go-chi/chi/middleware/realip.go
+++ b/vendor/github.com/go-chi/chi/v5/middleware/realip.go
@@ -12,7 +12,7 @@ var xForwardedFor = http.CanonicalHeaderKey("X-Forwarded-For")
 var xRealIP = http.CanonicalHeaderKey("X-Real-IP")
 
 // RealIP is a middleware that sets a http.Request's RemoteAddr to the results
-// of parsing either the X-Forwarded-For header or the X-Real-IP header (in that
+// of parsing either the X-Real-IP header or the X-Forwarded-For header (in that
 // order).
 //
 // This middleware should be inserted fairly early in the middleware stack to
diff --git a/vendor/github.com/go-chi/chi/middleware/recoverer.go b/vendor/github.com/go-chi/chi/v5/middleware/recoverer.go
index 785b18c52b..d673f13fd3 100644
--- a/vendor/github.com/go-chi/chi/middleware/recoverer.go
+++ b/vendor/github.com/go-chi/chi/v5/middleware/recoverer.go
@@ -124,17 +124,18 @@ func (s prettyStack) decorateFuncCallLine(line string, useColor bool, num int) (
 	// addr := line[idx:]
 	method := ""
 
-	idx = strings.LastIndex(pkg, string(os.PathSeparator))
-	if idx < 0 {
-		idx = strings.Index(pkg, ".")
-		method = pkg[idx:]
-		pkg = pkg[0:idx]
+	if idx := strings.LastIndex(pkg, string(os.PathSeparator)); idx < 0 {
+		if idx := strings.Index(pkg, "."); idx > 0 {
+			method = pkg[idx:]
+			pkg = pkg[0:idx]
+		}
 	} else {
 		method = pkg[idx+1:]
 		pkg = pkg[0 : idx+1]
-		idx = strings.Index(method, ".")
-		pkg += method[0:idx]
-		method = method[idx:]
+		if idx := strings.Index(method, "."); idx > 0 {
+			pkg += method[0:idx]
+			method = method[idx:]
+		}
 	}
 	pkgColor := nYellow
 	methodColor := bGreen
diff --git a/vendor/github.com/go-chi/chi/middleware/request_id.go b/vendor/github.com/go-chi/chi/v5/middleware/request_id.go
index 4903ecc214..4903ecc214 100644
--- a/vendor/github.com/go-chi/chi/middleware/request_id.go
+++ b/vendor/github.com/go-chi/chi/v5/middleware/request_id.go
diff --git a/vendor/github.com/go-chi/chi/middleware/route_headers.go b/vendor/github.com/go-chi/chi/v5/middleware/route_headers.go
index 0e67b5f768..ea914a1d3c 100644
--- a/vendor/github.com/go-chi/chi/middleware/route_headers.go
+++ b/vendor/github.com/go-chi/chi/v5/middleware/route_headers.go
@@ -112,9 +112,9 @@ func (hr HeaderRouter) Handler(next http.Handler) http.Handler {
 }
 
 type HeaderRoute struct {
-	MatchAny   []Pattern
-	MatchOne   Pattern
 	Middleware func(next http.Handler) http.Handler
+	MatchOne   Pattern
+	MatchAny   []Pattern
 }
 
 func (r HeaderRoute) IsMatch(value string) bool {
diff --git a/vendor/github.com/go-chi/chi/middleware/strip.go b/vendor/github.com/go-chi/chi/v5/middleware/strip.go
index 992184dbf6..ce8ebfccea 100644
--- a/vendor/github.com/go-chi/chi/middleware/strip.go
+++ b/vendor/github.com/go-chi/chi/v5/middleware/strip.go
@@ -4,7 +4,7 @@ import (
 	"fmt"
 	"net/http"
 
-	"github.com/go-chi/chi"
+	"github.com/go-chi/chi/v5"
 )
 
 // StripSlashes is a middleware that will match request paths with a trailing
diff --git a/vendor/github.com/go-chi/chi/middleware/terminal.go b/vendor/github.com/go-chi/chi/v5/middleware/terminal.go
index 5ead7b9243..5ead7b9243 100644
--- a/vendor/github.com/go-chi/chi/middleware/terminal.go
+++ b/vendor/github.com/go-chi/chi/v5/middleware/terminal.go
diff --git a/vendor/github.com/go-chi/chi/middleware/throttle.go b/vendor/github.com/go-chi/chi/v5/middleware/throttle.go
index 7bb2e804f2..8dcb9440bc 100644
--- a/vendor/github.com/go-chi/chi/middleware/throttle.go
+++ b/vendor/github.com/go-chi/chi/v5/middleware/throttle.go
@@ -18,10 +18,10 @@ var (
 
 // ThrottleOpts represents a set of throttling options.
 type ThrottleOpts struct {
+	RetryAfterFn   func(ctxDone bool) time.Duration
 	Limit          int
 	BacklogLimit   int
 	BacklogTimeout time.Duration
-	RetryAfterFn   func(ctxDone bool) time.Duration
 }
 
 // Throttle is a middleware that limits number of currently processed requests
@@ -119,8 +119,8 @@ type token struct{}
 type throttler struct {
 	tokens         chan token
 	backlogTokens  chan token
-	backlogTimeout time.Duration
 	retryAfterFn   func(ctxDone bool) time.Duration
+	backlogTimeout time.Duration
 }
 
 // setRetryAfterHeaderIfNeeded sets Retry-After HTTP header if corresponding retryAfterFn option of throttler is initialized.
diff --git a/vendor/github.com/go-chi/chi/middleware/timeout.go b/vendor/github.com/go-chi/chi/v5/middleware/timeout.go
index 8e373536cf..8e373536cf 100644
--- a/vendor/github.com/go-chi/chi/middleware/timeout.go
+++ b/vendor/github.com/go-chi/chi/v5/middleware/timeout.go
diff --git a/vendor/github.com/go-chi/chi/middleware/url_format.go b/vendor/github.com/go-chi/chi/v5/middleware/url_format.go
index d8f04b7cb9..10d7134dca 100644
--- a/vendor/github.com/go-chi/chi/middleware/url_format.go
+++ b/vendor/github.com/go-chi/chi/v5/middleware/url_format.go
@@ -5,7 +5,7 @@ import (
 	"net/http"
 	"strings"
 
-	"github.com/go-chi/chi"
+	"github.com/go-chi/chi/v5"
 )
 
 var (
diff --git a/vendor/github.com/go-chi/chi/middleware/value.go b/vendor/github.com/go-chi/chi/v5/middleware/value.go
index a9dfd4345d..a9dfd4345d 100644
--- a/vendor/github.com/go-chi/chi/middleware/value.go
+++ b/vendor/github.com/go-chi/chi/v5/middleware/value.go
diff --git a/vendor/github.com/go-chi/chi/middleware/wrap_writer.go b/vendor/github.com/go-chi/chi/v5/middleware/wrap_writer.go
index 6438c7a653..cf5c44de13 100644
--- a/vendor/github.com/go-chi/chi/middleware/wrap_writer.go
+++ b/vendor/github.com/go-chi/chi/v5/middleware/wrap_writer.go
@@ -19,15 +19,25 @@ func NewWrapResponseWriter(w http.ResponseWriter, protoMajor int) WrapResponseWr
 
 	if protoMajor == 2 {
 		_, ps := w.(http.Pusher)
-		if fl || ps {
+		if fl && ps {
 			return &http2FancyWriter{bw}
 		}
 	} else {
 		_, hj := w.(http.Hijacker)
 		_, rf := w.(io.ReaderFrom)
-		if fl || hj || rf {
+		if fl && hj && rf {
 			return &httpFancyWriter{bw}
 		}
+		if fl && hj {
+			return &flushHijackWriter{bw}
+		}
+		if hj {
+			return &hijackWriter{bw}
+		}
+	}
+
+	if fl {
+		return &flushWriter{bw}
 	}
 
 	return &bw
@@ -107,6 +117,50 @@ func (b *basicWriter) Unwrap() http.ResponseWriter {
 	return b.ResponseWriter
 }
 
+// flushWriter ...
+type flushWriter struct {
+	basicWriter
+}
+
+func (f *flushWriter) Flush() {
+	f.wroteHeader = true
+	fl := f.basicWriter.ResponseWriter.(http.Flusher)
+	fl.Flush()
+}
+
+var _ http.Flusher = &flushWriter{}
+
+// hijackWriter ...
+type hijackWriter struct {
+	basicWriter
+}
+
+func (f *hijackWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {
+	hj := f.basicWriter.ResponseWriter.(http.Hijacker)
+	return hj.Hijack()
+}
+
+var _ http.Hijacker = &hijackWriter{}
+
+// flushHijackWriter ...
+type flushHijackWriter struct {
+	basicWriter
+}
+
+func (f *flushHijackWriter) Flush() {
+	f.wroteHeader = true
+	fl := f.basicWriter.ResponseWriter.(http.Flusher)
+	fl.Flush()
+}
+
+func (f *flushHijackWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {
+	hj := f.basicWriter.ResponseWriter.(http.Hijacker)
+	return hj.Hijack()
+}
+
+var _ http.Flusher = &flushHijackWriter{}
+var _ http.Hijacker = &flushHijackWriter{}
+
 // httpFancyWriter is a HTTP writer that additionally satisfies
 // http.Flusher, http.Hijacker, and io.ReaderFrom. It exists for the common case
 // of wrapping the http.ResponseWriter that package http gives you, in order to
@@ -126,6 +180,10 @@ func (f *httpFancyWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {
 	return hj.Hijack()
 }
 
+func (f *http2FancyWriter) Push(target string, opts *http.PushOptions) error {
+	return f.basicWriter.ResponseWriter.(http.Pusher).Push(target, opts)
+}
+
 func (f *httpFancyWriter) ReadFrom(r io.Reader) (int64, error) {
 	if f.basicWriter.tee != nil {
 		n, err := io.Copy(&f.basicWriter, r)
@@ -141,6 +199,7 @@ func (f *httpFancyWriter) ReadFrom(r io.Reader) (int64, error) {
 
 var _ http.Flusher = &httpFancyWriter{}
 var _ http.Hijacker = &httpFancyWriter{}
+var _ http.Pusher = &http2FancyWriter{}
 var _ io.ReaderFrom = &httpFancyWriter{}
 
 // http2FancyWriter is a HTTP2 writer that additionally satisfies
@@ -157,9 +216,4 @@ func (f *http2FancyWriter) Flush() {
 	fl.Flush()
 }
 
-func (f *http2FancyWriter) Push(target string, opts *http.PushOptions) error {
-	return f.basicWriter.ResponseWriter.(http.Pusher).Push(target, opts)
-}
-
 var _ http.Flusher = &http2FancyWriter{}
-var _ http.Pusher = &http2FancyWriter{}
diff --git a/vendor/modules.txt b/vendor/modules.txt
index 77a624c4b6..6f3acc5627 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -272,13 +272,10 @@ github.com/gliderlabs/ssh
 # github.com/go-asn1-ber/asn1-ber v1.5.3
 ## explicit
 github.com/go-asn1-ber/asn1-ber
-# github.com/go-chi/chi v1.5.4
-## explicit
-github.com/go-chi/chi
-github.com/go-chi/chi/middleware
 # github.com/go-chi/chi/v5 v5.0.4
 ## explicit
 github.com/go-chi/chi/v5
+github.com/go-chi/chi/v5/middleware
 # github.com/go-chi/cors v1.2.0
 ## explicit
 github.com/go-chi/cors