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

2 years ago · 957c3fcb59
--- 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
--- 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=
--- 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
--- 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"
--- a/vendor/github.com/go-chi/chi/.gitignore
+++ b/vendor/github.com/go-chi/chi/.gitignore
@@ -1,3 +0,0 @@
 .idea
 *.sw?
 .vscode
--- a/vendor/github.com/go-chi/chi/CHANGELOG.md
+++ b/vendor/github.com/go-chi/chi/CHANGELOG.md
@@ -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")`
--- a/vendor/github.com/go-chi/chi/CONTRIBUTING.md
+++ b/vendor/github.com/go-chi/chi/CONTRIBUTING.md
@@ -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
--- a/vendor/github.com/go-chi/chi/LICENSE
+++ b/vendor/github.com/go-chi/chi/LICENSE
@@ -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.
--- a/vendor/github.com/go-chi/chi/Makefile
+++ b/vendor/github.com/go-chi/chi/Makefile
@@ -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
--- a/vendor/github.com/go-chi/chi/README.md
+++ b/vendor/github.com/go-chi/chi/README.md
@@ -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
--- a/vendor/github.com/go-chi/chi/chain.go
+++ b/vendor/github.com/go-chi/chi/chain.go
@@ -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
 }
--- a/vendor/github.com/go-chi/chi/chi.go
+++ b/vendor/github.com/go-chi/chi/chi.go
@@ -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
--- a/vendor/github.com/go-chi/chi/context.go
+++ b/vendor/github.com/go-chi/chi/context.go
@@ -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
 }
--- a/vendor/github.com/go-chi/chi/go.mod
+++ b/vendor/github.com/go-chi/chi/go.mod
@@ -1,3 +0,0 @@
 module github.com/go-chi/chi

 go 1.16
--- a/vendor/github.com/go-chi/chi/mux.go
+++ b/vendor/github.com/go-chi/chi/mux.go
@@ -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)
 }
--- a/vendor/github.com/go-chi/chi/tree.go
+++ b/vendor/github.com/go-chi/chi/tree.go
@@ -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
 }
--- a/vendor/github.com/go-chi/chi/v5/middleware/basic_auth.go
+++ b/vendor/github.com/go-chi/chi/v5/middleware/basic_auth.go
--- a/vendor/github.com/go-chi/chi/v5/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.
--- a/vendor/github.com/go-chi/chi/v5/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
 }
--- a/vendor/github.com/go-chi/chi/v5/middleware/content_charset.go
+++ b/vendor/github.com/go-chi/chi/v5/middleware/content_charset.go
--- a/vendor/github.com/go-chi/chi/v5/middleware/content_encoding.go
+++ b/vendor/github.com/go-chi/chi/v5/middleware/content_encoding.go
--- a/vendor/github.com/go-chi/chi/v5/middleware/content_type.go
+++ b/vendor/github.com/go-chi/chi/v5/middleware/content_type.go
--- a/vendor/github.com/go-chi/chi/v5/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.
--- a/vendor/github.com/go-chi/chi/v5/middleware/heartbeat.go
+++ b/vendor/github.com/go-chi/chi/v5/middleware/heartbeat.go
--- a/vendor/github.com/go-chi/chi/v5/middleware/logger.go
+++ b/vendor/github.com/go-chi/chi/v5/middleware/logger.go
--- a/vendor/github.com/go-chi/chi/v5/middleware/middleware.go
+++ b/vendor/github.com/go-chi/chi/v5/middleware/middleware.go
--- a/vendor/github.com/go-chi/chi/v5/middleware/nocache.go
+++ b/vendor/github.com/go-chi/chi/v5/middleware/nocache.go
--- a/vendor/github.com/go-chi/chi/v5/middleware/page_route.go
+++ 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)
 		})
 	}
 }
--- a/vendor/github.com/go-chi/chi/v5/middleware/path_rewrite.go
+++ 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)
 		})
 	}
 }
--- a/vendor/github.com/go-chi/chi/v5/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
 }

--- a/vendor/github.com/go-chi/chi/v5/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
--- a/vendor/github.com/go-chi/chi/v5/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
--- a/vendor/github.com/go-chi/chi/v5/middleware/request_id.go
+++ b/vendor/github.com/go-chi/chi/v5/middleware/request_id.go
--- a/vendor/github.com/go-chi/chi/v5/middleware/route_headers.go
+++ b/vendor/github.com/go-chi/chi/v5/middleware/route_headers.go
--- a/vendor/github.com/go-chi/chi/v5/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
--- a/vendor/github.com/go-chi/chi/v5/middleware/terminal.go
+++ b/vendor/github.com/go-chi/chi/v5/middleware/terminal.go
--- a/vendor/github.com/go-chi/chi/v5/middleware/throttle.go
+++ b/vendor/github.com/go-chi/chi/v5/middleware/throttle.go
--- a/vendor/github.com/go-chi/chi/v5/middleware/timeout.go
+++ b/vendor/github.com/go-chi/chi/v5/middleware/timeout.go
--- a/vendor/github.com/go-chi/chi/v5/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 (
--- a/vendor/github.com/go-chi/chi/v5/middleware/value.go
+++ b/vendor/github.com/go-chi/chi/v5/middleware/value.go
--- a/vendor/github.com/go-chi/chi/v5/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{}
--- 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