Bump github.com/docker/distribution in /gateway

Bumps [github.com/docker/distribution](https://github.com/docker/distribution) from 2.8.1+incompatible to 2.8.2+incompatible. - [Release notes](https://github.com/docker/distribution/releases) - [Commits](https://github.com/docker/distribution/compare/v2.8.1...v2.8.2) --- updated-dependencies: - dependency-name: github.com/docker/distribution dependency-type: direct:production ... Signed-off-by: dependabot[bot] <support@github.com>
2025-06-21 14:23:25 +00:00 · 2023-06-07 15:08:19 +00:00
470 changed files with 7772 additions and 30652 deletions
--- a/ADOPTERS.md
+++ b/ADOPTERS.md
@ -36,8 +36,6 @@ Tell us more:

 * [911 Security](https://www.911security.com/) - "We migrated our Python functions from AWS Lambda using automation, and now run them in airgapped environments for customers using OpenFaaS and arkade" - Scott Creager

-* [Altair Engineering](https://altair.com/) - OpenFaaS powers the customer functions capability of the IoT SaaS platform, and separately each private on-prem installation of the product.
-
 * [Axa France](https://www.axa.fr) - Axa uses OpenFaaS for inference and predictions at scale using ML models - Pierre-Henri Gache

 * [Baidu](https://baidu.com) - A team within Baidu provides ML models to customers which are hosted on OpenFaaS - He Sun.
@ -46,26 +44,26 @@ Tell us more:

 * [Black.ai](https://black.ai) - video encoding, transcoding - object detection for CCTV using AI.

+* [Corva.ai](https://corva.ai) - "Corva is an information-sharing, collaboration-driving, and productivity-powering solution for your Drilling, Completions, Geoscience, and Sustainability teams."
+
+* [3fs](https://3fs.si) - 3fs is using OpenFaaS for automating repetitive development tasks like automatic rebasing, vendoring of dependencies on merge requests and many other things that make our developers lives easier
+
+* [Baidu](https://baidu.com) - A team within Baidu provides ML models to customers which are hosted on OpenFaaS - He Sun.
+
 * [Breu](https://breu.io) - Breu is using OpenFaaS to build an end user monitoring solution for hybrid cloud.

 * [BT](https://www.bt.com) - BT are using OpenFaaS to enable collaboration between data-scientists and developers. The teams are going from 3-years to build and deliver a PoC, to 3 months. See: [KubeCon video](https://www.youtube.com/watch?v=y77HlN2Fa-w)

 * [BulletProof](https://www.bulletproof.co.uk/) - Bulletproof are using OpenFaaS to build an on demand and scalable Vulnerability Scanning (VA) engine. Using OpenFaaS allows us to use compute resource efficiently yet maintain the ability to grow to meet customer scanning demands. We also like the ability to use pure docker containers to compose multiple scanning tools with different technologies into a single, coherent interface. This has reduced the time need to add new tools to the platform.

-* [CDATA](https://cdata.com) - Used for background jobs and tasks such as backing up and exchanging data between systems.
-
 * [Citrix](https://www.citrix.com/en-gb/) - Citrix built out a closed-source multi-tenant functions platform and UI using OpenFaaS. It is used for testing hardware devices and for automated QA testing.

 * [Civo](https://www.civo.com) - Civo Cloud provide a 1-click Kubernetes marketplace application for OpenFaaS

-* [Cloud Initiatives](https://cloudinitiatives.com) - Used for customer installations for custom functionality, and for main product providing educational course metrics.
-
 * [Cognite](https://www.cognite.com) - Cognite targets heavy asset industries such as oil and gas, shipping and energy sector. They provide data integration tools that help you extract, import, and transform data from siloed source systems, and OpenFaaS is used to provide a cloud function service for heavy tasks.

 * [Contiamo](https://www.contiamo.com) - data-science platform hosting jupyter notebooks and functions for multiple tenants.

-* [Corva.ai](https://corva.ai) - "Corva is an information-sharing, collaboration-driving, and productivity-powering solution for your Drilling, Completions, Geoscience, and Sustainability teams."
-
 * [DB2 Limited](https://db2.io) - mobile and web development company in Ukraine. Our internal projects using OpenFaaS functions to run customers code in Kubernetes cluster.

 * [DigitalOcean](https://www.digitalocean.com) - DigitalOcean provide a one-click droplet and a 1-click Kubernetes marketplace application for OpenFaaS
@ -74,7 +72,7 @@ Tell us more:

 * [Dragonchain](https://dragonchain.com/) - "At Dragonchain, we focus on creating a hybrid blockchain-as-a-service product, with integrations of OpenFaaS as our 'smart contract' platform, to be able to automatically run customer code based on interactions that occur on the blockchain. This allows us to be extremely flexible, as customers only have to create a docker container and give it to us in order to create a 'smart contract' which can have deep integrations with our blockchain itself.". Blog: [Dragonchain & OpenFaaS](https://dragonchain.com/blog/blockchain-as-a-service-at-scale-for-enterprise)

-* [Edge Delta](https://www.edgedelta.com/) - "OpenFaaS powers parts of our "edge observability platform""
+* [Edge Delta](https://www.edgedelta.com/) - "OpenFaaS powers parts of the "edge observability platform"

 * [First Baptist Church Carrollton](https://www.fbcc.us) - "We use faasd as the backend for a Slack bot connected to our internal Slack workspace. The bot was initially created to facilitate remote question and answer sessions at our church by allowing viewers of our live stream to text or email questions in, have a staff member ask their question in the room, and then allow the staff member to send a response back to the sender. The texting is facilitated by Twilio while the email is done by interacting with a Gmail account via IMAP and SMTP."

@ -84,8 +82,6 @@ Tell us more:

 * [GalaxyCard](https://www.galaxycard.in/) - "GalaxyCard is a happy user of OpenFaaS"

-* [GH Electronic GmbH](https://gselectronic.com/) - "We've been using OpenFaaS in production for over 5 years and have 30 C# functions which are used in our manufacturing process."
-
 * [GMO Internet](https://www.gmo.jp/en/)

 * [HelloSafe](https://hellosafe.ca/en/) - "HelloSafe is one of the leading website of financial products comparison in Canada. We're using OpenFaas on our production applications."
@ -96,10 +92,10 @@ Tell us more:

 * [Iconscout](https://iconscout.com) - e-commerce site for stock photography and icons. OpenFaaS is used to resize images and to bundle assets for customers.

-* [Infotechpartners](www.infotechpartners.be)
-
 * [Ingrooves](https://ingrooves.com) - Ingrooves is a global music distribution, tech & marketing company, and OpenFaaS is a key component in its finance system for report generation, event publishing, and data ingestion.

+* [Infotechpartners](www.infotechpartners.be)
+
 * [Intel.com](https://intel.com) - OpenFaaS is used within a commercial service and within the Open Source group for AI model serving.

 * [Intraffic](https://www.intraffic.nl/) - "Using OpenFaaS for integration and callable AI/ML models for asset management."
@ -112,17 +108,15 @@ Tell us more:

 * [Live Time Value (LTV) Co.](https://www.ltvco.com) - "Data is at the heart of what we do" - the data-science team at LTV use OpenFaaS to provide a scalable and cost-effective way to run their models in production.

-* [Mercedes Benz Tech Innovation](https://mercedes-benz.com) - "We are currently using OpenFaaS as a communicative API between the vehicle app and the backend. In the future we plan to offer a service in the company, which every app developer can host an API on the OpenFaaS platform at short notice"
-
 * [metaspan](https://metaspan.com) - "End-to-end blockchain solutions". metaspan ported all api endpoints from monolith express.js/sails.js to openfaas micro-functions.

 * [MoneyLion](https://www.moneylion.com/)

 * [Naamio](https://naamio.cloud/) - "Naamio are providing an event-based serverless API to developers to enable rapid development of decentralized applications on the cloud. By providing progressive enhancement within the developer tools, OpenFaaS has enabled Naamio to go from clustered Docker container deployments with REST APIs using Kubernetes, to load balanced deployable functions over an open event queue interface. It was key to enabling a standard multilingual development kit across cloud providers."

-* [Neoskop](https://www.neoskop.de) - Neoskop is using OpenFaaS in production to provide our developers with a self-service platform for backend functionality and thereby our customers agile and rapid feature development.
+* [Neoskop](https://www.neoskop.de) - Neoskop is using OpenFAAS in production to provide our developers with a self-service platform for backend functionality and thereby our customers agile and rapid feature development.

-* [Nexylan](nexylan.com/) - "We are a French professional host that use OpenFaaS in dev and production inside our private extranet. We use OpenFaaS to split our historic monolith project and then simplify development/maintainability and speed up development times."
+* [Nexylan](nexylan.com/) - "We are a French professional hoster that use OpenFaaS in dev and production inside our private extranet. We use OpenFaaS to split our historic monolith project and then simplify development/maintainability and speed up development times."

 * [NGC](https://www.ngcsoftware.com/)

@ -148,11 +142,9 @@ Tell us more:

 * [Pypestream](https://www.pypestream.com) - "We have just migrated 50 of our customers from Kubeless, which is now deprecated to OpenFaaS" - Antoine Hamon

-* [Rapid Circle](https://www.rapidcircle.com) is using OpenFaaS within a Azure Kubernetes cluster to host a large amount of micro-services aiming at automating core activities of their Microsoft 365 Cloud Managed Services offering. Robustness, speed, scalable and simplicity have been major reasons to favor OpenFaaS over Azure Functions.
-
 * [Ratehub](https://www.ratehub.ca) - Ratehub is Canada's leading personal finance comparison site. We're breaking apart our monolithic PHP and Java codebases into Node, PHP and Java OpenFaaS functions; there's not much that we don't plan on moving to FaaS!

-* [skyslope.com](https://skyslope.com) - "We process millions of documents per day and moved from AWS Lambda to Kubernetes. We estimate that OpenFaaS has saved us 60,000 USD each year over the past three years that we've been running it in our business" - Derrick Martinez
+* [Rapid Circle](https://www.rapidcircle.com) is using OpenFaaS within a Azure Kubernetes cluster to host a large amount of micro-services aiming at automating core activities of their Microsoft 365 Cloud Managed Services offering. Robustness, speed, scalable and simplicity have been major reasons to favor OpenFaaS over Azure Functions.

 * [smashHit](https://smashhit.eu) - smashHit is a project funded by the European Union's Horizon 2020 research and innovation programme under grant agreement No. 871477. The objective of smashHit is to assure trusted and secure sharing of data streams from both personal and industrial platforms, needed to build sectorial and cross-sectorial services, by establishing a Framework for processing of data owner consent and legal rules (GDPR) and effective contracting, as well as joint security and privacy-preserving mechanisms. We are utilising OpenFaaS to support the need for scalable processing through the use of functions.

@ -164,7 +156,7 @@ Tell us more:

 * [Surge](https://www.workwithsurge.com) - Lending Platform and Salesforce integrations

-* [TeamViewer.com](https://teamviewer.com) - "TeamViewer users OpenFaaS across several clusters"
+* [skyslope.com](https://skyslope.com) - "We process millions of documents per day and moved from AWS Lambda to Kubernetes. We estimate that OpenFaaS has saved us 60,000 USD each year over the past three years that we've been running it in our business" - Derrick Martinez

 * [T-Mobile](https://www.t-mobile.com/) - T-Mobile is a global mobile network that provides mobile data, voice and text services to consumers and businesses.

@ -191,25 +183,8 @@ Tell us more:

 * [Wireline.io](https://wireline.io) - portable functions that can run on any hardware, indexed through blockchain.

-* [WorldQuant](https://worldquant.com) - Using OpenFaaS as part of WorldQuant's solutions.
-
 * [Yokogawa Electric](https://en.wikipedia.org/wiki/Yokogawa_Electric)

 * [Ytel](https://www.ytel.com) - Ytel are a Google Cloud customer and deployed OpenFaaS vs. the vendor alternative due to its wide range of templates, Dockerfile support and easier access to services within the VPC. The Dockerfile template allowed for easy migration of existing code. The latency of transactions for customers during purchase process was reduced by offloading synchronous code to NATS which is built into OpenFaaS. OpenFaaS also allowed "hot path" code to be refactored from large services into multiple functions, to take advantage of horizontal scaling.

 See the top of the file for how to participate.
-
-## Appendix
-
-### Sorting sections
-
-Adopeters list should be sorted after it's been updated, here's how you can do that with bash.
-
-```bash
-cat | sort --ignore-case
-# Copy / paste
-
-# Control + D
-```
-
-Please note, for few vendors multiple use case has been listed under same vendor. Hence, the output need to be compared with content in document before updating the document. 
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@ -1,14 +1,12 @@
-# Contributing guidelines
+# Contributing

-These are the guidelines for contributing to OpenFaaS Community Edition (CE) and faasd components.
+## Guidelines

-OpenFaaS Standard and OpenFaaS For Enterprises are commercial software, and maintained solely by employees of OpenFaaS Ltd.
+Guidelines for contributing.

-Customers can provide feedback via the [openfaas/customers](https://github.com/openfaas/customers) repository
+### First impressions - introducing yourself and your use-case

-## First impressions - introducing yourself and your use-case
-
-One of the best ways to participate within a new open source community is to introduce yourself and your use-case. This builds goodwill, but also means the community can start to understand your needs and how best to help you.
+One of the best ways to participate within a new open source communities is to introduce yourself and your use-case. This builds goodwill, but also means the community can start to understand your needs and how best to help you.

 Given that the community is made up of volunteers, making a good first impression is important to getting their ear and attention. 

@ -33,7 +31,7 @@ The primary ways to engage with the community are via GitHub Issues and [Enterpr

 See also: [The no-excuses guide to introducing yourself to a new open source project](https://opensource.com/education/13/7/introduce-yourself-open-source-project)

-## How can I get involved?
+### How can I get involved?

 There are a number of areas where contributions can be accepted:

@ -51,19 +49,17 @@ There are a number of areas where contributions can be accepted:

 This is just a short list of ideas, if you have other ideas for contributing please make a suggestion.

-If you'd like help getting involved, [join our weekly community call on Zoom](https://docs.openfaas.com/community).
+### I want to contribute on GitHub

-## I want to contribute on GitHub
+#### I've found a security issue

-### I've found a security issue
+Please follow [responsible disclosure practices](https://en.wikipedia.org/wiki/Responsible_disclosure) and send an email to support@openfaas.com. Bear in mind that instructions on how to reproduce the issue are key to proving an issue exists, and getting it resolved. Suggested solutions are also weclome.

-Please follow [responsible disclosure practices](https://en.wikipedia.org/wiki/Responsible_disclosure) and send an email to support@openfaas.com. Bear in mind that instructions on how to reproduce the issue are key to proving an issue exists, and getting it resolved.
-
-### I've found a typo
+#### I've found a typo

 * A Pull Request is not necessary. Raise an [Issue](https://github.com/openfaas/faas/issues) and we'll fix it as soon as we can. 

-### I have a (great) idea
+#### I have a (great) idea

 The OpenFaaS maintainers would like to make OpenFaaS the best it can be and welcome new contributions that align with the project's goals. Our time is limited so we'd like to make sure we agree on the proposed work before you spend time doing it. Saying "no" is hard which is why we'd rather say "yes" ahead of time. You need to raise a proposal.

@ -88,7 +84,7 @@ If you are proposing a new tool or service please do due diligence. Does this to

 Every effort will be made to work with contributors who do not follow the process. Your PR may be closed or marked as `invalid` if it is left inactive, or the proposal cannot move into a `design/approved` status.

-### Paperwork for Pull Requests
+#### Paperwork for Pull Requests

 Please read this whole guide and make sure you agree to the Developer Certificate of Origin (DCO) agreement (included below):

@ -99,7 +95,7 @@ Please read this whole guide and make sure you agree to the Developer Certificat
 * Always give instructions for testing
 * Provide us CLI commands and output or screenshots where you can

-#### Commit messages
+##### Commit messages

 The first line of the commit message is the *subject*, this should be followed by a blank line and then a message describing the intent and purpose of the commit. These guidelines are based upon a [post by Chris Beams](https://chris.beams.io/posts/git-commit/).

@ -182,50 +178,47 @@ defer goleak.VerifyNoLeaks(t)

 at the very beginning of the test, and it will fail the test if it detects goroutines that were opened but never cleaned up at the end of the test.

-#### I need to add a dependency
-
-All projects use [Go modules](https://github.com/golang/go/wiki/Modules) and vendoring. The concept of `vendoring` is still broadly used in projects written in Go. This means that a copy of the source-code of dependencies is stored within each repository in the `vendor` folder. It allows for a repeatable build and isolates change.
-
-Components must be licensed with an MIT, BSD, or Apache 2.0 license. We may ask you to write your own code when dependencies are trivial, or unmaintained by their authors.
-
-### I have a question, a suggestion or need help
+#### I have a question, a suggestion or need help

 If you have a deeply technical request or need help debugging your application then you should prepare a simple, public GitHub repository with the minimum amount of code required to reproduce the issue. 

+If you feel there is an issue with OpenFaaS or were unable to get the help you needed from the GitHub, [then send us an email](https://openfaas.com/support/)
+
 #### Setting expectations, support and SLAs

-* What kind of support can I expect?
+* What kind of support can I expect for free?

-    OpenFaaS Standard customers have self-service support, and can directly contact the OpenFaaS Ltd team via the [openfaas/customers](https://github.com/openfaas/customers) repository using Discussions.
+    OpenFaaS is licensed in a way that enables you to use the source code in or with your project or product.

-    Support is only offered to free users to fix bugs and issues in the codebase, where the full Issue Template is filled out with sufficient instructions to reproduce the issue. We will not debug your application, or comment on your architecture on GitHub.
+    If you are using one of the Open Source projects within the openfaas or openfaas-incubator repository, then help may be offered on a limited, good-will basis by volunteers, but if you are a commercial user, you will need to purchase support for timely help.
+    
+    Please be respectful of any time given to you and your needs. The person you are requesting help from may not reside in your timezone and contacting them via direct message is inappropriate.

-* Can we talk to you in person?
-
-    There is a weekly Zoom call for any free user or customer to attend, topics are taken at the beginning of the call, and we will strive to give everyone time to talk.
+    Enterprise support is the best place to ask questions, suggest features, and to get help. The GitHub issue tracker can be used for suspected issues with the codebase or deployment artifacts. The whole template must be filled out in detail.

 * Doesn't Open Source mean that everything is free?

-    The OpenFaaS Community Edition (CE) projects are licensed as MIT which means that you are free to use, modify and distribute the software within the terms of the license.
+    The OpenFaaS projects are licensed as MIT which means that you are free to use, modify and distribute the software within the terms of the license.
    
-    Contributions, suggestions and feedback is welcomed in the appropriate channels as outlined in this guide. The MIT license does not cover support for PRs, Issues, Technical Support questions, feature requests and technical support/professional services which you may require; the preceding are not free and have a cost to those providing the services.
+    Contributions, suggestions and feedback is welcomed in the appropriate channels as outlined in this guide. The MIT license does not cover support for PRs, Issues, Technical
+    Support questions, feature requests and technical support/professional services which you may require; the preceding are not free and have a cost to those providing the services. Where possible, this time may be volunteered for free, but it is not unlimited.

 * What is the SLA for my Issue?

    Issues are examined, triaged and answered on a best effort basis by volunteers and community contributors. This means that you may receive an initial response within any time period such as: 1 minute, 1 hour, 1 day, or 1 week. There is no implicit meaning to the time between you raising an issue and it being answered or resolved.

-    If you see an issue which does not have a response or does not have a resolution, it does not mean that it is not important, or that it is being ignored. It simply means it has not been worked on yet, or may have been missed.
+    If you see an issue which does not have a response or does not have a resolution, it does not mean that it is not important, or that it is being ignored. It simply means it has not been worked on by a volunteer yet.

    Please take responsibility for following up on your Issues if you feel further action is required.

-    If you're an OpenFaaS customer, then you will have a direct line of communication with the OpenFaaS Ltd team, feel free to reach out for an update.
+    If you are a business using OpenFaaS and need timely and attentive responses, then you should purchase Enterprise Support from OpenFaaS Ltd.

 * What is the SLA for my Pull Request?

    In a similar way to Issues, Pull Requests are triaged, reviewed, and considered by a team of volunteers - the Core Team,  Members Team and the Project Lead. There are dozens of components that make up the OpenFaaS project and a limited amount of people. Sometimes PRs may become blocked or require further action.
    
    Please take responsibility for following up on your Pull Requests if you feel further action is required.
-
+    
 * Why may your PR be delayed?

    * The contributing guide was not followed in some way
@ -236,19 +229,25 @@ If you have a deeply technical request or need help debugging your application t

    * Changes have been requested

-    * The PR is low priority or low impact
-
-    In addition, more information, a use-case, or context may be required for the change to be accepted.
+    More information, a use-case, or context may be required for the change to be accepted.

 * What if I am a GitHub Sponsor?

-    If you [sponsor OpenFaaS on GitHub](https://github.com/sponsors/openfaas), then you will show up as a Sponsor on your issues and PRs which is one way to show your support for the community and project. Thank you for your contribution.
- 
-    Most sponsors are individuals, not corporations. But if your organisation can also take up a GitHub Sponsorship using their GitHub organisation's existing billing relationship.
+    If you [sponsor OpenFaaS on GitHub](https://github.com/sponsors/openfaas), then you will show up as a Sponsor on your issues and PRs which is one way to show your support for the community and project. Whilst the entry-level sponsorship is only 25 USD / mo, you will benefit from access to regular updates on project development via the [Treasure Trove portal](https://faasd.exit.openfaas.pro/function/trove/). Your company can also take up a GitHub Sponsorship using their GitHub organisation's existing billing relationship.

-* What if I need more?
+* What if I need more than that?

-    [Check out the options for self-service and enterprise support](https://openfaas.com/pricing/).
+    If you're a company using any of these projects, you can get the following through an [Enterprise Support agreement with OpenFaaS Ltd](https://openfaas.com/support/) so that the time and resources required to support your business are paid for.
+
+    A support agreement can be tailored to your needs, you may benefit from support, if you need any of the following:
+
+    * security issues patched in a timely manner for all 40 +/- open source components
+    * priority responses to issues/PRs
+    * immediate help and access to experts
+
+#### I need to add a dependency
+
+All projects use [Go modules](https://github.com/golang/go/wiki/Modules) and vendoring. The concept of `vendoring` is still broadly used in projects written in Go. This means that a copy of the source-code of dependencies is stored within each repository in the `vendor` folder. It allows for a repeatable build and isolates change.

 ### How are releases made?

@ -303,10 +302,8 @@ Core Team attend all project meetings and calls. Allowances will be made for tim

 The Core Team includes:

- Alex Ellis (@alexellis) - Founder, OpenFaaS Ltd
- Han Verstraete (@welteki) - Junior Software Developer, OpenFaaS Ltd
- Lucas Roesler (@LucasRoesler) - SME for logs, provider model and secrets. Lead Developer @ Contiamo
- Nitishkumar Singh (@nitishkumar71) - Senior Engineer, CTO.ai
+- Alex Ellis (@alexellis) - Lead
+- Lucas Roesler (@LucasRoesler) - SME for logs, provider model and secrets

 #### Members Team

@ -392,9 +389,7 @@ See also: [OpenFaaS Pro](https://docs.openfaas.com/openfaas-pro/introduction/)

 ## License

-OpenFaaS Community Edition (CE) is licensed under the MIT License.
-
-OpenFaaS Standard and OpenFaaS for Enterprises are proprietary and binaries are licensed under the commercial [OpenFaaS Pro EULA](https://github.com/openfaas/faas/blob/master/pro/EULA.md).
+This project is licensed under the MIT License.

 ### Copyright notice

@ -403,7 +398,7 @@ It is important to state that you retain copyright for your contributions, but a
 Please add a Copyright notice to new files you add where this is not already present.

 ```
-// Copyright (c) OpenFaaS Author(s) 2023. All rights reserved.
+// Copyright (c) OpenFaaS Author(s) 2018. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 ```

--- a/6
+++ b/6
@ -5,12 +5,6 @@ NS?=openfaas
 build-gateway:
 	(cd gateway;  docker buildx build --platform linux/amd64 -t ${NS}/gateway:latest-dev .)

-
-# generate Go models from the OpenAPI spec using https://github.com/contiamo/openapi-generator-go
-generate:
-	rm gateway/models/model_*.go || true
-	openapi-generator-go generate models -s api-docs/spec.openapi.yml -o gateway/models --package-name models
-
 # .PHONY: test-ci
 # test-ci:
 # 	./contrib/ci.sh
--- a/api-docs/spec.openapi.yml
+++ b/api-docs/spec.openapi.yml
@ -1,996 +0,0 @@
-openapi: 3.0.1
-info:
-  title: OpenFaaS API Gateway
-  description: OpenFaaS API documentation
-  license:
-    name: MIT
-  version: 0.8.12
-  contact:
-    name: OpenFaaS Ltd
-    url: https://www.openfaas.com/support/
-servers:
- url: "http://localhost:8080"
-  description: Local server
-tags:
-  - name: internal
-    description: Internal use only
-  - name: system
-    description: System endpoints for managing functions and related objects
-  - name: function
-    description: Endpoints for invoking functions
-paths:
-  "/healthz":
-    get:
-      summary: Healthcheck
-      operationId: healthcheck
-      description: Healthcheck for the gateway, indicates if the gateway is running and available
-      tags:
-        - internal
-      responses:
-        '200':
-          description: Healthy
-        '500':
-          description: Not healthy
-  "/metrics":
-    get:
-      summary: Prometheus metrics
-      operationId: metrics
-      description: Prometheus metrics for the gateway
-      tags:
-        - internal
-      responses:
-        '200':
-          description: Prometheus metrics in text format
-  "/system/info":
-    get:
-      operationId: GetSystemInfo
-      description: Get system provider information
-      summary: Get info such as provider version number and provider orchestrator
-      tags:
-        - system
-      responses:
-        '200':
-          description: Info result
-          content:
-            application/json:
-              schema:
-                "$ref": "#/components/schemas/GatewayInfo"
-        '500':
-          description: Internal Server Error
-  "/system/alert":
-    post:
-      operationId: ScaleAlert
-      description: Scale a function based on an alert
-      summary: | 
-        Event-sink for AlertManager, for auto-scaling
-        
-        Internal use for AlertManager, requires valid AlertManager alert
-        JSON
-      tags:
-        - internal
-      requestBody:
-        description: Incoming alert
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/PrometheusAlert'
-        required: false
-      responses:
-        '200':
-          description: Alert handled successfully
-        '500':
-          description: Internal error with swarm or request JSON invalid
-  "/system/functions":
-    get:
-      operationId: GetFunctions
-      description: Get a list of deployed functions
-      summary: 'Get a list of deployed functions with: stats and image digest'
-      tags:
-        - system
-      responses:
-        '200':
-          description: List of deployed functions.
-          content:
-            application/json:
-              schema:
-                type: array
-                items:
-                  "$ref": "#/components/schemas/FunctionStatus"
-    put:
-      operationId: UpdateFunction
-      description: update a function spec
-      summary: Update a function.
-      tags:
-        - system
-      requestBody:
-        description: Function to update
-        content:
-          application/json:
-            schema:
-              "$ref": "#/components/schemas/FunctionDeployment"
-        required: true
-      responses:
-        '200':
-          description: Accepted
-        '400':
-          description: Bad Request
-        '404':
-          description: Not Found
-        '500':
-          description: Internal Server Error
-    post:
-      operationId: DeployFunction
-      description: Deploy a new function.
-      summary: Deploy a new function.
-      tags:
-        - system
-      requestBody:
-        description: Function to deploy
-        content:
-          application/json:
-            schema:
-              "$ref": "#/components/schemas/FunctionDeployment"
-        required: true
-      responses:
-        '202':
-          description: Accepted
-        '400':
-          description: Bad Request
-        '500':
-          description: Internal Server Error
-    delete:
-      operationId: DeleteFunction
-      description: Remove a deployed function.
-      summary: Remove a deployed function.
-      tags:
-        - system
-      requestBody:
-        description: Function to delete
-        content:
-          application/json:
-            schema:
-              "$ref": "#/components/schemas/DeleteFunctionRequest"
-        required: true
-      responses:
-        '200':
-          description: OK
-        '400':
-          description: Bad Request
-        '404':
-          description: Not Found
-        '500':
-          description: Internal Server Error
-  "/system/scale-function/{functionName}":
-    post:
-      operationId: ScaleFunction
-      description: Scale a function
-      summary: Scale a function to a specific replica count
-      tags:
-        - system
-      parameters:
-      - name: functionName
-        in: path
-        description: Function name
-        required: true
-        schema:
-          type: string
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/ScaleServiceRequest'
-      responses:
-        '200':
-          description: Scaling OK
-        '202':
-          description: Scaling OK
-        '404':
-          description: Function not found
-        '500':
-          description: Error scaling function
-
-  "/system/function/{functionName}":
-    get:
-      operationId: GetFunctionStatus
-      description: Get the status of a function by name
-      tags:
-        - system
-      parameters:
-      - name: functionName
-        in: path
-        description: Function name
-        required: true
-        schema:
-          type: string
-      - name: namespace
-        in: query
-        description: Namespace of the function
-        required: false
-        schema:
-          type: string
-      responses:
-        '200':
-          description: Function Summary
-          content:
-            "*/*":
-              schema:
-                "$ref": "#/components/schemas/FunctionStatus"
-        '404':
-          description: Not Found
-        '500':
-          description: Internal Server Error
-  "/system/secrets":
-    get:
-      operationId: ListSecrets
-      description: Get a list of secret names and metadata from the provider
-      summary: Get a list of secret names and metadata from the provider
-      tags:
-        - system
-      responses:
-        '200':
-          description: List of submitted secrets.
-          content:
-            application/json:
-              schema:
-                "$ref": "#/components/schemas/SecretDescription"
-    put:
-      operationId: UpdateSecret
-      description: Update a secret.
-      summary: Update a secret, the value is replaced.
-      tags:
-        - system
-      requestBody:
-        description: Secret to update
-        content:
-          application/json:
-            schema:
-              "$ref": "#/components/schemas/Secret"
-        required: true
-      responses:
-        '200':
-          description: Ok
-        '400':
-          description: Bad Request
-        '404':
-          description: Not Found
-        '405':
-          description: Method Not Allowed. Secret update is not allowed in faas-swarm.
-        '500':
-          description: Internal Server Error
-    post:
-      operationId: CreateSecret
-      description: Create a new secret.
-      tags:
-        - system
-      requestBody:
-        description: A new secret to create
-        content:
-          application/json:
-            schema:
-              "$ref": "#/components/schemas/Secret"
-        required: true
-      responses:
-        '201':
-          description: Created
-        '400':
-          description: Bad Request
-        '500':
-          description: Internal Server Error
-    delete:
-      operationId: DeleteSecret
-      description: Remove a secret.
-      tags:
-        - system
-      requestBody:
-        description: Secret to delete
-        content:
-          application/json:
-            schema:
-              "$ref": "#/components/schemas/SecretDescription"
-        required: true
-      responses:
-        '204':
-          description: OK
-        '400':
-          description: Bad Request
-        '404':
-          description: Not Found
-        '500':
-          description: Internal Server Error
-  "/system/logs":
-    get:
-      operationId: GetFunctionLogs
-      description: Get a stream of the logs for a specific function
-      tags:
-        - system
-      parameters:
-      - name: name
-        in: query
-        description: Function name
-        required: true
-        schema:
-          type: string
-      - name: namespace
-        in: query
-        description: Namespace of the function
-        required: false
-        schema:
-          type: string
-      - name: instance
-        in: query
-        description: Instance of the function
-        required: false
-        schema:
-          type: string
-      - name: tail
-        in: query
-        description: Sets the maximum number of log messages to return, <=0 means
-          unlimited
-        schema:
-          type: integer
-      - name: follow
-        in: query
-        description: When true, the request will stream logs until the request timeout
-        schema:
-          type: boolean
-      - name: since
-        in: query
-        description: Only return logs after a specific date (RFC3339)
-        schema:
-          type: string
-          format: date-time
-      responses:
-        '200':
-          description: Newline delimited stream of log messages
-          content:
-            application/x-ndjson:
-              schema:
-                "$ref": "#/components/schemas/LogEntry"
-        '404':
-          description: Not Found
-        '500':
-          description: Internal Server Error
-  
-  "/system/namespaces":
-    get:
-      operationId: ListNamespaces
-      description: Get a list of namespaces
-      tags:
-        - system
-      responses:
-        '200':
-          description: List of namespaces
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/ListNamespaceResponse'
-        '500':
-          description: Internal Server Error
-  
-  "/async-function/{functionName}":
-    post:
-      operationId: InvokeAsync
-      description: Invoke a function asynchronously
-      summary: |
-        Invoke a function asynchronously in the default OpenFaaS namespace
-
-        Any additional path segments and query parameters will be passed to the function as is.
-
-        See https://docs.openfaas.com/reference/async/.
-      tags:
-        - function
-      parameters:
-      - name: functionName
-        in: path
-        description: Function name
-        required: true
-        schema:
-          type: string
-      requestBody:
-        description: "(Optional) data to pass to function"
-        content:
-          "*/*":
-            schema:
-              type: string
-              format: binary
-              example: '{"hello": "world"}'
-        required: false
-      responses:
-        '202':
-          description: Request accepted and queued
-        '404':
-          description: Not Found
-        '500':
-          description: Internal Server Error
-
-  "/async-function/{functionName}.{namespace}":
-    post:
-      operationId: InvokeAsyncNamespaced
-      description: Invoke a function asynchronously in an OpenFaaS namespace.
-      summary: |
-        Invoke a function asynchronously in an OpenFaaS namespace.
-
-        Any additional path segments and query parameters will be passed to the function as is.
-
-        See https://docs.openfaas.com/reference/async/.
-      tags:
-        - function
-      parameters:
-      - name: functionName
-        in: path
-        description: Function name
-        required: true
-        schema:
-          type: string
-      - name: namespace
-        in: path
-        description: Namespace of the function
-        required: true
-        schema:
-          type: string
-      requestBody:
-        description: "(Optional) data to pass to function"
-        content:
-          "*/*":
-            schema:
-              type: string
-              format: binary
-              example: '{"hello": "world"}'
-        required: false
-      responses:
-        '202':
-          description: Request accepted and queued
-        '404':
-          description: Not Found
-        '500':
-          description: Internal Server Error
-
-  "/function/{functionName}":
-    post:
-      operationId: InvokeFunction
-      description: Invoke a function in the default OpenFaaS namespace.
-      summary: |
-        Synchronously invoke a function defined in te default OpenFaaS namespace.
-
-        Any additional path segments and query parameters will be passed to the function as is.
-      tags:
-        - function
-      parameters:
-      - name: functionName
-        in: path
-        description: Function name
-        required: true
-        schema:
-          type: string
-      requestBody:
-        description: "(Optional) data to pass to function"
-        content:
-          "*/*":
-            schema:
-              type: string
-              format: binary
-              example: '{"hello": "world"}'
-        required: false
-      responses:
-        '200':
-          description: Value returned from function
-        '404':
-          description: Not Found
-        '500':
-          description: Internal server error
-
-  "/function/{functionName}.{namespace}":
-    post:
-      operationId: InvokeFunctionNamespaced
-      description: Invoke a function in an OpenFaaS namespace.
-      summary: |
-        Synchronously invoke a function defined in the specified namespace.
-
-        Any additional path segments and query parameters will be passed to the function as is.
-      tags:
-        - function
-      parameters:
-      - name: functionName
-        in: path
-        description: Function name
-        required: true
-        schema:
-          type: string
-      - name: namespace
-        in: path
-        description: Namespace of the function
-        required: true
-        schema:
-          type: string
-      requestBody:
-        description: "(Optional) data to pass to function"
-        content:
-          "*/*":
-            schema:
-              type: string
-              format: binary
-              example: '{"hello": "world"}'
-        required: false
-      responses:
-        '200':
-          description: Value returned from function
-        '404':
-          description: Not Found
-        '500':
-          description: Internal server error
-components:
-  securitySchemes:
-    basicAuth:
-      type: http
-      scheme: basic
-
-  schemas:
-    GatewayInfo:
-      required:
-      - provider
-      - version
-      - arch
-      type: object
-      properties:
-        provider:
-          nullable: true
-          allOf:
-            - $ref: "#/components/schemas/ProviderInfo"
-        version:
-          nullable: true
-          description: version of the gateway
-          allOf:
-            - $ref: "#/components/schemas/VersionInfo"
-        arch:
-          type: string
-          description: Platform architecture
-          example: x86_64
-    VersionInfo:
-      type: object
-      required:
-        - sha
-        - release
-      properties:
-        commit_message:
-          type: string
-          example: Sample Message
-        sha:
-          type: string
-          example: 7108418d9dd6b329ddff40e7393b3166f8160a88
-        release:
-          type: string
-          format: semver
-          example: 0.8.9
-    ProviderInfo:
-      type: object
-      required:
-        - provider
-        - orchestration
-        - version
-      properties:
-        provider:
-          type: string
-          description: The orchestration provider / implementation
-          example: faas-netes
-        orchestration:
-          type: string
-          example: kubernetes
-        version:
-          description: The version of the provider
-          nullable: true
-          allOf:
-            - $ref: "#/components/schemas/VersionInfo"
-    
-    PrometheusAlert:
-      type: object
-      description: Prometheus alert produced by AlertManager. This is only a subset of the full alert payload.
-      required:
-        - status
-        - receiver
-        - alerts
-      properties:
-        status:
-          type: string
-          description: The status of the alert
-          example: resolved
-        receiver:
-          type: string
-          description: The name of the receiver
-          example: webhook
-        alerts:
-          type: array
-          description: The list of alerts
-          items:
-            $ref: "#/components/schemas/PrometheusInnerAlert"
-      example:
-        {
-          "receiver": "scale-up",
-          "status": "firing",
-          "alerts": [{
-              "status": "firing",
-              "labels": {
-                  "alertname": "APIHighInvocationRate",
-                  "code": "200",
-                  "function_name": "func_nodeinfo",
-                  "instance": "gateway:8080",
-                  "job": "gateway",
-                  "monitor": "faas-monitor",
-                  "service": "gateway",
-                  "severity": "major",
-                  "value": "8.998200359928017"
-              },
-              "annotations": {
-                  "description": "High invocation total on gateway:8080",
-                  "summary": "High invocation total on gateway:8080"
-              },
-              "startsAt": "2017-03-15T15:52:57.805Z",
-              "endsAt": "0001-01-01T00:00:00Z",
-              "generatorURL": "http://4156cb797423:9090/graph?g0.expr=rate%28gateway_function_invocation_total%5B10s%5D%29+%3E+5\u0026g0.tab=0"
-          }],
-          "groupLabels": {
-              "alertname": "APIHighInvocationRate",
-              "service": "gateway"
-          },
-          "commonLabels": {
-              "alertname": "APIHighInvocationRate",
-              "code": "200",
-              "function_name": "func_nodeinfo",
-              "instance": "gateway:8080",
-              "job": "gateway",
-              "monitor": "faas-monitor",
-              "service": "gateway",
-              "severity": "major",
-              "value": "8.998200359928017"
-          },
-          "commonAnnotations": {
-              "description": "High invocation total on gateway:8080",
-              "summary": "High invocation total on gateway:8080"
-          },
-          "externalURL": "http://f054879d97db:9093",
-          "version": "3",
-          "groupKey": 18195285354214864953
-        }
-      
-    PrometheusInnerAlert:
-      type: object
-      description: A single alert produced by Prometheus
-      required:
-        - status
-        - labels
-      properties:
-        status:
-          type: string
-          description: The status of the alert
-          example: resolved
-        labels:
-          $ref: "#/components/schemas/PrometheusInnerAlertLabel"
-
-    PrometheusInnerAlertLabel:
-      type: object
-      description: A single label of a Prometheus alert
-      required:
-        - alertname
-        - function_name
-      properties:
-        alertname:
-          type: string
-          description: The name of the alert
-        function_name:
-          type: string
-          description: The name of the function
-          example: nodeinfo
-
-    FunctionDeployment:
-      required:
-      - service
-      - image
-      type: object
-      properties:
-        service:
-          type: string
-          description: Name of deployed function
-          example: nodeinfo
-        image:
-          type: string
-          description: Docker image in accessible registry
-          example: functions/nodeinfo:latest
-        namespace:
-          type: string
-          description: Namespace to deploy function to. When omitted, the default namespace
-            is used, typically this is `openfaas-fn` but is configured by the provider.
-          example: openfaas-fn
-        envProcess:
-          type: string
-          description: |
-            Process for watchdog to fork, i.e. the command to start the function process.
-
-            This value configures the `fprocess` env variable.
-          example: node main.js
-        constraints:
-          type: array
-          items:
-            type: string
-            description: Constraints are specific to OpenFaaS Provider
-            example: node.platform.os == linux
-        envVars:
-          type: object
-          additionalProperties:
-            type: string
-          description: Overrides to environmental variables
-        secrets:
-          type: array
-          items:
-            type: string
-            description: An array of names of secrets that are required to be loaded
-              from the Docker Swarm.
-            example: secret-name-1
-        labels:
-          type: object
-          nullable: true
-          additionalProperties:
-            type: string
-          description: A map of labels for making scheduling or routing decisions
-          example:
-            foo: bar
-        annotations:
-          type: object
-          nullable: true
-          additionalProperties:
-            type: string
-          description: A map of annotations for management, orchestration, events
-            and build tasks
-          example:
-            topics: awesome-kafka-topic
-            foo: bar
-        limits:
-          nullable: true
-          allOf:
-            - $ref: "#/components/schemas/FunctionResources"
-        requests:
-          nullable: true
-          allOf:
-            - $ref: "#/components/schemas/FunctionResources"
-        readOnlyRootFilesystem:
-          type: boolean
-          description: Make the root filesystem of the function read-only
-
-        # DEPRECATED FIELDS, these fields are ignored in all current providers 
-        registryAuth:
-          type: string
-          description: |
-            Deprecated: Private registry base64-encoded basic auth (as present in ~/.docker/config.json)
-            
-            Use a Kubernetes Secret with registry-auth secret type to provide this value instead.
-
-            This value is completely ignored.
-          example: dXNlcjpwYXNzd29yZA==
-          deprecated: true
-        network:
-          type: string
-          description: |
-            Deprecated: Network, usually func_functions for Swarm.
-
-            This value is completely ignored.
-          deprecated: true
-          example: func_functions
-
-    FunctionStatus:
-      type: object
-      required:
-        - name
-        - image
-      properties:
-        name:
-          type: string
-          description: The name of the function
-          example: nodeinfo
-        image:
-          type: string
-          description: The fully qualified docker image name of the function
-          example: functions/nodeinfo:latest
-        namespace:
-          type: string
-          description: The namespace of the function
-          example: openfaas-fn
-        envProcess:
-          type: string
-          description: Process for watchdog to fork
-          example: node main.js
-        envVars:
-          type: object
-          additionalProperties:
-            type: string
-          description: environment variables for the function runtime
-        constraints:
-          type: array
-          items:
-            type: string
-            description: Constraints are specific to OpenFaaS Provider
-            example: node.platform.os == linux
-        secrets:
-          type: array
-          items:
-            type: string
-            description: An array of names of secrets that are made available to the function
-        labels:
-          type: object
-          nullable: true
-          additionalProperties:
-            type: string
-          description: A map of labels for making scheduling or routing decisions
-          example:
-            foo: bar
-        annotations:
-          type: object
-          nullable: true
-          additionalProperties:
-            type: string
-          description: A map of annotations for management, orchestration, events
-            and build tasks
-          example:
-            topics: awesome-kafka-topic
-            foo: bar
-        limits:
-          nullable: true
-          allOf:
-            - $ref: "#/components/schemas/FunctionResources"
-        requests:
-          nullable: true
-          allOf:
-            - $ref: "#/components/schemas/FunctionResources"
-        readOnlyRootFilesystem:
-          type: boolean
-          description: removes write-access from the root filesystem mount-point.
-        invocationCount:
-          type: number
-          description: The amount of invocations for the specified function
-          format: integer
-          example: 1337
-        replicas:
-          type: number
-          description: The current minimal ammount of replicas
-          format: integer
-          example: 2
-        availableReplicas:
-          type: number
-          description: The current available amount of replicas
-          format: integer
-          example: 2
-        createdAt:
-          type: string
-          description: | 
-            is the time read back from the faas backend's
-            data store for when the function or its container was created.
-          format: date-time
-        usage:
-          nullable: true
-          allOf:  
-            - $ref: "#/components/schemas/FunctionUsage"
-
-    FunctionResources:
-      type: object
-      properties:
-        memory:
-          type: string
-          description: The amount of memory that is allocated for the function
-          example: 128M
-        cpu:
-          type: string
-          description: The amount of cpu that is allocated for the function
-          example: '0.01'
-
-    FunctionUsage:
-      type: object
-      properties:
-        cpu:
-          type: number
-          description: | 
-            is the increase in CPU usage since the last measurement
-            equivalent to Kubernetes' concept of millicores.
-          format: double
-          example: 0.01
-        totalMemoryBytes:
-          type: number
-          description: is the total memory usage in bytes.
-          format: double
-          example: 1337
-
-    DeleteFunctionRequest:
-      required:
-      - functionName
-      type: object
-      properties:
-        functionName:
-          type: string
-          description: Name of deployed function
-          example: nodeinfo
-
-    ScaleServiceRequest:
-      required:
-      - serviceName
-      - namespace
-      - replicas
-      type: object
-      properties:
-        serviceName:
-          type: string
-          description: Name of deployed function
-          example: nodeinfo
-        namespace:
-          type: string
-          description: Namespace the function is deployed to.
-          example: openfaas-fn
-        replicas:
-          type: integer
-          format: int64
-          minimum: 0
-          description: Number of replicas to scale to
-          example: 2
-
-    SecretDescription:
-      required:
-        - name
-      type: object
-      properties:
-        name:
-          type: string
-          description: Name of secret
-          example: aws-key
-        namespace:
-          type: string
-          description: Namespace of secret
-          example: openfaas-fn
-    SecretValues:
-      type: object
-      properties:
-        value:
-          type: string
-          description: Value of secret in plain-text
-          example: changeme
-        rawValue:
-          type: string
-          format: byte
-          description: |
-            Value of secret in base64.
-
-            This can be used to provide raw binary data when the `value` field is omitted.
-          example: Y2hhbmdlbWU=
-
-    Secret:
-      type: object
-      allOf:
-        - $ref: "#/components/schemas/SecretDescription"
-        - $ref: "#/components/schemas/SecretValues"
-      
-    LogEntry:
-      type: object
-      required:
-        - name
-        - namespace
-        - instance
-        - timestamp
-        - text
-      properties:
-        name:
-          type: string
-          description: the function name
-        namespace:
-          type: string
-          description: the namespace of the function
-        instance:
-          type: string
-          description: the name/id of the specific function instance
-        timestamp:
-          type: string
-          description: the timestamp of when the log message was recorded
-          format: date-time
-        text:
-          type: string
-          description: raw log message content
-
-    ListNamespaceResponse:
-      type: array
-      items:
-        type: string
-        description: Namespace name
-        example: openfaas-fn
--- a/api-docs/swagger.yml
+++ b/api-docs/swagger.yml
@ -0,0 +1,628 @@
+swagger: '2.0'
+info:
+  description: OpenFaaS API documentation
+  version: 0.8.12
+  title: OpenFaaS API Gateway
+  license:
+    name: MIT
+basePath: /
+schemes:
+- http
+paths:
+  '/system/functions':
+    get:
+      summary: 'Get a list of deployed functions with: stats and image digest'
+      consumes:
+      - application/json
+      produces:
+      - application/json
+      responses:
+        '200':
+          description: List of deployed functions.
+          schema:
+            type: array
+            items:
+              $ref: '#/definitions/FunctionListEntry'
+    post:
+      summary: Deploy a new function.
+      description: ''
+      consumes:
+      - application/json
+      produces:
+      - application/json
+      parameters:
+      - in: body
+        name: body
+        description: Function to deploy
+        required: true
+        schema:
+          $ref: '#/definitions/FunctionDefinition'
+      responses:
+        '202':
+          description: Accepted
+        '400':
+          description: Bad Request
+        '500':
+          description: Internal Server Error
+    put:
+      summary: Update a function.
+      description: ''
+      consumes:
+      - application/json
+      produces:
+      - application/json
+      parameters:
+      - in: body
+        name: body
+        description: Function to update
+        required: true
+        schema:
+          $ref: '#/definitions/FunctionDefinition'
+      responses:
+        '200':
+          description: Accepted
+        '400':
+          description: Bad Request
+        '404':
+          description: Not Found
+        '500':
+          description: Internal Server Error
+    delete:
+      summary: Remove a deployed function.
+      description: ''
+      consumes:
+      - application/json
+      produces:
+      - application/json
+      parameters:
+      - in: body
+        name: body
+        description: Function to delete
+        required: true
+        schema:
+          $ref: '#/definitions/DeleteFunctionRequest'
+      responses:
+        '200':
+          description: OK
+        '400':
+          description: Bad Request
+        '404':
+          description: Not Found
+        '500':
+          description: Internal Server Error
+  '/system/alert':
+    post:
+      summary: 'Event-sink for AlertManager, for auto-scaling'
+      description: 'Internal use for AlertManager, requires valid AlertManager alert JSON'
+      consumes:
+      - application/json
+      produces:
+      - application/json
+      parameters:
+      - in: body
+        name: body
+        description: Incoming alert
+        schema:
+          type: object
+          example: |-
+            {"receiver": "scale-up",
+              "status": "firing",
+              "alerts": [{
+                  "status": "firing",
+                  "labels": {
+                      "alertname": "APIHighInvocationRate",
+                      "code": "200",
+                      "function_name": "func_nodeinfo",
+                      "instance": "gateway:8080",
+                      "job": "gateway",
+                      "monitor": "faas-monitor",
+                      "service": "gateway",
+                      "severity": "major",
+                      "value": "8.998200359928017"
+                  },
+                  "annotations": {
+                      "description": "High invocation total on gateway:8080",
+                      "summary": "High invocation total on gateway:8080"
+                  },
+                  "startsAt": "2017-03-15T15:52:57.805Z",
+                  "endsAt": "0001-01-01T00:00:00Z",
+                  "generatorURL": "http://4156cb797423:9090/graph?g0.expr=rate%28gateway_function_invocation_total%5B10s%5D%29+%3E+5\u0026g0.tab=0"
+              }],
+              "groupLabels": {
+                  "alertname": "APIHighInvocationRate",
+                  "service": "gateway"
+              },
+              "commonLabels": {
+                  "alertname": "APIHighInvocationRate",
+                  "code": "200",
+                  "function_name": "func_nodeinfo",
+                  "instance": "gateway:8080",
+                  "job": "gateway",
+                  "monitor": "faas-monitor",
+                  "service": "gateway",
+                  "severity": "major",
+                  "value": "8.998200359928017"
+              },
+              "commonAnnotations": {
+                  "description": "High invocation total on gateway:8080",
+                  "summary": "High invocation total on gateway:8080"
+              },
+              "externalURL": "http://f054879d97db:9093",
+              "version": "3",
+              "groupKey": 18195285354214864953
+            }
+      responses:
+        '200':
+          description: Alert handled successfully
+        '500':
+          description: Internal error with swarm or request JSON invalid
+  '/async-function/{functionName}':
+    post:
+      summary: 'Invoke a function asynchronously in OpenFaaS'
+      description: >-
+        See https://docs.openfaas.com/reference/async/.
+      parameters:
+      - in: path
+        name: functionName
+        description: Function name
+        type: string
+        required: true
+      - in: body
+        name: input
+        description: (Optional) data to pass to function
+        schema:
+          type: string
+          format: binary
+          example:
+            '{"hello": "world"}'
+        required: false
+      responses:
+        '202':
+          description: Request accepted and queued
+        '404':
+          description: Not Found
+        '500':
+          description: Internal Server Error
+  '/function/{functionName}':
+    post:
+      summary: Invoke a function defined in OpenFaaS
+      parameters:
+      - in: path
+        name: functionName
+        description: Function name
+        type: string
+        required: true
+      - in: body
+        name: input
+        description: (Optional) data to pass to function
+        schema:
+          type: string
+          format: binary
+          example:
+            '{"hello": "world"}'
+        required: false
+      responses:
+        '200':
+          description: Value returned from function
+        '404':
+          description: Not Found
+        '500':
+          description: Internal server error
+  '/system/scale-function/{functionName}':
+    post:
+      summary: Scale a function
+      parameters:
+      - in: path
+        name: functionName
+        description: Function name
+        type: string
+        required: true
+      - in: body
+        name: input
+        description: Function to scale plus replica count
+        schema:
+          type: string
+          format: binary
+          example:
+            '{"service": "hello-world", "replicas": 10}'
+        required: false
+      responses:
+        '200':
+          description: Scaling OK
+        '202':
+          description: Scaling OK
+        '404':
+          description: Function not found
+        '500':
+          description: Error scaling function
+  '/system/function/{functionName}':
+    get:
+      summary: Get a summary of an OpenFaaS function
+      parameters:
+      - in: path
+        name: functionName
+        description: Function name
+        type: string
+        required: true
+      responses:
+        '200':
+          description: Function Summary
+          schema:
+            $ref: '#/definitions/FunctionListEntry'
+        '404':
+          description: Not Found
+        '500':
+          description: Internal Server Error
+  '/system/secrets':
+    get:
+      summary: 'Get a list of secret names and metadata from the provider'
+      consumes:
+      - application/json
+      produces:
+      - application/json
+      responses:
+        '200':
+          description: List of submitted secrets.
+          schema:
+            $ref: '#/definitions/SecretName'
+    post:
+      summary: Create a new secret.
+      description: ''
+      consumes:
+      - application/json
+      produces:
+      - application/json
+      parameters:
+      - in: body
+        name: body
+        description: A new secret to create
+        required: true
+        schema:
+          $ref: '#/definitions/Secret'
+      responses:
+        '201':
+          description: Created
+        '400':
+          description: Bad Request
+        '500':
+          description: Internal Server Error
+    put:
+      summary: Update a secret.
+      description: ''
+      consumes:
+      - application/json
+      produces:
+      - application/json
+      parameters:
+      - in: body
+        name: body
+        description: Secret to update
+        required: true
+        schema:
+          $ref: '#/definitions/Secret'
+      responses:
+        '200':
+          description: Ok
+        '400':
+          description: Bad Request
+        '404':
+          description: Not Found
+        '405':
+          description: Method Not Allowed. Secret update is not allowed in faas-swarm.
+        '500':
+          description: Internal Server Error
+    delete:
+      summary: Remove a secret.
+      description: ''
+      consumes:
+      - application/json
+      produces:
+      - application/json
+      parameters:
+      - in: body
+        name: body
+        description: Secret to delete
+        required: true
+        schema:
+          $ref: '#/definitions/SecretName'
+      responses:
+        '204':
+          description: OK
+        '400':
+          description: Bad Request
+        '404':
+          description: Not Found
+        '500':
+          description: Internal Server Error
+  '/system/logs':
+    get:
+      summary: Get a stream of the logs for a specific function
+      produces:
+        - application/x-ndjson
+      parameters:
+      - in: query
+        name: name
+        description: Function name
+        type: string
+        required: true
+      - in: query
+        name: since
+        description: Only return logs after a specific date (RFC3339)
+        type: string
+        required: false
+      - in: query
+        name: tail
+        description: Sets the maximum number of log messages to return, <=0 means unlimited
+        type: integer
+        required: false
+      - in: query
+        name: follow
+        description: When true, the request will stream logs until the request timeout
+        type: boolean
+        required: false
+      responses:
+        '200':
+          description: Newline delimited stream of log messages
+          schema:
+            $ref: '#/definitions/LogEntry'
+        '404':
+          description: Not Found
+        '500':
+          description: Internal Server Error
+  '/system/info':
+    get:
+      summary: Get info such as provider version number and provider orchestrator
+      produces:
+      - application/json
+      responses:
+        '200':
+          description: Info result
+          schema:
+            $ref: '#/definitions/Info'
+        '404':
+          description: Provider does not support info endpoint
+        '500':
+          description: Internal Server Error
+  '/healthz':
+    get:
+      summary: Healthcheck
+      responses:
+        '200':
+          description: Healthy
+        '500':
+          description: Not healthy
+securityDefinitions:
+  basicAuth:
+    type: basic
+definitions:
+  Info:
+    type: object
+    properties:
+      provider:
+        type: object
+        description: The OpenFaaS Provider
+        properties:
+          provider:
+            type: string
+            example: faas-netes
+          orchestration:
+            type: string
+            example: kubernetes
+          version:
+            type: object
+            description: Version of the OpenFaaS Provider
+            properties:
+              commit_message:
+                type: string
+                example: Sample Message
+              sha:
+                type: string
+                example: 7108418d9dd6b329ddff40e7393b3166f8160a88
+              release:
+                type: string
+                format: semver
+                example: 0.2.6
+      version:
+        type: object
+        description: Version of the Gateway
+        properties:
+          commit_message:
+            type: string
+            example: Sample Message
+          sha:
+            type: string
+            example: 7108418d9dd6b329ddff40e7393b3166f8160a88
+          release:
+            type: string
+            format: semver
+            example: 0.8.9
+      arch:
+        type: string
+        description: "Platform architecture"
+        example: "x86_64"
+    required:
+    - provider
+    - version
+  DeleteFunctionRequest:
+    type: object
+    properties:
+      functionName:
+        type: string
+        description: Name of deployed function
+        example: nodeinfo
+    required:
+    - functionName
+  FunctionDefinition:
+    type: object
+    properties:
+      service:
+        type: string
+        description: Name of deployed function
+        example: nodeinfo
+      network:
+        type: string
+        description: Network, usually func_functions for Swarm (deprecated)
+        example: func_functions
+      image:
+        type: string
+        description: Docker image in accessible registry
+        example: functions/nodeinfo:latest
+      envProcess:
+        type: string
+        description: Process for watchdog to fork
+        example: node main.js
+      envVars:
+        type: object
+        additionalProperties:
+          type: string
+        description: Overrides to environmental variables
+      constraints:
+        type: array
+        items:
+          type: string
+          description: Constraints are specific to OpenFaaS Provider
+          example: "node.platform.os == linux"
+      labels:
+        description: A map of labels for making scheduling or routing decisions
+        type: object
+        additionalProperties:
+          type: string
+        example:
+          foo: bar
+      annotations:
+        description: A map of annotations for management, orchestration, events and build tasks
+        type: object
+        additionalProperties:
+          type: string
+        example:
+          topics: awesome-kafka-topic
+          foo: bar
+      secrets:
+        type: array
+        items:
+          type: string
+          description: An array of names of secrets that are required to be loaded from the Docker Swarm.
+          example: "secret-name-1"
+      registryAuth:
+        type: string
+        description: >-
+          Private registry base64-encoded basic auth (as present in
+          ~/.docker/config.json)
+        example: dXNlcjpwYXNzd29yZA==
+      limits:
+        type: object
+        properties:
+          memory:
+            type: string
+            example: "128M"
+          cpu:
+            type: string
+            example: "0.01"
+      requests:
+        type: object
+        properties:
+          memory:
+            type: string
+            example: "128M"
+          cpu:
+            type: string
+            example: "0.01"
+      readOnlyRootFilesystem:
+        type: boolean
+        description: Make the root filesystem of the function read-only
+    required:
+    - service
+    - image
+    - envProcess
+  FunctionListEntry:
+    type: object
+    properties:
+      name:
+        description: The name of the function
+        type: string
+        example: nodeinfo
+      image:
+        description: The fully qualified docker image name of the function
+        type: string
+        example: functions/nodeinfo:latest
+      invocationCount:
+        description: The amount of invocations for the specified function
+        type: number
+        format: integer
+        example: 1337
+      replicas:
+        description: The current minimal ammount of replicas
+        type: number
+        format: integer
+        example: 2
+      availableReplicas:
+        description: The current available amount of replicas
+        type: number
+        format: integer
+        example: 2
+      envProcess:
+        description: Process for watchdog to fork
+        type: string
+        example: node main.js
+      labels:
+        description: A map of labels for making scheduling or routing decisions
+        type: object
+        additionalProperties:
+          type: string
+        example:
+          foo: bar
+      annotations:
+        description: A map of annotations for management, orchestration, events and build tasks
+        type: object
+        additionalProperties:
+          type: string
+        example:
+          topics: awesome-kafka-topic
+          foo: bar
+    required:
+    - name
+    - image
+    - invocationCount
+    - replicas
+    - availableReplicas
+    - envProcess
+    - labels
+  Secret:
+    type: object
+    properties:
+      name:
+        type: string
+        description: Name of secret
+        example: aws-key
+      value:
+        type: string
+        description: Value of secret in plain-text
+        example: changeme
+    required:
+    - name
+  LogEntry:
+    type: object
+    properties:
+      name:
+        type: string
+        description: the function name
+      instance:
+        type: string
+        description: the name/id of the specific function instance
+      timestamp:
+        type: string
+        format: date-time
+        description: the timestamp of when the log message was recorded
+      text:
+        type: string
+        description: raw log message content
+  SecretName:
+    type: object
+    properties:
+      name:
+        type: string
+        description: Name of secret
+        example: aws-key
+externalDocs:
+  description: More documentation available on Github
+  url: 'https://github.com/openfaas/faas'
--- a/gateway/Dockerfile
+++ b/gateway/Dockerfile
@ -1,6 +1,6 @@
 FROM --platform=${BUILDPLATFORM:-linux/amd64} ghcr.io/openfaas/license-check:0.4.1 as license-check

-FROM --platform=${BUILDPLATFORM:-linux/amd64} golang:1.20 as build
+FROM --platform=${BUILDPLATFORM:-linux/amd64} golang:1.19 as build

 ENV GO111MODULE=on
 ENV CGO_ENABLED=0
@ -44,7 +44,7 @@ RUN CGO_ENABLED=${CGO_ENABLED} GOOS=${TARGETOS} GOARCH=${TARGETARCH} go build --
    -X github.com/openfaas/faas/gateway/types.Arch=${TARGETARCH}" \
    -a -installsuffix cgo -o gateway .

-FROM --platform=${TARGETPLATFORM:-linux/amd64} alpine:3.18.3 as ship
+FROM --platform=${TARGETPLATFORM:-linux/amd64} alpine:3.17 as ship

 LABEL org.label-schema.license="MIT" \
    org.label-schema.vcs-url="https://github.com/openfaas/faas" \
--- a/gateway/Makefile
+++ b/gateway/Makefile
@ -2,13 +2,13 @@ export DOCKER_CLI_EXPERIMENTAL=enabled

 PLATFORM := "linux/amd64,linux/arm/v7,linux/arm64"

-TAG?=dev
-SERVER?=ttl.sh
-OWNER?=openfaas
+TAG?=latest
+SERVER?=docker.io
+OWNER?=alexellis2
 NAME=gateway

-.PHONY: buildx-local
-buildx-local:
+.PHONY: local-docker
+build-local:
 	@echo $(SERVER)/$(OWNER)/$(NAME):$(TAG) \
 	&& docker buildx create --use --name=multiarch --node multiarch \
 	&& docker buildx build \
@ -17,8 +17,8 @@ buildx-local:
 		--output "type=docker,push=false" \
 		--tag $(SERVER)/$(OWNER)/$(NAME):$(TAG) .

-.PHONY: buildx-push
-buildx-push:
+.PHONY: push-docker
+push-docker:
 	@echo $(SERVER)/$(OWNER)/$(NAME):$(TAG) \
 	&& docker buildx create --use --name=multiarch --node multiarch \
 	&& docker buildx build \
--- a/gateway/go.mod
+++ b/gateway/go.mod
@ -1,35 +1,34 @@
 module github.com/openfaas/faas/gateway

-go 1.20
+go 1.19

 require (
-	github.com/docker/distribution v2.8.3+incompatible
+	github.com/docker/distribution v2.8.2+incompatible
 	github.com/gorilla/mux v1.8.0
-	github.com/openfaas/faas-provider v0.24.4
-	github.com/openfaas/nats-queue-worker v0.0.0-20231023101743-fa54e89c9db2
-	github.com/prometheus/client_golang v1.17.0
-	github.com/prometheus/client_model v0.5.0
-	go.uber.org/goleak v1.2.1
-	golang.org/x/sync v0.4.0
+	github.com/openfaas/faas-provider v0.19.1
+	github.com/openfaas/nats-queue-worker v0.0.0-20230117214128-3615ccb286cc
+	github.com/prometheus/client_golang v1.13.0
+	github.com/prometheus/client_model v0.2.0
+	go.uber.org/goleak v1.1.12
+	golang.org/x/sync v0.1.0
 )

-// replace github.com/openfaas/faas-provider => ../../faas-provider
-
 require (
 	github.com/beorn7/perks v1.0.1 // indirect
-	github.com/cespare/xxhash/v2 v2.2.0 // indirect
+	github.com/cespare/xxhash/v2 v2.1.2 // indirect
 	github.com/gogo/protobuf v1.3.2 // indirect
-	github.com/golang/protobuf v1.5.3 // indirect
-	github.com/klauspost/compress v1.17.2 // indirect
-	github.com/matttproud/golang_protobuf_extensions v1.0.4 // indirect
-	github.com/nats-io/nats.go v1.31.0 // indirect
-	github.com/nats-io/nkeys v0.4.5 // indirect
+	github.com/golang/protobuf v1.5.2 // indirect
+	github.com/matttproud/golang_protobuf_extensions v1.0.1 // indirect
+	github.com/nats-io/nats-server/v2 v2.9.11 // indirect
+	github.com/nats-io/nats-streaming-server v0.25.3 // indirect
+	github.com/nats-io/nats.go v1.22.1 // indirect
+	github.com/nats-io/nkeys v0.3.0 // indirect
 	github.com/nats-io/nuid v1.0.1 // indirect
 	github.com/nats-io/stan.go v0.10.4 // indirect
-	github.com/prometheus/common v0.44.0 // indirect
-	github.com/prometheus/procfs v0.12.0 // indirect
-	github.com/stretchr/testify v1.8.2 // indirect
-	golang.org/x/crypto v0.14.0 // indirect
-	golang.org/x/sys v0.13.0 // indirect
-	google.golang.org/protobuf v1.31.0 // indirect
+	github.com/prometheus/common v0.37.0 // indirect
+	github.com/prometheus/procfs v0.8.0 // indirect
+	github.com/stretchr/testify v1.7.1 // indirect
+	golang.org/x/crypto v0.5.0 // indirect
+	golang.org/x/sys v0.4.1-0.20230105183443-b8be2fde2a9e // indirect
+	google.golang.org/protobuf v1.28.1 // indirect
 )
--- a/gateway/go.sum
+++ b/gateway/go.sum
@ -33,45 +33,52 @@ cloud.google.com/go/storage v1.10.0/go.mod h1:FLPqc6j+Ki4BU591ie1oL6qBQGu2Bl/tZ9
 dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU=
 github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
 github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
+github.com/DataDog/datadog-go v2.2.0+incompatible/go.mod h1:LButxg5PwREeZtORoXG3tL4fMGNddJ+vMq1mwgfaqoQ=
 github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
 github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
 github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
 github.com/alecthomas/units v0.0.0-20190717042225-c3de453c63f4/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
 github.com/alecthomas/units v0.0.0-20190924025748-f65c72e2690d/go.mod h1:rBZYJk541a8SKzHPHnH3zbiI+7dagKZ0cgpgrD7Fyho=
-github.com/armon/go-metrics v0.4.1 h1:hR91U9KYmb6bLBYLQjyM+3j+rcd/UhE+G78SFnF8gJA=
+github.com/armon/go-metrics v0.0.0-20190430140413-ec5e00d3c878 h1:EFSB7Zo9Eg91v7MJPVsifUysc/wPdN+NOnVe6bWbdBM=
+github.com/armon/go-metrics v0.0.0-20190430140413-ec5e00d3c878/go.mod h1:3AMJUQhVx52RsWOnlkpikZr01T/yAVN2gn0861vByNg=
 github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
 github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8=
 github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
 github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
 github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/cespare/xxhash/v2 v2.1.2 h1:YRXhKfTDauu4ajMg1TPgFO5jnlC2HCbmLXMcTG5cbYE=
 github.com/cespare/xxhash/v2 v2.1.2/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
-github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44=
-github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI=
 github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI=
 github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=
+github.com/circonus-labs/circonus-gometrics v2.3.1+incompatible/go.mod h1:nmEj6Dob7S7YxXgwXpfOuvO54S+tGdZdw9fuRZt25Ag=
+github.com/circonus-labs/circonusllhist v0.1.3/go.mod h1:kMXHVDlOchFAehlya5ePtbp5jckzBHf4XRpQvBOLI+I=
 github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
 github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/docker/distribution v2.8.3+incompatible h1:AtKxIZ36LoNK51+Z6RpzLpddBirtxJnzDrHLEKxTAYk=
-github.com/docker/distribution v2.8.3+incompatible/go.mod h1:J2gT2udsDAN96Uj4KfcMRqY0/ypR+oyYUYmja8H+y+w=
+github.com/docker/distribution v2.8.2+incompatible h1:T3de5rq0dB1j30rp0sA2rER+m322EBzniBPB6ZIzuh8=
+github.com/docker/distribution v2.8.2+incompatible/go.mod h1:J2gT2udsDAN96Uj4KfcMRqY0/ypR+oyYUYmja8H+y+w=
 github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
 github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
 github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98=
 github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
-github.com/fatih/color v1.13.0 h1:8LOYc1KYPPmyKMuN8QV2DNRWNbLo6LZ0iLs8+mlH53w=
+github.com/fatih/color v1.7.0 h1:DkWD4oS2D8LGGgTQ6IvwJJXSL5Vp2ffcQg58nFV38Ys=
+github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
 github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU=
 github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
 github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
 github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
 github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
 github.com/go-kit/log v0.1.0/go.mod h1:zbhenjAZHb184qTLMA9ZjW7ThYL0H2mk7Q6pNt4vbaY=
+github.com/go-kit/log v0.2.0/go.mod h1:NwTd00d/i8cPZ3xOwwiv2PO5MOcx78fFErGNcVmBjv0=
 github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
 github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
 github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A=
+github.com/go-logfmt/logfmt v0.5.1/go.mod h1:WYhtIu8zTZfxdn5+rREduYbwxfcBr/Vr6KEVveWlfTs=
+github.com/go-sql-driver/mysql v1.7.0/go.mod h1:OXbVy3sEdcQ2Doequ6Z5BW6fXNQTmx+9S1MCJN5yJMI=
 github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
 github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
 github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
@ -102,9 +109,8 @@ github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QD
 github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
 github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
 github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
+github.com/golang/protobuf v1.5.2 h1:ROPKBNFfQgOUMifHyP+KYbvpjbdoFNs+aK7DXlji0Tw=
 github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
-github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg=
-github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
 github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
 github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
 github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
@ -116,7 +122,8 @@ github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/
 github.com/google/go-cmp v0.5.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
+github.com/google/go-cmp v0.5.8 h1:e6P7q2lk1O+qJJb4BtCQXlK8vWEO8V1ZeuEdJNOqZyg=
+github.com/google/go-cmp v0.5.8/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
 github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs=
 github.com/google/martian/v3 v3.0.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0=
@ -132,14 +139,22 @@ github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+
 github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk=
 github.com/gorilla/mux v1.8.0 h1:i40aqfkR1h2SlN9hojwV5ZA91wcXFOvkdNIeFDP5koI=
 github.com/gorilla/mux v1.8.0/go.mod h1:DVbg23sWSpFRCP0SfiEN6jmj59UnW/n46BH5rLB71So=
-github.com/hashicorp/go-hclog v1.5.0 h1:bI2ocEMgcVlz55Oj1xZNBsVi900c7II+fWDyV9o+13c=
+github.com/hashicorp/go-cleanhttp v0.5.0/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80=
+github.com/hashicorp/go-hclog v0.9.1/go.mod h1:5CU+agLiy3J7N7QjHK5d05KxGsuXiQLrjA0H7acj2lQ=
+github.com/hashicorp/go-hclog v1.1.0 h1:QsGcniKx5/LuX2eYoeL+Np3UKYPNaN7YKpTh29h8rbw=
+github.com/hashicorp/go-hclog v1.1.0/go.mod h1:whpDNt7SSdeAju8AWKIWsul05p54N/39EeqMAyrmvFQ=
 github.com/hashicorp/go-immutable-radix v1.0.0 h1:AKDB1HM5PWEA7i4nhcpwOrO2byshxBjXVn/J/3+z5/0=
-github.com/hashicorp/go-msgpack v0.5.5 h1:i9R9JSrqIz0QVLz3sz+i3YJdT7TTSLcfLLzJi9aZTuI=
-github.com/hashicorp/go-msgpack/v2 v2.1.0 h1:J2g2hMyjSefUPTnkLRU2MnsLLsPRB1n4Z/wJRN07GuA=
+github.com/hashicorp/go-immutable-radix v1.0.0/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60=
+github.com/hashicorp/go-msgpack v0.5.5/go.mod h1:ahLV/dePpqEmjfWmKiqvPkv/twdG7iPBM1vqhUKIvfM=
+github.com/hashicorp/go-msgpack v1.1.5 h1:9byZdVjKTe5mce63pRVNP1L7UAmdHOTEMGehn6KvJWs=
+github.com/hashicorp/go-msgpack v1.1.5/go.mod h1:gWVc3sv/wbDmR3rQsj1CAktEZzoz1YNK9NfGLXJ69/4=
+github.com/hashicorp/go-retryablehttp v0.5.3/go.mod h1:9B5zBasrRhHXnJnui7y6sL7es7NDiJgTc6Er0maI1Xs=
+github.com/hashicorp/go-uuid v1.0.0/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
 github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
 github.com/hashicorp/golang-lru v0.5.1 h1:0hERBMJE1eitiLkihrMvRVBYAkpHzc/J3QdDN+dAcgU=
 github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
-github.com/hashicorp/raft v1.5.0 h1:uNs9EfJ4FwiArZRxxfd/dQ5d33nV31/CdCHArH89hT8=
+github.com/hashicorp/raft v1.3.11 h1:p3v6gf6l3S797NnK5av3HcczOC1T5CLoaRvg0g9ys4A=
+github.com/hashicorp/raft v1.3.11/go.mod h1:J8naEwc6XaaCfts7+28whSeRvCqTd6e20BlCU3LtEO4=
 github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
 github.com/jpillora/backoff v1.0.0/go.mod h1:J/6gKK9jxlEcS3zixgDgUAsiuZ7yrSoa/FX5e0EB2j4=
 github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
@ -152,20 +167,24 @@ github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7V
 github.com/julienschmidt/httprouter v1.3.0/go.mod h1:JR6WtHb+2LUe8TCKY3cZOxFyyO8IZAc4RVcycCCAKdM=
 github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=
 github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
-github.com/klauspost/compress v1.17.2 h1:RlWWUY/Dr4fL8qk9YG7DTZ7PDgME2V4csBXA8L/ixi4=
-github.com/klauspost/compress v1.17.2/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE=
+github.com/klauspost/compress v1.15.11 h1:Lcadnb3RKGin4FYM/orgq0qde+nc15E5Cbqg4B9Sx9c=
+github.com/klauspost/compress v1.15.11/go.mod h1:QPwzmACJjUTFsnSHH934V6woptycfrDDJnH7hvFVbGM=
 github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
 github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
 github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
-github.com/mattn/go-colorable v0.1.12 h1:jF+Du6AlPIjs2BiUiQlKOX0rt3SujHxPnksPKZbaA40=
-github.com/mattn/go-isatty v0.0.14 h1:yVuAays6BHfxijgZPzw+3Zlu5yQgKGP2/hcQbHb7S9Y=
+github.com/lib/pq v1.10.4/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
+github.com/mattn/go-colorable v0.1.4 h1:snbPLB8fVfU9iwbbo30TPtbLRzwWu6aJS6Xh4eaaviA=
+github.com/mattn/go-colorable v0.1.4/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
+github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
+github.com/mattn/go-isatty v0.0.10 h1:qxFzApOv4WsAL965uUPIsXzAKCZxN2p9UqdhFS4ZW10=
+github.com/mattn/go-isatty v0.0.10/go.mod h1:qgIWMr58cqv1PHHyhnkY9lrL7etaEgOFcMEpPG5Rm84=
+github.com/matttproud/golang_protobuf_extensions v1.0.1 h1:4hp9jkHxhMHkqkrB3Ix0jegS5sx/RkqARlsWZ6pIwiU=
 github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
-github.com/matttproud/golang_protobuf_extensions v1.0.4 h1:mmDVorXM7PCGKw94cs5zkfA9PSy5pEvNWRP0ET0TIVo=
-github.com/matttproud/golang_protobuf_extensions v1.0.4/go.mod h1:BSXmuO+STAnVfrANrmjBb36TMTDstsz7MSK+HVaYKv4=
 github.com/minio/highwayhash v1.0.2 h1:Aak5U0nElisjDCfPSG79Tgzkn2gl66NxOMspRrKnA/g=
+github.com/minio/highwayhash v1.0.2/go.mod h1:BQskDq+xkJ12lmlUUi7U0M5Swg3EWR+dLTk+kldvVxY=
 github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
@ -173,94 +192,89 @@ github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3Rllmb
 github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
 github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
 github.com/mwitkow/go-conntrack v0.0.0-20190716064945-2f068394615f/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
-github.com/nats-io/jwt/v2 v2.5.2 h1:DhGH+nKt+wIkDxM6qnVSKjokq5t59AZV5HRcFW0zJwU=
-github.com/nats-io/nats-server/v2 v2.10.3 h1:nk2QVLpJUh3/AhZCJlQdTfj2oeLDvWnn1Z6XzGlNFm0=
-github.com/nats-io/nats-server/v2 v2.10.3/go.mod h1:lzrskZ/4gyMAh+/66cCd+q74c6v7muBypzfWhP/MAaM=
-github.com/nats-io/nats-streaming-server v0.25.5 h1:DX6xaPhKvVLhdpNsuEmmD+O9LfWSnw8cvxQU/H9LRy8=
-github.com/nats-io/nats-streaming-server v0.25.5/go.mod h1:dSBVdHGsT/tV91lT4MWFfE6+yjRCNhRIYJpBaTHFdAo=
+github.com/nats-io/jwt/v2 v2.3.0 h1:z2mA1a7tIf5ShggOFlR1oBPgd6hGqcDYsISxZByUzdI=
+github.com/nats-io/jwt/v2 v2.3.0/go.mod h1:0tqz9Hlu6bCBFLWAASKhE5vUA4c24L9KPUUgvwumE/k=
+github.com/nats-io/nats-server/v2 v2.9.11 h1:4y5SwWvWI59V5mcqtuoqKq6L9NDUydOP3Ekwuwl8cZI=
+github.com/nats-io/nats-server/v2 v2.9.11/go.mod h1:b0oVuxSlkvS3ZjMkncFeACGyZohbO4XhSqW1Lt7iRRY=
+github.com/nats-io/nats-streaming-server v0.25.3 h1:A9dmf4fMIxFPBGqgwePljWsBePMEjl3ugsIwK6F2wow=
+github.com/nats-io/nats-streaming-server v0.25.3/go.mod h1:0Cyht7y75el3if3Qdq31OPc/TNjVwzglMPz04Hn77kk=
+github.com/nats-io/nats.go v1.19.0/go.mod h1:tLqubohF7t4z3du1QDPYJIQQyhb4wl6DhjxEajSI7UA=
+github.com/nats-io/nats.go v1.22.1 h1:XzfqDspY0RNufzdrB8c4hFR+R3dahkxlpWe5+IWJzbE=
 github.com/nats-io/nats.go v1.22.1/go.mod h1:tLqubohF7t4z3du1QDPYJIQQyhb4wl6DhjxEajSI7UA=
-github.com/nats-io/nats.go v1.31.0 h1:/WFBHEc/dOKBF6qf1TZhrdEfTmOZ5JzdJ+Y3m6Y/p7E=
-github.com/nats-io/nats.go v1.31.0/go.mod h1:di3Bm5MLsoB4Bx61CBTsxuarI36WbhAwOm8QrW39+i8=
+github.com/nats-io/nkeys v0.3.0 h1:cgM5tL53EvYRU+2YLXIK0G2mJtK12Ft9oeooSZMA2G8=
 github.com/nats-io/nkeys v0.3.0/go.mod h1:gvUNGjVcM2IPr5rCsRsC6Wb3Hr2CQAm08dsxtV6A5y4=
-github.com/nats-io/nkeys v0.4.5 h1:Zdz2BUlFm4fJlierwvGK+yl20IAKUm7eV6AAZXEhkPk=
-github.com/nats-io/nkeys v0.4.5/go.mod h1:XUkxdLPTufzlihbamfzQ7mw/VGx6ObUs+0bN5sNvt64=
 github.com/nats-io/nuid v1.0.1 h1:5iA8DT8V7q8WK2EScv2padNa/rTESc1KdnPw4TC2paw=
 github.com/nats-io/nuid v1.0.1/go.mod h1:19wcPz3Ph3q0Jbyiqsd0kePYG7A95tJPxeL+1OSON2c=
 github.com/nats-io/stan.go v0.10.4 h1:19GS/eD1SeQJaVkeM9EkvEYattnvnWrZ3wkSWSw4uXw=
 github.com/nats-io/stan.go v0.10.4/go.mod h1:3XJXH8GagrGqajoO/9+HgPyKV5MWsv7S5ccdda+pc6k=
 github.com/openfaas/faas-provider v0.19.1 h1:xH8lTWabfDZwzIvC0u1AO48ghD3BNw6Vo231DLqTeI0=
 github.com/openfaas/faas-provider v0.19.1/go.mod h1:Farrp+9Med8LeK3aoYpqplMP8f5ebTILbCSLg2LPLZk=
-github.com/openfaas/faas-provider v0.24.4 h1:Zzbkabgd0PoQmnRjy53NbMXjhLaIyoIiwP3qaLkm9rE=
-github.com/openfaas/faas-provider v0.24.4/go.mod h1:NsETIfEndZn4mn/w/XnBTcDTwKqULCziphLp7KgeRcA=
-github.com/openfaas/nats-queue-worker v0.0.0-20230303171817-9dfe6fa61387 h1:D4xbdy309Wdyhlm6PgJqUV/aR77VQQG8UTF+q0ay71c=
-github.com/openfaas/nats-queue-worker v0.0.0-20230303171817-9dfe6fa61387/go.mod h1:s86POyW6C8S4CALFRhO8ax5sR2uaQUJQ0HaQGvbTpTc=
-github.com/openfaas/nats-queue-worker v0.0.0-20231023101743-fa54e89c9db2 h1:I8U2kq2h7Wl6pkd4hjRK6P0/o3AcCNdfmNJS5gdgxKU=
-github.com/openfaas/nats-queue-worker v0.0.0-20231023101743-fa54e89c9db2/go.mod h1:Ckz9JKcyzKtzLd9Obc5wVAXJhq05lKL3Ck+5r3MnKE0=
+github.com/openfaas/nats-queue-worker v0.0.0-20230117214128-3615ccb286cc h1:qMcVTwdbRAqZtQrYS9rvUxnbQY6nmqf7CIsjp7A+cOo=
+github.com/openfaas/nats-queue-worker v0.0.0-20230117214128-3615ccb286cc/go.mod h1:s86POyW6C8S4CALFRhO8ax5sR2uaQUJQ0HaQGvbTpTc=
+github.com/pascaldekloe/goe v0.1.0/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc=
 github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/prashantv/gostub v1.1.0/go.mod h1:A5zLQHz7ieHGG7is6LLXLz7I8+3LZzsrV0P1IAHhP5U=
 github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
+github.com/prometheus/client_golang v0.9.2/go.mod h1:OsXs2jCmiKlQ1lTBmv21f2mNfw4xf/QclQDMrYNZzcM=
 github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo=
 github.com/prometheus/client_golang v1.7.1/go.mod h1:PY5Wy2awLA44sXw4AOSfFBetzPP4j5+D6mVACh+pe2M=
 github.com/prometheus/client_golang v1.11.0/go.mod h1:Z6t4BnS23TR94PD6BsDNk8yVqroYurpAkEiz0P2BEV0=
-github.com/prometheus/client_golang v1.12.2 h1:51L9cDoUHVrXx4zWYlcLQIZ+d+VXHgqnYKkIuq4g/34=
-github.com/prometheus/client_golang v1.12.2/go.mod h1:3Z9XVyYiZYEO+YQWt3RD2R3jrbd179Rt297l4aS6nDY=
-github.com/prometheus/client_golang v1.16.0 h1:yk/hx9hDbrGHovbci4BY+pRMfSuuat626eFsHb7tmT8=
-github.com/prometheus/client_golang v1.16.0/go.mod h1:Zsulrv/L9oM40tJ7T815tM89lFEugiJ9HzIqaAx4LKc=
-github.com/prometheus/client_golang v1.17.0 h1:rl2sfwZMtSthVU752MqfjQozy7blglC+1SOtjMAMh+Q=
-github.com/prometheus/client_golang v1.17.0/go.mod h1:VeL+gMmOAxkS2IqfCq0ZmHSL+LjWfWDUmp1mBz9JgUY=
+github.com/prometheus/client_golang v1.12.1/go.mod h1:3Z9XVyYiZYEO+YQWt3RD2R3jrbd179Rt297l4aS6nDY=
+github.com/prometheus/client_golang v1.13.0 h1:b71QUfeo5M8gq2+evJdTPfZhYMAU0uKPkyPJ7TPsloU=
+github.com/prometheus/client_golang v1.13.0/go.mod h1:vTeo+zgvILHsnnj/39Ou/1fPN5nJFOEMgftOUOmlvYQ=
 github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
 github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
 github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/client_model v0.2.0 h1:uq5h0d+GuxiXLJLNABMgp2qUWDPiLvgCzz2dUR+/W/M=
 github.com/prometheus/client_model v0.2.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
-github.com/prometheus/client_model v0.5.0 h1:VQw1hfvPvk3Uv6Qf29VrPF32JB6rtbgI6cYPYQjL0Qw=
-github.com/prometheus/client_model v0.5.0/go.mod h1:dTiFglRmd66nLR9Pv9f0mZi7B7fk5Pm3gvsjB5tr+kI=
+github.com/prometheus/common v0.0.0-20181126121408-4724e9255275/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro=
 github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
 github.com/prometheus/common v0.10.0/go.mod h1:Tlit/dnDKsSWFlCLTWaA1cyBgKHSMdTB80sz/V91rCo=
 github.com/prometheus/common v0.26.0/go.mod h1:M7rCNAaPfAosfx8veZJCuw84e35h3Cfd9VFqTh1DIvc=
-github.com/prometheus/common v0.32.1 h1:hWIdL3N2HoUx3B8j3YN9mWor0qhY/NlEKZEaXxuIRh4=
 github.com/prometheus/common v0.32.1/go.mod h1:vu+V0TpY+O6vW9J44gczi3Ap/oXXR10b+M/gUGO4Hls=
-github.com/prometheus/common v0.42.0 h1:EKsfXEYo4JpWMHH5cg+KOUWeuJSov1Id8zGR8eeI1YM=
-github.com/prometheus/common v0.42.0/go.mod h1:xBwqVerjNdUDjgODMpudtOMwlOwf2SaTr1yjz4b7Zbc=
-github.com/prometheus/common v0.44.0 h1:+5BrQJwiBB9xsMygAB3TNvpQKOwlkc25LbISbrdOOfY=
-github.com/prometheus/common v0.44.0/go.mod h1:ofAIvZbQ1e/nugmZGz4/qCb9Ap1VoSTIO7x0VV9VvuY=
+github.com/prometheus/common v0.37.0 h1:ccBbHCgIiT9uSoFY0vX8H3zsNR5eLt17/RQLUvn8pXE=
+github.com/prometheus/common v0.37.0/go.mod h1:phzohg0JFMnBEFGxTDbfu3QyL5GI8gTQJFhYO5B3mfA=
 github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
+github.com/prometheus/procfs v0.0.0-20181204211112-1dc9a6cbc91a/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
 github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
 github.com/prometheus/procfs v0.1.3/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU=
 github.com/prometheus/procfs v0.6.0/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA=
 github.com/prometheus/procfs v0.7.3/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA=
-github.com/prometheus/procfs v0.12.0 h1:jluTpSng7V9hY0O2R9DzzJHYb2xULk9VTR1V1R/k6Bo=
-github.com/prometheus/procfs v0.12.0/go.mod h1:pcuDEFsWDnvcgNzo4EEweacyhjeA9Zk3cnaOZAZEfOo=
+github.com/prometheus/procfs v0.8.0 h1:ODq8ZFEaYeCaZOJlZZdJA2AbQR98dSHSM1KW/You5mo=
+github.com/prometheus/procfs v0.8.0/go.mod h1:z7EfXMXOkbkqb9IINtpCn86r/to3BnA0uaxHdg830/4=
 github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
 github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
 github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
 github.com/sirupsen/logrus v1.6.0/go.mod h1:7uNnSEd1DgxDLC74fIahvMZmmYsHGZGEOFrfsX/uA88=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
-github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.7.1 h1:5TQK59W5E3v0r2duFAb7P95B6hEeOyEnHRa8MjYSMTY=
 github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
-github.com/stretchr/testify v1.8.2 h1:+h33VjcLVPDHtOdpUCuF+7gSuG3yGIftsP1YvFihtJ8=
-github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+github.com/tv42/httpunix v0.0.0-20150427012821-b75d8614f926/go.mod h1:9ESjWnEqriFuLhtthL60Sar/7RFoluCcXsuvEwTV5KM=
 github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
 github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
-go.etcd.io/bbolt v1.3.7 h1:j+zJOnnEjF/kyHlDDgGnVL/AIqIJPq8UoB2GSNfkUfQ=
+go.etcd.io/bbolt v1.3.6 h1:/ecaJf0sk1l4l6V4awd65v2C3ILy7MSj+s/x1ADCIMU=
+go.etcd.io/bbolt v1.3.6/go.mod h1:qXsaaIqmgQH0T+OPdb99Bf+PKfBBQVAdyD6TY9G8XM4=
 go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=
 go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8=
 go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
 go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
 go.opencensus.io v0.22.4/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
-go.uber.org/goleak v1.2.1 h1:NBol2c7O1ZokfZ0LEU9K6Whx/KnwvepVetCUhtKja4A=
-go.uber.org/goleak v1.2.1/go.mod h1:qlT2yGI9QafXHhZZLxlSuNsMw3FFLxBr+tBRlmO1xH4=
+go.uber.org/automaxprocs v1.5.1/go.mod h1:BF4eumQw0P9GtnuxxovUd06vwm1o18oMzFtK66vU6XU=
+go.uber.org/goleak v1.1.12 h1:gZAh5/EyT/HQwlpkCy6wTpqfH9H8Lz8zbm3dZh+OyzA=
+go.uber.org/goleak v1.1.12/go.mod h1:cwTWslyiVhfpKIDGSZEM2HlOvcqm+tG4zioyIeLoqMQ=
 golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
@ -269,9 +283,8 @@ golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8U
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20210314154223-e6e6c4f2bb5b/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/crypto v0.5.0 h1:U/0M97KRkSFvyD/3FSmdP5W5swImpNgle/EHFhOsQPE=
 golang.org/x/crypto v0.5.0/go.mod h1:NK/OQwhpMQP3MwtdjgLlYHnH9ebylxKWv3e0fK+mkQU=
-golang.org/x/crypto v0.14.0 h1:wBqGXzWJW6m1XrIKlAH0Hs1JJ7+9KBwnIO8v66Q9cHc=
-golang.org/x/crypto v0.14.0/go.mod h1:MVFd36DqK4CsrnJYDkBA3VC4m2GkXAM0PvzMCn4JQf4=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8=
@ -293,6 +306,7 @@ golang.org/x/lint v0.0.0-20190909230951-414d861bb4ac/go.mod h1:6SW0HCj/g11FgYtHl
 golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
 golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f/go.mod h1:5qLYkcX4OjUUV8bRuDixDT3tpyyb+LUpUlRWLxfhWrs=
 golang.org/x/lint v0.0.0-20200130185559-910be7a94367/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
+golang.org/x/lint v0.0.0-20200302205851-738671d3881b h1:Wh+f8QHJXR411sJR8/vRBTZ7YapZaRvUcLFFJhusH0k=
 golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
 golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE=
 golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o=
@ -302,10 +316,12 @@ golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzB
 golang.org/x/mod v0.1.1-0.20191107180719-034126e5016b/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
 golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
 golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20181201002055-351d144fa1fc/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
@ -333,7 +349,10 @@ golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81R
 golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
 golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
 golang.org/x/net v0.0.0-20210525063256-abc453219eb5/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/net v0.0.0-20220127200216-cd36cc0744dd/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
+golang.org/x/net v0.0.0-20220225172249-27dd8689420f/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
 golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
 golang.org/x/net v0.5.0/go.mod h1:DivGGAXEgPSlEBzxGzZI+ZLohi+xUj054jfeKui00ws=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
@ -342,6 +361,7 @@ golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4Iltr
 golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/oauth2 v0.0.0-20210514164344-f6687ab2804c/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
+golang.org/x/oauth2 v0.0.0-20220223155221-ee480838109b/go.mod h1:DAh4E804XQdzx2j+YRIaUnCqCV2RuMz24cGBJ5QYIrc=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
@ -352,13 +372,17 @@ golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJ
 golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20220601150217-0de741cfad7f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.4.0 h1:zxkM55ReGkDlKSM+Fu41A+zmbZuaPVbGMzvvdUPznYQ=
-golang.org/x/sync v0.4.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y=
+golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o=
+golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190130150945-aca44879d564/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@ -368,6 +392,7 @@ golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191008105621-543471e840be/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200106162015-b016eb3dc98e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@ -386,18 +411,22 @@ golang.org/x/sys v0.0.0-20200523222454-059865788121/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200625212154-ddb9806d33ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200803210538-64077c9b5642/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200923182605-d9f96fdee20d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210603081109-ebe580a85c40/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220114195835-da31bd327af9/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.4.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.13.0 h1:Af8nKPmuFypiUBjVoU9V20FiaFXOcuZI21p0ycVYYGE=
-golang.org/x/sys v0.13.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.4.1-0.20230105183443-b8be2fde2a9e h1:Lw2b7QX5zDuEsD5ZkJNRUGEGkLuho3UAKsO25Ucv140=
+golang.org/x/sys v0.4.1-0.20230105183443-b8be2fde2a9e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
 golang.org/x/term v0.4.0/go.mod h1:9P2UbLfCdcvo3p/nzKvsmas4TnlujnuoV9hGgYzW1lQ=
@ -412,13 +441,15 @@ golang.org/x/text v0.6.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
 golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
-golang.org/x/time v0.3.0 h1:rg5rLMjNzMS1RkNLzCG38eapWhnYLFYXDXj2gOlr8j4=
+golang.org/x/time v0.0.0-20220922220347-f3bd1da661af h1:Yx9k8YCG3dvF87UAn2tu2HQLf2dt/eR1bXxpLMWeH+Y=
+golang.org/x/time v0.0.0-20220922220347-f3bd1da661af/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
 golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
 golang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
 golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190424220101-1e8e1cfdf96b/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
 golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
 golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
 golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
@ -455,6 +486,8 @@ golang.org/x/tools v0.0.0-20200729194436-6467de6f59a7/go.mod h1:njjCfa9FT2d7l9Bc
 golang.org/x/tools v0.0.0-20200804011535-6c149bb5ef0d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
 golang.org/x/tools v0.0.0-20200825202427-b303f430e36d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
 golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
+golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
+golang.org/x/tools v0.1.12 h1:VveCTK38A2rkS8ZqFY25HIDFscX5X9OoEhJd3quQmXU=
 golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
@ -535,8 +568,8 @@ google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGj
 google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
 google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
 google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
-google.golang.org/protobuf v1.31.0 h1:g0LDEJHgrBl9N9r17Ru3sqWhkIx2NB67okBHPwC7hs8=
-google.golang.org/protobuf v1.31.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
+google.golang.org/protobuf v1.28.1 h1:d0NfwRgPtno5B1Wa6L2DAG+KivqkdutMf1UhdNx175w=
+google.golang.org/protobuf v1.28.1/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
 gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
@ -549,8 +582,8 @@ gopkg.in/yaml.v2 v2.2.5/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
-gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b h1:h8qDotaEPuJATrMmW04NCwg7v22aHH28wwpauUhK9Oo=
+gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
--- a/gateway/handlers/alerthandler.go
+++ b/gateway/handlers/alerthandler.go
@ -6,7 +6,7 @@ package handlers
 import (
 	"encoding/json"
 	"fmt"
-	"io"
+	"io/ioutil"
 	"log"
 	"math"
 	"net/http"
@ -27,7 +27,7 @@ func MakeAlertHandler(service scaling.ServiceQuery, defaultNamespace string) htt

 		defer r.Body.Close()

-		body, err := io.ReadAll(r.Body)
+		body, err := ioutil.ReadAll(r.Body)
 		if err != nil {
 			w.WriteHeader(http.StatusBadRequest)
 			w.Write([]byte("Unable to read alert."))
@ -44,7 +44,7 @@ func MakeAlertHandler(service scaling.ServiceQuery, defaultNamespace string) htt
 			return
 		}

-		errors := handleAlerts(req, service, defaultNamespace)
+		errors := handleAlerts(&req, service, defaultNamespace)
 		if len(errors) > 0 {
 			log.Println(errors)
 			var errorOutput string
@ -60,7 +60,7 @@ func MakeAlertHandler(service scaling.ServiceQuery, defaultNamespace string) htt
 	}
 }

-func handleAlerts(req requests.PrometheusAlert, service scaling.ServiceQuery, defaultNamespace string) []error {
+func handleAlerts(req *requests.PrometheusAlert, service scaling.ServiceQuery, defaultNamespace string) []error {
 	var errors []error
 	for _, alert := range req.Alerts {
 		if err := scaleService(alert, service, defaultNamespace); err != nil {
--- a/gateway/handlers/callid_middleware.go
+++ b/gateway/handlers/callid_middleware.go
@ -9,14 +9,10 @@ import (
 	"time"

 	"github.com/docker/distribution/uuid"
-	"github.com/openfaas/faas/gateway/version"
 )

 // MakeCallIDMiddleware middleware tags a request with a uid
 func MakeCallIDMiddleware(next http.HandlerFunc) http.HandlerFunc {
-
-	version := version.Version
-
 	return func(w http.ResponseWriter, r *http.Request) {
 		start := time.Now()
 		if len(r.Header.Get("X-Call-Id")) == 0 {
@ -28,8 +24,6 @@ func MakeCallIDMiddleware(next http.HandlerFunc) http.HandlerFunc {
 		r.Header.Add("X-Start-Time", fmt.Sprintf("%d", start.UTC().UnixNano()))
 		w.Header().Add("X-Start-Time", fmt.Sprintf("%d", start.UTC().UnixNano()))

-		w.Header().Add("X-Served-By", fmt.Sprintf("openfaas-community/%s", version))
-
 		next(w, r)
 	}
 }
--- a/gateway/handlers/forwarding_proxy_test.go
+++ b/gateway/handlers/forwarding_proxy_test.go
@ -6,7 +6,7 @@ package handlers
 import (
 	"bytes"
 	"fmt"
-	"io"
+	"io/ioutil"
 	"net/http"
 	"net/url"
 	"testing"
@ -33,7 +33,7 @@ func Test_buildUpstreamRequest_Body_Method_Query(t *testing.T) {
 		t.Fail()
 	}

-	upstreamBytes, _ := io.ReadAll(upstream.Body)
+	upstreamBytes, _ := ioutil.ReadAll(upstream.Body)

 	if string(upstreamBytes) != string(srcBytes) {
 		t.Errorf("Body - want: %s, got: %s", string(upstreamBytes), string(srcBytes))
@ -212,7 +212,7 @@ func Test_buildUpstreamRequest_WithPathNoQuery(t *testing.T) {
 		t.Fail()
 	}

-	upstreamBytes, _ := io.ReadAll(upstream.Body)
+	upstreamBytes, _ := ioutil.ReadAll(upstream.Body)

 	if string(upstreamBytes) != string(srcBytes) {
 		t.Errorf("Body - want: %s, got: %s", string(upstreamBytes), string(srcBytes))
@ -268,7 +268,7 @@ func Test_buildUpstreamRequest_WithNoPathNoQuery(t *testing.T) {
 		t.Fail()
 	}

-	upstreamBytes, _ := io.ReadAll(upstream.Body)
+	upstreamBytes, _ := ioutil.ReadAll(upstream.Body)

 	if string(upstreamBytes) != string(srcBytes) {
 		t.Errorf("Body - want: %s, got: %s", string(upstreamBytes), string(srcBytes))
@ -322,7 +322,7 @@ func Test_buildUpstreamRequest_WithPathAndQuery(t *testing.T) {
 		t.Fail()
 	}

-	upstreamBytes, _ := io.ReadAll(upstream.Body)
+	upstreamBytes, _ := ioutil.ReadAll(upstream.Body)

 	if string(upstreamBytes) != string(srcBytes) {
 		t.Errorf("Body - want: %s, got: %s", string(upstreamBytes), string(srcBytes))
--- a/gateway/handlers/logs_test.go
+++ b/gateway/handlers/logs_test.go
@ -3,7 +3,7 @@ package handlers
 import (
 	"context"
 	"fmt"
-	"io"
+	"io/ioutil"
 	"net/http"
 	"net/http/httptest"
 	"net/url"
@ -52,7 +52,7 @@ func Test_logsProxyDoesNotLeakGoroutinesWhenProviderClosesConnection(t *testing.
 		t.Fatalf("unexpected error sending log request: %s", err)
 	}

-	body, err := io.ReadAll(resp.Body)
+	body, err := ioutil.ReadAll(resp.Body)
 	if err != nil {
 		t.Fatalf("unexpected error reading the response body: %s", err)
 	}
@ -126,7 +126,7 @@ func Test_logsProxyDoesNotLeakGoroutinesWhenClientClosesConnection(t *testing.T)
 	go func() {
 		defer resp.Body.Close()
 		defer close(errCh)
-		_, err := io.ReadAll(resp.Body)
+		_, err := ioutil.ReadAll(resp.Body)
 		errCh <- err
 	}()
 	cancel()
--- a/gateway/handlers/queue_proxy.go
+++ b/gateway/handlers/queue_proxy.go
@ -5,7 +5,7 @@ package handlers

 import (
 	"fmt"
-	"io"
+	"io/ioutil"
 	"log"
 	"net/http"
 	"net/url"
@ -27,7 +27,7 @@ func MakeQueuedProxy(metrics metrics.MetricOptions, queuer ftypes.RequestQueuer,
 			defer r.Body.Close()

 			var err error
-			body, err = io.ReadAll(r.Body)
+			body, err = ioutil.ReadAll(r.Body)
 			if err != nil {
 				http.Error(w, err.Error(), http.StatusBadRequest)
 				return
--- a/gateway/main.go
+++ b/gateway/main.go
@ -130,7 +130,6 @@ func main() {
 	faasHandlers.SecretHandler = handlers.MakeForwardingProxyHandler(reverseProxy, forwardingNotifiers, urlResolver, nilURLTransformer, serviceAuthInjector)

 	faasHandlers.NamespaceListerHandler = handlers.MakeForwardingProxyHandler(reverseProxy, forwardingNotifiers, urlResolver, nilURLTransformer, serviceAuthInjector)
-	faasHandlers.NamespaceMutatorHandler = handlers.MakeForwardingProxyHandler(reverseProxy, forwardingNotifiers, urlResolver, nilURLTransformer, serviceAuthInjector)

 	faasHandlers.Alert = handlers.MakeNotifierWrapper(
 		handlers.MakeAlertHandler(externalServiceQuery, config.Namespace),
@ -194,8 +193,6 @@ func main() {
 			auth.DecorateWithBasicAuth(faasHandlers.LogProxyHandler, credentials)
 		faasHandlers.NamespaceListerHandler =
 			auth.DecorateWithBasicAuth(faasHandlers.NamespaceListerHandler, credentials)
-		faasHandlers.NamespaceMutatorHandler =
-			auth.DecorateWithBasicAuth(faasHandlers.NamespaceMutatorHandler, credentials)
 	}

 	r := mux.NewRouter()
@ -219,8 +216,6 @@ func main() {
 	r.HandleFunc("/system/logs", faasHandlers.LogProxyHandler).Methods(http.MethodGet)

 	r.HandleFunc("/system/namespaces", faasHandlers.NamespaceListerHandler).Methods(http.MethodGet)
-	r.HandleFunc("/system/namespace/{namespace:["+NameExpression+"]*}", faasHandlers.NamespaceMutatorHandler).
-		Methods(http.MethodPost, http.MethodDelete, http.MethodPut, http.MethodGet)

 	if faasHandlers.QueuedProxy != nil {
 		r.HandleFunc("/async-function/{name:["+NameExpression+"]+}/", faasHandlers.QueuedProxy).Methods(http.MethodPost)
--- a/gateway/metrics/add_metrics.go
+++ b/gateway/metrics/add_metrics.go
@ -3,7 +3,7 @@ package metrics
 import (
 	"encoding/json"
 	"fmt"
-	"io"
+	"io/ioutil"
 	"log"
 	"net/http"
 	"net/http/httptest"
@ -28,7 +28,7 @@ func AddMetricsHandler(handler http.HandlerFunc, prometheusQuery PrometheusQuery
 		}

 		defer upstreamCall.Body.Close()
-		upstreamBody, _ := io.ReadAll(upstreamCall.Body)
+		upstreamBody, _ := ioutil.ReadAll(upstreamCall.Body)

 		if recorder.Code != http.StatusOK {
 			log.Printf("List functions responded with code %d, body: %s",
--- a/gateway/metrics/exporter.go
+++ b/gateway/metrics/exporter.go
@ -7,7 +7,7 @@ package metrics
 import (
 	"encoding/json"
 	"fmt"
-	"io"
+	"io/ioutil"
 	"net"
 	"net/http"
 	"net/url"
@ -159,7 +159,7 @@ func (e *Exporter) getFunctions(endpointURL url.URL, namespace string) ([]types.
 		return services, err
 	}

-	bytesOut, readErr := io.ReadAll(res.Body)
+	bytesOut, readErr := ioutil.ReadAll(res.Body)
 	if readErr != nil {
 		return services, readErr
 	}
@ -193,7 +193,7 @@ func (e *Exporter) getNamespaces(endpointURL url.URL) ([]string, error) {
 		return namespaces, nil
 	}

-	bytesOut, readErr := io.ReadAll(res.Body)
+	bytesOut, readErr := ioutil.ReadAll(res.Body)
 	if readErr != nil {
 		return namespaces, readErr
 	}
--- a/gateway/metrics/exporter_test.go
+++ b/gateway/metrics/exporter_test.go
@ -41,21 +41,21 @@ func Test_Describe_DescribesThePrometheusMetrics(t *testing.T) {
 	go exporter.Describe(ch)

 	d := <-ch
-	expectedGatewayFunctionInvocationDesc := `Desc{fqName: "gateway_function_invocation_total", help: "Function metrics", constLabels: {}, variableLabels: {function_name,code}}`
+	expectedGatewayFunctionInvocationDesc := `Desc{fqName: "gateway_function_invocation_total", help: "Function metrics", constLabels: {}, variableLabels: [function_name code]}`
 	actualGatewayFunctionInvocationDesc := d.String()
 	if expectedGatewayFunctionInvocationDesc != actualGatewayFunctionInvocationDesc {
 		t.Errorf("Want\n%s\ngot\n%s", expectedGatewayFunctionInvocationDesc, actualGatewayFunctionInvocationDesc)
 	}

 	d = <-ch
-	expectedGatewayFunctionsHistogramDesc := `Desc{fqName: "gateway_functions_seconds", help: "Function time taken", constLabels: {}, variableLabels: {function_name,code}}`
+	expectedGatewayFunctionsHistogramDesc := `Desc{fqName: "gateway_functions_seconds", help: "Function time taken", constLabels: {}, variableLabels: [function_name code]}`
 	actualGatewayFunctionsHistogramDesc := d.String()
 	if expectedGatewayFunctionsHistogramDesc != actualGatewayFunctionsHistogramDesc {
 		t.Errorf("Want\n%s\ngot\n%s", expectedGatewayFunctionsHistogramDesc, actualGatewayFunctionsHistogramDesc)
 	}

 	d = <-ch
-	expectedServiceReplicasGaugeDesc := `Desc{fqName: "gateway_service_count", help: "Current count of replicas for function", constLabels: {}, variableLabels: {function_name}}`
+	expectedServiceReplicasGaugeDesc := `Desc{fqName: "gateway_service_count", help: "Current count of replicas for function", constLabels: {}, variableLabels: [function_name]}`
 	actualServiceReplicasGaugeDesc := d.String()
 	if expectedServiceReplicasGaugeDesc != actualServiceReplicasGaugeDesc {
 		t.Errorf("Want\n%s\ngot\n%s", expectedServiceReplicasGaugeDesc, actualServiceReplicasGaugeDesc)
--- a/gateway/metrics/prometheus_query.go
+++ b/gateway/metrics/prometheus_query.go
@ -3,7 +3,7 @@ package metrics
 import (
 	"encoding/json"
 	"fmt"
-	"io"
+	"io/ioutil"
 	"net/http"
 )

@ -44,7 +44,7 @@ func (q PrometheusQuery) Fetch(query string) (*VectorQueryResponse, error) {
 		defer res.Body.Close()
 	}

-	bytesOut, readErr := io.ReadAll(res.Body)
+	bytesOut, readErr := ioutil.ReadAll(res.Body)
 	if readErr != nil {
 		return nil, readErr
 	}
--- a/gateway/requests/requests.go
+++ b/gateway/requests/requests.go
@ -0,0 +1,11 @@
+// Copyright (c) Alex Ellis 2017. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+// Package requests package provides a client SDK or library for
+// the OpenFaaS gateway REST API
+package requests
+
+// DeleteFunctionRequest delete a deployed function
+type DeleteFunctionRequest struct {
+	FunctionName string `json:"functionName"`
+}
--- a/gateway/scaling/ranges.go
+++ b/gateway/scaling/ranges.go
@ -3,7 +3,7 @@ package scaling
 import (
 	"bytes"
 	"encoding/json"
-	"io"
+	"io/ioutil"
 	"net/http"

 	"github.com/openfaas/faas-provider/types"
@ -43,7 +43,7 @@ func MakeHorizontalScalingHandler(next http.HandlerFunc) http.HandlerFunc {
 			return
 		}

-		body, err := io.ReadAll(r.Body)
+		body, err := ioutil.ReadAll(r.Body)
 		if err != nil {
 			http.Error(w, "Error reading request body", http.StatusBadRequest)
 			return
@ -65,7 +65,7 @@ func MakeHorizontalScalingHandler(next http.HandlerFunc) http.HandlerFunc {

 		upstreamReq, _ := json.Marshal(scaleRequest)
 		// Restore the io.ReadCloser to its original state
-		r.Body = io.NopCloser(bytes.NewBuffer(upstreamReq))
+		r.Body = ioutil.NopCloser(bytes.NewBuffer(upstreamReq))

 		next.ServeHTTP(w, r)
 	}
--- a/gateway/types/handler_set.go
+++ b/gateway/types/handler_set.go
@ -42,6 +42,4 @@ type HandlerSet struct {

 	// NamespaceListerHandler lists namespaces
 	NamespaceListerHandler http.HandlerFunc
-
-	NamespaceMutatorHandler http.HandlerFunc
 }
--- a/gateway/vendor/github.com/cespare/xxhash/v2/README.md
+++ b/gateway/vendor/github.com/cespare/xxhash/v2/README.md
@ -3,7 +3,8 @@
 [![Go Reference](https://pkg.go.dev/badge/github.com/cespare/xxhash/v2.svg)](https://pkg.go.dev/github.com/cespare/xxhash/v2)
 [![Test](https://github.com/cespare/xxhash/actions/workflows/test.yml/badge.svg)](https://github.com/cespare/xxhash/actions/workflows/test.yml)

-xxhash is a Go implementation of the 64-bit [xxHash] algorithm, XXH64. This is a
+xxhash is a Go implementation of the 64-bit
+[xxHash](http://cyan4973.github.io/xxHash/) algorithm, XXH64. This is a
 high-quality hashing algorithm that is much faster than anything in the Go
 standard library.

@ -24,11 +25,8 @@ func (*Digest) WriteString(string) (int, error)
 func (*Digest) Sum64() uint64
 ```

-The package is written with optimized pure Go and also contains even faster
-assembly implementations for amd64 and arm64. If desired, the `purego` build tag
-opts into using the Go code even on those architectures.
-
-[xxHash]: http://cyan4973.github.io/xxHash/
+This implementation provides a fast pure-Go implementation and an even faster
+assembly implementation for amd64.

 ## Compatibility

@ -47,20 +45,19 @@ I recommend using the latest release of Go.
 Here are some quick benchmarks comparing the pure-Go and assembly
 implementations of Sum64.

-| input size | purego    | asm       |
-| ---------- | --------- | --------- |
-| 4 B        |  1.3 GB/s |  1.2 GB/s |
-| 16 B       |  2.9 GB/s |  3.5 GB/s |
-| 100 B      |  6.9 GB/s |  8.1 GB/s |
-| 4 KB       | 11.7 GB/s | 16.7 GB/s |
-| 10 MB      | 12.0 GB/s | 17.3 GB/s |
+| input size | purego | asm |
+| --- | --- | --- |
+| 5 B   |  979.66 MB/s |  1291.17 MB/s  |
+| 100 B | 7475.26 MB/s | 7973.40 MB/s  |
+| 4 KB  | 17573.46 MB/s | 17602.65 MB/s |
+| 10 MB | 17131.46 MB/s | 17142.16 MB/s |

-These numbers were generated on Ubuntu 20.04 with an Intel Xeon Platinum 8252C
-CPU using the following commands under Go 1.19.2:
+These numbers were generated on Ubuntu 18.04 with an Intel i7-8700K CPU using
+the following commands under Go 1.11.2:

 ```
-benchstat <(go test -tags purego -benchtime 500ms -count 15 -bench 'Sum64$')
-benchstat <(go test -benchtime 500ms -count 15 -bench 'Sum64$')
+$ go test -tags purego -benchtime 10s -bench '/xxhash,direct,bytes'
+$ go test -benchtime 10s -bench '/xxhash,direct,bytes'
 ```

 ## Projects using this package
--- a/gateway/vendor/github.com/cespare/xxhash/v2/testall.sh
+++ b/gateway/vendor/github.com/cespare/xxhash/v2/testall.sh
@ -1,10 +0,0 @@
-#!/bin/bash
-set -eu -o pipefail
-
-# Small convenience script for running the tests with various combinations of
-# arch/tags. This assumes we're running on amd64 and have qemu available.
-
-go test ./...
-go test -tags purego ./...
-GOARCH=arm64 go test
-GOARCH=arm64 go test -tags purego
--- a/gateway/vendor/github.com/cespare/xxhash/v2/xxhash.go
+++ b/gateway/vendor/github.com/cespare/xxhash/v2/xxhash.go
@ -16,11 +16,19 @@ const (
 	prime5 uint64 = 2870177450012600261
 )

-// Store the primes in an array as well.
-//
-// The consts are used when possible in Go code to avoid MOVs but we need a
-// contiguous array of the assembly code.
-var primes = [...]uint64{prime1, prime2, prime3, prime4, prime5}
+// NOTE(caleb): I'm using both consts and vars of the primes. Using consts where
+// possible in the Go code is worth a small (but measurable) performance boost
+// by avoiding some MOVQs. Vars are needed for the asm and also are useful for
+// convenience in the Go code in a few places where we need to intentionally
+// avoid constant arithmetic (e.g., v1 := prime1 + prime2 fails because the
+// result overflows a uint64).
+var (
+	prime1v = prime1
+	prime2v = prime2
+	prime3v = prime3
+	prime4v = prime4
+	prime5v = prime5
+)

 // Digest implements hash.Hash64.
 type Digest struct {
@ -42,10 +50,10 @@ func New() *Digest {

 // Reset clears the Digest's state so that it can be reused.
 func (d *Digest) Reset() {
-	d.v1 = primes[0] + prime2
+	d.v1 = prime1v + prime2
 	d.v2 = prime2
 	d.v3 = 0
-	d.v4 = -primes[0]
+	d.v4 = -prime1v
 	d.total = 0
 	d.n = 0
 }
@ -61,23 +69,21 @@ func (d *Digest) Write(b []byte) (n int, err error) {
 	n = len(b)
 	d.total += uint64(n)

-	memleft := d.mem[d.n&(len(d.mem)-1):]
-
 	if d.n+n < 32 {
 		// This new data doesn't even fill the current block.
-		copy(memleft, b)
+		copy(d.mem[d.n:], b)
 		d.n += n
 		return
 	}

 	if d.n > 0 {
 		// Finish off the partial block.
-		c := copy(memleft, b)
+		copy(d.mem[d.n:], b)
 		d.v1 = round(d.v1, u64(d.mem[0:8]))
 		d.v2 = round(d.v2, u64(d.mem[8:16]))
 		d.v3 = round(d.v3, u64(d.mem[16:24]))
 		d.v4 = round(d.v4, u64(d.mem[24:32]))
-		b = b[c:]
+		b = b[32-d.n:]
 		d.n = 0
 	}

@ -127,20 +133,21 @@ func (d *Digest) Sum64() uint64 {

 	h += d.total

-	b := d.mem[:d.n&(len(d.mem)-1)]
-	for ; len(b) >= 8; b = b[8:] {
-		k1 := round(0, u64(b[:8]))
+	i, end := 0, d.n
+	for ; i+8 <= end; i += 8 {
+		k1 := round(0, u64(d.mem[i:i+8]))
 		h ^= k1
 		h = rol27(h)*prime1 + prime4
 	}
-	if len(b) >= 4 {
-		h ^= uint64(u32(b[:4])) * prime1
+	if i+4 <= end {
+		h ^= uint64(u32(d.mem[i:i+4])) * prime1
 		h = rol23(h)*prime2 + prime3
-		b = b[4:]
+		i += 4
 	}
-	for ; len(b) > 0; b = b[1:] {
-		h ^= uint64(b[0]) * prime5
+	for i < end {
+		h ^= uint64(d.mem[i]) * prime5
 		h = rol11(h) * prime1
+		i++
 	}

 	h ^= h >> 33
--- a/gateway/vendor/github.com/cespare/xxhash/v2/xxhash_amd64.go
+++ b/gateway/vendor/github.com/cespare/xxhash/v2/xxhash_amd64.go
@ -1,5 +1,3 @@
-//go:build (amd64 || arm64) && !appengine && gc && !purego
-// +build amd64 arm64
 // +build !appengine
 // +build gc
 // +build !purego
--- a/gateway/vendor/github.com/cespare/xxhash/v2/xxhash_amd64.s
+++ b/gateway/vendor/github.com/cespare/xxhash/v2/xxhash_amd64.s
@ -1,209 +1,215 @@
-//go:build !appengine && gc && !purego
 // +build !appengine
 // +build gc
 // +build !purego

 #include "textflag.h"

-// Registers:
-#define h      AX
-#define d      AX
-#define p      SI // pointer to advance through b
-#define n      DX
-#define end    BX // loop end
-#define v1     R8
-#define v2     R9
-#define v3     R10
-#define v4     R11
-#define x      R12
-#define prime1 R13
-#define prime2 R14
-#define prime4 DI
+// Register allocation:
+// AX	h
+// SI	pointer to advance through b
+// DX	n
+// BX	loop end
+// R8	v1, k1
+// R9	v2
+// R10	v3
+// R11	v4
+// R12	tmp
+// R13	prime1v
+// R14	prime2v
+// DI	prime4v

-#define round(acc, x) \
-	IMULQ prime2, x   \
-	ADDQ  x, acc      \
-	ROLQ  $31, acc    \
-	IMULQ prime1, acc
+// round reads from and advances the buffer pointer in SI.
+// It assumes that R13 has prime1v and R14 has prime2v.
+#define round(r) \
+	MOVQ  (SI), R12 \
+	ADDQ  $8, SI    \
+	IMULQ R14, R12  \
+	ADDQ  R12, r    \
+	ROLQ  $31, r    \
+	IMULQ R13, r

-// round0 performs the operation x = round(0, x).
-#define round0(x) \
-	IMULQ prime2, x \
-	ROLQ  $31, x    \
-	IMULQ prime1, x
-
-// mergeRound applies a merge round on the two registers acc and x.
-// It assumes that prime1, prime2, and prime4 have been loaded.
-#define mergeRound(acc, x) \
-	round0(x)         \
-	XORQ  x, acc      \
-	IMULQ prime1, acc \
-	ADDQ  prime4, acc
-
-// blockLoop processes as many 32-byte blocks as possible,
-// updating v1, v2, v3, and v4. It assumes that there is at least one block
-// to process.
-#define blockLoop() \
-loop:  \
-	MOVQ +0(p), x  \
-	round(v1, x)   \
-	MOVQ +8(p), x  \
-	round(v2, x)   \
-	MOVQ +16(p), x \
-	round(v3, x)   \
-	MOVQ +24(p), x \
-	round(v4, x)   \
-	ADDQ $32, p    \
-	CMPQ p, end    \
-	JLE  loop
+// mergeRound applies a merge round on the two registers acc and val.
+// It assumes that R13 has prime1v, R14 has prime2v, and DI has prime4v.
+#define mergeRound(acc, val) \
+	IMULQ R14, val \
+	ROLQ  $31, val \
+	IMULQ R13, val \
+	XORQ  val, acc \
+	IMULQ R13, acc \
+	ADDQ  DI, acc

 // func Sum64(b []byte) uint64
-TEXT ·Sum64(SB), NOSPLIT|NOFRAME, $0-32
+TEXT ·Sum64(SB), NOSPLIT, $0-32
 	// Load fixed primes.
-	MOVQ ·primes+0(SB), prime1
-	MOVQ ·primes+8(SB), prime2
-	MOVQ ·primes+24(SB), prime4
+	MOVQ ·prime1v(SB), R13
+	MOVQ ·prime2v(SB), R14
+	MOVQ ·prime4v(SB), DI

 	// Load slice.
-	MOVQ b_base+0(FP), p
-	MOVQ b_len+8(FP), n
-	LEAQ (p)(n*1), end
+	MOVQ b_base+0(FP), SI
+	MOVQ b_len+8(FP), DX
+	LEAQ (SI)(DX*1), BX

 	// The first loop limit will be len(b)-32.
-	SUBQ $32, end
+	SUBQ $32, BX

 	// Check whether we have at least one block.
-	CMPQ n, $32
+	CMPQ DX, $32
 	JLT  noBlocks

 	// Set up initial state (v1, v2, v3, v4).
-	MOVQ prime1, v1
-	ADDQ prime2, v1
-	MOVQ prime2, v2
-	XORQ v3, v3
-	XORQ v4, v4
-	SUBQ prime1, v4
+	MOVQ R13, R8
+	ADDQ R14, R8
+	MOVQ R14, R9
+	XORQ R10, R10
+	XORQ R11, R11
+	SUBQ R13, R11

-	blockLoop()
+	// Loop until SI > BX.
+blockLoop:
+	round(R8)
+	round(R9)
+	round(R10)
+	round(R11)

-	MOVQ v1, h
-	ROLQ $1, h
-	MOVQ v2, x
-	ROLQ $7, x
-	ADDQ x, h
-	MOVQ v3, x
-	ROLQ $12, x
-	ADDQ x, h
-	MOVQ v4, x
-	ROLQ $18, x
-	ADDQ x, h
+	CMPQ SI, BX
+	JLE  blockLoop

-	mergeRound(h, v1)
-	mergeRound(h, v2)
-	mergeRound(h, v3)
-	mergeRound(h, v4)
+	MOVQ R8, AX
+	ROLQ $1, AX
+	MOVQ R9, R12
+	ROLQ $7, R12
+	ADDQ R12, AX
+	MOVQ R10, R12
+	ROLQ $12, R12
+	ADDQ R12, AX
+	MOVQ R11, R12
+	ROLQ $18, R12
+	ADDQ R12, AX
+
+	mergeRound(AX, R8)
+	mergeRound(AX, R9)
+	mergeRound(AX, R10)
+	mergeRound(AX, R11)

 	JMP afterBlocks

 noBlocks:
-	MOVQ ·primes+32(SB), h
+	MOVQ ·prime5v(SB), AX

 afterBlocks:
-	ADDQ n, h
+	ADDQ DX, AX

-	ADDQ $24, end
-	CMPQ p, end
-	JG   try4
+	// Right now BX has len(b)-32, and we want to loop until SI > len(b)-8.
+	ADDQ $24, BX

-loop8:
-	MOVQ  (p), x
-	ADDQ  $8, p
-	round0(x)
-	XORQ  x, h
-	ROLQ  $27, h
-	IMULQ prime1, h
-	ADDQ  prime4, h
+	CMPQ SI, BX
+	JG   fourByte

-	CMPQ p, end
-	JLE  loop8
+wordLoop:
+	// Calculate k1.
+	MOVQ  (SI), R8
+	ADDQ  $8, SI
+	IMULQ R14, R8
+	ROLQ  $31, R8
+	IMULQ R13, R8

-try4:
-	ADDQ $4, end
-	CMPQ p, end
-	JG   try1
+	XORQ  R8, AX
+	ROLQ  $27, AX
+	IMULQ R13, AX
+	ADDQ  DI, AX

-	MOVL  (p), x
-	ADDQ  $4, p
-	IMULQ prime1, x
-	XORQ  x, h
+	CMPQ SI, BX
+	JLE  wordLoop

-	ROLQ  $23, h
-	IMULQ prime2, h
-	ADDQ  ·primes+16(SB), h
+fourByte:
+	ADDQ $4, BX
+	CMPQ SI, BX
+	JG   singles

-try1:
-	ADDQ $4, end
-	CMPQ p, end
+	MOVL  (SI), R8
+	ADDQ  $4, SI
+	IMULQ R13, R8
+	XORQ  R8, AX
+
+	ROLQ  $23, AX
+	IMULQ R14, AX
+	ADDQ  ·prime3v(SB), AX
+
+singles:
+	ADDQ $4, BX
+	CMPQ SI, BX
 	JGE  finalize

-loop1:
-	MOVBQZX (p), x
-	ADDQ    $1, p
-	IMULQ   ·primes+32(SB), x
-	XORQ    x, h
-	ROLQ    $11, h
-	IMULQ   prime1, h
+singlesLoop:
+	MOVBQZX (SI), R12
+	ADDQ    $1, SI
+	IMULQ   ·prime5v(SB), R12
+	XORQ    R12, AX

-	CMPQ p, end
-	JL   loop1
+	ROLQ  $11, AX
+	IMULQ R13, AX
+
+	CMPQ SI, BX
+	JL   singlesLoop

 finalize:
-	MOVQ  h, x
-	SHRQ  $33, x
-	XORQ  x, h
-	IMULQ prime2, h
-	MOVQ  h, x
-	SHRQ  $29, x
-	XORQ  x, h
-	IMULQ ·primes+16(SB), h
-	MOVQ  h, x
-	SHRQ  $32, x
-	XORQ  x, h
+	MOVQ  AX, R12
+	SHRQ  $33, R12
+	XORQ  R12, AX
+	IMULQ R14, AX
+	MOVQ  AX, R12
+	SHRQ  $29, R12
+	XORQ  R12, AX
+	IMULQ ·prime3v(SB), AX
+	MOVQ  AX, R12
+	SHRQ  $32, R12
+	XORQ  R12, AX

-	MOVQ h, ret+24(FP)
+	MOVQ AX, ret+24(FP)
 	RET

+// writeBlocks uses the same registers as above except that it uses AX to store
+// the d pointer.
+
 // func writeBlocks(d *Digest, b []byte) int
-TEXT ·writeBlocks(SB), NOSPLIT|NOFRAME, $0-40
+TEXT ·writeBlocks(SB), NOSPLIT, $0-40
 	// Load fixed primes needed for round.
-	MOVQ ·primes+0(SB), prime1
-	MOVQ ·primes+8(SB), prime2
+	MOVQ ·prime1v(SB), R13
+	MOVQ ·prime2v(SB), R14

 	// Load slice.
-	MOVQ b_base+8(FP), p
-	MOVQ b_len+16(FP), n
-	LEAQ (p)(n*1), end
-	SUBQ $32, end
+	MOVQ b_base+8(FP), SI
+	MOVQ b_len+16(FP), DX
+	LEAQ (SI)(DX*1), BX
+	SUBQ $32, BX

 	// Load vN from d.
-	MOVQ s+0(FP), d
-	MOVQ 0(d), v1
-	MOVQ 8(d), v2
-	MOVQ 16(d), v3
-	MOVQ 24(d), v4
+	MOVQ d+0(FP), AX
+	MOVQ 0(AX), R8   // v1
+	MOVQ 8(AX), R9   // v2
+	MOVQ 16(AX), R10 // v3
+	MOVQ 24(AX), R11 // v4

 	// We don't need to check the loop condition here; this function is
 	// always called with at least one block of data to process.
-	blockLoop()
+blockLoop:
+	round(R8)
+	round(R9)
+	round(R10)
+	round(R11)
+
+	CMPQ SI, BX
+	JLE  blockLoop

 	// Copy vN back to d.
-	MOVQ v1, 0(d)
-	MOVQ v2, 8(d)
-	MOVQ v3, 16(d)
-	MOVQ v4, 24(d)
+	MOVQ R8, 0(AX)
+	MOVQ R9, 8(AX)
+	MOVQ R10, 16(AX)
+	MOVQ R11, 24(AX)

-	// The number of bytes written is p minus the old base pointer.
-	SUBQ b_base+8(FP), p
-	MOVQ p, ret+32(FP)
+	// The number of bytes written is SI minus the old base pointer.
+	SUBQ b_base+8(FP), SI
+	MOVQ SI, ret+32(FP)

 	RET
--- a/gateway/vendor/github.com/cespare/xxhash/v2/xxhash_arm64.s
+++ b/gateway/vendor/github.com/cespare/xxhash/v2/xxhash_arm64.s
@ -1,183 +0,0 @@
-//go:build !appengine && gc && !purego
-// +build !appengine
-// +build gc
-// +build !purego
-
-#include "textflag.h"
-
-// Registers:
-#define digest	R1
-#define h	R2 // return value
-#define p	R3 // input pointer
-#define n	R4 // input length
-#define nblocks	R5 // n / 32
-#define prime1	R7
-#define prime2	R8
-#define prime3	R9
-#define prime4	R10
-#define prime5	R11
-#define v1	R12
-#define v2	R13
-#define v3	R14
-#define v4	R15
-#define x1	R20
-#define x2	R21
-#define x3	R22
-#define x4	R23
-
-#define round(acc, x) \
-	MADD prime2, acc, x, acc \
-	ROR  $64-31, acc         \
-	MUL  prime1, acc
-
-// round0 performs the operation x = round(0, x).
-#define round0(x) \
-	MUL prime2, x \
-	ROR $64-31, x \
-	MUL prime1, x
-
-#define mergeRound(acc, x) \
-	round0(x)                     \
-	EOR  x, acc                   \
-	MADD acc, prime4, prime1, acc
-
-// blockLoop processes as many 32-byte blocks as possible,
-// updating v1, v2, v3, and v4. It assumes that n >= 32.
-#define blockLoop() \
-	LSR     $5, n, nblocks  \
-	PCALIGN $16             \
-	loop:                   \
-	LDP.P   16(p), (x1, x2) \
-	LDP.P   16(p), (x3, x4) \
-	round(v1, x1)           \
-	round(v2, x2)           \
-	round(v3, x3)           \
-	round(v4, x4)           \
-	SUB     $1, nblocks     \
-	CBNZ    nblocks, loop
-
-// func Sum64(b []byte) uint64
-TEXT ·Sum64(SB), NOSPLIT|NOFRAME, $0-32
-	LDP b_base+0(FP), (p, n)
-
-	LDP  ·primes+0(SB), (prime1, prime2)
-	LDP  ·primes+16(SB), (prime3, prime4)
-	MOVD ·primes+32(SB), prime5
-
-	CMP  $32, n
-	CSEL LT, prime5, ZR, h // if n < 32 { h = prime5 } else { h = 0 }
-	BLT  afterLoop
-
-	ADD  prime1, prime2, v1
-	MOVD prime2, v2
-	MOVD $0, v3
-	NEG  prime1, v4
-
-	blockLoop()
-
-	ROR $64-1, v1, x1
-	ROR $64-7, v2, x2
-	ADD x1, x2
-	ROR $64-12, v3, x3
-	ROR $64-18, v4, x4
-	ADD x3, x4
-	ADD x2, x4, h
-
-	mergeRound(h, v1)
-	mergeRound(h, v2)
-	mergeRound(h, v3)
-	mergeRound(h, v4)
-
-afterLoop:
-	ADD n, h
-
-	TBZ   $4, n, try8
-	LDP.P 16(p), (x1, x2)
-
-	round0(x1)
-
-	// NOTE: here and below, sequencing the EOR after the ROR (using a
-	// rotated register) is worth a small but measurable speedup for small
-	// inputs.
-	ROR  $64-27, h
-	EOR  x1 @> 64-27, h, h
-	MADD h, prime4, prime1, h
-
-	round0(x2)
-	ROR  $64-27, h
-	EOR  x2 @> 64-27, h, h
-	MADD h, prime4, prime1, h
-
-try8:
-	TBZ    $3, n, try4
-	MOVD.P 8(p), x1
-
-	round0(x1)
-	ROR  $64-27, h
-	EOR  x1 @> 64-27, h, h
-	MADD h, prime4, prime1, h
-
-try4:
-	TBZ     $2, n, try2
-	MOVWU.P 4(p), x2
-
-	MUL  prime1, x2
-	ROR  $64-23, h
-	EOR  x2 @> 64-23, h, h
-	MADD h, prime3, prime2, h
-
-try2:
-	TBZ     $1, n, try1
-	MOVHU.P 2(p), x3
-	AND     $255, x3, x1
-	LSR     $8, x3, x2
-
-	MUL prime5, x1
-	ROR $64-11, h
-	EOR x1 @> 64-11, h, h
-	MUL prime1, h
-
-	MUL prime5, x2
-	ROR $64-11, h
-	EOR x2 @> 64-11, h, h
-	MUL prime1, h
-
-try1:
-	TBZ   $0, n, finalize
-	MOVBU (p), x4
-
-	MUL prime5, x4
-	ROR $64-11, h
-	EOR x4 @> 64-11, h, h
-	MUL prime1, h
-
-finalize:
-	EOR h >> 33, h
-	MUL prime2, h
-	EOR h >> 29, h
-	MUL prime3, h
-	EOR h >> 32, h
-
-	MOVD h, ret+24(FP)
-	RET
-
-// func writeBlocks(d *Digest, b []byte) int
-TEXT ·writeBlocks(SB), NOSPLIT|NOFRAME, $0-40
-	LDP ·primes+0(SB), (prime1, prime2)
-
-	// Load state. Assume v[1-4] are stored contiguously.
-	MOVD d+0(FP), digest
-	LDP  0(digest), (v1, v2)
-	LDP  16(digest), (v3, v4)
-
-	LDP b_base+8(FP), (p, n)
-
-	blockLoop()
-
-	// Store updated state.
-	STP (v1, v2), 0(digest)
-	STP (v3, v4), 16(digest)
-
-	BIC  $31, n
-	MOVD n, ret+32(FP)
-	RET
--- a/gateway/vendor/github.com/cespare/xxhash/v2/xxhash_other.go
+++ b/gateway/vendor/github.com/cespare/xxhash/v2/xxhash_other.go
@ -1,5 +1,4 @@
-//go:build (!amd64 && !arm64) || appengine || !gc || purego
-// +build !amd64,!arm64 appengine !gc purego
+// +build !amd64 appengine !gc purego

 package xxhash

@ -15,10 +14,10 @@ func Sum64(b []byte) uint64 {
 	var h uint64

 	if n >= 32 {
-		v1 := primes[0] + prime2
+		v1 := prime1v + prime2
 		v2 := prime2
 		v3 := uint64(0)
-		v4 := -primes[0]
+		v4 := -prime1v
 		for len(b) >= 32 {
 			v1 = round(v1, u64(b[0:8:len(b)]))
 			v2 = round(v2, u64(b[8:16:len(b)]))
@ -37,18 +36,19 @@ func Sum64(b []byte) uint64 {

 	h += uint64(n)

-	for ; len(b) >= 8; b = b[8:] {
-		k1 := round(0, u64(b[:8]))
+	i, end := 0, len(b)
+	for ; i+8 <= end; i += 8 {
+		k1 := round(0, u64(b[i:i+8:len(b)]))
 		h ^= k1
 		h = rol27(h)*prime1 + prime4
 	}
-	if len(b) >= 4 {
-		h ^= uint64(u32(b[:4])) * prime1
+	if i+4 <= end {
+		h ^= uint64(u32(b[i:i+4:len(b)])) * prime1
 		h = rol23(h)*prime2 + prime3
-		b = b[4:]
+		i += 4
 	}
-	for ; len(b) > 0; b = b[1:] {
-		h ^= uint64(b[0]) * prime5
+	for ; i < end; i++ {
+		h ^= uint64(b[i]) * prime5
 		h = rol11(h) * prime1
 	}

--- a/gateway/vendor/github.com/cespare/xxhash/v2/xxhash_safe.go
+++ b/gateway/vendor/github.com/cespare/xxhash/v2/xxhash_safe.go
@ -1,4 +1,3 @@
-//go:build appengine
 // +build appengine

 // This file contains the safe implementations of otherwise unsafe-using code.
--- a/gateway/vendor/github.com/cespare/xxhash/v2/xxhash_unsafe.go
+++ b/gateway/vendor/github.com/cespare/xxhash/v2/xxhash_unsafe.go
@ -1,4 +1,3 @@
-//go:build !appengine
 // +build !appengine

 // This file encapsulates usage of unsafe.
@ -12,7 +11,7 @@ import (

 // In the future it's possible that compiler optimizations will make these
 // XxxString functions unnecessary by realizing that calls such as
-// Sum64([]byte(s)) don't need to copy s. See https://go.dev/issue/2205.
+// Sum64([]byte(s)) don't need to copy s. See https://golang.org/issue/2205.
 // If that happens, even if we keep these functions they can be replaced with
 // the trivial safe code.

--- a/gateway/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.pb.go
+++ b/gateway/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.pb.go
@ -0,0 +1,64 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: github.com/golang/protobuf/ptypes/timestamp/timestamp.proto
+
+package timestamp
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
+	reflect "reflect"
+)
+
+// Symbols defined in public import of google/protobuf/timestamp.proto.
+
+type Timestamp = timestamppb.Timestamp
+
+var File_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto protoreflect.FileDescriptor
+
+var file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_rawDesc = []byte{
+	0x0a, 0x3b, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c,
+	0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79,
+	0x70, 0x65, 0x73, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2f, 0x74, 0x69,
+	0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74,
+	0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x42, 0x37,
+	0x5a, 0x35, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c,
+	0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79,
+	0x70, 0x65, 0x73, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x3b, 0x74, 0x69,
+	0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x50, 0x00, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x33,
+}
+
+var file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_goTypes = []interface{}{}
+var file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_depIdxs = []int32{
+	0, // [0:0] is the sub-list for method output_type
+	0, // [0:0] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_init() }
+func file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_init() {
+	if File_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto != nil {
+		return
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   0,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_goTypes,
+		DependencyIndexes: file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_depIdxs,
+	}.Build()
+	File_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto = out.File
+	file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_rawDesc = nil
+	file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_goTypes = nil
+	file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_depIdxs = nil
+}
--- a/gateway/vendor/github.com/klauspost/compress/LICENSE
+++ b/gateway/vendor/github.com/klauspost/compress/LICENSE
@ -1,304 +0,0 @@
-Copyright (c) 2012 The Go Authors. All rights reserved.
-Copyright (c) 2019 Klaus Post. All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-   * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-   * Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the following disclaimer
-in the documentation and/or other materials provided with the
-distribution.
-   * Neither the name of Google Inc. nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
------------------
-
-Files: gzhttp/*
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright 2016-2017 The New York Times Company
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-
------------------
-
-Files: s2/cmd/internal/readahead/*
-
-The MIT License (MIT)
-
-Copyright (c) 2015 Klaus Post
-
-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.
-
---------------------
-Files: snappy/*
-Files: internal/snapref/*
-
-Copyright (c) 2011 The Snappy-Go Authors. All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-   * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-   * Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the following disclaimer
-in the documentation and/or other materials provided with the
-distribution.
-   * Neither the name of Google Inc. nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------
-
-Files: s2/cmd/internal/filepathx/*
-
-Copyright 2016 The filepathx Authors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--- a/gateway/vendor/github.com/klauspost/compress/flate/deflate.go
+++ b/gateway/vendor/github.com/klauspost/compress/flate/deflate.go
--- a/gateway/vendor/github.com/klauspost/compress/flate/dict_decoder.go
+++ b/gateway/vendor/github.com/klauspost/compress/flate/dict_decoder.go
@ -1,184 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package flate
-
-// dictDecoder implements the LZ77 sliding dictionary as used in decompression.
-// LZ77 decompresses data through sequences of two forms of commands:
-//
-//   - Literal insertions: Runs of one or more symbols are inserted into the data
-//     stream as is. This is accomplished through the writeByte method for a
-//     single symbol, or combinations of writeSlice/writeMark for multiple symbols.
-//     Any valid stream must start with a literal insertion if no preset dictionary
-//     is used.
-//
-//   - Backward copies: Runs of one or more symbols are copied from previously
-//     emitted data. Backward copies come as the tuple (dist, length) where dist
-//     determines how far back in the stream to copy from and length determines how
-//     many bytes to copy. Note that it is valid for the length to be greater than
-//     the distance. Since LZ77 uses forward copies, that situation is used to
-//     perform a form of run-length encoding on repeated runs of symbols.
-//     The writeCopy and tryWriteCopy are used to implement this command.
-//
-// For performance reasons, this implementation performs little to no sanity
-// checks about the arguments. As such, the invariants documented for each
-// method call must be respected.
-type dictDecoder struct {
-	hist []byte // Sliding window history
-
-	// Invariant: 0 <= rdPos <= wrPos <= len(hist)
-	wrPos int  // Current output position in buffer
-	rdPos int  // Have emitted hist[:rdPos] already
-	full  bool // Has a full window length been written yet?
-}
-
-// init initializes dictDecoder to have a sliding window dictionary of the given
-// size. If a preset dict is provided, it will initialize the dictionary with
-// the contents of dict.
-func (dd *dictDecoder) init(size int, dict []byte) {
-	*dd = dictDecoder{hist: dd.hist}
-
-	if cap(dd.hist) < size {
-		dd.hist = make([]byte, size)
-	}
-	dd.hist = dd.hist[:size]
-
-	if len(dict) > len(dd.hist) {
-		dict = dict[len(dict)-len(dd.hist):]
-	}
-	dd.wrPos = copy(dd.hist, dict)
-	if dd.wrPos == len(dd.hist) {
-		dd.wrPos = 0
-		dd.full = true
-	}
-	dd.rdPos = dd.wrPos
-}
-
-// histSize reports the total amount of historical data in the dictionary.
-func (dd *dictDecoder) histSize() int {
-	if dd.full {
-		return len(dd.hist)
-	}
-	return dd.wrPos
-}
-
-// availRead reports the number of bytes that can be flushed by readFlush.
-func (dd *dictDecoder) availRead() int {
-	return dd.wrPos - dd.rdPos
-}
-
-// availWrite reports the available amount of output buffer space.
-func (dd *dictDecoder) availWrite() int {
-	return len(dd.hist) - dd.wrPos
-}
-
-// writeSlice returns a slice of the available buffer to write data to.
-//
-// This invariant will be kept: len(s) <= availWrite()
-func (dd *dictDecoder) writeSlice() []byte {
-	return dd.hist[dd.wrPos:]
-}
-
-// writeMark advances the writer pointer by cnt.
-//
-// This invariant must be kept: 0 <= cnt <= availWrite()
-func (dd *dictDecoder) writeMark(cnt int) {
-	dd.wrPos += cnt
-}
-
-// writeByte writes a single byte to the dictionary.
-//
-// This invariant must be kept: 0 < availWrite()
-func (dd *dictDecoder) writeByte(c byte) {
-	dd.hist[dd.wrPos] = c
-	dd.wrPos++
-}
-
-// writeCopy copies a string at a given (dist, length) to the output.
-// This returns the number of bytes copied and may be less than the requested
-// length if the available space in the output buffer is too small.
-//
-// This invariant must be kept: 0 < dist <= histSize()
-func (dd *dictDecoder) writeCopy(dist, length int) int {
-	dstBase := dd.wrPos
-	dstPos := dstBase
-	srcPos := dstPos - dist
-	endPos := dstPos + length
-	if endPos > len(dd.hist) {
-		endPos = len(dd.hist)
-	}
-
-	// Copy non-overlapping section after destination position.
-	//
-	// This section is non-overlapping in that the copy length for this section
-	// is always less than or equal to the backwards distance. This can occur
-	// if a distance refers to data that wraps-around in the buffer.
-	// Thus, a backwards copy is performed here; that is, the exact bytes in
-	// the source prior to the copy is placed in the destination.
-	if srcPos < 0 {
-		srcPos += len(dd.hist)
-		dstPos += copy(dd.hist[dstPos:endPos], dd.hist[srcPos:])
-		srcPos = 0
-	}
-
-	// Copy possibly overlapping section before destination position.
-	//
-	// This section can overlap if the copy length for this section is larger
-	// than the backwards distance. This is allowed by LZ77 so that repeated
-	// strings can be succinctly represented using (dist, length) pairs.
-	// Thus, a forwards copy is performed here; that is, the bytes copied is
-	// possibly dependent on the resulting bytes in the destination as the copy
-	// progresses along. This is functionally equivalent to the following:
-	//
-	//	for i := 0; i < endPos-dstPos; i++ {
-	//		dd.hist[dstPos+i] = dd.hist[srcPos+i]
-	//	}
-	//	dstPos = endPos
-	//
-	for dstPos < endPos {
-		dstPos += copy(dd.hist[dstPos:endPos], dd.hist[srcPos:dstPos])
-	}
-
-	dd.wrPos = dstPos
-	return dstPos - dstBase
-}
-
-// tryWriteCopy tries to copy a string at a given (distance, length) to the
-// output. This specialized version is optimized for short distances.
-//
-// This method is designed to be inlined for performance reasons.
-//
-// This invariant must be kept: 0 < dist <= histSize()
-func (dd *dictDecoder) tryWriteCopy(dist, length int) int {
-	dstPos := dd.wrPos
-	endPos := dstPos + length
-	if dstPos < dist || endPos > len(dd.hist) {
-		return 0
-	}
-	dstBase := dstPos
-	srcPos := dstPos - dist
-
-	// Copy possibly overlapping section before destination position.
-loop:
-	dstPos += copy(dd.hist[dstPos:endPos], dd.hist[srcPos:dstPos])
-	if dstPos < endPos {
-		goto loop // Avoid for-loop so that this function can be inlined
-	}
-
-	dd.wrPos = dstPos
-	return dstPos - dstBase
-}
-
-// readFlush returns a slice of the historical buffer that is ready to be
-// emitted to the user. The data returned by readFlush must be fully consumed
-// before calling any other dictDecoder methods.
-func (dd *dictDecoder) readFlush() []byte {
-	toRead := dd.hist[dd.rdPos:dd.wrPos]
-	dd.rdPos = dd.wrPos
-	if dd.wrPos == len(dd.hist) {
-		dd.wrPos, dd.rdPos = 0, 0
-		dd.full = true
-	}
-	return toRead
-}
--- a/gateway/vendor/github.com/klauspost/compress/flate/fast_encoder.go
+++ b/gateway/vendor/github.com/klauspost/compress/flate/fast_encoder.go
@ -1,193 +0,0 @@
-// Copyright 2011 The Snappy-Go Authors. All rights reserved.
-// Modified for deflate by Klaus Post (c) 2015.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package flate
-
-import (
-	"encoding/binary"
-	"fmt"
-)
-
-type fastEnc interface {
-	Encode(dst *tokens, src []byte)
-	Reset()
-}
-
-func newFastEnc(level int) fastEnc {
-	switch level {
-	case 1:
-		return &fastEncL1{fastGen: fastGen{cur: maxStoreBlockSize}}
-	case 2:
-		return &fastEncL2{fastGen: fastGen{cur: maxStoreBlockSize}}
-	case 3:
-		return &fastEncL3{fastGen: fastGen{cur: maxStoreBlockSize}}
-	case 4:
-		return &fastEncL4{fastGen: fastGen{cur: maxStoreBlockSize}}
-	case 5:
-		return &fastEncL5{fastGen: fastGen{cur: maxStoreBlockSize}}
-	case 6:
-		return &fastEncL6{fastGen: fastGen{cur: maxStoreBlockSize}}
-	default:
-		panic("invalid level specified")
-	}
-}
-
-const (
-	tableBits       = 15             // Bits used in the table
-	tableSize       = 1 << tableBits // Size of the table
-	tableShift      = 32 - tableBits // Right-shift to get the tableBits most significant bits of a uint32.
-	baseMatchOffset = 1              // The smallest match offset
-	baseMatchLength = 3              // The smallest match length per the RFC section 3.2.5
-	maxMatchOffset  = 1 << 15        // The largest match offset
-
-	bTableBits   = 17                                               // Bits used in the big tables
-	bTableSize   = 1 << bTableBits                                  // Size of the table
-	allocHistory = maxStoreBlockSize * 5                            // Size to preallocate for history.
-	bufferReset  = (1 << 31) - allocHistory - maxStoreBlockSize - 1 // Reset the buffer offset when reaching this.
-)
-
-const (
-	prime3bytes = 506832829
-	prime4bytes = 2654435761
-	prime5bytes = 889523592379
-	prime6bytes = 227718039650203
-	prime7bytes = 58295818150454627
-	prime8bytes = 0xcf1bbcdcb7a56463
-)
-
-func load3232(b []byte, i int32) uint32 {
-	return binary.LittleEndian.Uint32(b[i:])
-}
-
-func load6432(b []byte, i int32) uint64 {
-	return binary.LittleEndian.Uint64(b[i:])
-}
-
-type tableEntry struct {
-	offset int32
-}
-
-// fastGen maintains the table for matches,
-// and the previous byte block for level 2.
-// This is the generic implementation.
-type fastGen struct {
-	hist []byte
-	cur  int32
-}
-
-func (e *fastGen) addBlock(src []byte) int32 {
-	// check if we have space already
-	if len(e.hist)+len(src) > cap(e.hist) {
-		if cap(e.hist) == 0 {
-			e.hist = make([]byte, 0, allocHistory)
-		} else {
-			if cap(e.hist) < maxMatchOffset*2 {
-				panic("unexpected buffer size")
-			}
-			// Move down
-			offset := int32(len(e.hist)) - maxMatchOffset
-			// copy(e.hist[0:maxMatchOffset], e.hist[offset:])
-			*(*[maxMatchOffset]byte)(e.hist) = *(*[maxMatchOffset]byte)(e.hist[offset:])
-			e.cur += offset
-			e.hist = e.hist[:maxMatchOffset]
-		}
-	}
-	s := int32(len(e.hist))
-	e.hist = append(e.hist, src...)
-	return s
-}
-
-type tableEntryPrev struct {
-	Cur  tableEntry
-	Prev tableEntry
-}
-
-// hash7 returns the hash of the lowest 7 bytes of u to fit in a hash table with h bits.
-// Preferably h should be a constant and should always be <64.
-func hash7(u uint64, h uint8) uint32 {
-	return uint32(((u << (64 - 56)) * prime7bytes) >> ((64 - h) & reg8SizeMask64))
-}
-
-// hashLen returns a hash of the lowest mls bytes of with length output bits.
-// mls must be >=3 and <=8. Any other value will return hash for 4 bytes.
-// length should always be < 32.
-// Preferably length and mls should be a constant for inlining.
-func hashLen(u uint64, length, mls uint8) uint32 {
-	switch mls {
-	case 3:
-		return (uint32(u<<8) * prime3bytes) >> (32 - length)
-	case 5:
-		return uint32(((u << (64 - 40)) * prime5bytes) >> (64 - length))
-	case 6:
-		return uint32(((u << (64 - 48)) * prime6bytes) >> (64 - length))
-	case 7:
-		return uint32(((u << (64 - 56)) * prime7bytes) >> (64 - length))
-	case 8:
-		return uint32((u * prime8bytes) >> (64 - length))
-	default:
-		return (uint32(u) * prime4bytes) >> (32 - length)
-	}
-}
-
-// matchlen will return the match length between offsets and t in src.
-// The maximum length returned is maxMatchLength - 4.
-// It is assumed that s > t, that t >=0 and s < len(src).
-func (e *fastGen) matchlen(s, t int32, src []byte) int32 {
-	if debugDecode {
-		if t >= s {
-			panic(fmt.Sprint("t >=s:", t, s))
-		}
-		if int(s) >= len(src) {
-			panic(fmt.Sprint("s >= len(src):", s, len(src)))
-		}
-		if t < 0 {
-			panic(fmt.Sprint("t < 0:", t))
-		}
-		if s-t > maxMatchOffset {
-			panic(fmt.Sprint(s, "-", t, "(", s-t, ") > maxMatchLength (", maxMatchOffset, ")"))
-		}
-	}
-	s1 := int(s) + maxMatchLength - 4
-	if s1 > len(src) {
-		s1 = len(src)
-	}
-
-	// Extend the match to be as long as possible.
-	return int32(matchLen(src[s:s1], src[t:]))
-}
-
-// matchlenLong will return the match length between offsets and t in src.
-// It is assumed that s > t, that t >=0 and s < len(src).
-func (e *fastGen) matchlenLong(s, t int32, src []byte) int32 {
-	if debugDeflate {
-		if t >= s {
-			panic(fmt.Sprint("t >=s:", t, s))
-		}
-		if int(s) >= len(src) {
-			panic(fmt.Sprint("s >= len(src):", s, len(src)))
-		}
-		if t < 0 {
-			panic(fmt.Sprint("t < 0:", t))
-		}
-		if s-t > maxMatchOffset {
-			panic(fmt.Sprint(s, "-", t, "(", s-t, ") > maxMatchLength (", maxMatchOffset, ")"))
-		}
-	}
-	// Extend the match to be as long as possible.
-	return int32(matchLen(src[s:], src[t:]))
-}
-
-// Reset the encoding table.
-func (e *fastGen) Reset() {
-	if cap(e.hist) < allocHistory {
-		e.hist = make([]byte, 0, allocHistory)
-	}
-	// We offset current position so everything will be out of reach.
-	// If we are above the buffer reset it will be cleared anyway since len(hist) == 0.
-	if e.cur <= bufferReset {
-		e.cur += maxMatchOffset + int32(len(e.hist))
-	}
-	e.hist = e.hist[:0]
-}
--- a/gateway/vendor/github.com/klauspost/compress/flate/huffman_bit_writer.go
+++ b/gateway/vendor/github.com/klauspost/compress/flate/huffman_bit_writer.go
--- a/gateway/vendor/github.com/klauspost/compress/flate/huffman_code.go
+++ b/gateway/vendor/github.com/klauspost/compress/flate/huffman_code.go
@ -1,417 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package flate
-
-import (
-	"math"
-	"math/bits"
-)
-
-const (
-	maxBitsLimit = 16
-	// number of valid literals
-	literalCount = 286
-)
-
-// hcode is a huffman code with a bit code and bit length.
-type hcode uint32
-
-func (h hcode) len() uint8 {
-	return uint8(h)
-}
-
-func (h hcode) code64() uint64 {
-	return uint64(h >> 8)
-}
-
-func (h hcode) zero() bool {
-	return h == 0
-}
-
-type huffmanEncoder struct {
-	codes    []hcode
-	bitCount [17]int32
-
-	// Allocate a reusable buffer with the longest possible frequency table.
-	// Possible lengths are codegenCodeCount, offsetCodeCount and literalCount.
-	// The largest of these is literalCount, so we allocate for that case.
-	freqcache [literalCount + 1]literalNode
-}
-
-type literalNode struct {
-	literal uint16
-	freq    uint16
-}
-
-// A levelInfo describes the state of the constructed tree for a given depth.
-type levelInfo struct {
-	// Our level.  for better printing
-	level int32
-
-	// The frequency of the last node at this level
-	lastFreq int32
-
-	// The frequency of the next character to add to this level
-	nextCharFreq int32
-
-	// The frequency of the next pair (from level below) to add to this level.
-	// Only valid if the "needed" value of the next lower level is 0.
-	nextPairFreq int32
-
-	// The number of chains remaining to generate for this level before moving
-	// up to the next level
-	needed int32
-}
-
-// set sets the code and length of an hcode.
-func (h *hcode) set(code uint16, length uint8) {
-	*h = hcode(length) | (hcode(code) << 8)
-}
-
-func newhcode(code uint16, length uint8) hcode {
-	return hcode(length) | (hcode(code) << 8)
-}
-
-func reverseBits(number uint16, bitLength byte) uint16 {
-	return bits.Reverse16(number << ((16 - bitLength) & 15))
-}
-
-func maxNode() literalNode { return literalNode{math.MaxUint16, math.MaxUint16} }
-
-func newHuffmanEncoder(size int) *huffmanEncoder {
-	// Make capacity to next power of two.
-	c := uint(bits.Len32(uint32(size - 1)))
-	return &huffmanEncoder{codes: make([]hcode, size, 1<<c)}
-}
-
-// Generates a HuffmanCode corresponding to the fixed literal table
-func generateFixedLiteralEncoding() *huffmanEncoder {
-	h := newHuffmanEncoder(literalCount)
-	codes := h.codes
-	var ch uint16
-	for ch = 0; ch < literalCount; ch++ {
-		var bits uint16
-		var size uint8
-		switch {
-		case ch < 144:
-			// size 8, 000110000  .. 10111111
-			bits = ch + 48
-			size = 8
-		case ch < 256:
-			// size 9, 110010000 .. 111111111
-			bits = ch + 400 - 144
-			size = 9
-		case ch < 280:
-			// size 7, 0000000 .. 0010111
-			bits = ch - 256
-			size = 7
-		default:
-			// size 8, 11000000 .. 11000111
-			bits = ch + 192 - 280
-			size = 8
-		}
-		codes[ch] = newhcode(reverseBits(bits, size), size)
-	}
-	return h
-}
-
-func generateFixedOffsetEncoding() *huffmanEncoder {
-	h := newHuffmanEncoder(30)
-	codes := h.codes
-	for ch := range codes {
-		codes[ch] = newhcode(reverseBits(uint16(ch), 5), 5)
-	}
-	return h
-}
-
-var fixedLiteralEncoding = generateFixedLiteralEncoding()
-var fixedOffsetEncoding = generateFixedOffsetEncoding()
-
-func (h *huffmanEncoder) bitLength(freq []uint16) int {
-	var total int
-	for i, f := range freq {
-		if f != 0 {
-			total += int(f) * int(h.codes[i].len())
-		}
-	}
-	return total
-}
-
-func (h *huffmanEncoder) bitLengthRaw(b []byte) int {
-	var total int
-	for _, f := range b {
-		total += int(h.codes[f].len())
-	}
-	return total
-}
-
-// canReuseBits returns the number of bits or math.MaxInt32 if the encoder cannot be reused.
-func (h *huffmanEncoder) canReuseBits(freq []uint16) int {
-	var total int
-	for i, f := range freq {
-		if f != 0 {
-			code := h.codes[i]
-			if code.zero() {
-				return math.MaxInt32
-			}
-			total += int(f) * int(code.len())
-		}
-	}
-	return total
-}
-
-// Return the number of literals assigned to each bit size in the Huffman encoding
-//
-// This method is only called when list.length >= 3
-// The cases of 0, 1, and 2 literals are handled by special case code.
-//
-// list  An array of the literals with non-zero frequencies
-//
-//	and their associated frequencies. The array is in order of increasing
-//	frequency, and has as its last element a special element with frequency
-//	MaxInt32
-//
-// maxBits     The maximum number of bits that should be used to encode any literal.
-//
-//	Must be less than 16.
-//
-// return      An integer array in which array[i] indicates the number of literals
-//
-//	that should be encoded in i bits.
-func (h *huffmanEncoder) bitCounts(list []literalNode, maxBits int32) []int32 {
-	if maxBits >= maxBitsLimit {
-		panic("flate: maxBits too large")
-	}
-	n := int32(len(list))
-	list = list[0 : n+1]
-	list[n] = maxNode()
-
-	// The tree can't have greater depth than n - 1, no matter what. This
-	// saves a little bit of work in some small cases
-	if maxBits > n-1 {
-		maxBits = n - 1
-	}
-
-	// Create information about each of the levels.
-	// A bogus "Level 0" whose sole purpose is so that
-	// level1.prev.needed==0.  This makes level1.nextPairFreq
-	// be a legitimate value that never gets chosen.
-	var levels [maxBitsLimit]levelInfo
-	// leafCounts[i] counts the number of literals at the left
-	// of ancestors of the rightmost node at level i.
-	// leafCounts[i][j] is the number of literals at the left
-	// of the level j ancestor.
-	var leafCounts [maxBitsLimit][maxBitsLimit]int32
-
-	// Descending to only have 1 bounds check.
-	l2f := int32(list[2].freq)
-	l1f := int32(list[1].freq)
-	l0f := int32(list[0].freq) + int32(list[1].freq)
-
-	for level := int32(1); level <= maxBits; level++ {
-		// For every level, the first two items are the first two characters.
-		// We initialize the levels as if we had already figured this out.
-		levels[level] = levelInfo{
-			level:        level,
-			lastFreq:     l1f,
-			nextCharFreq: l2f,
-			nextPairFreq: l0f,
-		}
-		leafCounts[level][level] = 2
-		if level == 1 {
-			levels[level].nextPairFreq = math.MaxInt32
-		}
-	}
-
-	// We need a total of 2*n - 2 items at top level and have already generated 2.
-	levels[maxBits].needed = 2*n - 4
-
-	level := uint32(maxBits)
-	for level < 16 {
-		l := &levels[level]
-		if l.nextPairFreq == math.MaxInt32 && l.nextCharFreq == math.MaxInt32 {
-			// We've run out of both leafs and pairs.
-			// End all calculations for this level.
-			// To make sure we never come back to this level or any lower level,
-			// set nextPairFreq impossibly large.
-			l.needed = 0
-			levels[level+1].nextPairFreq = math.MaxInt32
-			level++
-			continue
-		}
-
-		prevFreq := l.lastFreq
-		if l.nextCharFreq < l.nextPairFreq {
-			// The next item on this row is a leaf node.
-			n := leafCounts[level][level] + 1
-			l.lastFreq = l.nextCharFreq
-			// Lower leafCounts are the same of the previous node.
-			leafCounts[level][level] = n
-			e := list[n]
-			if e.literal < math.MaxUint16 {
-				l.nextCharFreq = int32(e.freq)
-			} else {
-				l.nextCharFreq = math.MaxInt32
-			}
-		} else {
-			// The next item on this row is a pair from the previous row.
-			// nextPairFreq isn't valid until we generate two
-			// more values in the level below
-			l.lastFreq = l.nextPairFreq
-			// Take leaf counts from the lower level, except counts[level] remains the same.
-			if true {
-				save := leafCounts[level][level]
-				leafCounts[level] = leafCounts[level-1]
-				leafCounts[level][level] = save
-			} else {
-				copy(leafCounts[level][:level], leafCounts[level-1][:level])
-			}
-			levels[l.level-1].needed = 2
-		}
-
-		if l.needed--; l.needed == 0 {
-			// We've done everything we need to do for this level.
-			// Continue calculating one level up. Fill in nextPairFreq
-			// of that level with the sum of the two nodes we've just calculated on
-			// this level.
-			if l.level == maxBits {
-				// All done!
-				break
-			}
-			levels[l.level+1].nextPairFreq = prevFreq + l.lastFreq
-			level++
-		} else {
-			// If we stole from below, move down temporarily to replenish it.
-			for levels[level-1].needed > 0 {
-				level--
-			}
-		}
-	}
-
-	// Somethings is wrong if at the end, the top level is null or hasn't used
-	// all of the leaves.
-	if leafCounts[maxBits][maxBits] != n {
-		panic("leafCounts[maxBits][maxBits] != n")
-	}
-
-	bitCount := h.bitCount[:maxBits+1]
-	bits := 1
-	counts := &leafCounts[maxBits]
-	for level := maxBits; level > 0; level-- {
-		// chain.leafCount gives the number of literals requiring at least "bits"
-		// bits to encode.
-		bitCount[bits] = counts[level] - counts[level-1]
-		bits++
-	}
-	return bitCount
-}
-
-// Look at the leaves and assign them a bit count and an encoding as specified
-// in RFC 1951 3.2.2
-func (h *huffmanEncoder) assignEncodingAndSize(bitCount []int32, list []literalNode) {
-	code := uint16(0)
-	for n, bits := range bitCount {
-		code <<= 1
-		if n == 0 || bits == 0 {
-			continue
-		}
-		// The literals list[len(list)-bits] .. list[len(list)-bits]
-		// are encoded using "bits" bits, and get the values
-		// code, code + 1, ....  The code values are
-		// assigned in literal order (not frequency order).
-		chunk := list[len(list)-int(bits):]
-
-		sortByLiteral(chunk)
-		for _, node := range chunk {
-			h.codes[node.literal] = newhcode(reverseBits(code, uint8(n)), uint8(n))
-			code++
-		}
-		list = list[0 : len(list)-int(bits)]
-	}
-}
-
-// Update this Huffman Code object to be the minimum code for the specified frequency count.
-//
-// freq  An array of frequencies, in which frequency[i] gives the frequency of literal i.
-// maxBits  The maximum number of bits to use for any literal.
-func (h *huffmanEncoder) generate(freq []uint16, maxBits int32) {
-	list := h.freqcache[:len(freq)+1]
-	codes := h.codes[:len(freq)]
-	// Number of non-zero literals
-	count := 0
-	// Set list to be the set of all non-zero literals and their frequencies
-	for i, f := range freq {
-		if f != 0 {
-			list[count] = literalNode{uint16(i), f}
-			count++
-		} else {
-			codes[i] = 0
-		}
-	}
-	list[count] = literalNode{}
-
-	list = list[:count]
-	if count <= 2 {
-		// Handle the small cases here, because they are awkward for the general case code. With
-		// two or fewer literals, everything has bit length 1.
-		for i, node := range list {
-			// "list" is in order of increasing literal value.
-			h.codes[node.literal].set(uint16(i), 1)
-		}
-		return
-	}
-	sortByFreq(list)
-
-	// Get the number of literals for each bit count
-	bitCount := h.bitCounts(list, maxBits)
-	// And do the assignment
-	h.assignEncodingAndSize(bitCount, list)
-}
-
-// atLeastOne clamps the result between 1 and 15.
-func atLeastOne(v float32) float32 {
-	if v < 1 {
-		return 1
-	}
-	if v > 15 {
-		return 15
-	}
-	return v
-}
-
-func histogram(b []byte, h []uint16) {
-	if true && len(b) >= 8<<10 {
-		// Split for bigger inputs
-		histogramSplit(b, h)
-	} else {
-		h = h[:256]
-		for _, t := range b {
-			h[t]++
-		}
-	}
-}
-
-func histogramSplit(b []byte, h []uint16) {
-	// Tested, and slightly faster than 2-way.
-	// Writing to separate arrays and combining is also slightly slower.
-	h = h[:256]
-	for len(b)&3 != 0 {
-		h[b[0]]++
-		b = b[1:]
-	}
-	n := len(b) / 4
-	x, y, z, w := b[:n], b[n:], b[n+n:], b[n+n+n:]
-	y, z, w = y[:len(x)], z[:len(x)], w[:len(x)]
-	for i, t := range x {
-		v0 := &h[t]
-		v1 := &h[y[i]]
-		v3 := &h[w[i]]
-		v2 := &h[z[i]]
-		*v0++
-		*v1++
-		*v2++
-		*v3++
-	}
-}
--- a/gateway/vendor/github.com/klauspost/compress/flate/huffman_sortByFreq.go
+++ b/gateway/vendor/github.com/klauspost/compress/flate/huffman_sortByFreq.go
@ -1,159 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package flate
-
-// Sort sorts data.
-// It makes one call to data.Len to determine n, and O(n*log(n)) calls to
-// data.Less and data.Swap. The sort is not guaranteed to be stable.
-func sortByFreq(data []literalNode) {
-	n := len(data)
-	quickSortByFreq(data, 0, n, maxDepth(n))
-}
-
-func quickSortByFreq(data []literalNode, a, b, maxDepth int) {
-	for b-a > 12 { // Use ShellSort for slices <= 12 elements
-		if maxDepth == 0 {
-			heapSort(data, a, b)
-			return
-		}
-		maxDepth--
-		mlo, mhi := doPivotByFreq(data, a, b)
-		// Avoiding recursion on the larger subproblem guarantees
-		// a stack depth of at most lg(b-a).
-		if mlo-a < b-mhi {
-			quickSortByFreq(data, a, mlo, maxDepth)
-			a = mhi // i.e., quickSortByFreq(data, mhi, b)
-		} else {
-			quickSortByFreq(data, mhi, b, maxDepth)
-			b = mlo // i.e., quickSortByFreq(data, a, mlo)
-		}
-	}
-	if b-a > 1 {
-		// Do ShellSort pass with gap 6
-		// It could be written in this simplified form cause b-a <= 12
-		for i := a + 6; i < b; i++ {
-			if data[i].freq == data[i-6].freq && data[i].literal < data[i-6].literal || data[i].freq < data[i-6].freq {
-				data[i], data[i-6] = data[i-6], data[i]
-			}
-		}
-		insertionSortByFreq(data, a, b)
-	}
-}
-
-func doPivotByFreq(data []literalNode, lo, hi int) (midlo, midhi int) {
-	m := int(uint(lo+hi) >> 1) // Written like this to avoid integer overflow.
-	if hi-lo > 40 {
-		// Tukey's ``Ninther,'' median of three medians of three.
-		s := (hi - lo) / 8
-		medianOfThreeSortByFreq(data, lo, lo+s, lo+2*s)
-		medianOfThreeSortByFreq(data, m, m-s, m+s)
-		medianOfThreeSortByFreq(data, hi-1, hi-1-s, hi-1-2*s)
-	}
-	medianOfThreeSortByFreq(data, lo, m, hi-1)
-
-	// Invariants are:
-	//	data[lo] = pivot (set up by ChoosePivot)
-	//	data[lo < i < a] < pivot
-	//	data[a <= i < b] <= pivot
-	//	data[b <= i < c] unexamined
-	//	data[c <= i < hi-1] > pivot
-	//	data[hi-1] >= pivot
-	pivot := lo
-	a, c := lo+1, hi-1
-
-	for ; a < c && (data[a].freq == data[pivot].freq && data[a].literal < data[pivot].literal || data[a].freq < data[pivot].freq); a++ {
-	}
-	b := a
-	for {
-		for ; b < c && (data[pivot].freq == data[b].freq && data[pivot].literal > data[b].literal || data[pivot].freq > data[b].freq); b++ { // data[b] <= pivot
-		}
-		for ; b < c && (data[pivot].freq == data[c-1].freq && data[pivot].literal < data[c-1].literal || data[pivot].freq < data[c-1].freq); c-- { // data[c-1] > pivot
-		}
-		if b >= c {
-			break
-		}
-		// data[b] > pivot; data[c-1] <= pivot
-		data[b], data[c-1] = data[c-1], data[b]
-		b++
-		c--
-	}
-	// If hi-c<3 then there are duplicates (by property of median of nine).
-	// Let's be a bit more conservative, and set border to 5.
-	protect := hi-c < 5
-	if !protect && hi-c < (hi-lo)/4 {
-		// Lets test some points for equality to pivot
-		dups := 0
-		if data[pivot].freq == data[hi-1].freq && data[pivot].literal > data[hi-1].literal || data[pivot].freq > data[hi-1].freq { // data[hi-1] = pivot
-			data[c], data[hi-1] = data[hi-1], data[c]
-			c++
-			dups++
-		}
-		if data[b-1].freq == data[pivot].freq && data[b-1].literal > data[pivot].literal || data[b-1].freq > data[pivot].freq { // data[b-1] = pivot
-			b--
-			dups++
-		}
-		// m-lo = (hi-lo)/2 > 6
-		// b-lo > (hi-lo)*3/4-1 > 8
-		// ==> m < b ==> data[m] <= pivot
-		if data[m].freq == data[pivot].freq && data[m].literal > data[pivot].literal || data[m].freq > data[pivot].freq { // data[m] = pivot
-			data[m], data[b-1] = data[b-1], data[m]
-			b--
-			dups++
-		}
-		// if at least 2 points are equal to pivot, assume skewed distribution
-		protect = dups > 1
-	}
-	if protect {
-		// Protect against a lot of duplicates
-		// Add invariant:
-		//	data[a <= i < b] unexamined
-		//	data[b <= i < c] = pivot
-		for {
-			for ; a < b && (data[b-1].freq == data[pivot].freq && data[b-1].literal > data[pivot].literal || data[b-1].freq > data[pivot].freq); b-- { // data[b] == pivot
-			}
-			for ; a < b && (data[a].freq == data[pivot].freq && data[a].literal < data[pivot].literal || data[a].freq < data[pivot].freq); a++ { // data[a] < pivot
-			}
-			if a >= b {
-				break
-			}
-			// data[a] == pivot; data[b-1] < pivot
-			data[a], data[b-1] = data[b-1], data[a]
-			a++
-			b--
-		}
-	}
-	// Swap pivot into middle
-	data[pivot], data[b-1] = data[b-1], data[pivot]
-	return b - 1, c
-}
-
-// Insertion sort
-func insertionSortByFreq(data []literalNode, a, b int) {
-	for i := a + 1; i < b; i++ {
-		for j := i; j > a && (data[j].freq == data[j-1].freq && data[j].literal < data[j-1].literal || data[j].freq < data[j-1].freq); j-- {
-			data[j], data[j-1] = data[j-1], data[j]
-		}
-	}
-}
-
-// quickSortByFreq, loosely following Bentley and McIlroy,
-// ``Engineering a Sort Function,'' SP&E November 1993.
-
-// medianOfThreeSortByFreq moves the median of the three values data[m0], data[m1], data[m2] into data[m1].
-func medianOfThreeSortByFreq(data []literalNode, m1, m0, m2 int) {
-	// sort 3 elements
-	if data[m1].freq == data[m0].freq && data[m1].literal < data[m0].literal || data[m1].freq < data[m0].freq {
-		data[m1], data[m0] = data[m0], data[m1]
-	}
-	// data[m0] <= data[m1]
-	if data[m2].freq == data[m1].freq && data[m2].literal < data[m1].literal || data[m2].freq < data[m1].freq {
-		data[m2], data[m1] = data[m1], data[m2]
-		// data[m0] <= data[m2] && data[m1] < data[m2]
-		if data[m1].freq == data[m0].freq && data[m1].literal < data[m0].literal || data[m1].freq < data[m0].freq {
-			data[m1], data[m0] = data[m0], data[m1]
-		}
-	}
-	// now data[m0] <= data[m1] <= data[m2]
-}
--- a/gateway/vendor/github.com/klauspost/compress/flate/huffman_sortByLiteral.go
+++ b/gateway/vendor/github.com/klauspost/compress/flate/huffman_sortByLiteral.go
@ -1,201 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package flate
-
-// Sort sorts data.
-// It makes one call to data.Len to determine n, and O(n*log(n)) calls to
-// data.Less and data.Swap. The sort is not guaranteed to be stable.
-func sortByLiteral(data []literalNode) {
-	n := len(data)
-	quickSort(data, 0, n, maxDepth(n))
-}
-
-func quickSort(data []literalNode, a, b, maxDepth int) {
-	for b-a > 12 { // Use ShellSort for slices <= 12 elements
-		if maxDepth == 0 {
-			heapSort(data, a, b)
-			return
-		}
-		maxDepth--
-		mlo, mhi := doPivot(data, a, b)
-		// Avoiding recursion on the larger subproblem guarantees
-		// a stack depth of at most lg(b-a).
-		if mlo-a < b-mhi {
-			quickSort(data, a, mlo, maxDepth)
-			a = mhi // i.e., quickSort(data, mhi, b)
-		} else {
-			quickSort(data, mhi, b, maxDepth)
-			b = mlo // i.e., quickSort(data, a, mlo)
-		}
-	}
-	if b-a > 1 {
-		// Do ShellSort pass with gap 6
-		// It could be written in this simplified form cause b-a <= 12
-		for i := a + 6; i < b; i++ {
-			if data[i].literal < data[i-6].literal {
-				data[i], data[i-6] = data[i-6], data[i]
-			}
-		}
-		insertionSort(data, a, b)
-	}
-}
-func heapSort(data []literalNode, a, b int) {
-	first := a
-	lo := 0
-	hi := b - a
-
-	// Build heap with greatest element at top.
-	for i := (hi - 1) / 2; i >= 0; i-- {
-		siftDown(data, i, hi, first)
-	}
-
-	// Pop elements, largest first, into end of data.
-	for i := hi - 1; i >= 0; i-- {
-		data[first], data[first+i] = data[first+i], data[first]
-		siftDown(data, lo, i, first)
-	}
-}
-
-// siftDown implements the heap property on data[lo, hi).
-// first is an offset into the array where the root of the heap lies.
-func siftDown(data []literalNode, lo, hi, first int) {
-	root := lo
-	for {
-		child := 2*root + 1
-		if child >= hi {
-			break
-		}
-		if child+1 < hi && data[first+child].literal < data[first+child+1].literal {
-			child++
-		}
-		if data[first+root].literal > data[first+child].literal {
-			return
-		}
-		data[first+root], data[first+child] = data[first+child], data[first+root]
-		root = child
-	}
-}
-func doPivot(data []literalNode, lo, hi int) (midlo, midhi int) {
-	m := int(uint(lo+hi) >> 1) // Written like this to avoid integer overflow.
-	if hi-lo > 40 {
-		// Tukey's ``Ninther,'' median of three medians of three.
-		s := (hi - lo) / 8
-		medianOfThree(data, lo, lo+s, lo+2*s)
-		medianOfThree(data, m, m-s, m+s)
-		medianOfThree(data, hi-1, hi-1-s, hi-1-2*s)
-	}
-	medianOfThree(data, lo, m, hi-1)
-
-	// Invariants are:
-	//	data[lo] = pivot (set up by ChoosePivot)
-	//	data[lo < i < a] < pivot
-	//	data[a <= i < b] <= pivot
-	//	data[b <= i < c] unexamined
-	//	data[c <= i < hi-1] > pivot
-	//	data[hi-1] >= pivot
-	pivot := lo
-	a, c := lo+1, hi-1
-
-	for ; a < c && data[a].literal < data[pivot].literal; a++ {
-	}
-	b := a
-	for {
-		for ; b < c && data[pivot].literal > data[b].literal; b++ { // data[b] <= pivot
-		}
-		for ; b < c && data[pivot].literal < data[c-1].literal; c-- { // data[c-1] > pivot
-		}
-		if b >= c {
-			break
-		}
-		// data[b] > pivot; data[c-1] <= pivot
-		data[b], data[c-1] = data[c-1], data[b]
-		b++
-		c--
-	}
-	// If hi-c<3 then there are duplicates (by property of median of nine).
-	// Let's be a bit more conservative, and set border to 5.
-	protect := hi-c < 5
-	if !protect && hi-c < (hi-lo)/4 {
-		// Lets test some points for equality to pivot
-		dups := 0
-		if data[pivot].literal > data[hi-1].literal { // data[hi-1] = pivot
-			data[c], data[hi-1] = data[hi-1], data[c]
-			c++
-			dups++
-		}
-		if data[b-1].literal > data[pivot].literal { // data[b-1] = pivot
-			b--
-			dups++
-		}
-		// m-lo = (hi-lo)/2 > 6
-		// b-lo > (hi-lo)*3/4-1 > 8
-		// ==> m < b ==> data[m] <= pivot
-		if data[m].literal > data[pivot].literal { // data[m] = pivot
-			data[m], data[b-1] = data[b-1], data[m]
-			b--
-			dups++
-		}
-		// if at least 2 points are equal to pivot, assume skewed distribution
-		protect = dups > 1
-	}
-	if protect {
-		// Protect against a lot of duplicates
-		// Add invariant:
-		//	data[a <= i < b] unexamined
-		//	data[b <= i < c] = pivot
-		for {
-			for ; a < b && data[b-1].literal > data[pivot].literal; b-- { // data[b] == pivot
-			}
-			for ; a < b && data[a].literal < data[pivot].literal; a++ { // data[a] < pivot
-			}
-			if a >= b {
-				break
-			}
-			// data[a] == pivot; data[b-1] < pivot
-			data[a], data[b-1] = data[b-1], data[a]
-			a++
-			b--
-		}
-	}
-	// Swap pivot into middle
-	data[pivot], data[b-1] = data[b-1], data[pivot]
-	return b - 1, c
-}
-
-// Insertion sort
-func insertionSort(data []literalNode, a, b int) {
-	for i := a + 1; i < b; i++ {
-		for j := i; j > a && data[j].literal < data[j-1].literal; j-- {
-			data[j], data[j-1] = data[j-1], data[j]
-		}
-	}
-}
-
-// maxDepth returns a threshold at which quicksort should switch
-// to heapsort. It returns 2*ceil(lg(n+1)).
-func maxDepth(n int) int {
-	var depth int
-	for i := n; i > 0; i >>= 1 {
-		depth++
-	}
-	return depth * 2
-}
-
-// medianOfThree moves the median of the three values data[m0], data[m1], data[m2] into data[m1].
-func medianOfThree(data []literalNode, m1, m0, m2 int) {
-	// sort 3 elements
-	if data[m1].literal < data[m0].literal {
-		data[m1], data[m0] = data[m0], data[m1]
-	}
-	// data[m0] <= data[m1]
-	if data[m2].literal < data[m1].literal {
-		data[m2], data[m1] = data[m1], data[m2]
-		// data[m0] <= data[m2] && data[m1] < data[m2]
-		if data[m1].literal < data[m0].literal {
-			data[m1], data[m0] = data[m0], data[m1]
-		}
-	}
-	// now data[m0] <= data[m1] <= data[m2]
-}
--- a/gateway/vendor/github.com/klauspost/compress/flate/inflate.go
+++ b/gateway/vendor/github.com/klauspost/compress/flate/inflate.go
@ -1,829 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package flate implements the DEFLATE compressed data format, described in
-// RFC 1951.  The gzip and zlib packages implement access to DEFLATE-based file
-// formats.
-package flate
-
-import (
-	"bufio"
-	"compress/flate"
-	"fmt"
-	"io"
-	"math/bits"
-	"sync"
-)
-
-const (
-	maxCodeLen     = 16 // max length of Huffman code
-	maxCodeLenMask = 15 // mask for max length of Huffman code
-	// The next three numbers come from the RFC section 3.2.7, with the
-	// additional proviso in section 3.2.5 which implies that distance codes
-	// 30 and 31 should never occur in compressed data.
-	maxNumLit  = 286
-	maxNumDist = 30
-	numCodes   = 19 // number of codes in Huffman meta-code
-
-	debugDecode = false
-)
-
-// Value of length - 3 and extra bits.
-type lengthExtra struct {
-	length, extra uint8
-}
-
-var decCodeToLen = [32]lengthExtra{{length: 0x0, extra: 0x0}, {length: 0x1, extra: 0x0}, {length: 0x2, extra: 0x0}, {length: 0x3, extra: 0x0}, {length: 0x4, extra: 0x0}, {length: 0x5, extra: 0x0}, {length: 0x6, extra: 0x0}, {length: 0x7, extra: 0x0}, {length: 0x8, extra: 0x1}, {length: 0xa, extra: 0x1}, {length: 0xc, extra: 0x1}, {length: 0xe, extra: 0x1}, {length: 0x10, extra: 0x2}, {length: 0x14, extra: 0x2}, {length: 0x18, extra: 0x2}, {length: 0x1c, extra: 0x2}, {length: 0x20, extra: 0x3}, {length: 0x28, extra: 0x3}, {length: 0x30, extra: 0x3}, {length: 0x38, extra: 0x3}, {length: 0x40, extra: 0x4}, {length: 0x50, extra: 0x4}, {length: 0x60, extra: 0x4}, {length: 0x70, extra: 0x4}, {length: 0x80, extra: 0x5}, {length: 0xa0, extra: 0x5}, {length: 0xc0, extra: 0x5}, {length: 0xe0, extra: 0x5}, {length: 0xff, extra: 0x0}, {length: 0x0, extra: 0x0}, {length: 0x0, extra: 0x0}, {length: 0x0, extra: 0x0}}
-
-var bitMask32 = [32]uint32{
-	0, 1, 3, 7, 0xF, 0x1F, 0x3F, 0x7F, 0xFF,
-	0x1FF, 0x3FF, 0x7FF, 0xFFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF,
-	0x1ffff, 0x3ffff, 0x7FFFF, 0xfFFFF, 0x1fFFFF, 0x3fFFFF, 0x7fFFFF, 0xffFFFF,
-	0x1ffFFFF, 0x3ffFFFF, 0x7ffFFFF, 0xfffFFFF, 0x1fffFFFF, 0x3fffFFFF, 0x7fffFFFF,
-} // up to 32 bits
-
-// Initialize the fixedHuffmanDecoder only once upon first use.
-var fixedOnce sync.Once
-var fixedHuffmanDecoder huffmanDecoder
-
-// A CorruptInputError reports the presence of corrupt input at a given offset.
-type CorruptInputError = flate.CorruptInputError
-
-// An InternalError reports an error in the flate code itself.
-type InternalError string
-
-func (e InternalError) Error() string { return "flate: internal error: " + string(e) }
-
-// A ReadError reports an error encountered while reading input.
-//
-// Deprecated: No longer returned.
-type ReadError = flate.ReadError
-
-// A WriteError reports an error encountered while writing output.
-//
-// Deprecated: No longer returned.
-type WriteError = flate.WriteError
-
-// Resetter resets a ReadCloser returned by NewReader or NewReaderDict to
-// to switch to a new underlying Reader. This permits reusing a ReadCloser
-// instead of allocating a new one.
-type Resetter interface {
-	// Reset discards any buffered data and resets the Resetter as if it was
-	// newly initialized with the given reader.
-	Reset(r io.Reader, dict []byte) error
-}
-
-// The data structure for decoding Huffman tables is based on that of
-// zlib. There is a lookup table of a fixed bit width (huffmanChunkBits),
-// For codes smaller than the table width, there are multiple entries
-// (each combination of trailing bits has the same value). For codes
-// larger than the table width, the table contains a link to an overflow
-// table. The width of each entry in the link table is the maximum code
-// size minus the chunk width.
-//
-// Note that you can do a lookup in the table even without all bits
-// filled. Since the extra bits are zero, and the DEFLATE Huffman codes
-// have the property that shorter codes come before longer ones, the
-// bit length estimate in the result is a lower bound on the actual
-// number of bits.
-//
-// See the following:
-//	http://www.gzip.org/algorithm.txt
-
-// chunk & 15 is number of bits
-// chunk >> 4 is value, including table link
-
-const (
-	huffmanChunkBits  = 9
-	huffmanNumChunks  = 1 << huffmanChunkBits
-	huffmanCountMask  = 15
-	huffmanValueShift = 4
-)
-
-type huffmanDecoder struct {
-	maxRead  int                       // the maximum number of bits we can read and not overread
-	chunks   *[huffmanNumChunks]uint16 // chunks as described above
-	links    [][]uint16                // overflow links
-	linkMask uint32                    // mask the width of the link table
-}
-
-// Initialize Huffman decoding tables from array of code lengths.
-// Following this function, h is guaranteed to be initialized into a complete
-// tree (i.e., neither over-subscribed nor under-subscribed). The exception is a
-// degenerate case where the tree has only a single symbol with length 1. Empty
-// trees are permitted.
-func (h *huffmanDecoder) init(lengths []int) bool {
-	// Sanity enables additional runtime tests during Huffman
-	// table construction. It's intended to be used during
-	// development to supplement the currently ad-hoc unit tests.
-	const sanity = false
-
-	if h.chunks == nil {
-		h.chunks = new([huffmanNumChunks]uint16)
-	}
-
-	if h.maxRead != 0 {
-		*h = huffmanDecoder{chunks: h.chunks, links: h.links}
-	}
-
-	// Count number of codes of each length,
-	// compute maxRead and max length.
-	var count [maxCodeLen]int
-	var min, max int
-	for _, n := range lengths {
-		if n == 0 {
-			continue
-		}
-		if min == 0 || n < min {
-			min = n
-		}
-		if n > max {
-			max = n
-		}
-		count[n&maxCodeLenMask]++
-	}
-
-	// Empty tree. The decompressor.huffSym function will fail later if the tree
-	// is used. Technically, an empty tree is only valid for the HDIST tree and
-	// not the HCLEN and HLIT tree. However, a stream with an empty HCLEN tree
-	// is guaranteed to fail since it will attempt to use the tree to decode the
-	// codes for the HLIT and HDIST trees. Similarly, an empty HLIT tree is
-	// guaranteed to fail later since the compressed data section must be
-	// composed of at least one symbol (the end-of-block marker).
-	if max == 0 {
-		return true
-	}
-
-	code := 0
-	var nextcode [maxCodeLen]int
-	for i := min; i <= max; i++ {
-		code <<= 1
-		nextcode[i&maxCodeLenMask] = code
-		code += count[i&maxCodeLenMask]
-	}
-
-	// Check that the coding is complete (i.e., that we've
-	// assigned all 2-to-the-max possible bit sequences).
-	// Exception: To be compatible with zlib, we also need to
-	// accept degenerate single-code codings. See also
-	// TestDegenerateHuffmanCoding.
-	if code != 1<<uint(max) && !(code == 1 && max == 1) {
-		if debugDecode {
-			fmt.Println("coding failed, code, max:", code, max, code == 1<<uint(max), code == 1 && max == 1, "(one should be true)")
-		}
-		return false
-	}
-
-	h.maxRead = min
-
-	chunks := h.chunks[:]
-	for i := range chunks {
-		chunks[i] = 0
-	}
-
-	if max > huffmanChunkBits {
-		numLinks := 1 << (uint(max) - huffmanChunkBits)
-		h.linkMask = uint32(numLinks - 1)
-
-		// create link tables
-		link := nextcode[huffmanChunkBits+1] >> 1
-		if cap(h.links) < huffmanNumChunks-link {
-			h.links = make([][]uint16, huffmanNumChunks-link)
-		} else {
-			h.links = h.links[:huffmanNumChunks-link]
-		}
-		for j := uint(link); j < huffmanNumChunks; j++ {
-			reverse := int(bits.Reverse16(uint16(j)))
-			reverse >>= uint(16 - huffmanChunkBits)
-			off := j - uint(link)
-			if sanity && h.chunks[reverse] != 0 {
-				panic("impossible: overwriting existing chunk")
-			}
-			h.chunks[reverse] = uint16(off<<huffmanValueShift | (huffmanChunkBits + 1))
-			if cap(h.links[off]) < numLinks {
-				h.links[off] = make([]uint16, numLinks)
-			} else {
-				h.links[off] = h.links[off][:numLinks]
-			}
-		}
-	} else {
-		h.links = h.links[:0]
-	}
-
-	for i, n := range lengths {
-		if n == 0 {
-			continue
-		}
-		code := nextcode[n]
-		nextcode[n]++
-		chunk := uint16(i<<huffmanValueShift | n)
-		reverse := int(bits.Reverse16(uint16(code)))
-		reverse >>= uint(16 - n)
-		if n <= huffmanChunkBits {
-			for off := reverse; off < len(h.chunks); off += 1 << uint(n) {
-				// We should never need to overwrite
-				// an existing chunk. Also, 0 is
-				// never a valid chunk, because the
-				// lower 4 "count" bits should be
-				// between 1 and 15.
-				if sanity && h.chunks[off] != 0 {
-					panic("impossible: overwriting existing chunk")
-				}
-				h.chunks[off] = chunk
-			}
-		} else {
-			j := reverse & (huffmanNumChunks - 1)
-			if sanity && h.chunks[j]&huffmanCountMask != huffmanChunkBits+1 {
-				// Longer codes should have been
-				// associated with a link table above.
-				panic("impossible: not an indirect chunk")
-			}
-			value := h.chunks[j] >> huffmanValueShift
-			linktab := h.links[value]
-			reverse >>= huffmanChunkBits
-			for off := reverse; off < len(linktab); off += 1 << uint(n-huffmanChunkBits) {
-				if sanity && linktab[off] != 0 {
-					panic("impossible: overwriting existing chunk")
-				}
-				linktab[off] = chunk
-			}
-		}
-	}
-
-	if sanity {
-		// Above we've sanity checked that we never overwrote
-		// an existing entry. Here we additionally check that
-		// we filled the tables completely.
-		for i, chunk := range h.chunks {
-			if chunk == 0 {
-				// As an exception, in the degenerate
-				// single-code case, we allow odd
-				// chunks to be missing.
-				if code == 1 && i%2 == 1 {
-					continue
-				}
-				panic("impossible: missing chunk")
-			}
-		}
-		for _, linktab := range h.links {
-			for _, chunk := range linktab {
-				if chunk == 0 {
-					panic("impossible: missing chunk")
-				}
-			}
-		}
-	}
-
-	return true
-}
-
-// Reader is the actual read interface needed by NewReader.
-// If the passed in io.Reader does not also have ReadByte,
-// the NewReader will introduce its own buffering.
-type Reader interface {
-	io.Reader
-	io.ByteReader
-}
-
-type step uint8
-
-const (
-	copyData step = iota + 1
-	nextBlock
-	huffmanBytesBuffer
-	huffmanBytesReader
-	huffmanBufioReader
-	huffmanStringsReader
-	huffmanGenericReader
-)
-
-// Decompress state.
-type decompressor struct {
-	// Input source.
-	r       Reader
-	roffset int64
-
-	// Huffman decoders for literal/length, distance.
-	h1, h2 huffmanDecoder
-
-	// Length arrays used to define Huffman codes.
-	bits     *[maxNumLit + maxNumDist]int
-	codebits *[numCodes]int
-
-	// Output history, buffer.
-	dict dictDecoder
-
-	// Next step in the decompression,
-	// and decompression state.
-	step      step
-	stepState int
-	err       error
-	toRead    []byte
-	hl, hd    *huffmanDecoder
-	copyLen   int
-	copyDist  int
-
-	// Temporary buffer (avoids repeated allocation).
-	buf [4]byte
-
-	// Input bits, in top of b.
-	b uint32
-
-	nb    uint
-	final bool
-}
-
-func (f *decompressor) nextBlock() {
-	for f.nb < 1+2 {
-		if f.err = f.moreBits(); f.err != nil {
-			return
-		}
-	}
-	f.final = f.b&1 == 1
-	f.b >>= 1
-	typ := f.b & 3
-	f.b >>= 2
-	f.nb -= 1 + 2
-	switch typ {
-	case 0:
-		f.dataBlock()
-		if debugDecode {
-			fmt.Println("stored block")
-		}
-	case 1:
-		// compressed, fixed Huffman tables
-		f.hl = &fixedHuffmanDecoder
-		f.hd = nil
-		f.huffmanBlockDecoder()
-		if debugDecode {
-			fmt.Println("predefinied huffman block")
-		}
-	case 2:
-		// compressed, dynamic Huffman tables
-		if f.err = f.readHuffman(); f.err != nil {
-			break
-		}
-		f.hl = &f.h1
-		f.hd = &f.h2
-		f.huffmanBlockDecoder()
-		if debugDecode {
-			fmt.Println("dynamic huffman block")
-		}
-	default:
-		// 3 is reserved.
-		if debugDecode {
-			fmt.Println("reserved data block encountered")
-		}
-		f.err = CorruptInputError(f.roffset)
-	}
-}
-
-func (f *decompressor) Read(b []byte) (int, error) {
-	for {
-		if len(f.toRead) > 0 {
-			n := copy(b, f.toRead)
-			f.toRead = f.toRead[n:]
-			if len(f.toRead) == 0 {
-				return n, f.err
-			}
-			return n, nil
-		}
-		if f.err != nil {
-			return 0, f.err
-		}
-
-		f.doStep()
-
-		if f.err != nil && len(f.toRead) == 0 {
-			f.toRead = f.dict.readFlush() // Flush what's left in case of error
-		}
-	}
-}
-
-// WriteTo implements the io.WriteTo interface for io.Copy and friends.
-func (f *decompressor) WriteTo(w io.Writer) (int64, error) {
-	total := int64(0)
-	flushed := false
-	for {
-		if len(f.toRead) > 0 {
-			n, err := w.Write(f.toRead)
-			total += int64(n)
-			if err != nil {
-				f.err = err
-				return total, err
-			}
-			if n != len(f.toRead) {
-				return total, io.ErrShortWrite
-			}
-			f.toRead = f.toRead[:0]
-		}
-		if f.err != nil && flushed {
-			if f.err == io.EOF {
-				return total, nil
-			}
-			return total, f.err
-		}
-		if f.err == nil {
-			f.doStep()
-		}
-		if len(f.toRead) == 0 && f.err != nil && !flushed {
-			f.toRead = f.dict.readFlush() // Flush what's left in case of error
-			flushed = true
-		}
-	}
-}
-
-func (f *decompressor) Close() error {
-	if f.err == io.EOF {
-		return nil
-	}
-	return f.err
-}
-
-// RFC 1951 section 3.2.7.
-// Compression with dynamic Huffman codes
-
-var codeOrder = [...]int{16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}
-
-func (f *decompressor) readHuffman() error {
-	// HLIT[5], HDIST[5], HCLEN[4].
-	for f.nb < 5+5+4 {
-		if err := f.moreBits(); err != nil {
-			return err
-		}
-	}
-	nlit := int(f.b&0x1F) + 257
-	if nlit > maxNumLit {
-		if debugDecode {
-			fmt.Println("nlit > maxNumLit", nlit)
-		}
-		return CorruptInputError(f.roffset)
-	}
-	f.b >>= 5
-	ndist := int(f.b&0x1F) + 1
-	if ndist > maxNumDist {
-		if debugDecode {
-			fmt.Println("ndist > maxNumDist", ndist)
-		}
-		return CorruptInputError(f.roffset)
-	}
-	f.b >>= 5
-	nclen := int(f.b&0xF) + 4
-	// numCodes is 19, so nclen is always valid.
-	f.b >>= 4
-	f.nb -= 5 + 5 + 4
-
-	// (HCLEN+4)*3 bits: code lengths in the magic codeOrder order.
-	for i := 0; i < nclen; i++ {
-		for f.nb < 3 {
-			if err := f.moreBits(); err != nil {
-				return err
-			}
-		}
-		f.codebits[codeOrder[i]] = int(f.b & 0x7)
-		f.b >>= 3
-		f.nb -= 3
-	}
-	for i := nclen; i < len(codeOrder); i++ {
-		f.codebits[codeOrder[i]] = 0
-	}
-	if !f.h1.init(f.codebits[0:]) {
-		if debugDecode {
-			fmt.Println("init codebits failed")
-		}
-		return CorruptInputError(f.roffset)
-	}
-
-	// HLIT + 257 code lengths, HDIST + 1 code lengths,
-	// using the code length Huffman code.
-	for i, n := 0, nlit+ndist; i < n; {
-		x, err := f.huffSym(&f.h1)
-		if err != nil {
-			return err
-		}
-		if x < 16 {
-			// Actual length.
-			f.bits[i] = x
-			i++
-			continue
-		}
-		// Repeat previous length or zero.
-		var rep int
-		var nb uint
-		var b int
-		switch x {
-		default:
-			return InternalError("unexpected length code")
-		case 16:
-			rep = 3
-			nb = 2
-			if i == 0 {
-				if debugDecode {
-					fmt.Println("i==0")
-				}
-				return CorruptInputError(f.roffset)
-			}
-			b = f.bits[i-1]
-		case 17:
-			rep = 3
-			nb = 3
-			b = 0
-		case 18:
-			rep = 11
-			nb = 7
-			b = 0
-		}
-		for f.nb < nb {
-			if err := f.moreBits(); err != nil {
-				if debugDecode {
-					fmt.Println("morebits:", err)
-				}
-				return err
-			}
-		}
-		rep += int(f.b & uint32(1<<(nb&regSizeMaskUint32)-1))
-		f.b >>= nb & regSizeMaskUint32
-		f.nb -= nb
-		if i+rep > n {
-			if debugDecode {
-				fmt.Println("i+rep > n", i, rep, n)
-			}
-			return CorruptInputError(f.roffset)
-		}
-		for j := 0; j < rep; j++ {
-			f.bits[i] = b
-			i++
-		}
-	}
-
-	if !f.h1.init(f.bits[0:nlit]) || !f.h2.init(f.bits[nlit:nlit+ndist]) {
-		if debugDecode {
-			fmt.Println("init2 failed")
-		}
-		return CorruptInputError(f.roffset)
-	}
-
-	// As an optimization, we can initialize the maxRead bits to read at a time
-	// for the HLIT tree to the length of the EOB marker since we know that
-	// every block must terminate with one. This preserves the property that
-	// we never read any extra bytes after the end of the DEFLATE stream.
-	if f.h1.maxRead < f.bits[endBlockMarker] {
-		f.h1.maxRead = f.bits[endBlockMarker]
-	}
-	if !f.final {
-		// If not the final block, the smallest block possible is
-		// a predefined table, BTYPE=01, with a single EOB marker.
-		// This will take up 3 + 7 bits.
-		f.h1.maxRead += 10
-	}
-
-	return nil
-}
-
-// Copy a single uncompressed data block from input to output.
-func (f *decompressor) dataBlock() {
-	// Uncompressed.
-	// Discard current half-byte.
-	left := (f.nb) & 7
-	f.nb -= left
-	f.b >>= left
-
-	offBytes := f.nb >> 3
-	// Unfilled values will be overwritten.
-	f.buf[0] = uint8(f.b)
-	f.buf[1] = uint8(f.b >> 8)
-	f.buf[2] = uint8(f.b >> 16)
-	f.buf[3] = uint8(f.b >> 24)
-
-	f.roffset += int64(offBytes)
-	f.nb, f.b = 0, 0
-
-	// Length then ones-complement of length.
-	nr, err := io.ReadFull(f.r, f.buf[offBytes:4])
-	f.roffset += int64(nr)
-	if err != nil {
-		f.err = noEOF(err)
-		return
-	}
-	n := uint16(f.buf[0]) | uint16(f.buf[1])<<8
-	nn := uint16(f.buf[2]) | uint16(f.buf[3])<<8
-	if nn != ^n {
-		if debugDecode {
-			ncomp := ^n
-			fmt.Println("uint16(nn) != uint16(^n)", nn, ncomp)
-		}
-		f.err = CorruptInputError(f.roffset)
-		return
-	}
-
-	if n == 0 {
-		f.toRead = f.dict.readFlush()
-		f.finishBlock()
-		return
-	}
-
-	f.copyLen = int(n)
-	f.copyData()
-}
-
-// copyData copies f.copyLen bytes from the underlying reader into f.hist.
-// It pauses for reads when f.hist is full.
-func (f *decompressor) copyData() {
-	buf := f.dict.writeSlice()
-	if len(buf) > f.copyLen {
-		buf = buf[:f.copyLen]
-	}
-
-	cnt, err := io.ReadFull(f.r, buf)
-	f.roffset += int64(cnt)
-	f.copyLen -= cnt
-	f.dict.writeMark(cnt)
-	if err != nil {
-		f.err = noEOF(err)
-		return
-	}
-
-	if f.dict.availWrite() == 0 || f.copyLen > 0 {
-		f.toRead = f.dict.readFlush()
-		f.step = copyData
-		return
-	}
-	f.finishBlock()
-}
-
-func (f *decompressor) finishBlock() {
-	if f.final {
-		if f.dict.availRead() > 0 {
-			f.toRead = f.dict.readFlush()
-		}
-		f.err = io.EOF
-	}
-	f.step = nextBlock
-}
-
-func (f *decompressor) doStep() {
-	switch f.step {
-	case copyData:
-		f.copyData()
-	case nextBlock:
-		f.nextBlock()
-	case huffmanBytesBuffer:
-		f.huffmanBytesBuffer()
-	case huffmanBytesReader:
-		f.huffmanBytesReader()
-	case huffmanBufioReader:
-		f.huffmanBufioReader()
-	case huffmanStringsReader:
-		f.huffmanStringsReader()
-	case huffmanGenericReader:
-		f.huffmanGenericReader()
-	default:
-		panic("BUG: unexpected step state")
-	}
-}
-
-// noEOF returns err, unless err == io.EOF, in which case it returns io.ErrUnexpectedEOF.
-func noEOF(e error) error {
-	if e == io.EOF {
-		return io.ErrUnexpectedEOF
-	}
-	return e
-}
-
-func (f *decompressor) moreBits() error {
-	c, err := f.r.ReadByte()
-	if err != nil {
-		return noEOF(err)
-	}
-	f.roffset++
-	f.b |= uint32(c) << (f.nb & regSizeMaskUint32)
-	f.nb += 8
-	return nil
-}
-
-// Read the next Huffman-encoded symbol from f according to h.
-func (f *decompressor) huffSym(h *huffmanDecoder) (int, error) {
-	// Since a huffmanDecoder can be empty or be composed of a degenerate tree
-	// with single element, huffSym must error on these two edge cases. In both
-	// cases, the chunks slice will be 0 for the invalid sequence, leading it
-	// satisfy the n == 0 check below.
-	n := uint(h.maxRead)
-	// Optimization. Compiler isn't smart enough to keep f.b,f.nb in registers,
-	// but is smart enough to keep local variables in registers, so use nb and b,
-	// inline call to moreBits and reassign b,nb back to f on return.
-	nb, b := f.nb, f.b
-	for {
-		for nb < n {
-			c, err := f.r.ReadByte()
-			if err != nil {
-				f.b = b
-				f.nb = nb
-				return 0, noEOF(err)
-			}
-			f.roffset++
-			b |= uint32(c) << (nb & regSizeMaskUint32)
-			nb += 8
-		}
-		chunk := h.chunks[b&(huffmanNumChunks-1)]
-		n = uint(chunk & huffmanCountMask)
-		if n > huffmanChunkBits {
-			chunk = h.links[chunk>>huffmanValueShift][(b>>huffmanChunkBits)&h.linkMask]
-			n = uint(chunk & huffmanCountMask)
-		}
-		if n <= nb {
-			if n == 0 {
-				f.b = b
-				f.nb = nb
-				if debugDecode {
-					fmt.Println("huffsym: n==0")
-				}
-				f.err = CorruptInputError(f.roffset)
-				return 0, f.err
-			}
-			f.b = b >> (n & regSizeMaskUint32)
-			f.nb = nb - n
-			return int(chunk >> huffmanValueShift), nil
-		}
-	}
-}
-
-func makeReader(r io.Reader) Reader {
-	if rr, ok := r.(Reader); ok {
-		return rr
-	}
-	return bufio.NewReader(r)
-}
-
-func fixedHuffmanDecoderInit() {
-	fixedOnce.Do(func() {
-		// These come from the RFC section 3.2.6.
-		var bits [288]int
-		for i := 0; i < 144; i++ {
-			bits[i] = 8
-		}
-		for i := 144; i < 256; i++ {
-			bits[i] = 9
-		}
-		for i := 256; i < 280; i++ {
-			bits[i] = 7
-		}
-		for i := 280; i < 288; i++ {
-			bits[i] = 8
-		}
-		fixedHuffmanDecoder.init(bits[:])
-	})
-}
-
-func (f *decompressor) Reset(r io.Reader, dict []byte) error {
-	*f = decompressor{
-		r:        makeReader(r),
-		bits:     f.bits,
-		codebits: f.codebits,
-		h1:       f.h1,
-		h2:       f.h2,
-		dict:     f.dict,
-		step:     nextBlock,
-	}
-	f.dict.init(maxMatchOffset, dict)
-	return nil
-}
-
-// NewReader returns a new ReadCloser that can be used
-// to read the uncompressed version of r.
-// If r does not also implement io.ByteReader,
-// the decompressor may read more data than necessary from r.
-// It is the caller's responsibility to call Close on the ReadCloser
-// when finished reading.
-//
-// The ReadCloser returned by NewReader also implements Resetter.
-func NewReader(r io.Reader) io.ReadCloser {
-	fixedHuffmanDecoderInit()
-
-	var f decompressor
-	f.r = makeReader(r)
-	f.bits = new([maxNumLit + maxNumDist]int)
-	f.codebits = new([numCodes]int)
-	f.step = nextBlock
-	f.dict.init(maxMatchOffset, nil)
-	return &f
-}
-
-// NewReaderDict is like NewReader but initializes the reader
-// with a preset dictionary. The returned Reader behaves as if
-// the uncompressed data stream started with the given dictionary,
-// which has already been read. NewReaderDict is typically used
-// to read data compressed by NewWriterDict.
-//
-// The ReadCloser returned by NewReader also implements Resetter.
-func NewReaderDict(r io.Reader, dict []byte) io.ReadCloser {
-	fixedHuffmanDecoderInit()
-
-	var f decompressor
-	f.r = makeReader(r)
-	f.bits = new([maxNumLit + maxNumDist]int)
-	f.codebits = new([numCodes]int)
-	f.step = nextBlock
-	f.dict.init(maxMatchOffset, dict)
-	return &f
-}
--- a/gateway/vendor/github.com/klauspost/compress/flate/inflate_gen.go
+++ b/gateway/vendor/github.com/klauspost/compress/flate/inflate_gen.go
--- a/gateway/vendor/github.com/klauspost/compress/flate/level1.go
+++ b/gateway/vendor/github.com/klauspost/compress/flate/level1.go
@ -1,241 +0,0 @@
-package flate
-
-import (
-	"encoding/binary"
-	"fmt"
-	"math/bits"
-)
-
-// fastGen maintains the table for matches,
-// and the previous byte block for level 2.
-// This is the generic implementation.
-type fastEncL1 struct {
-	fastGen
-	table [tableSize]tableEntry
-}
-
-// EncodeL1 uses a similar algorithm to level 1
-func (e *fastEncL1) Encode(dst *tokens, src []byte) {
-	const (
-		inputMargin            = 12 - 1
-		minNonLiteralBlockSize = 1 + 1 + inputMargin
-		hashBytes              = 5
-	)
-	if debugDeflate && e.cur < 0 {
-		panic(fmt.Sprint("e.cur < 0: ", e.cur))
-	}
-
-	// Protect against e.cur wraparound.
-	for e.cur >= bufferReset {
-		if len(e.hist) == 0 {
-			for i := range e.table[:] {
-				e.table[i] = tableEntry{}
-			}
-			e.cur = maxMatchOffset
-			break
-		}
-		// Shift down everything in the table that isn't already too far away.
-		minOff := e.cur + int32(len(e.hist)) - maxMatchOffset
-		for i := range e.table[:] {
-			v := e.table[i].offset
-			if v <= minOff {
-				v = 0
-			} else {
-				v = v - e.cur + maxMatchOffset
-			}
-			e.table[i].offset = v
-		}
-		e.cur = maxMatchOffset
-	}
-
-	s := e.addBlock(src)
-
-	// This check isn't in the Snappy implementation, but there, the caller
-	// instead of the callee handles this case.
-	if len(src) < minNonLiteralBlockSize {
-		// We do not fill the token table.
-		// This will be picked up by caller.
-		dst.n = uint16(len(src))
-		return
-	}
-
-	// Override src
-	src = e.hist
-	nextEmit := s
-
-	// sLimit is when to stop looking for offset/length copies. The inputMargin
-	// lets us use a fast path for emitLiteral in the main loop, while we are
-	// looking for copies.
-	sLimit := int32(len(src) - inputMargin)
-
-	// nextEmit is where in src the next emitLiteral should start from.
-	cv := load6432(src, s)
-
-	for {
-		const skipLog = 5
-		const doEvery = 2
-
-		nextS := s
-		var candidate tableEntry
-		for {
-			nextHash := hashLen(cv, tableBits, hashBytes)
-			candidate = e.table[nextHash]
-			nextS = s + doEvery + (s-nextEmit)>>skipLog
-			if nextS > sLimit {
-				goto emitRemainder
-			}
-
-			now := load6432(src, nextS)
-			e.table[nextHash] = tableEntry{offset: s + e.cur}
-			nextHash = hashLen(now, tableBits, hashBytes)
-
-			offset := s - (candidate.offset - e.cur)
-			if offset < maxMatchOffset && uint32(cv) == load3232(src, candidate.offset-e.cur) {
-				e.table[nextHash] = tableEntry{offset: nextS + e.cur}
-				break
-			}
-
-			// Do one right away...
-			cv = now
-			s = nextS
-			nextS++
-			candidate = e.table[nextHash]
-			now >>= 8
-			e.table[nextHash] = tableEntry{offset: s + e.cur}
-
-			offset = s - (candidate.offset - e.cur)
-			if offset < maxMatchOffset && uint32(cv) == load3232(src, candidate.offset-e.cur) {
-				e.table[nextHash] = tableEntry{offset: nextS + e.cur}
-				break
-			}
-			cv = now
-			s = nextS
-		}
-
-		// A 4-byte match has been found. We'll later see if more than 4 bytes
-		// match. But, prior to the match, src[nextEmit:s] are unmatched. Emit
-		// them as literal bytes.
-		for {
-			// Invariant: we have a 4-byte match at s, and no need to emit any
-			// literal bytes prior to s.
-
-			// Extend the 4-byte match as long as possible.
-			t := candidate.offset - e.cur
-			var l = int32(4)
-			if false {
-				l = e.matchlenLong(s+4, t+4, src) + 4
-			} else {
-				// inlined:
-				a := src[s+4:]
-				b := src[t+4:]
-				for len(a) >= 8 {
-					if diff := binary.LittleEndian.Uint64(a) ^ binary.LittleEndian.Uint64(b); diff != 0 {
-						l += int32(bits.TrailingZeros64(diff) >> 3)
-						break
-					}
-					l += 8
-					a = a[8:]
-					b = b[8:]
-				}
-				if len(a) < 8 {
-					b = b[:len(a)]
-					for i := range a {
-						if a[i] != b[i] {
-							break
-						}
-						l++
-					}
-				}
-			}
-
-			// Extend backwards
-			for t > 0 && s > nextEmit && src[t-1] == src[s-1] {
-				s--
-				t--
-				l++
-			}
-			if nextEmit < s {
-				if false {
-					emitLiteral(dst, src[nextEmit:s])
-				} else {
-					for _, v := range src[nextEmit:s] {
-						dst.tokens[dst.n] = token(v)
-						dst.litHist[v]++
-						dst.n++
-					}
-				}
-			}
-
-			// Save the match found
-			if false {
-				dst.AddMatchLong(l, uint32(s-t-baseMatchOffset))
-			} else {
-				// Inlined...
-				xoffset := uint32(s - t - baseMatchOffset)
-				xlength := l
-				oc := offsetCode(xoffset)
-				xoffset |= oc << 16
-				for xlength > 0 {
-					xl := xlength
-					if xl > 258 {
-						if xl > 258+baseMatchLength {
-							xl = 258
-						} else {
-							xl = 258 - baseMatchLength
-						}
-					}
-					xlength -= xl
-					xl -= baseMatchLength
-					dst.extraHist[lengthCodes1[uint8(xl)]]++
-					dst.offHist[oc]++
-					dst.tokens[dst.n] = token(matchType | uint32(xl)<<lengthShift | xoffset)
-					dst.n++
-				}
-			}
-			s += l
-			nextEmit = s
-			if nextS >= s {
-				s = nextS + 1
-			}
-			if s >= sLimit {
-				// Index first pair after match end.
-				if int(s+l+8) < len(src) {
-					cv := load6432(src, s)
-					e.table[hashLen(cv, tableBits, hashBytes)] = tableEntry{offset: s + e.cur}
-				}
-				goto emitRemainder
-			}
-
-			// We could immediately start working at s now, but to improve
-			// compression we first update the hash table at s-2 and at s. If
-			// another emitCopy is not our next move, also calculate nextHash
-			// at s+1. At least on GOARCH=amd64, these three hash calculations
-			// are faster as one load64 call (with some shifts) instead of
-			// three load32 calls.
-			x := load6432(src, s-2)
-			o := e.cur + s - 2
-			prevHash := hashLen(x, tableBits, hashBytes)
-			e.table[prevHash] = tableEntry{offset: o}
-			x >>= 16
-			currHash := hashLen(x, tableBits, hashBytes)
-			candidate = e.table[currHash]
-			e.table[currHash] = tableEntry{offset: o + 2}
-
-			offset := s - (candidate.offset - e.cur)
-			if offset > maxMatchOffset || uint32(x) != load3232(src, candidate.offset-e.cur) {
-				cv = x >> 8
-				s++
-				break
-			}
-		}
-	}
-
-emitRemainder:
-	if int(nextEmit) < len(src) {
-		// If nothing was added, don't encode literals.
-		if dst.n == 0 {
-			return
-		}
-		emitLiteral(dst, src[nextEmit:])
-	}
-}
--- a/gateway/vendor/github.com/klauspost/compress/flate/level2.go
+++ b/gateway/vendor/github.com/klauspost/compress/flate/level2.go
@ -1,214 +0,0 @@
-package flate
-
-import "fmt"
-
-// fastGen maintains the table for matches,
-// and the previous byte block for level 2.
-// This is the generic implementation.
-type fastEncL2 struct {
-	fastGen
-	table [bTableSize]tableEntry
-}
-
-// EncodeL2 uses a similar algorithm to level 1, but is capable
-// of matching across blocks giving better compression at a small slowdown.
-func (e *fastEncL2) Encode(dst *tokens, src []byte) {
-	const (
-		inputMargin            = 12 - 1
-		minNonLiteralBlockSize = 1 + 1 + inputMargin
-		hashBytes              = 5
-	)
-
-	if debugDeflate && e.cur < 0 {
-		panic(fmt.Sprint("e.cur < 0: ", e.cur))
-	}
-
-	// Protect against e.cur wraparound.
-	for e.cur >= bufferReset {
-		if len(e.hist) == 0 {
-			for i := range e.table[:] {
-				e.table[i] = tableEntry{}
-			}
-			e.cur = maxMatchOffset
-			break
-		}
-		// Shift down everything in the table that isn't already too far away.
-		minOff := e.cur + int32(len(e.hist)) - maxMatchOffset
-		for i := range e.table[:] {
-			v := e.table[i].offset
-			if v <= minOff {
-				v = 0
-			} else {
-				v = v - e.cur + maxMatchOffset
-			}
-			e.table[i].offset = v
-		}
-		e.cur = maxMatchOffset
-	}
-
-	s := e.addBlock(src)
-
-	// This check isn't in the Snappy implementation, but there, the caller
-	// instead of the callee handles this case.
-	if len(src) < minNonLiteralBlockSize {
-		// We do not fill the token table.
-		// This will be picked up by caller.
-		dst.n = uint16(len(src))
-		return
-	}
-
-	// Override src
-	src = e.hist
-	nextEmit := s
-
-	// sLimit is when to stop looking for offset/length copies. The inputMargin
-	// lets us use a fast path for emitLiteral in the main loop, while we are
-	// looking for copies.
-	sLimit := int32(len(src) - inputMargin)
-
-	// nextEmit is where in src the next emitLiteral should start from.
-	cv := load6432(src, s)
-	for {
-		// When should we start skipping if we haven't found matches in a long while.
-		const skipLog = 5
-		const doEvery = 2
-
-		nextS := s
-		var candidate tableEntry
-		for {
-			nextHash := hashLen(cv, bTableBits, hashBytes)
-			s = nextS
-			nextS = s + doEvery + (s-nextEmit)>>skipLog
-			if nextS > sLimit {
-				goto emitRemainder
-			}
-			candidate = e.table[nextHash]
-			now := load6432(src, nextS)
-			e.table[nextHash] = tableEntry{offset: s + e.cur}
-			nextHash = hashLen(now, bTableBits, hashBytes)
-
-			offset := s - (candidate.offset - e.cur)
-			if offset < maxMatchOffset && uint32(cv) == load3232(src, candidate.offset-e.cur) {
-				e.table[nextHash] = tableEntry{offset: nextS + e.cur}
-				break
-			}
-
-			// Do one right away...
-			cv = now
-			s = nextS
-			nextS++
-			candidate = e.table[nextHash]
-			now >>= 8
-			e.table[nextHash] = tableEntry{offset: s + e.cur}
-
-			offset = s - (candidate.offset - e.cur)
-			if offset < maxMatchOffset && uint32(cv) == load3232(src, candidate.offset-e.cur) {
-				break
-			}
-			cv = now
-		}
-
-		// A 4-byte match has been found. We'll later see if more than 4 bytes
-		// match. But, prior to the match, src[nextEmit:s] are unmatched. Emit
-		// them as literal bytes.
-
-		// Call emitCopy, and then see if another emitCopy could be our next
-		// move. Repeat until we find no match for the input immediately after
-		// what was consumed by the last emitCopy call.
-		//
-		// If we exit this loop normally then we need to call emitLiteral next,
-		// though we don't yet know how big the literal will be. We handle that
-		// by proceeding to the next iteration of the main loop. We also can
-		// exit this loop via goto if we get close to exhausting the input.
-		for {
-			// Invariant: we have a 4-byte match at s, and no need to emit any
-			// literal bytes prior to s.
-
-			// Extend the 4-byte match as long as possible.
-			t := candidate.offset - e.cur
-			l := e.matchlenLong(s+4, t+4, src) + 4
-
-			// Extend backwards
-			for t > 0 && s > nextEmit && src[t-1] == src[s-1] {
-				s--
-				t--
-				l++
-			}
-			if nextEmit < s {
-				if false {
-					emitLiteral(dst, src[nextEmit:s])
-				} else {
-					for _, v := range src[nextEmit:s] {
-						dst.tokens[dst.n] = token(v)
-						dst.litHist[v]++
-						dst.n++
-					}
-				}
-			}
-
-			dst.AddMatchLong(l, uint32(s-t-baseMatchOffset))
-			s += l
-			nextEmit = s
-			if nextS >= s {
-				s = nextS + 1
-			}
-
-			if s >= sLimit {
-				// Index first pair after match end.
-				if int(s+l+8) < len(src) {
-					cv := load6432(src, s)
-					e.table[hashLen(cv, bTableBits, hashBytes)] = tableEntry{offset: s + e.cur}
-				}
-				goto emitRemainder
-			}
-
-			// Store every second hash in-between, but offset by 1.
-			for i := s - l + 2; i < s-5; i += 7 {
-				x := load6432(src, i)
-				nextHash := hashLen(x, bTableBits, hashBytes)
-				e.table[nextHash] = tableEntry{offset: e.cur + i}
-				// Skip one
-				x >>= 16
-				nextHash = hashLen(x, bTableBits, hashBytes)
-				e.table[nextHash] = tableEntry{offset: e.cur + i + 2}
-				// Skip one
-				x >>= 16
-				nextHash = hashLen(x, bTableBits, hashBytes)
-				e.table[nextHash] = tableEntry{offset: e.cur + i + 4}
-			}
-
-			// We could immediately start working at s now, but to improve
-			// compression we first update the hash table at s-2 to s. If
-			// another emitCopy is not our next move, also calculate nextHash
-			// at s+1. At least on GOARCH=amd64, these three hash calculations
-			// are faster as one load64 call (with some shifts) instead of
-			// three load32 calls.
-			x := load6432(src, s-2)
-			o := e.cur + s - 2
-			prevHash := hashLen(x, bTableBits, hashBytes)
-			prevHash2 := hashLen(x>>8, bTableBits, hashBytes)
-			e.table[prevHash] = tableEntry{offset: o}
-			e.table[prevHash2] = tableEntry{offset: o + 1}
-			currHash := hashLen(x>>16, bTableBits, hashBytes)
-			candidate = e.table[currHash]
-			e.table[currHash] = tableEntry{offset: o + 2}
-
-			offset := s - (candidate.offset - e.cur)
-			if offset > maxMatchOffset || uint32(x>>16) != load3232(src, candidate.offset-e.cur) {
-				cv = x >> 24
-				s++
-				break
-			}
-		}
-	}
-
-emitRemainder:
-	if int(nextEmit) < len(src) {
-		// If nothing was added, don't encode literals.
-		if dst.n == 0 {
-			return
-		}
-
-		emitLiteral(dst, src[nextEmit:])
-	}
-}
--- a/gateway/vendor/github.com/klauspost/compress/flate/level3.go
+++ b/gateway/vendor/github.com/klauspost/compress/flate/level3.go
@ -1,241 +0,0 @@
-package flate
-
-import "fmt"
-
-// fastEncL3
-type fastEncL3 struct {
-	fastGen
-	table [1 << 16]tableEntryPrev
-}
-
-// Encode uses a similar algorithm to level 2, will check up to two candidates.
-func (e *fastEncL3) Encode(dst *tokens, src []byte) {
-	const (
-		inputMargin            = 12 - 1
-		minNonLiteralBlockSize = 1 + 1 + inputMargin
-		tableBits              = 16
-		tableSize              = 1 << tableBits
-		hashBytes              = 5
-	)
-
-	if debugDeflate && e.cur < 0 {
-		panic(fmt.Sprint("e.cur < 0: ", e.cur))
-	}
-
-	// Protect against e.cur wraparound.
-	for e.cur >= bufferReset {
-		if len(e.hist) == 0 {
-			for i := range e.table[:] {
-				e.table[i] = tableEntryPrev{}
-			}
-			e.cur = maxMatchOffset
-			break
-		}
-		// Shift down everything in the table that isn't already too far away.
-		minOff := e.cur + int32(len(e.hist)) - maxMatchOffset
-		for i := range e.table[:] {
-			v := e.table[i]
-			if v.Cur.offset <= minOff {
-				v.Cur.offset = 0
-			} else {
-				v.Cur.offset = v.Cur.offset - e.cur + maxMatchOffset
-			}
-			if v.Prev.offset <= minOff {
-				v.Prev.offset = 0
-			} else {
-				v.Prev.offset = v.Prev.offset - e.cur + maxMatchOffset
-			}
-			e.table[i] = v
-		}
-		e.cur = maxMatchOffset
-	}
-
-	s := e.addBlock(src)
-
-	// Skip if too small.
-	if len(src) < minNonLiteralBlockSize {
-		// We do not fill the token table.
-		// This will be picked up by caller.
-		dst.n = uint16(len(src))
-		return
-	}
-
-	// Override src
-	src = e.hist
-	nextEmit := s
-
-	// sLimit is when to stop looking for offset/length copies. The inputMargin
-	// lets us use a fast path for emitLiteral in the main loop, while we are
-	// looking for copies.
-	sLimit := int32(len(src) - inputMargin)
-
-	// nextEmit is where in src the next emitLiteral should start from.
-	cv := load6432(src, s)
-	for {
-		const skipLog = 7
-		nextS := s
-		var candidate tableEntry
-		for {
-			nextHash := hashLen(cv, tableBits, hashBytes)
-			s = nextS
-			nextS = s + 1 + (s-nextEmit)>>skipLog
-			if nextS > sLimit {
-				goto emitRemainder
-			}
-			candidates := e.table[nextHash]
-			now := load6432(src, nextS)
-
-			// Safe offset distance until s + 4...
-			minOffset := e.cur + s - (maxMatchOffset - 4)
-			e.table[nextHash] = tableEntryPrev{Prev: candidates.Cur, Cur: tableEntry{offset: s + e.cur}}
-
-			// Check both candidates
-			candidate = candidates.Cur
-			if candidate.offset < minOffset {
-				cv = now
-				// Previous will also be invalid, we have nothing.
-				continue
-			}
-
-			if uint32(cv) == load3232(src, candidate.offset-e.cur) {
-				if candidates.Prev.offset < minOffset || uint32(cv) != load3232(src, candidates.Prev.offset-e.cur) {
-					break
-				}
-				// Both match and are valid, pick longest.
-				offset := s - (candidate.offset - e.cur)
-				o2 := s - (candidates.Prev.offset - e.cur)
-				l1, l2 := matchLen(src[s+4:], src[s-offset+4:]), matchLen(src[s+4:], src[s-o2+4:])
-				if l2 > l1 {
-					candidate = candidates.Prev
-				}
-				break
-			} else {
-				// We only check if value mismatches.
-				// Offset will always be invalid in other cases.
-				candidate = candidates.Prev
-				if candidate.offset > minOffset && uint32(cv) == load3232(src, candidate.offset-e.cur) {
-					break
-				}
-			}
-			cv = now
-		}
-
-		// Call emitCopy, and then see if another emitCopy could be our next
-		// move. Repeat until we find no match for the input immediately after
-		// what was consumed by the last emitCopy call.
-		//
-		// If we exit this loop normally then we need to call emitLiteral next,
-		// though we don't yet know how big the literal will be. We handle that
-		// by proceeding to the next iteration of the main loop. We also can
-		// exit this loop via goto if we get close to exhausting the input.
-		for {
-			// Invariant: we have a 4-byte match at s, and no need to emit any
-			// literal bytes prior to s.
-
-			// Extend the 4-byte match as long as possible.
-			//
-			t := candidate.offset - e.cur
-			l := e.matchlenLong(s+4, t+4, src) + 4
-
-			// Extend backwards
-			for t > 0 && s > nextEmit && src[t-1] == src[s-1] {
-				s--
-				t--
-				l++
-			}
-			if nextEmit < s {
-				if false {
-					emitLiteral(dst, src[nextEmit:s])
-				} else {
-					for _, v := range src[nextEmit:s] {
-						dst.tokens[dst.n] = token(v)
-						dst.litHist[v]++
-						dst.n++
-					}
-				}
-			}
-
-			dst.AddMatchLong(l, uint32(s-t-baseMatchOffset))
-			s += l
-			nextEmit = s
-			if nextS >= s {
-				s = nextS + 1
-			}
-
-			if s >= sLimit {
-				t += l
-				// Index first pair after match end.
-				if int(t+8) < len(src) && t > 0 {
-					cv = load6432(src, t)
-					nextHash := hashLen(cv, tableBits, hashBytes)
-					e.table[nextHash] = tableEntryPrev{
-						Prev: e.table[nextHash].Cur,
-						Cur:  tableEntry{offset: e.cur + t},
-					}
-				}
-				goto emitRemainder
-			}
-
-			// Store every 5th hash in-between.
-			for i := s - l + 2; i < s-5; i += 6 {
-				nextHash := hashLen(load6432(src, i), tableBits, hashBytes)
-				e.table[nextHash] = tableEntryPrev{
-					Prev: e.table[nextHash].Cur,
-					Cur:  tableEntry{offset: e.cur + i}}
-			}
-			// We could immediately start working at s now, but to improve
-			// compression we first update the hash table at s-2 to s.
-			x := load6432(src, s-2)
-			prevHash := hashLen(x, tableBits, hashBytes)
-
-			e.table[prevHash] = tableEntryPrev{
-				Prev: e.table[prevHash].Cur,
-				Cur:  tableEntry{offset: e.cur + s - 2},
-			}
-			x >>= 8
-			prevHash = hashLen(x, tableBits, hashBytes)
-
-			e.table[prevHash] = tableEntryPrev{
-				Prev: e.table[prevHash].Cur,
-				Cur:  tableEntry{offset: e.cur + s - 1},
-			}
-			x >>= 8
-			currHash := hashLen(x, tableBits, hashBytes)
-			candidates := e.table[currHash]
-			cv = x
-			e.table[currHash] = tableEntryPrev{
-				Prev: candidates.Cur,
-				Cur:  tableEntry{offset: s + e.cur},
-			}
-
-			// Check both candidates
-			candidate = candidates.Cur
-			minOffset := e.cur + s - (maxMatchOffset - 4)
-
-			if candidate.offset > minOffset {
-				if uint32(cv) == load3232(src, candidate.offset-e.cur) {
-					// Found a match...
-					continue
-				}
-				candidate = candidates.Prev
-				if candidate.offset > minOffset && uint32(cv) == load3232(src, candidate.offset-e.cur) {
-					// Match at prev...
-					continue
-				}
-			}
-			cv = x >> 8
-			s++
-			break
-		}
-	}
-
-emitRemainder:
-	if int(nextEmit) < len(src) {
-		// If nothing was added, don't encode literals.
-		if dst.n == 0 {
-			return
-		}
-
-		emitLiteral(dst, src[nextEmit:])
-	}
-}
--- a/gateway/vendor/github.com/klauspost/compress/flate/level4.go
+++ b/gateway/vendor/github.com/klauspost/compress/flate/level4.go
@ -1,221 +0,0 @@
-package flate
-
-import "fmt"
-
-type fastEncL4 struct {
-	fastGen
-	table  [tableSize]tableEntry
-	bTable [tableSize]tableEntry
-}
-
-func (e *fastEncL4) Encode(dst *tokens, src []byte) {
-	const (
-		inputMargin            = 12 - 1
-		minNonLiteralBlockSize = 1 + 1 + inputMargin
-		hashShortBytes         = 4
-	)
-	if debugDeflate && e.cur < 0 {
-		panic(fmt.Sprint("e.cur < 0: ", e.cur))
-	}
-	// Protect against e.cur wraparound.
-	for e.cur >= bufferReset {
-		if len(e.hist) == 0 {
-			for i := range e.table[:] {
-				e.table[i] = tableEntry{}
-			}
-			for i := range e.bTable[:] {
-				e.bTable[i] = tableEntry{}
-			}
-			e.cur = maxMatchOffset
-			break
-		}
-		// Shift down everything in the table that isn't already too far away.
-		minOff := e.cur + int32(len(e.hist)) - maxMatchOffset
-		for i := range e.table[:] {
-			v := e.table[i].offset
-			if v <= minOff {
-				v = 0
-			} else {
-				v = v - e.cur + maxMatchOffset
-			}
-			e.table[i].offset = v
-		}
-		for i := range e.bTable[:] {
-			v := e.bTable[i].offset
-			if v <= minOff {
-				v = 0
-			} else {
-				v = v - e.cur + maxMatchOffset
-			}
-			e.bTable[i].offset = v
-		}
-		e.cur = maxMatchOffset
-	}
-
-	s := e.addBlock(src)
-
-	// This check isn't in the Snappy implementation, but there, the caller
-	// instead of the callee handles this case.
-	if len(src) < minNonLiteralBlockSize {
-		// We do not fill the token table.
-		// This will be picked up by caller.
-		dst.n = uint16(len(src))
-		return
-	}
-
-	// Override src
-	src = e.hist
-	nextEmit := s
-
-	// sLimit is when to stop looking for offset/length copies. The inputMargin
-	// lets us use a fast path for emitLiteral in the main loop, while we are
-	// looking for copies.
-	sLimit := int32(len(src) - inputMargin)
-
-	// nextEmit is where in src the next emitLiteral should start from.
-	cv := load6432(src, s)
-	for {
-		const skipLog = 6
-		const doEvery = 1
-
-		nextS := s
-		var t int32
-		for {
-			nextHashS := hashLen(cv, tableBits, hashShortBytes)
-			nextHashL := hash7(cv, tableBits)
-
-			s = nextS
-			nextS = s + doEvery + (s-nextEmit)>>skipLog
-			if nextS > sLimit {
-				goto emitRemainder
-			}
-			// Fetch a short+long candidate
-			sCandidate := e.table[nextHashS]
-			lCandidate := e.bTable[nextHashL]
-			next := load6432(src, nextS)
-			entry := tableEntry{offset: s + e.cur}
-			e.table[nextHashS] = entry
-			e.bTable[nextHashL] = entry
-
-			t = lCandidate.offset - e.cur
-			if s-t < maxMatchOffset && uint32(cv) == load3232(src, lCandidate.offset-e.cur) {
-				// We got a long match. Use that.
-				break
-			}
-
-			t = sCandidate.offset - e.cur
-			if s-t < maxMatchOffset && uint32(cv) == load3232(src, sCandidate.offset-e.cur) {
-				// Found a 4 match...
-				lCandidate = e.bTable[hash7(next, tableBits)]
-
-				// If the next long is a candidate, check if we should use that instead...
-				lOff := nextS - (lCandidate.offset - e.cur)
-				if lOff < maxMatchOffset && load3232(src, lCandidate.offset-e.cur) == uint32(next) {
-					l1, l2 := matchLen(src[s+4:], src[t+4:]), matchLen(src[nextS+4:], src[nextS-lOff+4:])
-					if l2 > l1 {
-						s = nextS
-						t = lCandidate.offset - e.cur
-					}
-				}
-				break
-			}
-			cv = next
-		}
-
-		// A 4-byte match has been found. We'll later see if more than 4 bytes
-		// match. But, prior to the match, src[nextEmit:s] are unmatched. Emit
-		// them as literal bytes.
-
-		// Extend the 4-byte match as long as possible.
-		l := e.matchlenLong(s+4, t+4, src) + 4
-
-		// Extend backwards
-		for t > 0 && s > nextEmit && src[t-1] == src[s-1] {
-			s--
-			t--
-			l++
-		}
-		if nextEmit < s {
-			if false {
-				emitLiteral(dst, src[nextEmit:s])
-			} else {
-				for _, v := range src[nextEmit:s] {
-					dst.tokens[dst.n] = token(v)
-					dst.litHist[v]++
-					dst.n++
-				}
-			}
-		}
-		if debugDeflate {
-			if t >= s {
-				panic("s-t")
-			}
-			if (s - t) > maxMatchOffset {
-				panic(fmt.Sprintln("mmo", t))
-			}
-			if l < baseMatchLength {
-				panic("bml")
-			}
-		}
-
-		dst.AddMatchLong(l, uint32(s-t-baseMatchOffset))
-		s += l
-		nextEmit = s
-		if nextS >= s {
-			s = nextS + 1
-		}
-
-		if s >= sLimit {
-			// Index first pair after match end.
-			if int(s+8) < len(src) {
-				cv := load6432(src, s)
-				e.table[hashLen(cv, tableBits, hashShortBytes)] = tableEntry{offset: s + e.cur}
-				e.bTable[hash7(cv, tableBits)] = tableEntry{offset: s + e.cur}
-			}
-			goto emitRemainder
-		}
-
-		// Store every 3rd hash in-between
-		if true {
-			i := nextS
-			if i < s-1 {
-				cv := load6432(src, i)
-				t := tableEntry{offset: i + e.cur}
-				t2 := tableEntry{offset: t.offset + 1}
-				e.bTable[hash7(cv, tableBits)] = t
-				e.bTable[hash7(cv>>8, tableBits)] = t2
-				e.table[hashLen(cv>>8, tableBits, hashShortBytes)] = t2
-
-				i += 3
-				for ; i < s-1; i += 3 {
-					cv := load6432(src, i)
-					t := tableEntry{offset: i + e.cur}
-					t2 := tableEntry{offset: t.offset + 1}
-					e.bTable[hash7(cv, tableBits)] = t
-					e.bTable[hash7(cv>>8, tableBits)] = t2
-					e.table[hashLen(cv>>8, tableBits, hashShortBytes)] = t2
-				}
-			}
-		}
-
-		// We could immediately start working at s now, but to improve
-		// compression we first update the hash table at s-1 and at s.
-		x := load6432(src, s-1)
-		o := e.cur + s - 1
-		prevHashS := hashLen(x, tableBits, hashShortBytes)
-		prevHashL := hash7(x, tableBits)
-		e.table[prevHashS] = tableEntry{offset: o}
-		e.bTable[prevHashL] = tableEntry{offset: o}
-		cv = x >> 8
-	}
-
-emitRemainder:
-	if int(nextEmit) < len(src) {
-		// If nothing was added, don't encode literals.
-		if dst.n == 0 {
-			return
-		}
-
-		emitLiteral(dst, src[nextEmit:])
-	}
-}
--- a/gateway/vendor/github.com/klauspost/compress/flate/level5.go
+++ b/gateway/vendor/github.com/klauspost/compress/flate/level5.go
@ -1,708 +0,0 @@
-package flate
-
-import "fmt"
-
-type fastEncL5 struct {
-	fastGen
-	table  [tableSize]tableEntry
-	bTable [tableSize]tableEntryPrev
-}
-
-func (e *fastEncL5) Encode(dst *tokens, src []byte) {
-	const (
-		inputMargin            = 12 - 1
-		minNonLiteralBlockSize = 1 + 1 + inputMargin
-		hashShortBytes         = 4
-	)
-	if debugDeflate && e.cur < 0 {
-		panic(fmt.Sprint("e.cur < 0: ", e.cur))
-	}
-
-	// Protect against e.cur wraparound.
-	for e.cur >= bufferReset {
-		if len(e.hist) == 0 {
-			for i := range e.table[:] {
-				e.table[i] = tableEntry{}
-			}
-			for i := range e.bTable[:] {
-				e.bTable[i] = tableEntryPrev{}
-			}
-			e.cur = maxMatchOffset
-			break
-		}
-		// Shift down everything in the table that isn't already too far away.
-		minOff := e.cur + int32(len(e.hist)) - maxMatchOffset
-		for i := range e.table[:] {
-			v := e.table[i].offset
-			if v <= minOff {
-				v = 0
-			} else {
-				v = v - e.cur + maxMatchOffset
-			}
-			e.table[i].offset = v
-		}
-		for i := range e.bTable[:] {
-			v := e.bTable[i]
-			if v.Cur.offset <= minOff {
-				v.Cur.offset = 0
-				v.Prev.offset = 0
-			} else {
-				v.Cur.offset = v.Cur.offset - e.cur + maxMatchOffset
-				if v.Prev.offset <= minOff {
-					v.Prev.offset = 0
-				} else {
-					v.Prev.offset = v.Prev.offset - e.cur + maxMatchOffset
-				}
-			}
-			e.bTable[i] = v
-		}
-		e.cur = maxMatchOffset
-	}
-
-	s := e.addBlock(src)
-
-	// This check isn't in the Snappy implementation, but there, the caller
-	// instead of the callee handles this case.
-	if len(src) < minNonLiteralBlockSize {
-		// We do not fill the token table.
-		// This will be picked up by caller.
-		dst.n = uint16(len(src))
-		return
-	}
-
-	// Override src
-	src = e.hist
-	nextEmit := s
-
-	// sLimit is when to stop looking for offset/length copies. The inputMargin
-	// lets us use a fast path for emitLiteral in the main loop, while we are
-	// looking for copies.
-	sLimit := int32(len(src) - inputMargin)
-
-	// nextEmit is where in src the next emitLiteral should start from.
-	cv := load6432(src, s)
-	for {
-		const skipLog = 6
-		const doEvery = 1
-
-		nextS := s
-		var l int32
-		var t int32
-		for {
-			nextHashS := hashLen(cv, tableBits, hashShortBytes)
-			nextHashL := hash7(cv, tableBits)
-
-			s = nextS
-			nextS = s + doEvery + (s-nextEmit)>>skipLog
-			if nextS > sLimit {
-				goto emitRemainder
-			}
-			// Fetch a short+long candidate
-			sCandidate := e.table[nextHashS]
-			lCandidate := e.bTable[nextHashL]
-			next := load6432(src, nextS)
-			entry := tableEntry{offset: s + e.cur}
-			e.table[nextHashS] = entry
-			eLong := &e.bTable[nextHashL]
-			eLong.Cur, eLong.Prev = entry, eLong.Cur
-
-			nextHashS = hashLen(next, tableBits, hashShortBytes)
-			nextHashL = hash7(next, tableBits)
-
-			t = lCandidate.Cur.offset - e.cur
-			if s-t < maxMatchOffset {
-				if uint32(cv) == load3232(src, lCandidate.Cur.offset-e.cur) {
-					// Store the next match
-					e.table[nextHashS] = tableEntry{offset: nextS + e.cur}
-					eLong := &e.bTable[nextHashL]
-					eLong.Cur, eLong.Prev = tableEntry{offset: nextS + e.cur}, eLong.Cur
-
-					t2 := lCandidate.Prev.offset - e.cur
-					if s-t2 < maxMatchOffset && uint32(cv) == load3232(src, lCandidate.Prev.offset-e.cur) {
-						l = e.matchlen(s+4, t+4, src) + 4
-						ml1 := e.matchlen(s+4, t2+4, src) + 4
-						if ml1 > l {
-							t = t2
-							l = ml1
-							break
-						}
-					}
-					break
-				}
-				t = lCandidate.Prev.offset - e.cur
-				if s-t < maxMatchOffset && uint32(cv) == load3232(src, lCandidate.Prev.offset-e.cur) {
-					// Store the next match
-					e.table[nextHashS] = tableEntry{offset: nextS + e.cur}
-					eLong := &e.bTable[nextHashL]
-					eLong.Cur, eLong.Prev = tableEntry{offset: nextS + e.cur}, eLong.Cur
-					break
-				}
-			}
-
-			t = sCandidate.offset - e.cur
-			if s-t < maxMatchOffset && uint32(cv) == load3232(src, sCandidate.offset-e.cur) {
-				// Found a 4 match...
-				l = e.matchlen(s+4, t+4, src) + 4
-				lCandidate = e.bTable[nextHashL]
-				// Store the next match
-
-				e.table[nextHashS] = tableEntry{offset: nextS + e.cur}
-				eLong := &e.bTable[nextHashL]
-				eLong.Cur, eLong.Prev = tableEntry{offset: nextS + e.cur}, eLong.Cur
-
-				// If the next long is a candidate, use that...
-				t2 := lCandidate.Cur.offset - e.cur
-				if nextS-t2 < maxMatchOffset {
-					if load3232(src, lCandidate.Cur.offset-e.cur) == uint32(next) {
-						ml := e.matchlen(nextS+4, t2+4, src) + 4
-						if ml > l {
-							t = t2
-							s = nextS
-							l = ml
-							break
-						}
-					}
-					// If the previous long is a candidate, use that...
-					t2 = lCandidate.Prev.offset - e.cur
-					if nextS-t2 < maxMatchOffset && load3232(src, lCandidate.Prev.offset-e.cur) == uint32(next) {
-						ml := e.matchlen(nextS+4, t2+4, src) + 4
-						if ml > l {
-							t = t2
-							s = nextS
-							l = ml
-							break
-						}
-					}
-				}
-				break
-			}
-			cv = next
-		}
-
-		// A 4-byte match has been found. We'll later see if more than 4 bytes
-		// match. But, prior to the match, src[nextEmit:s] are unmatched. Emit
-		// them as literal bytes.
-
-		if l == 0 {
-			// Extend the 4-byte match as long as possible.
-			l = e.matchlenLong(s+4, t+4, src) + 4
-		} else if l == maxMatchLength {
-			l += e.matchlenLong(s+l, t+l, src)
-		}
-
-		// Try to locate a better match by checking the end of best match...
-		if sAt := s + l; l < 30 && sAt < sLimit {
-			// Allow some bytes at the beginning to mismatch.
-			// Sweet spot is 2/3 bytes depending on input.
-			// 3 is only a little better when it is but sometimes a lot worse.
-			// The skipped bytes are tested in Extend backwards,
-			// and still picked up as part of the match if they do.
-			const skipBeginning = 2
-			eLong := e.bTable[hash7(load6432(src, sAt), tableBits)].Cur.offset
-			t2 := eLong - e.cur - l + skipBeginning
-			s2 := s + skipBeginning
-			off := s2 - t2
-			if t2 >= 0 && off < maxMatchOffset && off > 0 {
-				if l2 := e.matchlenLong(s2, t2, src); l2 > l {
-					t = t2
-					l = l2
-					s = s2
-				}
-			}
-		}
-
-		// Extend backwards
-		for t > 0 && s > nextEmit && src[t-1] == src[s-1] {
-			s--
-			t--
-			l++
-		}
-		if nextEmit < s {
-			if false {
-				emitLiteral(dst, src[nextEmit:s])
-			} else {
-				for _, v := range src[nextEmit:s] {
-					dst.tokens[dst.n] = token(v)
-					dst.litHist[v]++
-					dst.n++
-				}
-			}
-		}
-		if debugDeflate {
-			if t >= s {
-				panic(fmt.Sprintln("s-t", s, t))
-			}
-			if (s - t) > maxMatchOffset {
-				panic(fmt.Sprintln("mmo", s-t))
-			}
-			if l < baseMatchLength {
-				panic("bml")
-			}
-		}
-
-		dst.AddMatchLong(l, uint32(s-t-baseMatchOffset))
-		s += l
-		nextEmit = s
-		if nextS >= s {
-			s = nextS + 1
-		}
-
-		if s >= sLimit {
-			goto emitRemainder
-		}
-
-		// Store every 3rd hash in-between.
-		if true {
-			const hashEvery = 3
-			i := s - l + 1
-			if i < s-1 {
-				cv := load6432(src, i)
-				t := tableEntry{offset: i + e.cur}
-				e.table[hashLen(cv, tableBits, hashShortBytes)] = t
-				eLong := &e.bTable[hash7(cv, tableBits)]
-				eLong.Cur, eLong.Prev = t, eLong.Cur
-
-				// Do an long at i+1
-				cv >>= 8
-				t = tableEntry{offset: t.offset + 1}
-				eLong = &e.bTable[hash7(cv, tableBits)]
-				eLong.Cur, eLong.Prev = t, eLong.Cur
-
-				// We only have enough bits for a short entry at i+2
-				cv >>= 8
-				t = tableEntry{offset: t.offset + 1}
-				e.table[hashLen(cv, tableBits, hashShortBytes)] = t
-
-				// Skip one - otherwise we risk hitting 's'
-				i += 4
-				for ; i < s-1; i += hashEvery {
-					cv := load6432(src, i)
-					t := tableEntry{offset: i + e.cur}
-					t2 := tableEntry{offset: t.offset + 1}
-					eLong := &e.bTable[hash7(cv, tableBits)]
-					eLong.Cur, eLong.Prev = t, eLong.Cur
-					e.table[hashLen(cv>>8, tableBits, hashShortBytes)] = t2
-				}
-			}
-		}
-
-		// We could immediately start working at s now, but to improve
-		// compression we first update the hash table at s-1 and at s.
-		x := load6432(src, s-1)
-		o := e.cur + s - 1
-		prevHashS := hashLen(x, tableBits, hashShortBytes)
-		prevHashL := hash7(x, tableBits)
-		e.table[prevHashS] = tableEntry{offset: o}
-		eLong := &e.bTable[prevHashL]
-		eLong.Cur, eLong.Prev = tableEntry{offset: o}, eLong.Cur
-		cv = x >> 8
-	}
-
-emitRemainder:
-	if int(nextEmit) < len(src) {
-		// If nothing was added, don't encode literals.
-		if dst.n == 0 {
-			return
-		}
-
-		emitLiteral(dst, src[nextEmit:])
-	}
-}
-
-// fastEncL5Window is a level 5 encoder,
-// but with a custom window size.
-type fastEncL5Window struct {
-	hist      []byte
-	cur       int32
-	maxOffset int32
-	table     [tableSize]tableEntry
-	bTable    [tableSize]tableEntryPrev
-}
-
-func (e *fastEncL5Window) Encode(dst *tokens, src []byte) {
-	const (
-		inputMargin            = 12 - 1
-		minNonLiteralBlockSize = 1 + 1 + inputMargin
-		hashShortBytes         = 4
-	)
-	maxMatchOffset := e.maxOffset
-	if debugDeflate && e.cur < 0 {
-		panic(fmt.Sprint("e.cur < 0: ", e.cur))
-	}
-
-	// Protect against e.cur wraparound.
-	for e.cur >= bufferReset {
-		if len(e.hist) == 0 {
-			for i := range e.table[:] {
-				e.table[i] = tableEntry{}
-			}
-			for i := range e.bTable[:] {
-				e.bTable[i] = tableEntryPrev{}
-			}
-			e.cur = maxMatchOffset
-			break
-		}
-		// Shift down everything in the table that isn't already too far away.
-		minOff := e.cur + int32(len(e.hist)) - maxMatchOffset
-		for i := range e.table[:] {
-			v := e.table[i].offset
-			if v <= minOff {
-				v = 0
-			} else {
-				v = v - e.cur + maxMatchOffset
-			}
-			e.table[i].offset = v
-		}
-		for i := range e.bTable[:] {
-			v := e.bTable[i]
-			if v.Cur.offset <= minOff {
-				v.Cur.offset = 0
-				v.Prev.offset = 0
-			} else {
-				v.Cur.offset = v.Cur.offset - e.cur + maxMatchOffset
-				if v.Prev.offset <= minOff {
-					v.Prev.offset = 0
-				} else {
-					v.Prev.offset = v.Prev.offset - e.cur + maxMatchOffset
-				}
-			}
-			e.bTable[i] = v
-		}
-		e.cur = maxMatchOffset
-	}
-
-	s := e.addBlock(src)
-
-	// This check isn't in the Snappy implementation, but there, the caller
-	// instead of the callee handles this case.
-	if len(src) < minNonLiteralBlockSize {
-		// We do not fill the token table.
-		// This will be picked up by caller.
-		dst.n = uint16(len(src))
-		return
-	}
-
-	// Override src
-	src = e.hist
-	nextEmit := s
-
-	// sLimit is when to stop looking for offset/length copies. The inputMargin
-	// lets us use a fast path for emitLiteral in the main loop, while we are
-	// looking for copies.
-	sLimit := int32(len(src) - inputMargin)
-
-	// nextEmit is where in src the next emitLiteral should start from.
-	cv := load6432(src, s)
-	for {
-		const skipLog = 6
-		const doEvery = 1
-
-		nextS := s
-		var l int32
-		var t int32
-		for {
-			nextHashS := hashLen(cv, tableBits, hashShortBytes)
-			nextHashL := hash7(cv, tableBits)
-
-			s = nextS
-			nextS = s + doEvery + (s-nextEmit)>>skipLog
-			if nextS > sLimit {
-				goto emitRemainder
-			}
-			// Fetch a short+long candidate
-			sCandidate := e.table[nextHashS]
-			lCandidate := e.bTable[nextHashL]
-			next := load6432(src, nextS)
-			entry := tableEntry{offset: s + e.cur}
-			e.table[nextHashS] = entry
-			eLong := &e.bTable[nextHashL]
-			eLong.Cur, eLong.Prev = entry, eLong.Cur
-
-			nextHashS = hashLen(next, tableBits, hashShortBytes)
-			nextHashL = hash7(next, tableBits)
-
-			t = lCandidate.Cur.offset - e.cur
-			if s-t < maxMatchOffset {
-				if uint32(cv) == load3232(src, lCandidate.Cur.offset-e.cur) {
-					// Store the next match
-					e.table[nextHashS] = tableEntry{offset: nextS + e.cur}
-					eLong := &e.bTable[nextHashL]
-					eLong.Cur, eLong.Prev = tableEntry{offset: nextS + e.cur}, eLong.Cur
-
-					t2 := lCandidate.Prev.offset - e.cur
-					if s-t2 < maxMatchOffset && uint32(cv) == load3232(src, lCandidate.Prev.offset-e.cur) {
-						l = e.matchlen(s+4, t+4, src) + 4
-						ml1 := e.matchlen(s+4, t2+4, src) + 4
-						if ml1 > l {
-							t = t2
-							l = ml1
-							break
-						}
-					}
-					break
-				}
-				t = lCandidate.Prev.offset - e.cur
-				if s-t < maxMatchOffset && uint32(cv) == load3232(src, lCandidate.Prev.offset-e.cur) {
-					// Store the next match
-					e.table[nextHashS] = tableEntry{offset: nextS + e.cur}
-					eLong := &e.bTable[nextHashL]
-					eLong.Cur, eLong.Prev = tableEntry{offset: nextS + e.cur}, eLong.Cur
-					break
-				}
-			}
-
-			t = sCandidate.offset - e.cur
-			if s-t < maxMatchOffset && uint32(cv) == load3232(src, sCandidate.offset-e.cur) {
-				// Found a 4 match...
-				l = e.matchlen(s+4, t+4, src) + 4
-				lCandidate = e.bTable[nextHashL]
-				// Store the next match
-
-				e.table[nextHashS] = tableEntry{offset: nextS + e.cur}
-				eLong := &e.bTable[nextHashL]
-				eLong.Cur, eLong.Prev = tableEntry{offset: nextS + e.cur}, eLong.Cur
-
-				// If the next long is a candidate, use that...
-				t2 := lCandidate.Cur.offset - e.cur
-				if nextS-t2 < maxMatchOffset {
-					if load3232(src, lCandidate.Cur.offset-e.cur) == uint32(next) {
-						ml := e.matchlen(nextS+4, t2+4, src) + 4
-						if ml > l {
-							t = t2
-							s = nextS
-							l = ml
-							break
-						}
-					}
-					// If the previous long is a candidate, use that...
-					t2 = lCandidate.Prev.offset - e.cur
-					if nextS-t2 < maxMatchOffset && load3232(src, lCandidate.Prev.offset-e.cur) == uint32(next) {
-						ml := e.matchlen(nextS+4, t2+4, src) + 4
-						if ml > l {
-							t = t2
-							s = nextS
-							l = ml
-							break
-						}
-					}
-				}
-				break
-			}
-			cv = next
-		}
-
-		// A 4-byte match has been found. We'll later see if more than 4 bytes
-		// match. But, prior to the match, src[nextEmit:s] are unmatched. Emit
-		// them as literal bytes.
-
-		if l == 0 {
-			// Extend the 4-byte match as long as possible.
-			l = e.matchlenLong(s+4, t+4, src) + 4
-		} else if l == maxMatchLength {
-			l += e.matchlenLong(s+l, t+l, src)
-		}
-
-		// Try to locate a better match by checking the end of best match...
-		if sAt := s + l; l < 30 && sAt < sLimit {
-			// Allow some bytes at the beginning to mismatch.
-			// Sweet spot is 2/3 bytes depending on input.
-			// 3 is only a little better when it is but sometimes a lot worse.
-			// The skipped bytes are tested in Extend backwards,
-			// and still picked up as part of the match if they do.
-			const skipBeginning = 2
-			eLong := e.bTable[hash7(load6432(src, sAt), tableBits)].Cur.offset
-			t2 := eLong - e.cur - l + skipBeginning
-			s2 := s + skipBeginning
-			off := s2 - t2
-			if t2 >= 0 && off < maxMatchOffset && off > 0 {
-				if l2 := e.matchlenLong(s2, t2, src); l2 > l {
-					t = t2
-					l = l2
-					s = s2
-				}
-			}
-		}
-
-		// Extend backwards
-		for t > 0 && s > nextEmit && src[t-1] == src[s-1] {
-			s--
-			t--
-			l++
-		}
-		if nextEmit < s {
-			if false {
-				emitLiteral(dst, src[nextEmit:s])
-			} else {
-				for _, v := range src[nextEmit:s] {
-					dst.tokens[dst.n] = token(v)
-					dst.litHist[v]++
-					dst.n++
-				}
-			}
-		}
-		if debugDeflate {
-			if t >= s {
-				panic(fmt.Sprintln("s-t", s, t))
-			}
-			if (s - t) > maxMatchOffset {
-				panic(fmt.Sprintln("mmo", s-t))
-			}
-			if l < baseMatchLength {
-				panic("bml")
-			}
-		}
-
-		dst.AddMatchLong(l, uint32(s-t-baseMatchOffset))
-		s += l
-		nextEmit = s
-		if nextS >= s {
-			s = nextS + 1
-		}
-
-		if s >= sLimit {
-			goto emitRemainder
-		}
-
-		// Store every 3rd hash in-between.
-		if true {
-			const hashEvery = 3
-			i := s - l + 1
-			if i < s-1 {
-				cv := load6432(src, i)
-				t := tableEntry{offset: i + e.cur}
-				e.table[hashLen(cv, tableBits, hashShortBytes)] = t
-				eLong := &e.bTable[hash7(cv, tableBits)]
-				eLong.Cur, eLong.Prev = t, eLong.Cur
-
-				// Do an long at i+1
-				cv >>= 8
-				t = tableEntry{offset: t.offset + 1}
-				eLong = &e.bTable[hash7(cv, tableBits)]
-				eLong.Cur, eLong.Prev = t, eLong.Cur
-
-				// We only have enough bits for a short entry at i+2
-				cv >>= 8
-				t = tableEntry{offset: t.offset + 1}
-				e.table[hashLen(cv, tableBits, hashShortBytes)] = t
-
-				// Skip one - otherwise we risk hitting 's'
-				i += 4
-				for ; i < s-1; i += hashEvery {
-					cv := load6432(src, i)
-					t := tableEntry{offset: i + e.cur}
-					t2 := tableEntry{offset: t.offset + 1}
-					eLong := &e.bTable[hash7(cv, tableBits)]
-					eLong.Cur, eLong.Prev = t, eLong.Cur
-					e.table[hashLen(cv>>8, tableBits, hashShortBytes)] = t2
-				}
-			}
-		}
-
-		// We could immediately start working at s now, but to improve
-		// compression we first update the hash table at s-1 and at s.
-		x := load6432(src, s-1)
-		o := e.cur + s - 1
-		prevHashS := hashLen(x, tableBits, hashShortBytes)
-		prevHashL := hash7(x, tableBits)
-		e.table[prevHashS] = tableEntry{offset: o}
-		eLong := &e.bTable[prevHashL]
-		eLong.Cur, eLong.Prev = tableEntry{offset: o}, eLong.Cur
-		cv = x >> 8
-	}
-
-emitRemainder:
-	if int(nextEmit) < len(src) {
-		// If nothing was added, don't encode literals.
-		if dst.n == 0 {
-			return
-		}
-
-		emitLiteral(dst, src[nextEmit:])
-	}
-}
-
-// Reset the encoding table.
-func (e *fastEncL5Window) Reset() {
-	// We keep the same allocs, since we are compressing the same block sizes.
-	if cap(e.hist) < allocHistory {
-		e.hist = make([]byte, 0, allocHistory)
-	}
-
-	// We offset current position so everything will be out of reach.
-	// If we are above the buffer reset it will be cleared anyway since len(hist) == 0.
-	if e.cur <= int32(bufferReset) {
-		e.cur += e.maxOffset + int32(len(e.hist))
-	}
-	e.hist = e.hist[:0]
-}
-
-func (e *fastEncL5Window) addBlock(src []byte) int32 {
-	// check if we have space already
-	maxMatchOffset := e.maxOffset
-
-	if len(e.hist)+len(src) > cap(e.hist) {
-		if cap(e.hist) == 0 {
-			e.hist = make([]byte, 0, allocHistory)
-		} else {
-			if cap(e.hist) < int(maxMatchOffset*2) {
-				panic("unexpected buffer size")
-			}
-			// Move down
-			offset := int32(len(e.hist)) - maxMatchOffset
-			copy(e.hist[0:maxMatchOffset], e.hist[offset:])
-			e.cur += offset
-			e.hist = e.hist[:maxMatchOffset]
-		}
-	}
-	s := int32(len(e.hist))
-	e.hist = append(e.hist, src...)
-	return s
-}
-
-// matchlen will return the match length between offsets and t in src.
-// The maximum length returned is maxMatchLength - 4.
-// It is assumed that s > t, that t >=0 and s < len(src).
-func (e *fastEncL5Window) matchlen(s, t int32, src []byte) int32 {
-	if debugDecode {
-		if t >= s {
-			panic(fmt.Sprint("t >=s:", t, s))
-		}
-		if int(s) >= len(src) {
-			panic(fmt.Sprint("s >= len(src):", s, len(src)))
-		}
-		if t < 0 {
-			panic(fmt.Sprint("t < 0:", t))
-		}
-		if s-t > e.maxOffset {
-			panic(fmt.Sprint(s, "-", t, "(", s-t, ") > maxMatchLength (", maxMatchOffset, ")"))
-		}
-	}
-	s1 := int(s) + maxMatchLength - 4
-	if s1 > len(src) {
-		s1 = len(src)
-	}
-
-	// Extend the match to be as long as possible.
-	return int32(matchLen(src[s:s1], src[t:]))
-}
-
-// matchlenLong will return the match length between offsets and t in src.
-// It is assumed that s > t, that t >=0 and s < len(src).
-func (e *fastEncL5Window) matchlenLong(s, t int32, src []byte) int32 {
-	if debugDeflate {
-		if t >= s {
-			panic(fmt.Sprint("t >=s:", t, s))
-		}
-		if int(s) >= len(src) {
-			panic(fmt.Sprint("s >= len(src):", s, len(src)))
-		}
-		if t < 0 {
-			panic(fmt.Sprint("t < 0:", t))
-		}
-		if s-t > e.maxOffset {
-			panic(fmt.Sprint(s, "-", t, "(", s-t, ") > maxMatchLength (", maxMatchOffset, ")"))
-		}
-	}
-	// Extend the match to be as long as possible.
-	return int32(matchLen(src[s:], src[t:]))
-}
--- a/gateway/vendor/github.com/klauspost/compress/flate/level6.go
+++ b/gateway/vendor/github.com/klauspost/compress/flate/level6.go
@ -1,325 +0,0 @@
-package flate
-
-import "fmt"
-
-type fastEncL6 struct {
-	fastGen
-	table  [tableSize]tableEntry
-	bTable [tableSize]tableEntryPrev
-}
-
-func (e *fastEncL6) Encode(dst *tokens, src []byte) {
-	const (
-		inputMargin            = 12 - 1
-		minNonLiteralBlockSize = 1 + 1 + inputMargin
-		hashShortBytes         = 4
-	)
-	if debugDeflate && e.cur < 0 {
-		panic(fmt.Sprint("e.cur < 0: ", e.cur))
-	}
-
-	// Protect against e.cur wraparound.
-	for e.cur >= bufferReset {
-		if len(e.hist) == 0 {
-			for i := range e.table[:] {
-				e.table[i] = tableEntry{}
-			}
-			for i := range e.bTable[:] {
-				e.bTable[i] = tableEntryPrev{}
-			}
-			e.cur = maxMatchOffset
-			break
-		}
-		// Shift down everything in the table that isn't already too far away.
-		minOff := e.cur + int32(len(e.hist)) - maxMatchOffset
-		for i := range e.table[:] {
-			v := e.table[i].offset
-			if v <= minOff {
-				v = 0
-			} else {
-				v = v - e.cur + maxMatchOffset
-			}
-			e.table[i].offset = v
-		}
-		for i := range e.bTable[:] {
-			v := e.bTable[i]
-			if v.Cur.offset <= minOff {
-				v.Cur.offset = 0
-				v.Prev.offset = 0
-			} else {
-				v.Cur.offset = v.Cur.offset - e.cur + maxMatchOffset
-				if v.Prev.offset <= minOff {
-					v.Prev.offset = 0
-				} else {
-					v.Prev.offset = v.Prev.offset - e.cur + maxMatchOffset
-				}
-			}
-			e.bTable[i] = v
-		}
-		e.cur = maxMatchOffset
-	}
-
-	s := e.addBlock(src)
-
-	// This check isn't in the Snappy implementation, but there, the caller
-	// instead of the callee handles this case.
-	if len(src) < minNonLiteralBlockSize {
-		// We do not fill the token table.
-		// This will be picked up by caller.
-		dst.n = uint16(len(src))
-		return
-	}
-
-	// Override src
-	src = e.hist
-	nextEmit := s
-
-	// sLimit is when to stop looking for offset/length copies. The inputMargin
-	// lets us use a fast path for emitLiteral in the main loop, while we are
-	// looking for copies.
-	sLimit := int32(len(src) - inputMargin)
-
-	// nextEmit is where in src the next emitLiteral should start from.
-	cv := load6432(src, s)
-	// Repeat MUST be > 1 and within range
-	repeat := int32(1)
-	for {
-		const skipLog = 7
-		const doEvery = 1
-
-		nextS := s
-		var l int32
-		var t int32
-		for {
-			nextHashS := hashLen(cv, tableBits, hashShortBytes)
-			nextHashL := hash7(cv, tableBits)
-			s = nextS
-			nextS = s + doEvery + (s-nextEmit)>>skipLog
-			if nextS > sLimit {
-				goto emitRemainder
-			}
-			// Fetch a short+long candidate
-			sCandidate := e.table[nextHashS]
-			lCandidate := e.bTable[nextHashL]
-			next := load6432(src, nextS)
-			entry := tableEntry{offset: s + e.cur}
-			e.table[nextHashS] = entry
-			eLong := &e.bTable[nextHashL]
-			eLong.Cur, eLong.Prev = entry, eLong.Cur
-
-			// Calculate hashes of 'next'
-			nextHashS = hashLen(next, tableBits, hashShortBytes)
-			nextHashL = hash7(next, tableBits)
-
-			t = lCandidate.Cur.offset - e.cur
-			if s-t < maxMatchOffset {
-				if uint32(cv) == load3232(src, lCandidate.Cur.offset-e.cur) {
-					// Long candidate matches at least 4 bytes.
-
-					// Store the next match
-					e.table[nextHashS] = tableEntry{offset: nextS + e.cur}
-					eLong := &e.bTable[nextHashL]
-					eLong.Cur, eLong.Prev = tableEntry{offset: nextS + e.cur}, eLong.Cur
-
-					// Check the previous long candidate as well.
-					t2 := lCandidate.Prev.offset - e.cur
-					if s-t2 < maxMatchOffset && uint32(cv) == load3232(src, lCandidate.Prev.offset-e.cur) {
-						l = e.matchlen(s+4, t+4, src) + 4
-						ml1 := e.matchlen(s+4, t2+4, src) + 4
-						if ml1 > l {
-							t = t2
-							l = ml1
-							break
-						}
-					}
-					break
-				}
-				// Current value did not match, but check if previous long value does.
-				t = lCandidate.Prev.offset - e.cur
-				if s-t < maxMatchOffset && uint32(cv) == load3232(src, lCandidate.Prev.offset-e.cur) {
-					// Store the next match
-					e.table[nextHashS] = tableEntry{offset: nextS + e.cur}
-					eLong := &e.bTable[nextHashL]
-					eLong.Cur, eLong.Prev = tableEntry{offset: nextS + e.cur}, eLong.Cur
-					break
-				}
-			}
-
-			t = sCandidate.offset - e.cur
-			if s-t < maxMatchOffset && uint32(cv) == load3232(src, sCandidate.offset-e.cur) {
-				// Found a 4 match...
-				l = e.matchlen(s+4, t+4, src) + 4
-
-				// Look up next long candidate (at nextS)
-				lCandidate = e.bTable[nextHashL]
-
-				// Store the next match
-				e.table[nextHashS] = tableEntry{offset: nextS + e.cur}
-				eLong := &e.bTable[nextHashL]
-				eLong.Cur, eLong.Prev = tableEntry{offset: nextS + e.cur}, eLong.Cur
-
-				// Check repeat at s + repOff
-				const repOff = 1
-				t2 := s - repeat + repOff
-				if load3232(src, t2) == uint32(cv>>(8*repOff)) {
-					ml := e.matchlen(s+4+repOff, t2+4, src) + 4
-					if ml > l {
-						t = t2
-						l = ml
-						s += repOff
-						// Not worth checking more.
-						break
-					}
-				}
-
-				// If the next long is a candidate, use that...
-				t2 = lCandidate.Cur.offset - e.cur
-				if nextS-t2 < maxMatchOffset {
-					if load3232(src, lCandidate.Cur.offset-e.cur) == uint32(next) {
-						ml := e.matchlen(nextS+4, t2+4, src) + 4
-						if ml > l {
-							t = t2
-							s = nextS
-							l = ml
-							// This is ok, but check previous as well.
-						}
-					}
-					// If the previous long is a candidate, use that...
-					t2 = lCandidate.Prev.offset - e.cur
-					if nextS-t2 < maxMatchOffset && load3232(src, lCandidate.Prev.offset-e.cur) == uint32(next) {
-						ml := e.matchlen(nextS+4, t2+4, src) + 4
-						if ml > l {
-							t = t2
-							s = nextS
-							l = ml
-							break
-						}
-					}
-				}
-				break
-			}
-			cv = next
-		}
-
-		// A 4-byte match has been found. We'll later see if more than 4 bytes
-		// match. But, prior to the match, src[nextEmit:s] are unmatched. Emit
-		// them as literal bytes.
-
-		// Extend the 4-byte match as long as possible.
-		if l == 0 {
-			l = e.matchlenLong(s+4, t+4, src) + 4
-		} else if l == maxMatchLength {
-			l += e.matchlenLong(s+l, t+l, src)
-		}
-
-		// Try to locate a better match by checking the end-of-match...
-		if sAt := s + l; sAt < sLimit {
-			// Allow some bytes at the beginning to mismatch.
-			// Sweet spot is 2/3 bytes depending on input.
-			// 3 is only a little better when it is but sometimes a lot worse.
-			// The skipped bytes are tested in Extend backwards,
-			// and still picked up as part of the match if they do.
-			const skipBeginning = 2
-			eLong := &e.bTable[hash7(load6432(src, sAt), tableBits)]
-			// Test current
-			t2 := eLong.Cur.offset - e.cur - l + skipBeginning
-			s2 := s + skipBeginning
-			off := s2 - t2
-			if off < maxMatchOffset {
-				if off > 0 && t2 >= 0 {
-					if l2 := e.matchlenLong(s2, t2, src); l2 > l {
-						t = t2
-						l = l2
-						s = s2
-					}
-				}
-				// Test next:
-				t2 = eLong.Prev.offset - e.cur - l + skipBeginning
-				off := s2 - t2
-				if off > 0 && off < maxMatchOffset && t2 >= 0 {
-					if l2 := e.matchlenLong(s2, t2, src); l2 > l {
-						t = t2
-						l = l2
-						s = s2
-					}
-				}
-			}
-		}
-
-		// Extend backwards
-		for t > 0 && s > nextEmit && src[t-1] == src[s-1] {
-			s--
-			t--
-			l++
-		}
-		if nextEmit < s {
-			if false {
-				emitLiteral(dst, src[nextEmit:s])
-			} else {
-				for _, v := range src[nextEmit:s] {
-					dst.tokens[dst.n] = token(v)
-					dst.litHist[v]++
-					dst.n++
-				}
-			}
-		}
-		if false {
-			if t >= s {
-				panic(fmt.Sprintln("s-t", s, t))
-			}
-			if (s - t) > maxMatchOffset {
-				panic(fmt.Sprintln("mmo", s-t))
-			}
-			if l < baseMatchLength {
-				panic("bml")
-			}
-		}
-
-		dst.AddMatchLong(l, uint32(s-t-baseMatchOffset))
-		repeat = s - t
-		s += l
-		nextEmit = s
-		if nextS >= s {
-			s = nextS + 1
-		}
-
-		if s >= sLimit {
-			// Index after match end.
-			for i := nextS + 1; i < int32(len(src))-8; i += 2 {
-				cv := load6432(src, i)
-				e.table[hashLen(cv, tableBits, hashShortBytes)] = tableEntry{offset: i + e.cur}
-				eLong := &e.bTable[hash7(cv, tableBits)]
-				eLong.Cur, eLong.Prev = tableEntry{offset: i + e.cur}, eLong.Cur
-			}
-			goto emitRemainder
-		}
-
-		// Store every long hash in-between and every second short.
-		if true {
-			for i := nextS + 1; i < s-1; i += 2 {
-				cv := load6432(src, i)
-				t := tableEntry{offset: i + e.cur}
-				t2 := tableEntry{offset: t.offset + 1}
-				eLong := &e.bTable[hash7(cv, tableBits)]
-				eLong2 := &e.bTable[hash7(cv>>8, tableBits)]
-				e.table[hashLen(cv, tableBits, hashShortBytes)] = t
-				eLong.Cur, eLong.Prev = t, eLong.Cur
-				eLong2.Cur, eLong2.Prev = t2, eLong2.Cur
-			}
-		}
-
-		// We could immediately start working at s now, but to improve
-		// compression we first update the hash table at s-1 and at s.
-		cv = load6432(src, s)
-	}
-
-emitRemainder:
-	if int(nextEmit) < len(src) {
-		// If nothing was added, don't encode literals.
-		if dst.n == 0 {
-			return
-		}
-
-		emitLiteral(dst, src[nextEmit:])
-	}
-}
--- a/gateway/vendor/github.com/klauspost/compress/flate/matchlen_amd64.go
+++ b/gateway/vendor/github.com/klauspost/compress/flate/matchlen_amd64.go
@ -1,16 +0,0 @@
-//go:build amd64 && !appengine && !noasm && gc
-// +build amd64,!appengine,!noasm,gc
-
-// Copyright 2019+ Klaus Post. All rights reserved.
-// License information can be found in the LICENSE file.
-
-package flate
-
-// matchLen returns how many bytes match in a and b
-//
-// It assumes that:
-//
-//	len(a) <= len(b) and len(a) > 0
-//
-//go:noescape
-func matchLen(a []byte, b []byte) int
--- a/gateway/vendor/github.com/klauspost/compress/flate/matchlen_amd64.s
+++ b/gateway/vendor/github.com/klauspost/compress/flate/matchlen_amd64.s
@ -1,68 +0,0 @@
-// Copied from S2 implementation.
-
-//go:build !appengine && !noasm && gc && !noasm
-
-#include "textflag.h"
-
-// func matchLen(a []byte, b []byte) int
-// Requires: BMI
-TEXT ·matchLen(SB), NOSPLIT, $0-56
-	MOVQ a_base+0(FP), AX
-	MOVQ b_base+24(FP), CX
-	MOVQ a_len+8(FP), DX
-
-	// matchLen
-	XORL SI, SI
-	CMPL DX, $0x08
-	JB   matchlen_match4_standalone
-
-matchlen_loopback_standalone:
-	MOVQ  (AX)(SI*1), BX
-	XORQ  (CX)(SI*1), BX
-	TESTQ BX, BX
-	JZ    matchlen_loop_standalone
-
-#ifdef GOAMD64_v3
-	TZCNTQ BX, BX
-#else
-	BSFQ BX, BX
-#endif
-	SARQ $0x03, BX
-	LEAL (SI)(BX*1), SI
-	JMP  gen_match_len_end
-
-matchlen_loop_standalone:
-	LEAL -8(DX), DX
-	LEAL 8(SI), SI
-	CMPL DX, $0x08
-	JAE  matchlen_loopback_standalone
-
-matchlen_match4_standalone:
-	CMPL DX, $0x04
-	JB   matchlen_match2_standalone
-	MOVL (AX)(SI*1), BX
-	CMPL (CX)(SI*1), BX
-	JNE  matchlen_match2_standalone
-	LEAL -4(DX), DX
-	LEAL 4(SI), SI
-
-matchlen_match2_standalone:
-	CMPL DX, $0x02
-	JB   matchlen_match1_standalone
-	MOVW (AX)(SI*1), BX
-	CMPW (CX)(SI*1), BX
-	JNE  matchlen_match1_standalone
-	LEAL -2(DX), DX
-	LEAL 2(SI), SI
-
-matchlen_match1_standalone:
-	CMPL DX, $0x01
-	JB   gen_match_len_end
-	MOVB (AX)(SI*1), BL
-	CMPB (CX)(SI*1), BL
-	JNE  gen_match_len_end
-	INCL SI
-
-gen_match_len_end:
-	MOVQ SI, ret+48(FP)
-	RET
--- a/gateway/vendor/github.com/klauspost/compress/flate/matchlen_generic.go
+++ b/gateway/vendor/github.com/klauspost/compress/flate/matchlen_generic.go
@ -1,33 +0,0 @@
-//go:build !amd64 || appengine || !gc || noasm
-// +build !amd64 appengine !gc noasm
-
-// Copyright 2019+ Klaus Post. All rights reserved.
-// License information can be found in the LICENSE file.
-
-package flate
-
-import (
-	"encoding/binary"
-	"math/bits"
-)
-
-// matchLen returns the maximum common prefix length of a and b.
-// a must be the shortest of the two.
-func matchLen(a, b []byte) (n int) {
-	for ; len(a) >= 8 && len(b) >= 8; a, b = a[8:], b[8:] {
-		diff := binary.LittleEndian.Uint64(a) ^ binary.LittleEndian.Uint64(b)
-		if diff != 0 {
-			return n + bits.TrailingZeros64(diff)>>3
-		}
-		n += 8
-	}
-
-	for i := range a {
-		if a[i] != b[i] {
-			break
-		}
-		n++
-	}
-	return n
-
-}
--- a/gateway/vendor/github.com/klauspost/compress/flate/regmask_amd64.go
+++ b/gateway/vendor/github.com/klauspost/compress/flate/regmask_amd64.go
@ -1,37 +0,0 @@
-package flate
-
-const (
-	// Masks for shifts with register sizes of the shift value.
-	// This can be used to work around the x86 design of shifting by mod register size.
-	// It can be used when a variable shift is always smaller than the register size.
-
-	// reg8SizeMaskX - shift value is 8 bits, shifted is X
-	reg8SizeMask8  = 7
-	reg8SizeMask16 = 15
-	reg8SizeMask32 = 31
-	reg8SizeMask64 = 63
-
-	// reg16SizeMaskX - shift value is 16 bits, shifted is X
-	reg16SizeMask8  = reg8SizeMask8
-	reg16SizeMask16 = reg8SizeMask16
-	reg16SizeMask32 = reg8SizeMask32
-	reg16SizeMask64 = reg8SizeMask64
-
-	// reg32SizeMaskX - shift value is 32 bits, shifted is X
-	reg32SizeMask8  = reg8SizeMask8
-	reg32SizeMask16 = reg8SizeMask16
-	reg32SizeMask32 = reg8SizeMask32
-	reg32SizeMask64 = reg8SizeMask64
-
-	// reg64SizeMaskX - shift value is 64 bits, shifted is X
-	reg64SizeMask8  = reg8SizeMask8
-	reg64SizeMask16 = reg8SizeMask16
-	reg64SizeMask32 = reg8SizeMask32
-	reg64SizeMask64 = reg8SizeMask64
-
-	// regSizeMaskUintX - shift value is uint, shifted is X
-	regSizeMaskUint8  = reg8SizeMask8
-	regSizeMaskUint16 = reg8SizeMask16
-	regSizeMaskUint32 = reg8SizeMask32
-	regSizeMaskUint64 = reg8SizeMask64
-)
--- a/gateway/vendor/github.com/klauspost/compress/flate/regmask_other.go
+++ b/gateway/vendor/github.com/klauspost/compress/flate/regmask_other.go
@ -1,40 +0,0 @@
-//go:build !amd64
-// +build !amd64
-
-package flate
-
-const (
-	// Masks for shifts with register sizes of the shift value.
-	// This can be used to work around the x86 design of shifting by mod register size.
-	// It can be used when a variable shift is always smaller than the register size.
-
-	// reg8SizeMaskX - shift value is 8 bits, shifted is X
-	reg8SizeMask8  = 0xff
-	reg8SizeMask16 = 0xff
-	reg8SizeMask32 = 0xff
-	reg8SizeMask64 = 0xff
-
-	// reg16SizeMaskX - shift value is 16 bits, shifted is X
-	reg16SizeMask8  = 0xffff
-	reg16SizeMask16 = 0xffff
-	reg16SizeMask32 = 0xffff
-	reg16SizeMask64 = 0xffff
-
-	// reg32SizeMaskX - shift value is 32 bits, shifted is X
-	reg32SizeMask8  = 0xffffffff
-	reg32SizeMask16 = 0xffffffff
-	reg32SizeMask32 = 0xffffffff
-	reg32SizeMask64 = 0xffffffff
-
-	// reg64SizeMaskX - shift value is 64 bits, shifted is X
-	reg64SizeMask8  = 0xffffffffffffffff
-	reg64SizeMask16 = 0xffffffffffffffff
-	reg64SizeMask32 = 0xffffffffffffffff
-	reg64SizeMask64 = 0xffffffffffffffff
-
-	// regSizeMaskUintX - shift value is uint, shifted is X
-	regSizeMaskUint8  = ^uint(0)
-	regSizeMaskUint16 = ^uint(0)
-	regSizeMaskUint32 = ^uint(0)
-	regSizeMaskUint64 = ^uint(0)
-)
--- a/gateway/vendor/github.com/klauspost/compress/flate/stateless.go
+++ b/gateway/vendor/github.com/klauspost/compress/flate/stateless.go
@ -1,318 +0,0 @@
-package flate
-
-import (
-	"io"
-	"math"
-	"sync"
-)
-
-const (
-	maxStatelessBlock = math.MaxInt16
-	// dictionary will be taken from maxStatelessBlock, so limit it.
-	maxStatelessDict = 8 << 10
-
-	slTableBits  = 13
-	slTableSize  = 1 << slTableBits
-	slTableShift = 32 - slTableBits
-)
-
-type statelessWriter struct {
-	dst    io.Writer
-	closed bool
-}
-
-func (s *statelessWriter) Close() error {
-	if s.closed {
-		return nil
-	}
-	s.closed = true
-	// Emit EOF block
-	return StatelessDeflate(s.dst, nil, true, nil)
-}
-
-func (s *statelessWriter) Write(p []byte) (n int, err error) {
-	err = StatelessDeflate(s.dst, p, false, nil)
-	if err != nil {
-		return 0, err
-	}
-	return len(p), nil
-}
-
-func (s *statelessWriter) Reset(w io.Writer) {
-	s.dst = w
-	s.closed = false
-}
-
-// NewStatelessWriter will do compression but without maintaining any state
-// between Write calls.
-// There will be no memory kept between Write calls,
-// but compression and speed will be suboptimal.
-// Because of this, the size of actual Write calls will affect output size.
-func NewStatelessWriter(dst io.Writer) io.WriteCloser {
-	return &statelessWriter{dst: dst}
-}
-
-// bitWriterPool contains bit writers that can be reused.
-var bitWriterPool = sync.Pool{
-	New: func() interface{} {
-		return newHuffmanBitWriter(nil)
-	},
-}
-
-// StatelessDeflate allows compressing directly to a Writer without retaining state.
-// When returning everything will be flushed.
-// Up to 8KB of an optional dictionary can be given which is presumed to precede the block.
-// Longer dictionaries will be truncated and will still produce valid output.
-// Sending nil dictionary is perfectly fine.
-func StatelessDeflate(out io.Writer, in []byte, eof bool, dict []byte) error {
-	var dst tokens
-	bw := bitWriterPool.Get().(*huffmanBitWriter)
-	bw.reset(out)
-	defer func() {
-		// don't keep a reference to our output
-		bw.reset(nil)
-		bitWriterPool.Put(bw)
-	}()
-	if eof && len(in) == 0 {
-		// Just write an EOF block.
-		// Could be faster...
-		bw.writeStoredHeader(0, true)
-		bw.flush()
-		return bw.err
-	}
-
-	// Truncate dict
-	if len(dict) > maxStatelessDict {
-		dict = dict[len(dict)-maxStatelessDict:]
-	}
-
-	// For subsequent loops, keep shallow dict reference to avoid alloc+copy.
-	var inDict []byte
-
-	for len(in) > 0 {
-		todo := in
-		if len(inDict) > 0 {
-			if len(todo) > maxStatelessBlock-maxStatelessDict {
-				todo = todo[:maxStatelessBlock-maxStatelessDict]
-			}
-		} else if len(todo) > maxStatelessBlock-len(dict) {
-			todo = todo[:maxStatelessBlock-len(dict)]
-		}
-		inOrg := in
-		in = in[len(todo):]
-		uncompressed := todo
-		if len(dict) > 0 {
-			// combine dict and source
-			bufLen := len(todo) + len(dict)
-			combined := make([]byte, bufLen)
-			copy(combined, dict)
-			copy(combined[len(dict):], todo)
-			todo = combined
-		}
-		// Compress
-		if len(inDict) == 0 {
-			statelessEnc(&dst, todo, int16(len(dict)))
-		} else {
-			statelessEnc(&dst, inDict[:maxStatelessDict+len(todo)], maxStatelessDict)
-		}
-		isEof := eof && len(in) == 0
-
-		if dst.n == 0 {
-			bw.writeStoredHeader(len(uncompressed), isEof)
-			if bw.err != nil {
-				return bw.err
-			}
-			bw.writeBytes(uncompressed)
-		} else if int(dst.n) > len(uncompressed)-len(uncompressed)>>4 {
-			// If we removed less than 1/16th, huffman compress the block.
-			bw.writeBlockHuff(isEof, uncompressed, len(in) == 0)
-		} else {
-			bw.writeBlockDynamic(&dst, isEof, uncompressed, len(in) == 0)
-		}
-		if len(in) > 0 {
-			// Retain a dict if we have more
-			inDict = inOrg[len(uncompressed)-maxStatelessDict:]
-			dict = nil
-			dst.Reset()
-		}
-		if bw.err != nil {
-			return bw.err
-		}
-	}
-	if !eof {
-		// Align, only a stored block can do that.
-		bw.writeStoredHeader(0, false)
-	}
-	bw.flush()
-	return bw.err
-}
-
-func hashSL(u uint32) uint32 {
-	return (u * 0x1e35a7bd) >> slTableShift
-}
-
-func load3216(b []byte, i int16) uint32 {
-	// Help the compiler eliminate bounds checks on the read so it can be done in a single read.
-	b = b[i:]
-	b = b[:4]
-	return uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
-}
-
-func load6416(b []byte, i int16) uint64 {
-	// Help the compiler eliminate bounds checks on the read so it can be done in a single read.
-	b = b[i:]
-	b = b[:8]
-	return uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 |
-		uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56
-}
-
-func statelessEnc(dst *tokens, src []byte, startAt int16) {
-	const (
-		inputMargin            = 12 - 1
-		minNonLiteralBlockSize = 1 + 1 + inputMargin
-	)
-
-	type tableEntry struct {
-		offset int16
-	}
-
-	var table [slTableSize]tableEntry
-
-	// This check isn't in the Snappy implementation, but there, the caller
-	// instead of the callee handles this case.
-	if len(src)-int(startAt) < minNonLiteralBlockSize {
-		// We do not fill the token table.
-		// This will be picked up by caller.
-		dst.n = 0
-		return
-	}
-	// Index until startAt
-	if startAt > 0 {
-		cv := load3232(src, 0)
-		for i := int16(0); i < startAt; i++ {
-			table[hashSL(cv)] = tableEntry{offset: i}
-			cv = (cv >> 8) | (uint32(src[i+4]) << 24)
-		}
-	}
-
-	s := startAt + 1
-	nextEmit := startAt
-	// sLimit is when to stop looking for offset/length copies. The inputMargin
-	// lets us use a fast path for emitLiteral in the main loop, while we are
-	// looking for copies.
-	sLimit := int16(len(src) - inputMargin)
-
-	// nextEmit is where in src the next emitLiteral should start from.
-	cv := load3216(src, s)
-
-	for {
-		const skipLog = 5
-		const doEvery = 2
-
-		nextS := s
-		var candidate tableEntry
-		for {
-			nextHash := hashSL(cv)
-			candidate = table[nextHash]
-			nextS = s + doEvery + (s-nextEmit)>>skipLog
-			if nextS > sLimit || nextS <= 0 {
-				goto emitRemainder
-			}
-
-			now := load6416(src, nextS)
-			table[nextHash] = tableEntry{offset: s}
-			nextHash = hashSL(uint32(now))
-
-			if cv == load3216(src, candidate.offset) {
-				table[nextHash] = tableEntry{offset: nextS}
-				break
-			}
-
-			// Do one right away...
-			cv = uint32(now)
-			s = nextS
-			nextS++
-			candidate = table[nextHash]
-			now >>= 8
-			table[nextHash] = tableEntry{offset: s}
-
-			if cv == load3216(src, candidate.offset) {
-				table[nextHash] = tableEntry{offset: nextS}
-				break
-			}
-			cv = uint32(now)
-			s = nextS
-		}
-
-		// A 4-byte match has been found. We'll later see if more than 4 bytes
-		// match. But, prior to the match, src[nextEmit:s] are unmatched. Emit
-		// them as literal bytes.
-		for {
-			// Invariant: we have a 4-byte match at s, and no need to emit any
-			// literal bytes prior to s.
-
-			// Extend the 4-byte match as long as possible.
-			t := candidate.offset
-			l := int16(matchLen(src[s+4:], src[t+4:]) + 4)
-
-			// Extend backwards
-			for t > 0 && s > nextEmit && src[t-1] == src[s-1] {
-				s--
-				t--
-				l++
-			}
-			if nextEmit < s {
-				if false {
-					emitLiteral(dst, src[nextEmit:s])
-				} else {
-					for _, v := range src[nextEmit:s] {
-						dst.tokens[dst.n] = token(v)
-						dst.litHist[v]++
-						dst.n++
-					}
-				}
-			}
-
-			// Save the match found
-			dst.AddMatchLong(int32(l), uint32(s-t-baseMatchOffset))
-			s += l
-			nextEmit = s
-			if nextS >= s {
-				s = nextS + 1
-			}
-			if s >= sLimit {
-				goto emitRemainder
-			}
-
-			// We could immediately start working at s now, but to improve
-			// compression we first update the hash table at s-2 and at s. If
-			// another emitCopy is not our next move, also calculate nextHash
-			// at s+1. At least on GOARCH=amd64, these three hash calculations
-			// are faster as one load64 call (with some shifts) instead of
-			// three load32 calls.
-			x := load6416(src, s-2)
-			o := s - 2
-			prevHash := hashSL(uint32(x))
-			table[prevHash] = tableEntry{offset: o}
-			x >>= 16
-			currHash := hashSL(uint32(x))
-			candidate = table[currHash]
-			table[currHash] = tableEntry{offset: o + 2}
-
-			if uint32(x) != load3216(src, candidate.offset) {
-				cv = uint32(x >> 8)
-				s++
-				break
-			}
-		}
-	}
-
-emitRemainder:
-	if int(nextEmit) < len(src) {
-		// If nothing was added, don't encode literals.
-		if dst.n == 0 {
-			return
-		}
-		emitLiteral(dst, src[nextEmit:])
-	}
-}
--- a/gateway/vendor/github.com/klauspost/compress/flate/token.go
+++ b/gateway/vendor/github.com/klauspost/compress/flate/token.go
@ -1,379 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package flate
-
-import (
-	"bytes"
-	"encoding/binary"
-	"fmt"
-	"io"
-	"math"
-)
-
-const (
-	// bits 0-16  	xoffset = offset - MIN_OFFSET_SIZE, or literal - 16 bits
-	// bits 16-22	offsetcode - 5 bits
-	// bits 22-30   xlength = length - MIN_MATCH_LENGTH - 8 bits
-	// bits 30-32   type   0 = literal  1=EOF  2=Match   3=Unused - 2 bits
-	lengthShift         = 22
-	offsetMask          = 1<<lengthShift - 1
-	typeMask            = 3 << 30
-	literalType         = 0 << 30
-	matchType           = 1 << 30
-	matchOffsetOnlyMask = 0xffff
-)
-
-// The length code for length X (MIN_MATCH_LENGTH <= X <= MAX_MATCH_LENGTH)
-// is lengthCodes[length - MIN_MATCH_LENGTH]
-var lengthCodes = [256]uint8{
-	0, 1, 2, 3, 4, 5, 6, 7, 8, 8,
-	9, 9, 10, 10, 11, 11, 12, 12, 12, 12,
-	13, 13, 13, 13, 14, 14, 14, 14, 15, 15,
-	15, 15, 16, 16, 16, 16, 16, 16, 16, 16,
-	17, 17, 17, 17, 17, 17, 17, 17, 18, 18,
-	18, 18, 18, 18, 18, 18, 19, 19, 19, 19,
-	19, 19, 19, 19, 20, 20, 20, 20, 20, 20,
-	20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
-	21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
-	21, 21, 21, 21, 21, 21, 22, 22, 22, 22,
-	22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-	22, 22, 23, 23, 23, 23, 23, 23, 23, 23,
-	23, 23, 23, 23, 23, 23, 23, 23, 24, 24,
-	24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
-	24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
-	24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
-	25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
-	25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
-	25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
-	25, 25, 26, 26, 26, 26, 26, 26, 26, 26,
-	26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
-	26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
-	26, 26, 26, 26, 27, 27, 27, 27, 27, 27,
-	27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
-	27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
-	27, 27, 27, 27, 27, 28,
-}
-
-// lengthCodes1 is length codes, but starting at 1.
-var lengthCodes1 = [256]uint8{
-	1, 2, 3, 4, 5, 6, 7, 8, 9, 9,
-	10, 10, 11, 11, 12, 12, 13, 13, 13, 13,
-	14, 14, 14, 14, 15, 15, 15, 15, 16, 16,
-	16, 16, 17, 17, 17, 17, 17, 17, 17, 17,
-	18, 18, 18, 18, 18, 18, 18, 18, 19, 19,
-	19, 19, 19, 19, 19, 19, 20, 20, 20, 20,
-	20, 20, 20, 20, 21, 21, 21, 21, 21, 21,
-	21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
-	22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-	22, 22, 22, 22, 22, 22, 23, 23, 23, 23,
-	23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
-	23, 23, 24, 24, 24, 24, 24, 24, 24, 24,
-	24, 24, 24, 24, 24, 24, 24, 24, 25, 25,
-	25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
-	25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
-	25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
-	26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
-	26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
-	26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
-	26, 26, 27, 27, 27, 27, 27, 27, 27, 27,
-	27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
-	27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
-	27, 27, 27, 27, 28, 28, 28, 28, 28, 28,
-	28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
-	28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
-	28, 28, 28, 28, 28, 29,
-}
-
-var offsetCodes = [256]uint32{
-	0, 1, 2, 3, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7,
-	8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9,
-	10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
-	11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
-	12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
-	12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
-	13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
-	13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
-	14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
-	14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
-	14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
-	14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
-	15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
-	15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
-	15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
-	15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
-}
-
-// offsetCodes14 are offsetCodes, but with 14 added.
-var offsetCodes14 = [256]uint32{
-	14, 15, 16, 17, 18, 18, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21,
-	22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23,
-	24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
-	25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
-	26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
-	26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
-	27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
-	27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
-	28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
-	28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
-	28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
-	28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
-	29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
-	29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
-	29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
-	29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
-}
-
-type token uint32
-
-type tokens struct {
-	extraHist [32]uint16  // codes 256->maxnumlit
-	offHist   [32]uint16  // offset codes
-	litHist   [256]uint16 // codes 0->255
-	nFilled   int
-	n         uint16 // Must be able to contain maxStoreBlockSize
-	tokens    [maxStoreBlockSize + 1]token
-}
-
-func (t *tokens) Reset() {
-	if t.n == 0 {
-		return
-	}
-	t.n = 0
-	t.nFilled = 0
-	for i := range t.litHist[:] {
-		t.litHist[i] = 0
-	}
-	for i := range t.extraHist[:] {
-		t.extraHist[i] = 0
-	}
-	for i := range t.offHist[:] {
-		t.offHist[i] = 0
-	}
-}
-
-func (t *tokens) Fill() {
-	if t.n == 0 {
-		return
-	}
-	for i, v := range t.litHist[:] {
-		if v == 0 {
-			t.litHist[i] = 1
-			t.nFilled++
-		}
-	}
-	for i, v := range t.extraHist[:literalCount-256] {
-		if v == 0 {
-			t.nFilled++
-			t.extraHist[i] = 1
-		}
-	}
-	for i, v := range t.offHist[:offsetCodeCount] {
-		if v == 0 {
-			t.offHist[i] = 1
-		}
-	}
-}
-
-func indexTokens(in []token) tokens {
-	var t tokens
-	t.indexTokens(in)
-	return t
-}
-
-func (t *tokens) indexTokens(in []token) {
-	t.Reset()
-	for _, tok := range in {
-		if tok < matchType {
-			t.AddLiteral(tok.literal())
-			continue
-		}
-		t.AddMatch(uint32(tok.length()), tok.offset()&matchOffsetOnlyMask)
-	}
-}
-
-// emitLiteral writes a literal chunk and returns the number of bytes written.
-func emitLiteral(dst *tokens, lit []byte) {
-	for _, v := range lit {
-		dst.tokens[dst.n] = token(v)
-		dst.litHist[v]++
-		dst.n++
-	}
-}
-
-func (t *tokens) AddLiteral(lit byte) {
-	t.tokens[t.n] = token(lit)
-	t.litHist[lit]++
-	t.n++
-}
-
-// from https://stackoverflow.com/a/28730362
-func mFastLog2(val float32) float32 {
-	ux := int32(math.Float32bits(val))
-	log2 := (float32)(((ux >> 23) & 255) - 128)
-	ux &= -0x7f800001
-	ux += 127 << 23
-	uval := math.Float32frombits(uint32(ux))
-	log2 += ((-0.34484843)*uval+2.02466578)*uval - 0.67487759
-	return log2
-}
-
-// EstimatedBits will return an minimum size estimated by an *optimal*
-// compression of the block.
-// The size of the block
-func (t *tokens) EstimatedBits() int {
-	shannon := float32(0)
-	bits := int(0)
-	nMatches := 0
-	total := int(t.n) + t.nFilled
-	if total > 0 {
-		invTotal := 1.0 / float32(total)
-		for _, v := range t.litHist[:] {
-			if v > 0 {
-				n := float32(v)
-				shannon += atLeastOne(-mFastLog2(n*invTotal)) * n
-			}
-		}
-		// Just add 15 for EOB
-		shannon += 15
-		for i, v := range t.extraHist[1 : literalCount-256] {
-			if v > 0 {
-				n := float32(v)
-				shannon += atLeastOne(-mFastLog2(n*invTotal)) * n
-				bits += int(lengthExtraBits[i&31]) * int(v)
-				nMatches += int(v)
-			}
-		}
-	}
-	if nMatches > 0 {
-		invTotal := 1.0 / float32(nMatches)
-		for i, v := range t.offHist[:offsetCodeCount] {
-			if v > 0 {
-				n := float32(v)
-				shannon += atLeastOne(-mFastLog2(n*invTotal)) * n
-				bits += int(offsetExtraBits[i&31]) * int(v)
-			}
-		}
-	}
-	return int(shannon) + bits
-}
-
-// AddMatch adds a match to the tokens.
-// This function is very sensitive to inlining and right on the border.
-func (t *tokens) AddMatch(xlength uint32, xoffset uint32) {
-	if debugDeflate {
-		if xlength >= maxMatchLength+baseMatchLength {
-			panic(fmt.Errorf("invalid length: %v", xlength))
-		}
-		if xoffset >= maxMatchOffset+baseMatchOffset {
-			panic(fmt.Errorf("invalid offset: %v", xoffset))
-		}
-	}
-	oCode := offsetCode(xoffset)
-	xoffset |= oCode << 16
-
-	t.extraHist[lengthCodes1[uint8(xlength)]]++
-	t.offHist[oCode&31]++
-	t.tokens[t.n] = token(matchType | xlength<<lengthShift | xoffset)
-	t.n++
-}
-
-// AddMatchLong adds a match to the tokens, potentially longer than max match length.
-// Length should NOT have the base subtracted, only offset should.
-func (t *tokens) AddMatchLong(xlength int32, xoffset uint32) {
-	if debugDeflate {
-		if xoffset >= maxMatchOffset+baseMatchOffset {
-			panic(fmt.Errorf("invalid offset: %v", xoffset))
-		}
-	}
-	oc := offsetCode(xoffset)
-	xoffset |= oc << 16
-	for xlength > 0 {
-		xl := xlength
-		if xl > 258 {
-			// We need to have at least baseMatchLength left over for next loop.
-			if xl > 258+baseMatchLength {
-				xl = 258
-			} else {
-				xl = 258 - baseMatchLength
-			}
-		}
-		xlength -= xl
-		xl -= baseMatchLength
-		t.extraHist[lengthCodes1[uint8(xl)]]++
-		t.offHist[oc&31]++
-		t.tokens[t.n] = token(matchType | uint32(xl)<<lengthShift | xoffset)
-		t.n++
-	}
-}
-
-func (t *tokens) AddEOB() {
-	t.tokens[t.n] = token(endBlockMarker)
-	t.extraHist[0]++
-	t.n++
-}
-
-func (t *tokens) Slice() []token {
-	return t.tokens[:t.n]
-}
-
-// VarInt returns the tokens as varint encoded bytes.
-func (t *tokens) VarInt() []byte {
-	var b = make([]byte, binary.MaxVarintLen32*int(t.n))
-	var off int
-	for _, v := range t.tokens[:t.n] {
-		off += binary.PutUvarint(b[off:], uint64(v))
-	}
-	return b[:off]
-}
-
-// FromVarInt restores t to the varint encoded tokens provided.
-// Any data in t is removed.
-func (t *tokens) FromVarInt(b []byte) error {
-	var buf = bytes.NewReader(b)
-	var toks []token
-	for {
-		r, err := binary.ReadUvarint(buf)
-		if err == io.EOF {
-			break
-		}
-		if err != nil {
-			return err
-		}
-		toks = append(toks, token(r))
-	}
-	t.indexTokens(toks)
-	return nil
-}
-
-// Returns the type of a token
-func (t token) typ() uint32 { return uint32(t) & typeMask }
-
-// Returns the literal of a literal token
-func (t token) literal() uint8 { return uint8(t) }
-
-// Returns the extra offset of a match token
-func (t token) offset() uint32 { return uint32(t) & offsetMask }
-
-func (t token) length() uint8 { return uint8(t >> lengthShift) }
-
-// Convert length to code.
-func lengthCode(len uint8) uint8 { return lengthCodes[len] }
-
-// Returns the offset code corresponding to a specific offset
-func offsetCode(off uint32) uint32 {
-	if false {
-		if off < uint32(len(offsetCodes)) {
-			return offsetCodes[off&255]
-		} else if off>>7 < uint32(len(offsetCodes)) {
-			return offsetCodes[(off>>7)&255] + 14
-		} else {
-			return offsetCodes[(off>>14)&255] + 28
-		}
-	}
-	if off < uint32(len(offsetCodes)) {
-		return offsetCodes[uint8(off)]
-	}
-	return offsetCodes14[uint8(off>>7)]
-}
--- a/gateway/vendor/github.com/nats-io/nats.go/.golangci.yaml
+++ b/gateway/vendor/github.com/nats-io/nats.go/.golangci.yaml
@ -1,13 +0,0 @@
-issues:
-  max-issues-per-linter: 0
-  max-same-issues: 0
-  exclude-rules:
-    - linters:
-      - errcheck
-      text: "Unsubscribe"
-    - linters:
-      - errcheck
-      text: "msg.Ack"
-    - linters:
-      - errcheck
-      text: "watcher.Stop"
--- a/gateway/vendor/github.com/nats-io/nats.go/.travis.yml
+++ b/gateway/vendor/github.com/nats-io/nats.go/.travis.yml
@ -1,12 +1,11 @@
 language: go
 go:
- "1.21.x"
- "1.20.x"
+- 1.18.x
+- 1.17.x
 go_import_path: github.com/nats-io/nats.go
 install:
 - go get -t ./...
- curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s -- -b $(go env GOPATH)/bin
- if [[ "$TRAVIS_GO_VERSION" =~ 1.21 ]]; then
+- if [[ "$TRAVIS_GO_VERSION" =~ 1.18 ]]; then
    go install github.com/mattn/goveralls@latest;
    go install github.com/wadey/gocovmerge@latest;
    go install honnef.co/go/tools/cmd/staticcheck@latest;
@ -15,22 +14,12 @@ install:
 before_script:
 - $(exit $(go fmt ./... | wc -l))
 - go vet -modfile=go_test.mod ./...
- if [[ "$TRAVIS_GO_VERSION" =~ 1.21 ]]; then
+- if [[ "$TRAVIS_GO_VERSION" =~ 1.18 ]]; then
    find . -type f -name "*.go" | xargs misspell -error -locale US;
    GOFLAGS="-mod=mod -modfile=go_test.mod" staticcheck ./...;
  fi
- golangci-lint run ./jetstream/...
 script:
 - go test -modfile=go_test.mod -v -run=TestNoRace -p=1 ./... --failfast -vet=off
- if [[ "$TRAVIS_GO_VERSION" =~ 1.21 ]]; then ./scripts/cov.sh TRAVIS; else go test -modfile=go_test.mod -race -v -p=1 ./... --failfast -vet=off -tags=internal_testing; fi
+- if [[ "$TRAVIS_GO_VERSION" =~ 1.18 ]]; then ./scripts/cov.sh TRAVIS; else go test -modfile=go_test.mod -race -v -p=1 ./... --failfast -vet=off; fi
 after_success:
- if [[ "$TRAVIS_GO_VERSION" =~ 1.21 ]]; then $HOME/gopath/bin/goveralls -coverprofile=acc.out -service travis-ci; fi
-
-jobs:
-  include:
-  - name: "Go: 1.21.x (nats-server@main)"
-    go: "1.21.x"
-    before_script:
-    - go get -modfile go_test.mod github.com/nats-io/nats-server/v2@main
-  allow_failures:
-  - name: "Go: 1.21.x (nats-server@main)"
+- if [[ "$TRAVIS_GO_VERSION" =~ 1.18 ]]; then $HOME/gopath/bin/goveralls -coverprofile=acc.out -service travis-ci; fi
--- a/gateway/vendor/github.com/nats-io/nats.go/README.md
+++ b/gateway/vendor/github.com/nats-io/nats.go/README.md
@ -29,7 +29,7 @@ When using or transitioning to Go modules support:
 ```bash
 # Go client latest or explicit version
 go get github.com/nats-io/nats.go/@latest
-go get github.com/nats-io/nats.go/@v1.31.0
+go get github.com/nats-io/nats.go/@v1.22.1

 # For latest NATS Server, add /v2 at the end
 go get github.com/nats-io/nats-server/v2
@ -90,47 +90,84 @@ nc.Drain()
 nc.Close()
 ```

-## JetStream
-
-JetStream is the built-in NATS persistence system. `nats.go` provides a built-in
-API enabling both managing JetStream assets as well as publishing/consuming
-persistent messages.
-
-### Basic usage
+## JetStream Basic Usage

 ```go
-// connect to nats server
+import "github.com/nats-io/nats.go"
+
+// Connect to NATS
 nc, _ := nats.Connect(nats.DefaultURL)

-// create jetstream context from nats connection
-js, _ := jetstream.New(nc)
+// Create JetStream Context
+js, _ := nc.JetStream(nats.PublishAsyncMaxPending(256))

-ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
-defer cancel()
+// Simple Stream Publisher
+js.Publish("ORDERS.scratch", []byte("hello"))

-// get existing stream handle
-stream, _ := js.Stream(ctx, "foo")
+// Simple Async Stream Publisher
+for i := 0; i < 500; i++ {
+	js.PublishAsync("ORDERS.scratch", []byte("hello"))
+}
+select {
+case <-js.PublishAsyncComplete():
+case <-time.After(5 * time.Second):
+	fmt.Println("Did not resolve in time")
+}

-// retrieve consumer handle from a stream
-cons, _ := stream.Consumer(ctx, "cons")
-
-// consume messages from the consumer in callback
-cc, _ := cons.Consume(func(msg jetstream.Msg) {
-    fmt.Println("Received jetstream message: ", string(msg.Data()))
-    msg.Ack()
+// Simple Async Ephemeral Consumer
+js.Subscribe("ORDERS.*", func(m *nats.Msg) {
+	fmt.Printf("Received a JetStream message: %s\n", string(m.Data))
 })
-defer cc.Stop()
+
+// Simple Sync Durable Consumer (optional SubOpts at the end)
+sub, err := js.SubscribeSync("ORDERS.*", nats.Durable("MONITOR"), nats.MaxDeliver(3))
+m, err := sub.NextMsg(timeout)
+
+// Simple Pull Consumer
+sub, err := js.PullSubscribe("ORDERS.*", "MONITOR")
+msgs, err := sub.Fetch(10)
+
+// Unsubscribe
+sub.Unsubscribe()
+
+// Drain
+sub.Drain()
 ```

-To find more information on `nats.go` JetStream API, visit
-[`jetstream/README.md`](jetstream/README.md)
+## JetStream Basic Management

-> The current JetStream API replaces the [legacy JetStream API](legacy_jetstream.md)
+```go
+import "github.com/nats-io/nats.go"

-## Service API
+// Connect to NATS
+nc, _ := nats.Connect(nats.DefaultURL)

-The service API (`micro`) allows you to [easily build NATS services](micro/README.md) The
-services API is currently in beta release.
+// Create JetStream Context
+js, _ := nc.JetStream()
+
+// Create a Stream
+js.AddStream(&nats.StreamConfig{
+	Name:     "ORDERS",
+	Subjects: []string{"ORDERS.*"},
+})
+
+// Update a Stream
+js.UpdateStream(&nats.StreamConfig{
+	Name:     "ORDERS",
+	MaxBytes: 8,
+})
+
+// Create a Consumer
+js.AddConsumer("ORDERS", &nats.ConsumerConfig{
+	Durable: "MONITOR",
+})
+
+// Delete Consumer
+js.DeleteConsumer("ORDERS", "MONITOR")
+
+// Delete Stream
+js.DeleteStream("ORDERS")
+```

 ## Encoded Connections

--- a/gateway/vendor/github.com/nats-io/nats.go/context.go
+++ b/gateway/vendor/github.com/nats-io/nats.go/context.go
@ -136,8 +136,9 @@ func (s *Subscription) nextMsgWithContext(ctx context.Context, pullSubInternal,
 		}
 		if err := s.processNextMsgDelivered(msg); err != nil {
 			return nil, err
+		} else {
+			return msg, nil
 		}
-		return msg, nil
 	default:
 		// If internal and we don't want to wait, signal that there is no
 		// message in the internal queue.
@ -217,7 +218,7 @@ func (nc *Conn) FlushWithContext(ctx context.Context) error {
 // RequestWithContext will create an Inbox and perform a Request
 // using the provided cancellation context with the Inbox reply
 // for the data v. A response will be decoded into the vPtr last parameter.
-func (c *EncodedConn) RequestWithContext(ctx context.Context, subject string, v any, vPtr any) error {
+func (c *EncodedConn) RequestWithContext(ctx context.Context, subject string, v interface{}, vPtr interface{}) error {
 	if ctx == nil {
 		return ErrInvalidContext
 	}
--- a/gateway/vendor/github.com/nats-io/nats.go/dependencies.md
+++ b/gateway/vendor/github.com/nats-io/nats.go/dependencies.md
@ -2,14 +2,12 @@

 This file lists the dependencies used in this repository.

-| Dependency                        | License      |
-|-----------------------------------|--------------|
-| Go                                | BSD 3-Clause |
-| github.com/golang/protobuf/proto  | BSD-3-Clause |
-| github.com/klauspost/compress     | BSD-3-Clause |
-| github.com/nats-io/nats-server/v2 | Apache-2.0   |
-| github.com/nats-io/nkeys          | Apache-2.0   |
-| github.com/nats-io/nuid           | Apache-2.0   |
-| go.uber.org/goleak                | MIT          |
-| golang.org/x/text                 | BSD-3-Clause |
-| google.golang.org/protobuf        | BSD-3-Clause |
+| Dependency | License |
+|-|-|
+| Go | BSD 3-Clause "New" or "Revised" License |
+| github.com/nats-io/nats.go | Apache License 2.0 |
+| github.com/golang/protobuf v1.4.2 | BSD 3-Clause "New" or "Revised" License |
+| github.com/nats-io/nats-server/v2 v2.1.8-0.20201115145023-f61fa8529a0f | Apache License 2.0 |
+| github.com/nats-io/nkeys v0.2.0 | Apache License 2.0 |
+| github.com/nats-io/nuid v1.0.1 | Apache License 2.0 |
+| google.golang.org/protobuf v1.23.0 | BSD 3-Clause License |
--- a/gateway/vendor/github.com/nats-io/nats.go/enc.go
+++ b/gateway/vendor/github.com/nats-io/nats.go/enc.go
@ -26,8 +26,8 @@ import (

 // Encoder interface is for all register encoders
 type Encoder interface {
-	Encode(subject string, v any) ([]byte, error)
-	Decode(subject string, data []byte, vPtr any) error
+	Encode(subject string, v interface{}) ([]byte, error)
+	Decode(subject string, data []byte, vPtr interface{}) error
 }

 var encMap map[string]Encoder
@ -88,7 +88,7 @@ func EncoderForType(encType string) Encoder {

 // Publish publishes the data argument to the given subject. The data argument
 // will be encoded using the associated encoder.
-func (c *EncodedConn) Publish(subject string, v any) error {
+func (c *EncodedConn) Publish(subject string, v interface{}) error {
 	b, err := c.Enc.Encode(subject, v)
 	if err != nil {
 		return err
@ -99,7 +99,7 @@ func (c *EncodedConn) Publish(subject string, v any) error {
 // PublishRequest will perform a Publish() expecting a response on the
 // reply subject. Use Request() for automatically waiting for a response
 // inline.
-func (c *EncodedConn) PublishRequest(subject, reply string, v any) error {
+func (c *EncodedConn) PublishRequest(subject, reply string, v interface{}) error {
 	b, err := c.Enc.Encode(subject, v)
 	if err != nil {
 		return err
@ -110,7 +110,7 @@ func (c *EncodedConn) PublishRequest(subject, reply string, v any) error {
 // Request will create an Inbox and perform a Request() call
 // with the Inbox reply for the data v. A response will be
 // decoded into the vPtr Response.
-func (c *EncodedConn) Request(subject string, v any, vPtr any, timeout time.Duration) error {
+func (c *EncodedConn) Request(subject string, v interface{}, vPtr interface{}, timeout time.Duration) error {
 	b, err := c.Enc.Encode(subject, v)
 	if err != nil {
 		return err
@ -129,7 +129,7 @@ func (c *EncodedConn) Request(subject string, v any, vPtr any, timeout time.Dura
 }

 // Handler is a specific callback used for Subscribe. It is generalized to
-// an any, but we will discover its format and arguments at runtime
+// an interface{}, but we will discover its format and arguments at runtime
 // and perform the correct callback, including demarshaling encoded data
 // back into the appropriate struct based on the signature of the Handler.
 //
@ -150,7 +150,7 @@ func (c *EncodedConn) Request(subject string, v any, vPtr any, timeout time.Dura
 // and demarshal it into the given struct, e.g. person.
 // There are also variants where the callback wants either the subject, or the
 // subject and the reply subject.
-type Handler any
+type Handler interface{}

 // Dissect the cb Handler's signature
 func argInfo(cb Handler) (reflect.Type, int) {
@ -265,5 +265,5 @@ func (c *EncodedConn) Drain() error {

 // LastError reports the last error encountered via the Connection.
 func (c *EncodedConn) LastError() error {
-	return c.Conn.LastError()
+	return c.Conn.err
 }
--- a/gateway/vendor/github.com/nats-io/nats.go/encoders/builtin/default_enc.go
+++ b/gateway/vendor/github.com/nats-io/nats.go/encoders/builtin/default_enc.go
@ -35,7 +35,7 @@ var falseB = []byte("false")
 var nilB = []byte("")

 // Encode
-func (je *DefaultEncoder) Encode(subject string, v any) ([]byte, error) {
+func (je *DefaultEncoder) Encode(subject string, v interface{}) ([]byte, error) {
 	switch arg := v.(type) {
 	case string:
 		bytes := *(*[]byte)(unsafe.Pointer(&arg))
@ -58,7 +58,7 @@ func (je *DefaultEncoder) Encode(subject string, v any) ([]byte, error) {
 }

 // Decode
-func (je *DefaultEncoder) Decode(subject string, data []byte, vPtr any) error {
+func (je *DefaultEncoder) Decode(subject string, data []byte, vPtr interface{}) error {
 	// Figure out what it's pointing to...
 	sData := *(*string)(unsafe.Pointer(&data))
 	switch arg := vPtr.(type) {
--- a/gateway/vendor/github.com/nats-io/nats.go/encoders/builtin/gob_enc.go
+++ b/gateway/vendor/github.com/nats-io/nats.go/encoders/builtin/gob_enc.go
@ -28,7 +28,7 @@ type GobEncoder struct {
 // FIXME(dlc) - This could probably be more efficient.

 // Encode
-func (ge *GobEncoder) Encode(subject string, v any) ([]byte, error) {
+func (ge *GobEncoder) Encode(subject string, v interface{}) ([]byte, error) {
 	b := new(bytes.Buffer)
 	enc := gob.NewEncoder(b)
 	if err := enc.Encode(v); err != nil {
@ -38,7 +38,7 @@ func (ge *GobEncoder) Encode(subject string, v any) ([]byte, error) {
 }

 // Decode
-func (ge *GobEncoder) Decode(subject string, data []byte, vPtr any) (err error) {
+func (ge *GobEncoder) Decode(subject string, data []byte, vPtr interface{}) (err error) {
 	dec := gob.NewDecoder(bytes.NewBuffer(data))
 	err = dec.Decode(vPtr)
 	return
--- a/gateway/vendor/github.com/nats-io/nats.go/encoders/builtin/json_enc.go
+++ b/gateway/vendor/github.com/nats-io/nats.go/encoders/builtin/json_enc.go
@ -26,7 +26,7 @@ type JsonEncoder struct {
 }

 // Encode
-func (je *JsonEncoder) Encode(subject string, v any) ([]byte, error) {
+func (je *JsonEncoder) Encode(subject string, v interface{}) ([]byte, error) {
 	b, err := json.Marshal(v)
 	if err != nil {
 		return nil, err
@ -35,7 +35,7 @@ func (je *JsonEncoder) Encode(subject string, v any) ([]byte, error) {
 }

 // Decode
-func (je *JsonEncoder) Decode(subject string, data []byte, vPtr any) (err error) {
+func (je *JsonEncoder) Decode(subject string, data []byte, vPtr interface{}) (err error) {
 	switch arg := vPtr.(type) {
 	case *string:
 		// If they want a string and it is a JSON string, strip quotes
--- a/gateway/vendor/github.com/nats-io/nats.go/go_test.mod
+++ b/gateway/vendor/github.com/nats-io/nats.go/go_test.mod
@ -1,22 +1,20 @@
 module github.com/nats-io/nats.go

-go 1.19
+go 1.17

 require (
 	github.com/golang/protobuf v1.4.2
-	github.com/klauspost/compress v1.17.0
-	github.com/nats-io/nats-server/v2 v2.10.0
-	github.com/nats-io/nkeys v0.4.5
+	github.com/nats-io/nats-server/v2 v2.9.6
+	github.com/nats-io/nkeys v0.3.0
 	github.com/nats-io/nuid v1.0.1
-	go.uber.org/goleak v1.2.1
-	golang.org/x/text v0.13.0
 	google.golang.org/protobuf v1.23.0
 )

 require (
+	github.com/klauspost/compress v1.15.11 // indirect
 	github.com/minio/highwayhash v1.0.2 // indirect
-	github.com/nats-io/jwt/v2 v2.5.2 // indirect
-	golang.org/x/crypto v0.13.0 // indirect
-	golang.org/x/sys v0.12.0 // indirect
-	golang.org/x/time v0.3.0 // indirect
+	github.com/nats-io/jwt/v2 v2.3.0 // indirect
+	golang.org/x/crypto v0.0.0-20220926161630-eccd6366d1be // indirect
+	golang.org/x/sys v0.0.0-20220928140112-f11e5e49a4ec // indirect
+	golang.org/x/time v0.0.0-20220922220347-f3bd1da661af // indirect
 )
--- a/gateway/vendor/github.com/nats-io/nats.go/go_test.sum
+++ b/gateway/vendor/github.com/nats-io/nats.go/go_test.sum
@ -1,4 +1,5 @@
-github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
 github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
 github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
@ -10,32 +11,45 @@ github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMyw
 github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
 github.com/google/go-cmp v0.4.0 h1:xsAVV57WRhGj6kEIi8ReJzQlHHqcBYCElAvkovg3B/4=
 github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/klauspost/compress v1.17.0 h1:Rnbp4K9EjcDuVuHtd0dgA4qNuv9yKDYKK1ulpJwgrqM=
-github.com/klauspost/compress v1.17.0/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE=
+github.com/klauspost/compress v1.15.11 h1:Lcadnb3RKGin4FYM/orgq0qde+nc15E5Cbqg4B9Sx9c=
+github.com/klauspost/compress v1.15.11/go.mod h1:QPwzmACJjUTFsnSHH934V6woptycfrDDJnH7hvFVbGM=
+github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/minio/highwayhash v1.0.2 h1:Aak5U0nElisjDCfPSG79Tgzkn2gl66NxOMspRrKnA/g=
 github.com/minio/highwayhash v1.0.2/go.mod h1:BQskDq+xkJ12lmlUUi7U0M5Swg3EWR+dLTk+kldvVxY=
-github.com/nats-io/jwt/v2 v2.5.2 h1:DhGH+nKt+wIkDxM6qnVSKjokq5t59AZV5HRcFW0zJwU=
-github.com/nats-io/jwt/v2 v2.5.2/go.mod h1:24BeQtRwxRV8ruvC4CojXlx/WQ/VjuwlYiH+vu/+ibI=
-github.com/nats-io/nats-server/v2 v2.10.0 h1:rcU++Hzo+wARxtJugrV3J5z5iGdHeVG8tT8Chb3bKDg=
-github.com/nats-io/nats-server/v2 v2.10.0/go.mod h1:3PMvMSu2cuK0J9YInRLWdFpFsswKKGUS77zVSAudRto=
-github.com/nats-io/nkeys v0.4.5 h1:Zdz2BUlFm4fJlierwvGK+yl20IAKUm7eV6AAZXEhkPk=
-github.com/nats-io/nkeys v0.4.5/go.mod h1:XUkxdLPTufzlihbamfzQ7mw/VGx6ObUs+0bN5sNvt64=
+github.com/nats-io/jwt/v2 v2.3.0 h1:z2mA1a7tIf5ShggOFlR1oBPgd6hGqcDYsISxZByUzdI=
+github.com/nats-io/jwt/v2 v2.3.0/go.mod h1:0tqz9Hlu6bCBFLWAASKhE5vUA4c24L9KPUUgvwumE/k=
+github.com/nats-io/nats-server/v2 v2.9.6 h1:RTtK+rv/4CcliOuqGsy58g7MuWkBaWmF5TUNwuUo9Uw=
+github.com/nats-io/nats-server/v2 v2.9.6/go.mod h1:AB6hAnGZDlYfqb7CTAm66ZKMZy9DpfierY1/PbpvI2g=
+github.com/nats-io/nats.go v1.19.0/go.mod h1:tLqubohF7t4z3du1QDPYJIQQyhb4wl6DhjxEajSI7UA=
+github.com/nats-io/nkeys v0.3.0 h1:cgM5tL53EvYRU+2YLXIK0G2mJtK12Ft9oeooSZMA2G8=
+github.com/nats-io/nkeys v0.3.0/go.mod h1:gvUNGjVcM2IPr5rCsRsC6Wb3Hr2CQAm08dsxtV6A5y4=
 github.com/nats-io/nuid v1.0.1 h1:5iA8DT8V7q8WK2EScv2padNa/rTESc1KdnPw4TC2paw=
 github.com/nats-io/nuid v1.0.1/go.mod h1:19wcPz3Ph3q0Jbyiqsd0kePYG7A95tJPxeL+1OSON2c=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
-github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk=
-go.uber.org/goleak v1.2.1 h1:NBol2c7O1ZokfZ0LEU9K6Whx/KnwvepVetCUhtKja4A=
-go.uber.org/goleak v1.2.1/go.mod h1:qlT2yGI9QafXHhZZLxlSuNsMw3FFLxBr+tBRlmO1xH4=
-golang.org/x/crypto v0.13.0 h1:mvySKfSWJ+UKUii46M40LOvyWfN0s2U+46/jDd0e6Ck=
-golang.org/x/crypto v0.13.0/go.mod h1:y6Z2r+Rw4iayiXXAIxJIDAJ1zMW4yaTpebo8fPOliYc=
-golang.org/x/exp v0.0.0-20230905200255-921286631fa9 h1:GoHiUyI/Tp2nVkLI2mCxVkOjsbSXD66ic0XW0js0R9g=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/prashantv/gostub v1.1.0/go.mod h1:A5zLQHz7ieHGG7is6LLXLz7I8+3LZzsrV0P1IAHhP5U=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+go.uber.org/automaxprocs v1.5.1/go.mod h1:BF4eumQw0P9GtnuxxovUd06vwm1o18oMzFtK66vU6XU=
+golang.org/x/crypto v0.0.0-20210314154223-e6e6c4f2bb5b/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
+golang.org/x/crypto v0.0.0-20220926161630-eccd6366d1be h1:fmw3UbQh+nxngCAHrDCCztao/kbYFnWjoqop8dHx05A=
+golang.org/x/crypto v0.0.0-20220926161630-eccd6366d1be/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
+golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/sys v0.0.0-20190130150945-aca44879d564/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.12.0 h1:CM0HF96J0hcLAwsHPJZjfdNzs0gftsLfgKt57wWHJ0o=
-golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/text v0.13.0 h1:ablQoSUd0tRdKxZewP80B+BaqeKJuVhuRxj/dkrun3k=
-golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
-golang.org/x/time v0.3.0 h1:rg5rLMjNzMS1RkNLzCG38eapWhnYLFYXDXj2gOlr8j4=
-golang.org/x/time v0.3.0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220928140112-f11e5e49a4ec h1:BkDtF2Ih9xZ7le9ndzTA7KJow28VbQW3odyk/8drmuI=
+golang.org/x/sys v0.0.0-20220928140112-f11e5e49a4ec/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/time v0.0.0-20220922220347-f3bd1da661af h1:Yx9k8YCG3dvF87UAn2tu2HQLf2dt/eR1bXxpLMWeH+Y=
+golang.org/x/time v0.0.0-20220922220347-f3bd1da661af/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
@ -45,4 +59,7 @@ google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miE
 google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
 google.golang.org/protobuf v1.23.0 h1:4MY060fB1DLGMB/7MBTLnwQUY6+F09GEiz6SsrNqyzM=
 google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
-gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
--- a/gateway/vendor/github.com/nats-io/nats.go/internal/parser/parse.go
+++ b/gateway/vendor/github.com/nats-io/nats.go/internal/parser/parse.go
@ -1,104 +0,0 @@
-// Copyright 2020-2022 The NATS Authors
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package parser
-
-import (
-	"errors"
-	"fmt"
-)
-
-const (
-	AckDomainTokenPos = iota + 2
-	AckAccHashTokenPos
-	AckStreamTokenPos
-	AckConsumerTokenPos
-	AckNumDeliveredTokenPos
-	AckStreamSeqTokenPos
-	AckConsumerSeqTokenPos
-	AckTimestampSeqTokenPos
-	AckNumPendingTokenPos
-)
-
-var ErrInvalidSubjectFormat = errors.New("invalid format of ACK subject")
-
-// Quick parser for positive numbers in ack reply encoding.
-// NOTE: This parser does not detect uint64 overflow
-func ParseNum(d string) (n uint64) {
-	if len(d) == 0 {
-		return 0
-	}
-
-	// ASCII numbers 0-9
-	const (
-		asciiZero = 48
-		asciiNine = 57
-	)
-
-	for _, dec := range d {
-		if dec < asciiZero || dec > asciiNine {
-			return 0
-		}
-		n = n*10 + uint64(dec) - asciiZero
-	}
-	return
-}
-
-func GetMetadataFields(subject string) ([]string, error) {
-	v1TokenCounts, v2TokenCounts := 9, 12
-
-	var start int
-	tokens := make([]string, 0, v2TokenCounts)
-	for i := 0; i < len(subject); i++ {
-		if subject[i] == '.' {
-			tokens = append(tokens, subject[start:i])
-			start = i + 1
-		}
-	}
-	tokens = append(tokens, subject[start:])
-	//
-	// Newer server will include the domain name and account hash in the subject,
-	// and a token at the end.
-	//
-	// Old subject was:
-	// $JS.ACK.<stream>.<consumer>.<delivered>.<sseq>.<cseq>.<tm>.<pending>
-	//
-	// New subject would be:
-	// $JS.ACK.<domain>.<account hash>.<stream>.<consumer>.<delivered>.<sseq>.<cseq>.<tm>.<pending>.<a token with a random value>
-	//
-	// v1 has 9 tokens, v2 has 12, but we must not be strict on the 12th since
-	// it may be removed in the future. Also, the library has no use for it.
-	// The point is that a v2 ACK subject is valid if it has at least 11 tokens.
-	//
-	tokensLen := len(tokens)
-	// If lower than 9 or more than 9 but less than 11, report an error
-	if tokensLen < v1TokenCounts || (tokensLen > v1TokenCounts && tokensLen < v2TokenCounts-1) {
-		return nil, ErrInvalidSubjectFormat
-	}
-	if tokens[0] != "$JS" || tokens[1] != "ACK" {
-		return nil, fmt.Errorf("%w: subject should start with $JS.ACK", ErrInvalidSubjectFormat)
-	}
-	// For v1 style, we insert 2 empty tokens (domain and hash) so that the
-	// rest of the library references known fields at a constant location.
-	if tokensLen == v1TokenCounts {
-		// Extend the array (we know the backend is big enough)
-		tokens = append(tokens[:AckDomainTokenPos+2], tokens[AckDomainTokenPos:]...)
-		// Clear the domain and hash tokens
-		tokens[AckDomainTokenPos], tokens[AckAccHashTokenPos] = "", ""
-
-	} else if tokens[AckDomainTokenPos] == "_" {
-		// If domain is "_", replace with empty value.
-		tokens[AckDomainTokenPos] = ""
-	}
-	return tokens, nil
-}
--- a/gateway/vendor/github.com/nats-io/nats.go/js.go
+++ b/gateway/vendor/github.com/nats-io/nats.go/js.go
--- a/gateway/vendor/github.com/nats-io/nats.go/jserrors.go
+++ b/gateway/vendor/github.com/nats-io/nats.go/jserrors.go
@ -33,26 +33,6 @@ var (
 	// ErrStreamNameAlreadyInUse is returned when a stream with given name already exists and has a different configuration.
 	ErrStreamNameAlreadyInUse JetStreamError = &jsError{apiErr: &APIError{ErrorCode: JSErrCodeStreamNameInUse, Description: "stream name already in use", Code: 400}}

-	// ErrStreamSubjectTransformNotSupported is returned when the connected nats-server version does not support setting
-	// the stream subject transform. If this error is returned when executing AddStream(), the stream with invalid
-	// configuration was already created in the server.
-	ErrStreamSubjectTransformNotSupported JetStreamError = &jsError{message: "stream subject transformation not supported by nats-server"}
-
-	// ErrStreamSourceSubjectTransformNotSupported is returned when the connected nats-server version does not support setting
-	// the stream source subject transform. If this error is returned when executing AddStream(), the stream with invalid
-	// configuration was already created in the server.
-	ErrStreamSourceSubjectTransformNotSupported JetStreamError = &jsError{message: "stream subject transformation not supported by nats-server"}
-
-	// ErrStreamSourceNotSupported is returned when the connected nats-server version does not support setting
-	// the stream sources. If this error is returned when executing AddStream(), the stream with invalid
-	// configuration was already created in the server.
-	ErrStreamSourceNotSupported JetStreamError = &jsError{message: "stream sourcing is not supported by nats-server"}
-
-	// ErrStreamSourceMultipleSubjectTransformsNotSupported is returned when the connected nats-server version does not support setting
-	// the stream sources. If this error is returned when executing AddStream(), the stream with invalid
-	// configuration was already created in the server.
-	ErrStreamSourceMultipleSubjectTransformsNotSupported JetStreamError = &jsError{message: "stream sourceing with multiple subject transforms not supported by nats-server"}
-
 	// ErrConsumerNotFound is an error returned when consumer with given name does not exist.
 	ErrConsumerNotFound JetStreamError = &jsError{apiErr: &APIError{ErrorCode: JSErrCodeConsumerNotFound, Description: "consumer not found", Code: 404}}

@ -62,15 +42,6 @@ var (
 	// ErrBadRequest is returned when invalid request is sent to JetStream API.
 	ErrBadRequest JetStreamError = &jsError{apiErr: &APIError{ErrorCode: JSErrCodeBadRequest, Description: "bad request", Code: 400}}

-	// ErrDuplicateFilterSubjects is returned when both FilterSubject and FilterSubjects are specified when creating consumer.
-	ErrDuplicateFilterSubjects JetStreamError = &jsError{apiErr: &APIError{ErrorCode: JSErrCodeDuplicateFilterSubjects, Description: "consumer cannot have both FilterSubject and FilterSubjects specified", Code: 500}}
-
-	// ErrDuplicateFilterSubjects is returned when filter subjects overlap when creating consumer.
-	ErrOverlappingFilterSubjects JetStreamError = &jsError{apiErr: &APIError{ErrorCode: JSErrCodeOverlappingFilterSubjects, Description: "consumer subject filters cannot overlap", Code: 500}}
-
-	// ErrEmptyFilter is returned when a filter in FilterSubjects is empty.
-	ErrEmptyFilter JetStreamError = &jsError{apiErr: &APIError{ErrorCode: JSErrCodeConsumerEmptyFilter, Description: "consumer filter in FilterSubjects cannot be empty", Code: 500}}
-
 	// Client errors

 	// ErrConsumerNameAlreadyInUse is an error returned when consumer with given name already exists.
@ -91,11 +62,6 @@ var (
 	// ErrConsumerNameRequired is returned when the provided consumer durable name is empty.
 	ErrConsumerNameRequired JetStreamError = &jsError{message: "consumer name is required"}

-	// ErrConsumerMultipleFilterSubjectsNotSupported is returned when the connected nats-server version does not support setting
-	// multiple filter subjects with filter_subjects field. If this error is returned when executing AddConsumer(), the consumer with invalid
-	// configuration was already created in the server.
-	ErrConsumerMultipleFilterSubjectsNotSupported JetStreamError = &jsError{message: "multiple consumer filter subjects not supported by nats-server"}
-
 	// ErrConsumerConfigRequired is returned when empty consumer consuguration is supplied to add/update consumer.
 	ErrConsumerConfigRequired JetStreamError = &jsError{message: "consumer configuration is required"}

@ -114,10 +80,10 @@ var (
 	// ErrNotJSMessage is returned when attempting to get metadata from non JetStream message .
 	ErrNotJSMessage JetStreamError = &jsError{message: "not a jetstream message"}

-	// ErrInvalidStreamName is returned when the provided stream name is invalid (contains '.' or ' ').
+	// ErrInvalidStreamName is returned when the provided stream name is invalid (contains '.').
 	ErrInvalidStreamName JetStreamError = &jsError{message: "invalid stream name"}

-	// ErrInvalidConsumerName is returned when the provided consumer name is invalid (contains '.' or ' ').
+	// ErrInvalidConsumerName is returned when the provided consumer name is invalid (contains '.').
 	ErrInvalidConsumerName JetStreamError = &jsError{message: "invalid consumer name"}

 	// ErrNoMatchingStream is returned when stream lookup by subject is unsuccessful.
@ -138,9 +104,6 @@ var (
 	// ErrConsumerLeadershipChanged is returned when pending requests are no longer valid after leadership has changed
 	ErrConsumerLeadershipChanged JetStreamError = &jsError{message: "Leadership Changed"}

-	// ErrNoHeartbeat is returned when no heartbeat is received from server when sending requests with pull consumer.
-	ErrNoHeartbeat JetStreamError = &jsError{message: "no heartbeat received"}
-
 	// DEPRECATED: ErrInvalidDurableName is no longer returned and will be removed in future releases.
 	// Use ErrInvalidConsumerName instead.
 	ErrInvalidDurableName = errors.New("nats: invalid durable name")
@ -152,22 +115,17 @@ type ErrorCode uint16
 const (
 	JSErrCodeJetStreamNotEnabledForAccount ErrorCode = 10039
 	JSErrCodeJetStreamNotEnabled           ErrorCode = 10076
-	JSErrCodeInsufficientResourcesErr      ErrorCode = 10023

 	JSErrCodeStreamNotFound  ErrorCode = 10059
 	JSErrCodeStreamNameInUse ErrorCode = 10058

-	JSErrCodeConsumerNotFound          ErrorCode = 10014
-	JSErrCodeConsumerNameExists        ErrorCode = 10013
-	JSErrCodeConsumerAlreadyExists     ErrorCode = 10105
-	JSErrCodeDuplicateFilterSubjects   ErrorCode = 10136
-	JSErrCodeOverlappingFilterSubjects ErrorCode = 10138
-	JSErrCodeConsumerEmptyFilter       ErrorCode = 10139
+	JSErrCodeConsumerNotFound      ErrorCode = 10014
+	JSErrCodeConsumerNameExists    ErrorCode = 10013
+	JSErrCodeConsumerAlreadyExists ErrorCode = 10105

 	JSErrCodeMessageNotFound ErrorCode = 10037

-	JSErrCodeBadRequest   ErrorCode = 10003
-	JSStreamInvalidConfig ErrorCode = 10052
+	JSErrCodeBadRequest ErrorCode = 10003

 	JSErrCodeStreamWrongLastSequence ErrorCode = 10071
 )
--- a/gateway/vendor/github.com/nats-io/nats.go/jsm.go
+++ b/gateway/vendor/github.com/nats-io/nats.go/jsm.go
@ -102,35 +102,30 @@ type JetStreamManager interface {
 // There are sensible defaults for most. If no subjects are
 // given the name will be used as the only subject.
 type StreamConfig struct {
-	Name                 string           `json:"name"`
-	Description          string           `json:"description,omitempty"`
-	Subjects             []string         `json:"subjects,omitempty"`
-	Retention            RetentionPolicy  `json:"retention"`
-	MaxConsumers         int              `json:"max_consumers"`
-	MaxMsgs              int64            `json:"max_msgs"`
-	MaxBytes             int64            `json:"max_bytes"`
-	Discard              DiscardPolicy    `json:"discard"`
-	DiscardNewPerSubject bool             `json:"discard_new_per_subject,omitempty"`
-	MaxAge               time.Duration    `json:"max_age"`
-	MaxMsgsPerSubject    int64            `json:"max_msgs_per_subject"`
-	MaxMsgSize           int32            `json:"max_msg_size,omitempty"`
-	Storage              StorageType      `json:"storage"`
-	Replicas             int              `json:"num_replicas"`
-	NoAck                bool             `json:"no_ack,omitempty"`
-	Template             string           `json:"template_owner,omitempty"`
-	Duplicates           time.Duration    `json:"duplicate_window,omitempty"`
-	Placement            *Placement       `json:"placement,omitempty"`
-	Mirror               *StreamSource    `json:"mirror,omitempty"`
-	Sources              []*StreamSource  `json:"sources,omitempty"`
-	Sealed               bool             `json:"sealed,omitempty"`
-	DenyDelete           bool             `json:"deny_delete,omitempty"`
-	DenyPurge            bool             `json:"deny_purge,omitempty"`
-	AllowRollup          bool             `json:"allow_rollup_hdrs,omitempty"`
-	Compression          StoreCompression `json:"compression"`
-	FirstSeq             uint64           `json:"first_seq,omitempty"`
-
-	// Allow applying a subject transform to incoming messages before doing anything else.
-	SubjectTransform *SubjectTransformConfig `json:"subject_transform,omitempty"`
+	Name                 string          `json:"name"`
+	Description          string          `json:"description,omitempty"`
+	Subjects             []string        `json:"subjects,omitempty"`
+	Retention            RetentionPolicy `json:"retention"`
+	MaxConsumers         int             `json:"max_consumers"`
+	MaxMsgs              int64           `json:"max_msgs"`
+	MaxBytes             int64           `json:"max_bytes"`
+	Discard              DiscardPolicy   `json:"discard"`
+	DiscardNewPerSubject bool            `json:"discard_new_per_subject,omitempty"`
+	MaxAge               time.Duration   `json:"max_age"`
+	MaxMsgsPerSubject    int64           `json:"max_msgs_per_subject"`
+	MaxMsgSize           int32           `json:"max_msg_size,omitempty"`
+	Storage              StorageType     `json:"storage"`
+	Replicas             int             `json:"num_replicas"`
+	NoAck                bool            `json:"no_ack,omitempty"`
+	Template             string          `json:"template_owner,omitempty"`
+	Duplicates           time.Duration   `json:"duplicate_window,omitempty"`
+	Placement            *Placement      `json:"placement,omitempty"`
+	Mirror               *StreamSource   `json:"mirror,omitempty"`
+	Sources              []*StreamSource `json:"sources,omitempty"`
+	Sealed               bool            `json:"sealed,omitempty"`
+	DenyDelete           bool            `json:"deny_delete,omitempty"`
+	DenyPurge            bool            `json:"deny_purge,omitempty"`
+	AllowRollup          bool            `json:"allow_rollup_hdrs,omitempty"`

 	// Allow republish of the message after being sequenced and stored.
 	RePublish *RePublish `json:"republish,omitempty"`
@ -139,20 +134,6 @@ type StreamConfig struct {
 	AllowDirect bool `json:"allow_direct"`
 	// Allow higher performance and unified direct access for mirrors as well.
 	MirrorDirect bool `json:"mirror_direct"`
-
-	// Limits for consumers on this stream.
-	ConsumerLimits StreamConsumerLimits `json:"consumer_limits,omitempty"`
-
-	// Metadata is additional metadata for the Stream.
-	// Keys starting with `_nats` are reserved.
-	// NOTE: Metadata requires nats-server v2.10.0+
-	Metadata map[string]string `json:"metadata,omitempty"`
-}
-
-// SubjectTransformConfig is for applying a subject transform (to matching messages) before doing anything else when a new message is received.
-type SubjectTransformConfig struct {
-	Source      string `json:"src,omitempty"`
-	Destination string `json:"dest"`
 }

 // RePublish is for republishing messages once committed to a stream. The original
@ -171,13 +152,12 @@ type Placement struct {

 // StreamSource dictates how streams can source from other streams.
 type StreamSource struct {
-	Name              string                   `json:"name"`
-	OptStartSeq       uint64                   `json:"opt_start_seq,omitempty"`
-	OptStartTime      *time.Time               `json:"opt_start_time,omitempty"`
-	FilterSubject     string                   `json:"filter_subject,omitempty"`
-	SubjectTransforms []SubjectTransformConfig `json:"subject_transforms,omitempty"`
-	External          *ExternalStream          `json:"external,omitempty"`
-	Domain            string                   `json:"-"`
+	Name          string          `json:"name"`
+	OptStartSeq   uint64          `json:"opt_start_seq,omitempty"`
+	OptStartTime  *time.Time      `json:"opt_start_time,omitempty"`
+	FilterSubject string          `json:"filter_subject,omitempty"`
+	External      *ExternalStream `json:"external,omitempty"`
+	Domain        string          `json:"-"`
 }

 // ExternalStream allows you to qualify access to a stream source in another
@ -187,13 +167,6 @@ type ExternalStream struct {
 	DeliverPrefix string `json:"deliver,omitempty"`
 }

-// StreamConsumerLimits are the limits for a consumer on a stream.
-// These can be overridden on a per consumer basis.
-type StreamConsumerLimits struct {
-	InactiveThreshold time.Duration `json:"inactive_threshold,omitempty"`
-	MaxAckPending     int           `json:"max_ack_pending,omitempty"`
-}
-
 // Helper for copying when we do not want to change user's version.
 func (ss *StreamSource) copy() *StreamSource {
 	nss := *ss
@ -337,7 +310,7 @@ func (js *js) AddConsumer(stream string, cfg *ConsumerConfig, opts ...JSOpt) (*C
 		consumerName = cfg.Durable
 	}
 	if consumerName != _EMPTY_ {
-		consInfo, err := js.ConsumerInfo(stream, consumerName, opts...)
+		consInfo, err := js.ConsumerInfo(stream, consumerName)
 		if err != nil && !errors.Is(err, ErrConsumerNotFound) && !errors.Is(err, ErrStreamNotFound) {
 			return nil, err
 		}
@ -346,8 +319,6 @@ func (js *js) AddConsumer(stream string, cfg *ConsumerConfig, opts ...JSOpt) (*C
 			sameConfig := checkConfig(&consInfo.Config, cfg)
 			if sameConfig != nil {
 				return nil, fmt.Errorf("%w: creating consumer %q on stream %q", ErrConsumerNameAlreadyInUse, consumerName, stream)
-			} else {
-				return consInfo, nil
 			}
 		}
 	}
@ -388,29 +359,20 @@ func (js *js) upsertConsumer(stream, consumerName string, cfg *ConsumerConfig, o

 	var ccSubj string
 	if consumerName == _EMPTY_ {
-		// if consumer name is empty (neither Durable nor Name is set), use the legacy ephemeral endpoint
+		// if consumer name is empty, use the legacy ephemeral endpoint
 		ccSubj = fmt.Sprintf(apiLegacyConsumerCreateT, stream)
 	} else if err := checkConsumerName(consumerName); err != nil {
 		return nil, err
-	} else if js.nc.serverMinVersion(2, 9, 0) {
-		if cfg.Durable != "" && js.opts.featureFlags.useDurableConsumerCreate {
-			// if user set the useDurableConsumerCreate flag, use the legacy DURABLE.CREATE endpoint
-			ccSubj = fmt.Sprintf(apiDurableCreateT, stream, consumerName)
-		} else if cfg.FilterSubject == _EMPTY_ || cfg.FilterSubject == ">" {
-			// if filter subject is empty or ">", use the endpoint without filter subject
+	} else if !js.nc.serverMinVersion(2, 9, 0) || (cfg.Durable != "" && js.opts.featureFlags.useDurableConsumerCreate) {
+		// if server version is lower than 2.9.0 or user set the useDurableConsumerCreate flag, use the legacy DURABLE.CREATE endpoint
+		ccSubj = fmt.Sprintf(apiDurableCreateT, stream, consumerName)
+	} else {
+		// if above server version 2.9.0, use the endpoints with consumer name
+		if cfg.FilterSubject == _EMPTY_ || cfg.FilterSubject == ">" {
 			ccSubj = fmt.Sprintf(apiConsumerCreateT, stream, consumerName)
 		} else {
-			// if filter subject is not empty, use the endpoint with filter subject
 			ccSubj = fmt.Sprintf(apiConsumerCreateWithFilterSubjectT, stream, consumerName, cfg.FilterSubject)
 		}
-	} else {
-		if cfg.Durable != "" {
-			// if Durable is set, use the DURABLE.CREATE endpoint
-			ccSubj = fmt.Sprintf(apiDurableCreateT, stream, consumerName)
-		} else {
-			// if Durable is not set, use the legacy ephemeral endpoint
-			ccSubj = fmt.Sprintf(apiLegacyConsumerCreateT, stream)
-		}
 	}

 	resp, err := js.apiRequestWithContext(o.ctx, js.apiSubj(ccSubj), req)
@ -434,11 +396,6 @@ func (js *js) upsertConsumer(stream, consumerName string, cfg *ConsumerConfig, o
 		}
 		return nil, info.Error
 	}
-
-	// check whether multiple filter subjects (if used) are reflected in the returned ConsumerInfo
-	if len(cfg.FilterSubjects) != 0 && len(info.Config.FilterSubjects) == 0 {
-		return nil, ErrConsumerMultipleFilterSubjectsNotSupported
-	}
 	return info.ConsumerInfo, nil
 }

@ -452,20 +409,19 @@ func checkStreamName(stream string) error {
 	if stream == _EMPTY_ {
 		return ErrStreamNameRequired
 	}
-	if strings.ContainsAny(stream, ". ") {
+	if strings.Contains(stream, ".") {
 		return ErrInvalidStreamName
 	}
 	return nil
 }

-// Check that the consumer name is not empty and is valid (does not contain "." and " ").
-// Additional consumer name validation is done in nats-server.
+// Check that the durable name exists and is valid, that is, that it does not contain any "."
 // Returns ErrConsumerNameRequired if consumer name is empty, ErrInvalidConsumerName is invalid, otherwise nil
 func checkConsumerName(consumer string) error {
 	if consumer == _EMPTY_ {
 		return ErrConsumerNameRequired
 	}
-	if strings.ContainsAny(consumer, ". ") {
+	if strings.Contains(consumer, ".") {
 		return ErrInvalidConsumerName
 	}
 	return nil
@ -812,21 +768,6 @@ func (js *js) AddStream(cfg *StreamConfig, opts ...JSOpt) (*StreamInfo, error) {
 		return nil, resp.Error
 	}

-	// check that input subject transform (if used) is reflected in the returned ConsumerInfo
-	if cfg.SubjectTransform != nil && resp.StreamInfo.Config.SubjectTransform == nil {
-		return nil, ErrStreamSubjectTransformNotSupported
-	}
-	if len(cfg.Sources) != 0 {
-		if len(cfg.Sources) != len(resp.Config.Sources) {
-			return nil, ErrStreamSourceNotSupported
-		}
-		for i := range cfg.Sources {
-			if len(cfg.Sources[i].SubjectTransforms) != 0 && len(resp.Sources[i].SubjectTransforms) == 0 {
-				return nil, ErrStreamSourceMultipleSubjectTransformsNotSupported
-			}
-		}
-	}
-
 	return resp.StreamInfo, nil
 }

@ -944,13 +885,11 @@ type StreamAlternate struct {

 // StreamSourceInfo shows information about an upstream stream source.
 type StreamSourceInfo struct {
-	Name              string                   `json:"name"`
-	Lag               uint64                   `json:"lag"`
-	Active            time.Duration            `json:"active"`
-	External          *ExternalStream          `json:"external"`
-	Error             *APIError                `json:"error"`
-	FilterSubject     string                   `json:"filter_subject,omitempty"`
-	SubjectTransforms []SubjectTransformConfig `json:"subject_transforms,omitempty"`
+	Name     string          `json:"name"`
+	Lag      uint64          `json:"lag"`
+	Active   time.Duration   `json:"active"`
+	External *ExternalStream `json:"external"`
+	Error    *APIError       `json:"error"`
 }

 // StreamState is information about the given stream.
@ -1022,23 +961,6 @@ func (js *js) UpdateStream(cfg *StreamConfig, opts ...JSOpt) (*StreamInfo, error
 		}
 		return nil, resp.Error
 	}
-
-	// check that input subject transform (if used) is reflected in the returned StreamInfo
-	if cfg.SubjectTransform != nil && resp.StreamInfo.Config.SubjectTransform == nil {
-		return nil, ErrStreamSubjectTransformNotSupported
-	}
-
-	if len(cfg.Sources) != 0 {
-		if len(cfg.Sources) != len(resp.Config.Sources) {
-			return nil, ErrStreamSourceNotSupported
-		}
-		for i := range cfg.Sources {
-			if len(cfg.Sources[i].SubjectTransforms) != 0 && len(resp.Sources[i].SubjectTransforms) == 0 {
-				return nil, ErrStreamSourceMultipleSubjectTransformsNotSupported
-			}
-		}
-	}
-
 	return resp.StreamInfo, nil
 }

@ -1185,7 +1107,7 @@ func (js *js) getMsg(name string, mreq *apiMsgGetRequest, opts ...JSOpt) (*RawSt

 	var hdr Header
 	if len(msg.Header) > 0 {
-		hdr, err = DecodeHeadersMsg(msg.Header)
+		hdr, err = decodeHeadersMsg(msg.Header)
 		if err != nil {
 			return nil, err
 		}
--- a/gateway/vendor/github.com/nats-io/nats.go/kv.go
+++ b/gateway/vendor/github.com/nats-io/nats.go/kv.go
@ -23,8 +23,6 @@ import (
 	"strings"
 	"sync"
 	"time"
-
-	"github.com/nats-io/nats.go/internal/parser"
 )

 // KeyValueManager is used to manage KeyValue stores.
@ -123,8 +121,6 @@ type watchOpts struct {
 	ignoreDeletes bool
 	// Include all history per subject, not just last one.
 	includeHistory bool
-	// Include only updates for keys.
-	updatesOnly bool
 	// retrieve only the meta data of the entry
 	metaOnly bool
 }
@ -138,25 +134,11 @@ func (opt watchOptFn) configureWatcher(opts *watchOpts) error {
 // IncludeHistory instructs the key watcher to include historical values as well.
 func IncludeHistory() WatchOpt {
 	return watchOptFn(func(opts *watchOpts) error {
-		if opts.updatesOnly {
-			return errors.New("nats: include history can not be used with updates only")
-		}
 		opts.includeHistory = true
 		return nil
 	})
 }

-// UpdatesOnly instructs the key watcher to only include updates on values (without latest values when started).
-func UpdatesOnly() WatchOpt {
-	return watchOptFn(func(opts *watchOpts) error {
-		if opts.includeHistory {
-			return errors.New("nats: updates only can not be used with include history")
-		}
-		opts.updatesOnly = true
-		return nil
-	})
-}
-
 // IgnoreDeletes will have the key watcher not pass any deleted keys.
 func IgnoreDeletes() WatchOpt {
 	return watchOptFn(func(opts *watchOpts) error {
@ -432,21 +414,14 @@ func (js *js) CreateKeyValue(cfg *KeyValueConfig) (KeyValue, error) {
 		scfg.Mirror = m
 		scfg.MirrorDirect = true
 	} else if len(cfg.Sources) > 0 {
+		// For now we do not allow direct subjects for sources. If that is desired a user could use stream API directly.
 		for _, ss := range cfg.Sources {
-			var sourceBucketName string
-			if strings.HasPrefix(ss.Name, kvBucketNamePre) {
-				sourceBucketName = ss.Name[len(kvBucketNamePre):]
-			} else {
-				sourceBucketName = ss.Name
+			if !strings.HasPrefix(ss.Name, kvBucketNamePre) {
+				ss = ss.copy()
 				ss.Name = fmt.Sprintf(kvBucketNameTmpl, ss.Name)
 			}
-
-			if ss.External == nil || sourceBucketName != cfg.Bucket {
-				ss.SubjectTransforms = []SubjectTransformConfig{{Source: fmt.Sprintf(kvSubjectsTmpl, sourceBucketName), Destination: fmt.Sprintf(kvSubjectsTmpl, cfg.Bucket)}}
-			}
 			scfg.Sources = append(scfg.Sources, ss)
 		}
-		scfg.Subjects = []string{fmt.Sprintf(kvSubjectsTmpl, cfg.Bucket)}
 	} else {
 		scfg.Subjects = []string{fmt.Sprintf(kvSubjectsTmpl, cfg.Bucket)}
 	}
@ -463,15 +438,11 @@ func (js *js) CreateKeyValue(cfg *KeyValueConfig) (KeyValue, error) {
 		// and we are now moving to a v2.7.2+. If that is the case
 		// and the only difference is the discard policy, then update
 		// the stream.
-		// The same logic applies for KVs created pre 2.9.x and
-		// the AllowDirect setting.
 		if err == ErrStreamNameAlreadyInUse {
 			if si, _ = js.StreamInfo(scfg.Name); si != nil {
 				// To compare, make the server's stream info discard
 				// policy same than ours.
 				si.Config.Discard = scfg.Discard
-				// Also need to set allow direct for v2.9.x+
-				si.Config.AllowDirect = scfg.AllowDirect
 				if reflect.DeepEqual(&si.Config, scfg) {
 					si, err = js.UpdateStream(scfg)
 				}
@ -645,7 +616,7 @@ func (kv *kvs) PutString(key string, value string) (revision uint64, err error)
 	return kv.Put(key, []byte(value))
 }

-// Create will add the key/value pair if it does not exist.
+// Create will add the key/value pair iff it does not exist.
 func (kv *kvs) Create(key string, value []byte) (revision uint64, err error) {
 	v, err := kv.Update(key, value, 0)
 	if err == nil {
@ -668,7 +639,7 @@ func (kv *kvs) Create(key string, value []byte) (revision uint64, err error) {
 	return 0, err
 }

-// Update will update the value if the latest revision matches.
+// Update will update the value iff the latest revision matches.
 func (kv *kvs) Update(key string, value []byte, revision uint64) (uint64, error) {
 	if !keyValid(key) {
 		return 0, ErrInvalidKey
@ -914,7 +885,7 @@ func (kv *kvs) Watch(keys string, opts ...WatchOpt) (KeyWatcher, error) {
 	w := &watcher{updates: make(chan KeyValueEntry, 256), ctx: o.ctx}

 	update := func(m *Msg) {
-		tokens, err := parser.GetMetadataFields(m.Reply)
+		tokens, err := getMetadataFields(m.Reply)
 		if err != nil {
 			return
 		}
@ -932,7 +903,7 @@ func (kv *kvs) Watch(keys string, opts ...WatchOpt) (KeyWatcher, error) {
 				op = KeyValuePurge
 			}
 		}
-		delta := parser.ParseNum(tokens[parser.AckNumPendingTokenPos])
+		delta := uint64(parseNum(tokens[ackNumPendingTokenPos]))
 		w.mu.Lock()
 		defer w.mu.Unlock()
 		if !o.ignoreDeletes || (op != KeyValueDelete && op != KeyValuePurge) {
@ -940,15 +911,14 @@ func (kv *kvs) Watch(keys string, opts ...WatchOpt) (KeyWatcher, error) {
 				bucket:   kv.name,
 				key:      subj,
 				value:    m.Data,
-				revision: parser.ParseNum(tokens[parser.AckStreamSeqTokenPos]),
-				created:  time.Unix(0, int64(parser.ParseNum(tokens[parser.AckTimestampSeqTokenPos]))),
+				revision: uint64(parseNum(tokens[ackStreamSeqTokenPos])),
+				created:  time.Unix(0, parseNum(tokens[ackTimestampSeqTokenPos])),
 				delta:    delta,
 				op:       op,
 			}
 			w.updates <- entry
 		}
 		// Check if done and initial values.
-		// Skip if UpdatesOnly() is set, since there will never be updates initially.
 		if !w.initDone {
 			w.received++
 			// We set this on the first trip through..
@ -967,9 +937,6 @@ func (kv *kvs) Watch(keys string, opts ...WatchOpt) (KeyWatcher, error) {
 	if !o.includeHistory {
 		subOpts = append(subOpts, DeliverLastPerSubject())
 	}
-	if o.updatesOnly {
-		subOpts = append(subOpts, DeliverNew())
-	}
 	if o.metaOnly {
 		subOpts = append(subOpts, HeadersOnly())
 	}
@ -988,18 +955,12 @@ func (kv *kvs) Watch(keys string, opts ...WatchOpt) (KeyWatcher, error) {
 	sub.mu.Lock()
 	// If there were no pending messages at the time of the creation
 	// of the consumer, send the marker.
-	// Skip if UpdatesOnly() is set, since there will never be updates initially.
-	if !o.updatesOnly {
-		if sub.jsi != nil && sub.jsi.pending == 0 {
-			w.initDone = true
-			w.updates <- nil
-		}
-	} else {
-		// if UpdatesOnly was used, mark initialization as complete
+	if sub.jsi != nil && sub.jsi.pending == 0 {
 		w.initDone = true
+		w.updates <- nil
 	}
 	// Set us up to close when the waitForMessages func returns.
-	sub.pDone = func(_ string) {
+	sub.pDone = func() {
 		close(w.updates)
 	}
 	sub.mu.Unlock()
@ -1053,16 +1014,16 @@ func (kv *kvs) Status() (KeyValueStatus, error) {
 // KeyValueStoreNames is used to retrieve a list of key value store names
 func (js *js) KeyValueStoreNames() <-chan string {
 	ch := make(chan string)
-	l := &streamNamesLister{js: js}
+	l := &streamLister{js: js}
 	l.js.opts.streamListSubject = fmt.Sprintf(kvSubjectsTmpl, "*")
 	go func() {
 		defer close(ch)
 		for l.Next() {
-			for _, name := range l.Page() {
-				if !strings.HasPrefix(name, kvBucketNamePre) {
+			for _, info := range l.Page() {
+				if !strings.HasPrefix(info.Config.Name, kvBucketNamePre) {
 					continue
 				}
-				ch <- name
+				ch <- info.Config.Name
 			}
 		}
 	}()
--- a/gateway/vendor/github.com/nats-io/nats.go/legacy_jetstream.md
+++ b/gateway/vendor/github.com/nats-io/nats.go/legacy_jetstream.md
@ -1,83 +0,0 @@
-# Legacy JetStream API
-
-This is a documentation for the legacy JetStream API. A README for the current
-API can be found [here](jetstream/README.md)
-
-## JetStream Basic Usage
-
-```go
-import "github.com/nats-io/nats.go"
-
-// Connect to NATS
-nc, _ := nats.Connect(nats.DefaultURL)
-
-// Create JetStream Context
-js, _ := nc.JetStream(nats.PublishAsyncMaxPending(256))
-
-// Simple Stream Publisher
-js.Publish("ORDERS.scratch", []byte("hello"))
-
-// Simple Async Stream Publisher
-for i := 0; i < 500; i++ {
-    js.PublishAsync("ORDERS.scratch", []byte("hello"))
-}
-select {
-case <-js.PublishAsyncComplete():
-case <-time.After(5 * time.Second):
-    fmt.Println("Did not resolve in time")
-}
-
-// Simple Async Ephemeral Consumer
-js.Subscribe("ORDERS.*", func(m *nats.Msg) {
-    fmt.Printf("Received a JetStream message: %s\n", string(m.Data))
-})
-
-// Simple Sync Durable Consumer (optional SubOpts at the end)
-sub, err := js.SubscribeSync("ORDERS.*", nats.Durable("MONITOR"), nats.MaxDeliver(3))
-m, err := sub.NextMsg(timeout)
-
-// Simple Pull Consumer
-sub, err := js.PullSubscribe("ORDERS.*", "MONITOR")
-msgs, err := sub.Fetch(10)
-
-// Unsubscribe
-sub.Unsubscribe()
-
-// Drain
-sub.Drain()
-```
-
-## JetStream Basic Management
-
-```go
-import "github.com/nats-io/nats.go"
-
-// Connect to NATS
-nc, _ := nats.Connect(nats.DefaultURL)
-
-// Create JetStream Context
-js, _ := nc.JetStream()
-
-// Create a Stream
-js.AddStream(&nats.StreamConfig{
-    Name:     "ORDERS",
-    Subjects: []string{"ORDERS.*"},
-})
-
-// Update a Stream
-js.UpdateStream(&nats.StreamConfig{
-    Name:     "ORDERS",
-    MaxBytes: 8,
-})
-
-// Create a Consumer
-js.AddConsumer("ORDERS", &nats.ConsumerConfig{
-    Durable: "MONITOR",
-})
-
-// Delete Consumer
-js.DeleteConsumer("ORDERS", "MONITOR")
-
-// Delete Stream
-js.DeleteStream("ORDERS")
-```
--- a/gateway/vendor/github.com/nats-io/nats.go/nats.go
+++ b/gateway/vendor/github.com/nats-io/nats.go/nats.go
@ -1,4 +1,4 @@
-// Copyright 2012-2023 The NATS Authors
+// Copyright 2012-2022 The NATS Authors
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
@ -47,7 +47,7 @@ import (

 // Default Constants
 const (
-	Version                   = "1.31.0"
+	Version                   = "1.22.1"
 	DefaultURL                = "nats://127.0.0.1:4222"
 	DefaultPort               = 4222
 	DefaultMaxReconnect       = 60
@ -61,7 +61,6 @@ const (
 	DefaultReconnectBufSize   = 8 * 1024 * 1024 // 8MB
 	RequestChanLen            = 8
 	DefaultDrainTimeout       = 30 * time.Second
-	DefaultFlusherTimeout     = time.Minute
 	LangString                = "go"
 )

@ -141,6 +140,10 @@ var (
 	ErrConnectionNotTLS       = errors.New("nats: connection is not tls")
 )

+func init() {
+	rand.Seed(time.Now().UnixNano())
+}
+
 // GetDefaultOptions returns default configuration options for the client.
 func GetDefaultOptions() Options {
 	return Options{
@ -155,7 +158,6 @@ func GetDefaultOptions() Options {
 		SubChanLen:         DefaultMaxChanLen,
 		ReconnectBufSize:   DefaultReconnectBufSize,
 		DrainTimeout:       DefaultDrainTimeout,
-		FlusherTimeout:     DefaultFlusherTimeout,
 	}
 }

@ -213,13 +215,6 @@ type ErrHandler func(*Conn, *Subscription, error)
 // JWT for this user.
 type UserJWTHandler func() (string, error)

-// TLSCertHandler is used to fetch and return tls certificate.
-type TLSCertHandler func() (tls.Certificate, error)
-
-// RootCAsHandler is used to fetch and return a set of root certificate
-// authorities that clients use when verifying server certificates.
-type RootCAsHandler func() (*x509.CertPool, error)
-
 // SignatureHandler is used to sign a nonce from the server while
 // authenticating with nkeys. The user should sign the nonce and
 // return the raw signature. The client will base64 encode this to
@ -308,20 +303,6 @@ type Options struct {
 	// transports.
 	TLSConfig *tls.Config

-	// TLSCertCB is used to fetch and return custom tls certificate.
-	TLSCertCB TLSCertHandler
-
-	// TLSHandshakeFirst is used to instruct the library perform
-	// the TLS handshake right after the connect and before receiving
-	// the INFO protocol from the server. If this option is enabled
-	// but the server is not configured to perform the TLS handshake
-	// first, the connection will fail.
-	TLSHandshakeFirst bool
-
-	// RootCAsCB is used to fetch and return a set of root certificate
-	// authorities that clients use when verifying server certificates.
-	RootCAsCB RootCAsHandler
-
 	// AllowReconnect enables reconnection logic to be used when we
 	// encounter a disconnect from the current server.
 	AllowReconnect bool
@ -365,7 +346,6 @@ type Options struct {

 	// FlusherTimeout is the maximum time to wait for write operations
 	// to the underlying connection to complete (including the flusher loop).
-	// Defaults to 1m.
 	FlusherTimeout time.Duration

 	// PingInterval is the period at which the client will be sending ping
@ -495,9 +475,6 @@ type Options struct {
 	// IgnoreAuthErrorAbort - if set to true, client opts out of the default connect behavior of aborting
 	// subsequent reconnect attempts if server returns the same auth error twice (regardless of reconnect policy).
 	IgnoreAuthErrorAbort bool
-
-	// SkipHostLookup skips the DNS lookup for the server hostname.
-	SkipHostLookup bool
 }

 const (
@ -534,32 +511,31 @@ type Conn struct {
 	mu sync.RWMutex
 	// Opts holds the configuration of the Conn.
 	// Modifying the configuration of a running Conn is a race.
-	Opts          Options
-	wg            sync.WaitGroup
-	srvPool       []*srv
-	current       *srv
-	urls          map[string]struct{} // Keep track of all known URLs (used by processInfo)
-	conn          net.Conn
-	bw            *natsWriter
-	br            *natsReader
-	fch           chan struct{}
-	info          serverInfo
-	ssid          int64
-	subsMu        sync.RWMutex
-	subs          map[int64]*Subscription
-	ach           *asyncCallbacksHandler
-	pongs         []chan struct{}
-	scratch       [scratchSize]byte
-	status        Status
-	statListeners map[Status][]chan Status
-	initc         bool // true if the connection is performing the initial connect
-	err           error
-	ps            *parseState
-	ptmr          *time.Timer
-	pout          int
-	ar            bool // abort reconnect
-	rqch          chan struct{}
-	ws            bool // true if a websocket connection
+	Opts    Options
+	wg      sync.WaitGroup
+	srvPool []*srv
+	current *srv
+	urls    map[string]struct{} // Keep track of all known URLs (used by processInfo)
+	conn    net.Conn
+	bw      *natsWriter
+	br      *natsReader
+	fch     chan struct{}
+	info    serverInfo
+	ssid    int64
+	subsMu  sync.RWMutex
+	subs    map[int64]*Subscription
+	ach     *asyncCallbacksHandler
+	pongs   []chan struct{}
+	scratch [scratchSize]byte
+	status  Status
+	initc   bool // true if the connection is performing the initial connect
+	err     error
+	ps      *parseState
+	ptmr    *time.Timer
+	pout    int
+	ar      bool // abort reconnect
+	rqch    chan struct{}
+	ws      bool // true if a websocket connection

 	// New style response handler
 	respSub       string               // The wildcard subject
@ -623,7 +599,7 @@ type Subscription struct {
 	pHead *Msg
 	pTail *Msg
 	pCond *sync.Cond
-	pDone func(subject string)
+	pDone func()

 	// Pending stats, async subscriptions, high-speed etc.
 	pMsgs       int
@ -697,15 +673,6 @@ func (m *Msg) Equal(msg *Msg) bool {
 	return true
 }

-// Size returns a message size in bytes.
-func (m *Msg) Size() int {
-	if m.wsz != 0 {
-		return m.wsz
-	}
-	hdr, _ := m.headerBytes()
-	return len(m.Subject) + len(m.Reply) + len(hdr) + len(m.Data)
-}
-
 func (m *Msg) headerBytes() ([]byte, error) {
 	var hdr []byte
 	if len(m.Header) == 0 {
@ -868,27 +835,21 @@ func Secure(tls ...*tls.Config) Option {
 // If Secure is not already set this will set it as well.
 func RootCAs(file ...string) Option {
 	return func(o *Options) error {
-		rootCAsCB := func() (*x509.CertPool, error) {
-			pool := x509.NewCertPool()
-			for _, f := range file {
-				rootPEM, err := os.ReadFile(f)
-				if err != nil || rootPEM == nil {
-					return nil, fmt.Errorf("nats: error loading or parsing rootCA file: %w", err)
-				}
-				ok := pool.AppendCertsFromPEM(rootPEM)
-				if !ok {
-					return nil, fmt.Errorf("nats: failed to parse root certificate from %q", f)
-				}
+		pool := x509.NewCertPool()
+		for _, f := range file {
+			rootPEM, err := os.ReadFile(f)
+			if err != nil || rootPEM == nil {
+				return fmt.Errorf("nats: error loading or parsing rootCA file: %v", err)
+			}
+			ok := pool.AppendCertsFromPEM(rootPEM)
+			if !ok {
+				return fmt.Errorf("nats: failed to parse root certificate from %q", f)
 			}
-			return pool, nil
 		}
 		if o.TLSConfig == nil {
 			o.TLSConfig = &tls.Config{MinVersion: tls.VersionTLS12}
 		}
-		if _, err := rootCAsCB(); err != nil {
-			return err
-		}
-		o.RootCAsCB = rootCAsCB
+		o.TLSConfig.RootCAs = pool
 		o.Secure = true
 		return nil
 	}
@ -898,24 +859,18 @@ func RootCAs(file ...string) Option {
 // If Secure is not already set this will set it as well.
 func ClientCert(certFile, keyFile string) Option {
 	return func(o *Options) error {
-		tlsCertCB := func() (tls.Certificate, error) {
-			cert, err := tls.LoadX509KeyPair(certFile, keyFile)
-			if err != nil {
-				return tls.Certificate{}, fmt.Errorf("nats: error loading client certificate: %w", err)
-			}
-			cert.Leaf, err = x509.ParseCertificate(cert.Certificate[0])
-			if err != nil {
-				return tls.Certificate{}, fmt.Errorf("nats: error parsing client certificate: %w", err)
-			}
-			return cert, nil
+		cert, err := tls.LoadX509KeyPair(certFile, keyFile)
+		if err != nil {
+			return fmt.Errorf("nats: error loading client certificate: %v", err)
+		}
+		cert.Leaf, err = x509.ParseCertificate(cert.Certificate[0])
+		if err != nil {
+			return fmt.Errorf("nats: error parsing client certificate: %v", err)
 		}
 		if o.TLSConfig == nil {
 			o.TLSConfig = &tls.Config{MinVersion: tls.VersionTLS12}
 		}
-		if _, err := tlsCertCB(); err != nil {
-			return err
-		}
-		o.TLSCertCB = tlsCertCB
+		o.TLSConfig.Certificates = []tls.Certificate{cert}
 		o.Secure = true
 		return nil
 	}
@ -956,7 +911,6 @@ func ReconnectWait(t time.Duration) Option {
 }

 // MaxReconnects is an Option to set the maximum number of reconnect attempts.
-// If negative, it will never stop trying to reconnect.
 // Defaults to 60.
 func MaxReconnects(max int) Option {
 	return func(o *Options) error {
@ -1004,7 +958,7 @@ func MaxPingsOutstanding(max int) Option {
 }

 // ReconnectBufSize sets the buffer size of messages kept while busy reconnecting.
-// Defaults to 8388608 bytes (8MB).  It can be disabled by setting it to -1.
+// Defaults to 8388608 bytes (8MB).
 func ReconnectBufSize(size int) Option {
 	return func(o *Options) error {
 		o.ReconnectBufSize = size
@ -1159,7 +1113,7 @@ func UserJWTAndSeed(jwt string, seed string) Option {
 	sigCB := func(nonce []byte) ([]byte, error) {
 		kp, err := nkeys.FromSeed([]byte(seed))
 		if err != nil {
-			return nil, fmt.Errorf("unable to extract key pair from seed: %w", err)
+			return nil, fmt.Errorf("unable to extract key pair from seed: %v", err)
 		}
 		// Wipe our key on exit.
 		defer kp.Wipe()
@ -1182,12 +1136,6 @@ func UserJWT(userCB UserJWTHandler, sigCB SignatureHandler) Option {
 		if sigCB == nil {
 			return ErrUserButNoSigCB
 		}
-		// Smoke test the user callback to ensure it is setup properly
-		// when processing options.
-		if _, err := userCB(); err != nil {
-			return err
-		}
-
 		o.UserJWT = userCB
 		o.SignatureCB = sigCB
 		return nil
@ -1314,25 +1262,6 @@ func IgnoreAuthErrorAbort() Option {
 	}
 }

-// SkipHostLookup is an Option to skip the host lookup when connecting to a server.
-func SkipHostLookup() Option {
-	return func(o *Options) error {
-		o.SkipHostLookup = true
-		return nil
-	}
-}
-
-// TLSHandshakeFirst is an Option to perform the TLS handshake first, that is
-// before receiving the INFO protocol. This requires the server to also be
-// configured with such option, otherwise the connection will fail.
-func TLSHandshakeFirst() Option {
-	return func(o *Options) error {
-		o.TLSHandshakeFirst = true
-		o.Secure = true
-		return nil
-	}
-}
-
 // Handler processing

 // SetDisconnectHandler will set the disconnect event handler.
@ -1499,12 +1428,6 @@ func (o Options) Connect() (*Conn, error) {
 		}
 	}

-	// If the TLSHandshakeFirst option is specified, make sure that
-	// the Secure boolean is true.
-	if nc.Opts.TLSHandshakeFirst {
-		nc.Opts.Secure = true
-	}
-
 	if err := nc.setupServerPool(); err != nil {
 		return nil, err
 	}
@ -1972,7 +1895,7 @@ func (nc *Conn) createConn() (err error) {
 	hosts := []string{}
 	u := nc.current.url

-	if !nc.Opts.SkipHostLookup && net.ParseIP(u.Hostname()) == nil {
+	if net.ParseIP(u.Hostname()) == nil {
 		addrs, _ := net.LookupHost(u.Hostname())
 		for _, addr := range addrs {
 			hosts = append(hosts, net.JoinHostPort(addr, u.Port()))
@ -2033,23 +1956,11 @@ func (nc *Conn) makeTLSConn() error {
 		}
 	}
 	// Allow the user to configure their own tls.Config structure.
-	tlsCopy := &tls.Config{}
+	var tlsCopy *tls.Config
 	if nc.Opts.TLSConfig != nil {
 		tlsCopy = util.CloneTLSConfig(nc.Opts.TLSConfig)
-	}
-	if nc.Opts.TLSCertCB != nil {
-		cert, err := nc.Opts.TLSCertCB()
-		if err != nil {
-			return err
-		}
-		tlsCopy.Certificates = []tls.Certificate{cert}
-	}
-	if nc.Opts.RootCAsCB != nil {
-		rootCAs, err := nc.Opts.RootCAsCB()
-		if err != nil {
-			return err
-		}
-		tlsCopy.RootCAs = rootCAs
+	} else {
+		tlsCopy = &tls.Config{}
 	}
 	// If its blank we will override it with the current host
 	if tlsCopy.ServerName == _EMPTY_ {
@ -2257,15 +2168,7 @@ func (nc *Conn) processConnectInit() error {
 	defer nc.conn.SetDeadline(time.Time{})

 	// Set our status to connecting.
-	nc.changeConnStatus(CONNECTING)
-
-	// If we need to have a TLS connection and want the TLS handshake to occur
-	// first, do it now.
-	if nc.Opts.Secure && nc.Opts.TLSHandshakeFirst {
-		if err := nc.makeTLSConn(); err != nil {
-			return err
-		}
-	}
+	nc.status = CONNECTING

 	// Process the INFO protocol received from the server
 	err := nc.processExpectedInfo()
@ -2357,7 +2260,7 @@ func (nc *Conn) connect() (bool, error) {
 		nc.initc = false
 	} else if nc.Opts.RetryOnFailedConnect {
 		nc.setup()
-		nc.changeConnStatus(RECONNECTING)
+		nc.status = RECONNECTING
 		nc.bw.switchToPending()
 		go nc.doReconnect(ErrNoServers)
 		err = nil
@ -2383,13 +2286,8 @@ func (nc *Conn) checkForSecure() error {
 		o.Secure = true
 	}

+	// Need to rewrap with bufio
 	if o.Secure {
-		// If TLS handshake first is true, we have already done
-		// the handshake, so we are done here.
-		if o.TLSHandshakeFirst {
-			return nil
-		}
-		// Need to rewrap with bufio
 		if err := nc.makeTLSConn(); err != nil {
 			return err
 		}
@ -2484,7 +2382,7 @@ func (nc *Conn) connectProto() (string, error) {
 		}
 		sigraw, err := o.SignatureCB([]byte(nc.info.Nonce))
 		if err != nil {
-			return _EMPTY_, fmt.Errorf("error signing nonce: %w", err)
+			return _EMPTY_, fmt.Errorf("error signing nonce: %v", err)
 		}
 		sig = base64.RawURLEncoding.EncodeToString(sigraw)
 	}
@ -2541,9 +2439,6 @@ func (nc *Conn) sendConnect() error {
 	// Construct the CONNECT protocol string
 	cProto, err := nc.connectProto()
 	if err != nil {
-		if !nc.initc && nc.Opts.AsyncErrorCB != nil {
-			nc.ach.push(func() { nc.Opts.AsyncErrorCB(nc, nil, err) })
-		}
 		return err
 	}

@ -2558,9 +2453,6 @@ func (nc *Conn) sendConnect() error {
 	// reading byte-by-byte here is ok.
 	proto, err := nc.readProto()
 	if err != nil {
-		if !nc.initc && nc.Opts.AsyncErrorCB != nil {
-			nc.ach.push(func() { nc.Opts.AsyncErrorCB(nc, nil, err) })
-		}
 		return err
 	}

@ -2569,9 +2461,6 @@ func (nc *Conn) sendConnect() error {
 		// Read the rest now...
 		proto, err = nc.readProto()
 		if err != nil {
-			if !nc.initc && nc.Opts.AsyncErrorCB != nil {
-				nc.ach.push(func() { nc.Opts.AsyncErrorCB(nc, nil, err) })
-			}
 			return err
 		}
 	}
@ -2605,7 +2494,7 @@ func (nc *Conn) sendConnect() error {
 	}

 	// This is where we are truly connected.
-	nc.changeConnStatus(CONNECTED)
+	nc.status = CONNECTED

 	return nil
 }
@ -2780,7 +2669,7 @@ func (nc *Conn) doReconnect(err error) {
 			if nc.ar {
 				break
 			}
-			nc.changeConnStatus(RECONNECTING)
+			nc.status = RECONNECTING
 			continue
 		}

@ -2798,7 +2687,7 @@ func (nc *Conn) doReconnect(err error) {
 		// Now send off and clear pending buffer
 		nc.err = nc.flushReconnectPendingItems()
 		if nc.err != nil {
-			nc.changeConnStatus(RECONNECTING)
+			nc.status = RECONNECTING
 			// Stop the ping timer (if set)
 			nc.stopPingTimer()
 			// Since processConnectInit() returned without error, the
@ -2851,7 +2740,7 @@ func (nc *Conn) processOpErr(err error) {

 	if nc.Opts.AllowReconnect && nc.status == CONNECTED {
 		// Set our new status
-		nc.changeConnStatus(RECONNECTING)
+		nc.status = RECONNECTING
 		// Stop ping timer if set
 		nc.stopPingTimer()
 		if nc.conn != nil {
@ -2870,7 +2759,7 @@ func (nc *Conn) processOpErr(err error) {
 		return
 	}

-	nc.changeConnStatus(DISCONNECTED)
+	nc.status = DISCONNECTED
 	nc.err = err
 	nc.mu.Unlock()
 	nc.close(CLOSED, true, nil)
@ -3069,7 +2958,7 @@ func (nc *Conn) waitForMsgs(s *Subscription) {
 	s.mu.Unlock()

 	if done != nil {
-		done(s.Subject)
+		done()
 	}
 }

@ -3077,6 +2966,28 @@ func (nc *Conn) waitForMsgs(s *Subscription) {
 // Return what is to be used. If we return nil the message will be dropped.
 type msgFilter func(m *Msg) *Msg

+func (nc *Conn) addMsgFilter(subject string, filter msgFilter) {
+	nc.subsMu.Lock()
+	defer nc.subsMu.Unlock()
+
+	if nc.filters == nil {
+		nc.filters = make(map[string]msgFilter)
+	}
+	nc.filters[subject] = filter
+}
+
+func (nc *Conn) removeMsgFilter(subject string) {
+	nc.subsMu.Lock()
+	defer nc.subsMu.Unlock()
+
+	if nc.filters != nil {
+		delete(nc.filters, subject)
+		if len(nc.filters) == 0 {
+			nc.filters = nil
+		}
+	}
+}
+
 // processMsg is called by parse and will place the msg on the
 // appropriate channel/pending queue for processing. If the channel is full,
 // or the pending queue is over the pending limits, the connection is
@ -3125,7 +3036,7 @@ func (nc *Conn) processMsg(data []byte) {
 	if nc.ps.ma.hdr > 0 {
 		hbuf := msgPayload[:nc.ps.ma.hdr]
 		msgPayload = msgPayload[nc.ps.ma.hdr:]
-		h, err = DecodeHeadersMsg(hbuf)
+		h, err = decodeHeadersMsg(hbuf)
 		if err != nil {
 			// We will pass the message through but send async error.
 			nc.mu.Lock()
@ -3183,10 +3094,8 @@ func (nc *Conn) processMsg(data []byte) {
 		}
 	}

-	// Skip processing if this is a control message and
-	// if not a pull consumer heartbeat. For pull consumers,
-	// heartbeats have to be handled on per request basis.
-	if !ctrlMsg || (jsi != nil && jsi.pull) {
+	// Skip processing if this is a control message.
+	if !ctrlMsg {
 		var chanSubCheckFC bool
 		// Subscription internal stats (applicable only for non ChanSubscription's)
 		if sub.typ != ChanSubscription {
@ -3642,10 +3551,9 @@ const (
 	statusLen          = 3 // e.g. 20x, 40x, 50x
 )

-// DecodeHeadersMsg will decode and headers.
-func DecodeHeadersMsg(data []byte) (Header, error) {
-	br := bufio.NewReaderSize(bytes.NewReader(data), 128)
-	tp := textproto.NewReader(br)
+// decodeHeadersMsg will decode and headers.
+func decodeHeadersMsg(data []byte) (Header, error) {
+	tp := textproto.NewReader(bufio.NewReader(bytes.NewReader(data)))
 	l, err := tp.ReadLine()
 	if err != nil || len(l) < hdrPreEnd || l[:hdrPreEnd] != hdrLine[:hdrPreEnd] {
 		return nil, ErrBadHeaderMsg
@ -4474,14 +4382,6 @@ func (s *Subscription) AutoUnsubscribe(max int) error {
 	return conn.unsubscribe(s, max, false)
 }

-// SetClosedHandler will set the closed handler for when a subscription
-// is closed (either unsubscribed or drained).
-func (s *Subscription) SetClosedHandler(handler func(subject string)) {
-	s.mu.Lock()
-	s.pDone = handler
-	s.mu.Unlock()
-}
-
 // unsubscribe performs the low level unsubscribe to the server.
 // Use Subscription.Unsubscribe()
 func (nc *Conn) unsubscribe(sub *Subscription, max int, drainMode bool) error {
@ -5107,15 +5007,15 @@ func (nc *Conn) close(status Status, doCBs bool, err error) {
 	nc.subs = nil
 	nc.subsMu.Unlock()

-	nc.changeConnStatus(status)
+	nc.status = status

 	// Perform appropriate callback if needed for a disconnect.
 	if doCBs {
 		if nc.conn != nil {
-			if disconnectedErrCB := nc.Opts.DisconnectedErrCB; disconnectedErrCB != nil {
-				nc.ach.push(func() { disconnectedErrCB(nc, err) })
-			} else if disconnectedCB := nc.Opts.DisconnectedCB; disconnectedCB != nil {
-				nc.ach.push(func() { disconnectedCB(nc) })
+			if nc.Opts.DisconnectedErrCB != nil {
+				nc.ach.push(func() { nc.Opts.DisconnectedErrCB(nc, err) })
+			} else if nc.Opts.DisconnectedCB != nil {
+				nc.ach.push(func() { nc.Opts.DisconnectedCB(nc) })
 			}
 		}
 		if nc.Opts.ClosedCB != nil {
@ -5252,7 +5152,7 @@ func (nc *Conn) drainConnection() {

 	// Flip State
 	nc.mu.Lock()
-	nc.changeConnStatus(DRAINING_PUBS)
+	nc.status = DRAINING_PUBS
 	nc.mu.Unlock()

 	// Do publish drain via Flush() call.
@ -5287,7 +5187,7 @@ func (nc *Conn) Drain() error {
 		nc.mu.Unlock()
 		return nil
 	}
-	nc.changeConnStatus(DRAINING_SUBS)
+	nc.status = DRAINING_SUBS
 	go nc.drainConnection()
 	nc.mu.Unlock()

@ -5497,68 +5397,6 @@ func (nc *Conn) GetClientID() (uint64, error) {
 	return nc.info.CID, nil
 }

-// StatusChanged returns a channel on which given list of connection status changes will be reported.
-// If no statuses are provided, defaults will be used: CONNECTED, RECONNECTING, DISCONNECTED, CLOSED.
-func (nc *Conn) StatusChanged(statuses ...Status) chan Status {
-	if len(statuses) == 0 {
-		statuses = []Status{CONNECTED, RECONNECTING, DISCONNECTED, CLOSED}
-	}
-	ch := make(chan Status, 10)
-	for _, s := range statuses {
-		nc.registerStatusChangeListener(s, ch)
-	}
-	return ch
-}
-
-// registerStatusChangeListener registers a channel waiting for a specific status change event.
-// Status change events are non-blocking - if no receiver is waiting for the status change,
-// it will not be sent on the channel. Closed channels are ignored.
-func (nc *Conn) registerStatusChangeListener(status Status, ch chan Status) {
-	nc.mu.Lock()
-	defer nc.mu.Unlock()
-	if nc.statListeners == nil {
-		nc.statListeners = make(map[Status][]chan Status)
-	}
-	if _, ok := nc.statListeners[status]; !ok {
-		nc.statListeners[status] = make([]chan Status, 0)
-	}
-	nc.statListeners[status] = append(nc.statListeners[status], ch)
-}
-
-// sendStatusEvent sends connection status event to all channels.
-// If channel is closed, or there is no listener, sendStatusEvent
-// will not block. Lock should be held entering.
-func (nc *Conn) sendStatusEvent(s Status) {
-Loop:
-	for i := 0; i < len(nc.statListeners[s]); i++ {
-		// make sure channel is not closed
-		select {
-		case <-nc.statListeners[s][i]:
-			// if chan is closed, remove it
-			nc.statListeners[s][i] = nc.statListeners[s][len(nc.statListeners[s])-1]
-			nc.statListeners[s] = nc.statListeners[s][:len(nc.statListeners[s])-1]
-			i--
-			continue Loop
-		default:
-		}
-		// only send event if someone's listening
-		select {
-		case nc.statListeners[s][i] <- s:
-		default:
-		}
-	}
-}
-
-// changeConnStatus changes connections status and sends events
-// to all listeners. Lock should be held entering.
-func (nc *Conn) changeConnStatus(status Status) {
-	if nc == nil {
-		return
-	}
-	nc.sendStatusEvent(status)
-	nc.status = status
-}
-
 // NkeyOptionFromSeed will load an nkey pair from a seed file.
 // It will return the NKey Option and will handle
 // signing of nonce challenges from the server. It will take
@ -5594,12 +5432,12 @@ func wipeSlice(buf []byte) {
 func userFromFile(userFile string) (string, error) {
 	path, err := expandPath(userFile)
 	if err != nil {
-		return _EMPTY_, fmt.Errorf("nats: %w", err)
+		return _EMPTY_, fmt.Errorf("nats: %v", err)
 	}

 	contents, err := os.ReadFile(path)
 	if err != nil {
-		return _EMPTY_, fmt.Errorf("nats: %w", err)
+		return _EMPTY_, fmt.Errorf("nats: %v", err)
 	}
 	defer wipeSlice(contents)
 	return nkeys.ParseDecoratedJWT(contents)
@ -5648,7 +5486,7 @@ func expandPath(p string) (string, error) {
 func nkeyPairFromSeedFile(seedFile string) (nkeys.KeyPair, error) {
 	contents, err := os.ReadFile(seedFile)
 	if err != nil {
-		return nil, fmt.Errorf("nats: %w", err)
+		return nil, fmt.Errorf("nats: %v", err)
 	}
 	defer wipeSlice(contents)
 	return nkeys.ParseDecoratedNKey(contents)
@ -5659,7 +5497,7 @@ func nkeyPairFromSeedFile(seedFile string) (nkeys.KeyPair, error) {
 func sigHandler(nonce []byte, seedFile string) ([]byte, error) {
 	kp, err := nkeyPairFromSeedFile(seedFile)
 	if err != nil {
-		return nil, fmt.Errorf("unable to extract key pair from file %q: %w", seedFile, err)
+		return nil, fmt.Errorf("unable to extract key pair from file %q: %v", seedFile, err)
 	}
 	// Wipe our key on exit.
 	defer kp.Wipe()
--- a/gateway/vendor/github.com/nats-io/nats.go/netchan.go
+++ b/gateway/vendor/github.com/nats-io/nats.go/netchan.go
@ -23,7 +23,7 @@ import (
 // Data will be encoded and decoded via the EncodedConn and its associated encoders.

 // BindSendChan binds a channel for send operations to NATS.
-func (c *EncodedConn) BindSendChan(subject string, channel any) error {
+func (c *EncodedConn) BindSendChan(subject string, channel interface{}) error {
 	chVal := reflect.ValueOf(channel)
 	if chVal.Kind() != reflect.Chan {
 		return ErrChanArg
@ -61,17 +61,17 @@ func chPublish(c *EncodedConn, chVal reflect.Value, subject string) {
 }

 // BindRecvChan binds a channel for receive operations from NATS.
-func (c *EncodedConn) BindRecvChan(subject string, channel any) (*Subscription, error) {
+func (c *EncodedConn) BindRecvChan(subject string, channel interface{}) (*Subscription, error) {
 	return c.bindRecvChan(subject, _EMPTY_, channel)
 }

 // BindRecvQueueChan binds a channel for queue-based receive operations from NATS.
-func (c *EncodedConn) BindRecvQueueChan(subject, queue string, channel any) (*Subscription, error) {
+func (c *EncodedConn) BindRecvQueueChan(subject, queue string, channel interface{}) (*Subscription, error) {
 	return c.bindRecvChan(subject, queue, channel)
 }

 // Internal function to bind receive operations for a channel.
-func (c *EncodedConn) bindRecvChan(subject, queue string, channel any) (*Subscription, error) {
+func (c *EncodedConn) bindRecvChan(subject, queue string, channel interface{}) (*Subscription, error) {
 	chVal := reflect.ValueOf(channel)
 	if chVal.Kind() != reflect.Chan {
 		return nil, ErrChanArg
--- a/gateway/vendor/github.com/nats-io/nats.go/object.go
+++ b/gateway/vendor/github.com/nats-io/nats.go/object.go
@ -29,11 +29,14 @@ import (
 	"sync"
 	"time"

-	"github.com/nats-io/nats.go/internal/parser"
 	"github.com/nats-io/nuid"
 )

 // ObjectStoreManager creates, loads and deletes Object Stores
+//
+// Notice: Experimental Preview
+//
+// This functionality is EXPERIMENTAL and may be changed in later releases.
 type ObjectStoreManager interface {
 	// ObjectStore will look up and bind to an existing object store instance.
 	ObjectStore(bucket string) (ObjectStore, error)
@ -49,6 +52,10 @@ type ObjectStoreManager interface {

 // ObjectStore is a blob store capable of storing large objects efficiently in
 // JetStream streams
+//
+// Notice: Experimental Preview
+//
+// This functionality is EXPERIMENTAL and may be changed in later releases.
 type ObjectStore interface {
 	// Put will place the contents from the reader into a new object.
 	Put(obj *ObjectMeta, reader io.Reader, opts ...ObjectOpt) (*ObjectInfo, error)
@ -142,17 +149,13 @@ var (

 // ObjectStoreConfig is the config for the object store.
 type ObjectStoreConfig struct {
-	Bucket      string        `json:"bucket"`
-	Description string        `json:"description,omitempty"`
-	TTL         time.Duration `json:"max_age,omitempty"`
-	MaxBytes    int64         `json:"max_bytes,omitempty"`
-	Storage     StorageType   `json:"storage,omitempty"`
-	Replicas    int           `json:"num_replicas,omitempty"`
-	Placement   *Placement    `json:"placement,omitempty"`
-
-	// Bucket-specific metadata
-	// NOTE: Metadata requires nats-server v2.10.0+
-	Metadata map[string]string `json:"metadata,omitempty"`
+	Bucket      string
+	Description string
+	TTL         time.Duration
+	MaxBytes    int64
+	Storage     StorageType
+	Replicas    int
+	Placement   *Placement
 }

 type ObjectStoreStatus interface {
@ -172,8 +175,6 @@ type ObjectStoreStatus interface {
 	Size() uint64
 	// BackingStore provides details about the underlying storage
 	BackingStore() string
-	// Metadata is the user supplied metadata for the bucket
-	Metadata() map[string]string
 }

 // ObjectMetaOptions
@ -184,10 +185,9 @@ type ObjectMetaOptions struct {

 // ObjectMeta is high level information about an object.
 type ObjectMeta struct {
-	Name        string            `json:"name"`
-	Description string            `json:"description,omitempty"`
-	Headers     Header            `json:"headers,omitempty"`
-	Metadata    map[string]string `json:"metadata,omitempty"`
+	Name        string `json:"name"`
+	Description string `json:"description,omitempty"`
+	Headers     Header `json:"headers,omitempty"`

 	// Optional options.
 	Opts *ObjectMetaOptions `json:"options,omitempty"`
@ -279,7 +279,6 @@ func (js *js) CreateObjectStore(cfg *ObjectStoreConfig) (ObjectStore, error) {
 		Discard:     DiscardNew,
 		AllowRollup: true,
 		AllowDirect: true,
-		Metadata:    cfg.Metadata,
 	}

 	// Create our stream.
@ -369,23 +368,14 @@ func (obs *obs) Put(meta *ObjectMeta, r io.Reader, opts ...ObjectOpt) (*ObjectIn
 		return perr
 	}

+	purgePartial := func() { obs.js.purgeStream(obs.stream, &StreamPurgeRequest{Subject: chunkSubj}) }
+
 	// Create our own JS context to handle errors etc.
-	jetStream, err := obs.js.nc.JetStream(PublishAsyncErrHandler(func(js JetStream, _ *Msg, err error) { setErr(err) }))
+	js, err := obs.js.nc.JetStream(PublishAsyncErrHandler(func(js JetStream, _ *Msg, err error) { setErr(err) }))
 	if err != nil {
 		return nil, err
 	}

-	defer jetStream.(*js).cleanupReplySub()
-
-	purgePartial := func() {
-		// wait until all pubs are complete or up to default timeout before attempting purge
-		select {
-		case <-jetStream.PublishAsyncComplete():
-		case <-time.After(obs.js.opts.wait):
-		}
-		obs.js.purgeStream(obs.stream, &StreamPurgeRequest{Subject: chunkSubj})
-	}
-
 	m, h := NewMsg(chunkSubj), sha256.New()
 	chunk, sent, total := make([]byte, meta.Opts.ChunkSize), 0, uint64(0)

@ -426,7 +416,7 @@ func (obs *obs) Put(meta *ObjectMeta, r io.Reader, opts ...ObjectOpt) (*ObjectIn
 			h.Write(m.Data)

 			// Send msg itself.
-			if _, err := jetStream.PublishMsgAsync(m); err != nil {
+			if _, err := js.PublishMsgAsync(m); err != nil {
 				purgePartial()
 				return nil, err
 			}
@ -461,7 +451,7 @@ func (obs *obs) Put(meta *ObjectMeta, r io.Reader, opts ...ObjectOpt) (*ObjectIn
 	}

 	// Publish the meta message.
-	_, err = jetStream.PublishMsgAsync(mm)
+	_, err = js.PublishMsgAsync(mm)
 	if err != nil {
 		if r != nil {
 			purgePartial()
@ -471,7 +461,7 @@ func (obs *obs) Put(meta *ObjectMeta, r io.Reader, opts ...ObjectOpt) (*ObjectIn

 	// Wait for all to be processed.
 	select {
-	case <-jetStream.PublishAsyncComplete():
+	case <-js.PublishAsyncComplete():
 		if err := getErr(); err != nil {
 			if r != nil {
 				purgePartial()
@ -622,7 +612,6 @@ func (obs *obs) Get(name string, opts ...GetObjectOpt) (ObjectResult, error) {
 	result.digest = sha256.New()

 	processChunk := func(m *Msg) {
-		var err error
 		if ctx != nil {
 			select {
 			case <-ctx.Done():
@ -639,7 +628,7 @@ func (obs *obs) Get(name string, opts ...GetObjectOpt) (ObjectResult, error) {
 			}
 		}

-		tokens, err := parser.GetMetadataFields(m.Reply)
+		tokens, err := getMetadataFields(m.Reply)
 		if err != nil {
 			gotErr(m, err)
 			return
@ -658,7 +647,7 @@ func (obs *obs) Get(name string, opts ...GetObjectOpt) (ObjectResult, error) {
 		result.digest.Write(m.Data)

 		// Check if we are done.
-		if tokens[parser.AckNumPendingTokenPos] == objNoPending {
+		if tokens[ackNumPendingTokenPos] == objNoPending {
 			pw.Close()
 			m.Sub.Unsubscribe()
 		}
@ -974,7 +963,6 @@ func (obs *obs) UpdateMeta(name string, meta *ObjectMeta) error {
 	info.Name = meta.Name
 	info.Description = meta.Description
 	info.Headers = meta.Headers
-	info.Metadata = meta.Metadata

 	// Prepare the meta message
 	if err = publishMeta(info, obs.js); err != nil {
@ -1057,8 +1045,6 @@ func (obs *obs) Watch(opts ...WatchOpt) (ObjectWatcher, error) {
 			w.updates <- &info
 		}

-		// if UpdatesOnly is set, no not send nil to the channel
-		// as it would always be triggered after initializing the watcher
 		if !initDoneMarker && meta.NumPending == 0 {
 			initDoneMarker = true
 			w.updates <- nil
@ -1067,17 +1053,9 @@ func (obs *obs) Watch(opts ...WatchOpt) (ObjectWatcher, error) {

 	allMeta := fmt.Sprintf(objAllMetaPreTmpl, obs.name)
 	_, err := obs.js.GetLastMsg(obs.stream, allMeta)
-	// if there are no messages on the stream and we are not watching
-	// updates only, send nil to the channel to indicate that the initial
-	// watch is done
-	if !o.updatesOnly {
-		if errors.Is(err, ErrMsgNotFound) {
-			initDoneMarker = true
-			w.updates <- nil
-		}
-	} else {
-		// if UpdatesOnly was used, mark initialization as complete
+	if err == ErrMsgNotFound {
 		initDoneMarker = true
+		w.updates <- nil
 	}

 	// Used ordered consumer to deliver results.
@ -1085,9 +1063,6 @@ func (obs *obs) Watch(opts ...WatchOpt) (ObjectWatcher, error) {
 	if !o.includeHistory {
 		subOpts = append(subOpts, DeliverLastPerSubject())
 	}
-	if o.updatesOnly {
-		subOpts = append(subOpts, DeliverNew())
-	}
 	sub, err := obs.js.Subscribe(allMeta, update, subOpts...)
 	if err != nil {
 		return nil, err
@ -1198,9 +1173,6 @@ func (s *ObjectBucketStatus) Size() uint64 { return s.nfo.State.Bytes }
 // BackingStore indicates what technology is used for storage of the bucket
 func (s *ObjectBucketStatus) BackingStore() string { return "JetStream" }

-// Metadata is the metadata supplied when creating the bucket
-func (s *ObjectBucketStatus) Metadata() map[string]string { return s.nfo.Config.Metadata }
-
 // StreamInfo is the stream info retrieved to create the status
 func (s *ObjectBucketStatus) StreamInfo() *StreamInfo { return s.nfo }

@ -1235,7 +1207,7 @@ func (o *objResult) Read(p []byte) (n int, err error) {
 		}
 	}
 	if o.err != nil {
-		return 0, o.err
+		return 0, err
 	}
 	if o.r == nil {
 		return 0, io.EOF
--- a/gateway/vendor/github.com/nats-io/nats.go/parser.go
+++ b/gateway/vendor/github.com/nats-io/nats.go/parser.go
@ -1,4 +1,4 @@
-// Copyright 2012-2023 The NATS Authors
+// Copyright 2012-2122 The NATS Authors
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
--- a/gateway/vendor/github.com/nats-io/nats.go/rand.go
+++ b/gateway/vendor/github.com/nats-io/nats.go/rand.go
@ -1,29 +0,0 @@
-// Copyright 2023 The NATS Authors
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-//go:build !go1.20
-// +build !go1.20
-
-// A Go client for the NATS messaging system (https://nats.io).
-package nats
-
-import (
-	"math/rand"
-	"time"
-)
-
-func init() {
-	// This is not needed since Go 1.20 because now rand.Seed always happens
-	// by default (uses runtime.fastrand64 instead as source).
-	rand.Seed(time.Now().UnixNano())
-}
--- a/gateway/vendor/github.com/nats-io/nats.go/testing_internal.go
+++ b/gateway/vendor/github.com/nats-io/nats.go/testing_internal.go
@ -1,59 +0,0 @@
-// Copyright 2023 The NATS Authors
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-//go:build internal_testing
-// +build internal_testing
-
-// Functions in this file are only available when building nats.go with the
-// internal_testing build tag. They are used by the nats.go test suite.
-package nats
-
-// AddMsgFilter adds a message filter for the given subject
-// to the connection. The filter will be called for each
-// message received on the subject. If the filter returns
-// nil, the message will be dropped.
-func (nc *Conn) AddMsgFilter(subject string, filter msgFilter) {
-	nc.subsMu.Lock()
-	defer nc.subsMu.Unlock()
-
-	if nc.filters == nil {
-		nc.filters = make(map[string]msgFilter)
-	}
-	nc.filters[subject] = filter
-}
-
-// RemoveMsgFilter removes a message filter for the given subject.
-func (nc *Conn) RemoveMsgFilter(subject string) {
-	nc.subsMu.Lock()
-	defer nc.subsMu.Unlock()
-
-	if nc.filters != nil {
-		delete(nc.filters, subject)
-		if len(nc.filters) == 0 {
-			nc.filters = nil
-		}
-	}
-}
-
-// IsJSControlMessage returns true if the message is a JetStream control message.
-func IsJSControlMessage(msg *Msg) (bool, int) {
-	return isJSControlMessage(msg)
-}
-
-// CloseTCPConn closes the underlying TCP connection.
-// It can be used to simulate a disconnect.
-func (nc *Conn) CloseTCPConn() {
-	nc.mu.Lock()
-	defer nc.mu.Unlock()
-	nc.conn.Close()
-}
--- a/gateway/vendor/github.com/nats-io/nats.go/ws.go
+++ b/gateway/vendor/github.com/nats-io/nats.go/ws.go
@ -1,4 +1,4 @@
-// Copyright 2021-2023 The NATS Authors
+// Copyright 2021-2022 The NATS Authors
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
@ -16,6 +16,7 @@ package nats
 import (
 	"bufio"
 	"bytes"
+	"compress/flate"
 	"crypto/rand"
 	"crypto/sha1"
 	"encoding/base64"
@ -29,8 +30,6 @@ import (
 	"strings"
 	"time"
 	"unicode/utf8"
-
-	"github.com/klauspost/compress/flate"
 )

 type wsOpCode int
@ -449,12 +448,8 @@ func (w *websocketWriter) Write(p []byte) (int, error) {
 			} else {
 				w.compressor.Reset(buf)
 			}
-			if n, err = w.compressor.Write(p); err != nil {
-				return n, err
-			}
-			if err = w.compressor.Flush(); err != nil {
-				return n, err
-			}
+			w.compressor.Write(p)
+			w.compressor.Close()
 			b := buf.Bytes()
 			p = b[:len(b)-4]
 		}
@ -555,7 +550,7 @@ func wsFillFrameHeader(fh []byte, compressed bool, frameType wsOpCode, l int) (i

 func (nc *Conn) wsInitHandshake(u *url.URL) error {
 	compress := nc.Opts.Compression
-	tlsRequired := u.Scheme == wsSchemeTLS || nc.Opts.Secure || nc.Opts.TLSConfig != nil || nc.Opts.TLSCertCB != nil || nc.Opts.RootCAsCB != nil
+	tlsRequired := u.Scheme == wsSchemeTLS || nc.Opts.Secure || nc.Opts.TLSConfig != nil
 	// Do TLS here as needed.
 	if tlsRequired {
 		if err := nc.makeTLSConn(); err != nil {
@ -697,9 +692,6 @@ func (nc *Conn) wsEnqueueCloseMsgLocked(status int, payload string) {
 	wr.cm = frame
 	wr.cmDone = true
 	nc.bw.flush()
-	if c := wr.compressor; c != nil {
-		c.Close()
-	}
 }

 func (nc *Conn) wsEnqueueControlMsg(needsLock bool, frameType wsOpCode, payload []byte) {
--- a/gateway/vendor/github.com/nats-io/nkeys/.gitignore
+++ b/gateway/vendor/github.com/nats-io/nkeys/.gitignore
@ -13,4 +13,3 @@ build/

 # Project-local glide cache, RE: https://github.com/Masterminds/glide/issues/736
 .glide/
-.idea/
--- a/gateway/vendor/github.com/nats-io/nkeys/.goreleaser.yml
+++ b/gateway/vendor/github.com/nats-io/nkeys/.goreleaser.yml
@ -6,45 +6,23 @@ release:
  name_template: '{{.Tag}}'
  draft: true
 builds:
-  - id: nk
-    main: ./nk/main.go
+  - main: ./nk/main.go
    ldflags: "-X main.Version={{.Tag}}_{{.Commit}}"
    binary: nk
    goos:
-      - darwin
      - linux
-      - windows
-      - freebsd
+      - darwin
    goarch:
      - amd64
-      - arm
-      - arm64
-      - 386
-      - mips64le
-      - s390x
-    goarm:
-      - 6
-      - 7
-    ignore:
-      - goos: darwin
-        goarch: 386
-      - goos: freebsd
-        goarch: arm
-      - goos: freebsd
-        goarch: arm64
-      - goos: freebsd
-        goarch: 386
+

 dist: build

-archives:
-  - name_template: '{{ .ProjectName }}-v{{ .Version }}-{{ .Os }}-{{ .Arch }}{{ if .Arm
+archive:
+  wrap_in_directory: true
+  name_template: '{{ .ProjectName }}-v{{ .Version }}-{{ .Os }}-{{ .Arch }}{{ if .Arm
    }}v{{ .Arm }}{{ end }}'
-    wrap_in_directory: true
-    format: zip
-    files:
-      - README.md
-      - LICENSE
+  format: zip

 checksum:
  name_template: '{{ .ProjectName }}-v{{ .Version }}-checksums.txt'
@ -52,12 +30,9 @@ checksum:
 snapshot:
  name_template: 'dev'

-nfpms:
-  - file_name_template: '{{ .ProjectName }}-v{{ .Version }}-{{ .Arch }}{{ if .Arm
-    }}v{{ .Arm }}{{ end }}'
-    maintainer: nats.io
-    description: NKeys utility cli program
-    vendor: nats-io
-    bindir: /usr/local/bin
-    formats:
-      - deb
+nfpm:
+  formats:
+    - deb
+  bindir: /usr/local/bin
+  description: NKeys utility cli program
+  vendor: nats-io
--- a/gateway/vendor/github.com/nats-io/nkeys/.travis.yml
+++ b/gateway/vendor/github.com/nats-io/nkeys/.travis.yml
@ -0,0 +1,35 @@
+language: go
+sudo: false
+
+arch:
+- amd64
+- ppc64le
+go:
+- 1.16.x
+- 1.15.x
+
+install:
+- go get -t ./...
+- go get github.com/mattn/goveralls
+- go get -u honnef.co/go/tools/cmd/staticcheck
+- go get -u github.com/client9/misspell/cmd/misspell
+
+before_script:
+- $(exit $(go fmt ./... | wc -l))
+- go vet ./...
+- misspell -error -locale US .
+- staticcheck ./...
+
+script:
+- go test -v
+- go test -v --race
+- go test -v -covermode=count -coverprofile=coverage.out
+- $HOME/gopath/bin/goveralls -coverprofile coverage.out -service travis-ci
+
+#deploy:
+#- provider: script
+#  skip_cleanup: true
+#  script: curl -sL http://git.io/goreleaser | bash
+#  on:
+#    tags: true
+#    condition: $TRAVIS_OS_NAME = linux
--- a/gateway/vendor/github.com/nats-io/nkeys/README.md
+++ b/gateway/vendor/github.com/nats-io/nkeys/README.md
@ -1,9 +1,9 @@
 # NKEYS

 [![License Apache 2](https://img.shields.io/badge/License-Apache2-blue.svg)](https://www.apache.org/licenses/LICENSE-2.0)
-[![Go Report Card](https://goreportcard.com/badge/github.com/nats-io/nkeys)](https://goreportcard.com/report/github.com/nats-io/nkeys)
-[![Build Status](https://app.travis-ci.com/nats-io/nkeys.svg?branch=master)](https://app.travis-ci.com/nats-io/nkeys)
-[![GoDoc](https://godoc.org/github.com/nats-io/nkeys?status.svg)](https://godoc.org/github.com/nats-io/nkeys)
+[![ReportCard](http://goreportcard.com/badge/nats-io/nkeys)](http://goreportcard.com/report/nats-io/nkeys)
+[![Build Status](https://travis-ci.com/nats-io/nkeys.svg?branch=master)](http://travis-ci.com/nats-io/nkeys)
+[![GoDoc](http://godoc.org/github.com/nats-io/nkeys?status.svg)](http://godoc.org/github.com/nats-io/nkeys)
 [![Coverage Status](https://coveralls.io/repos/github/nats-io/nkeys/badge.svg?branch=master&service=github)](https://coveralls.io/github/nats-io/nkeys?branch=master)

 A public-key signature system based on [Ed25519](https://ed25519.cr.yp.to/) for the NATS ecosystem.
--- a/gateway/vendor/github.com/nats-io/nkeys/crc16.go
+++ b/gateway/vendor/github.com/nats-io/nkeys/crc16.go
@ -13,8 +13,15 @@

 package nkeys

+import (
+	"errors"
+)
+
 // An implementation of crc16 according to CCITT standards for XMODEM.

+// ErrInvalidChecksum indicates a failed verification.
+var ErrInvalidChecksum = errors.New("nkeys: invalid checksum")
+
 var crc16tab = [256]uint16{
 	0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,
 	0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,
--- a/gateway/vendor/github.com/nats-io/nkeys/creds_utils.go
+++ b/gateway/vendor/github.com/nats-io/nkeys/creds_utils.go
@ -2,8 +2,8 @@ package nkeys

 import (
 	"bytes"
+	"errors"
 	"regexp"
-	"strings"
 )

 var userConfigRE = regexp.MustCompile(`\s*(?:(?:[-]{3,}.*[-]{3,}\r?\n)([\w\-.=]+)(?:\r?\n[-]{3,}.*[-]{3,}\r?\n))`)
@ -19,7 +19,7 @@ func ParseDecoratedJWT(contents []byte) (string, error) {
 	raw := items[0][1]
 	tmp := make([]byte, len(raw))
 	copy(tmp, raw)
-	return strings.TrimSpace(string(tmp)), nil
+	return string(tmp), nil
 }

 // ParseDecoratedNKey takes a creds file, finds the NKey portion and creates a
@ -42,12 +42,12 @@ func ParseDecoratedNKey(contents []byte) (KeyPair, error) {
 		}
 	}
 	if seed == nil {
-		return nil, ErrNoSeedFound
+		return nil, errors.New("no nkey seed found")
 	}
 	if !bytes.HasPrefix(seed, []byte("SO")) &&
 		!bytes.HasPrefix(seed, []byte("SA")) &&
 		!bytes.HasPrefix(seed, []byte("SU")) {
-		return nil, ErrInvalidNkeySeed
+		return nil, errors.New("doesn't contain a seed nkey")
 	}
 	kp, err := FromSeed(seed)
 	if err != nil {
@ -68,7 +68,7 @@ func ParseDecoratedUserNKey(contents []byte) (KeyPair, error) {
 		return nil, err
 	}
 	if !bytes.HasPrefix(seed, []byte("SU")) {
-		return nil, ErrInvalidUserSeed
+		return nil, errors.New("doesn't contain an user seed nkey")
 	}
 	kp, err := FromSeed(seed)
 	if err != nil {
--- a/gateway/vendor/github.com/nats-io/nkeys/dependencies.md
+++ b/gateway/vendor/github.com/nats-io/nkeys/dependencies.md
@ -1,12 +0,0 @@
-# External Dependencies
-
-This file lists the dependencies used in this repository.
-
-| Dependency | License |
-|-|-|
-| Go | BSD 3-Clause "New" or "Revised" License |
-| golang.org/x/crypto v0.3.0 | BSD 3-Clause "New" or "Revised" License |
-| golang.org/x/net v0.2.0 | BSD 3-Clause "New" or "Revised" License |
-| golang.org/x/sys v0.2.0 | BSD 3-Clause "New" or "Revised" License |
-| golang.org/x/term v0.2.0 | BSD 3-Clause "New" or "Revised" License |
-| golang.org/x/text v0.4.0 | BSD 3-Clause "New" or "Revised" License |
--- a/gateway/vendor/github.com/nats-io/nkeys/errors.go
+++ b/gateway/vendor/github.com/nats-io/nkeys/errors.go
@ -1,50 +0,0 @@
-// Copyright 2022 The NATS Authors
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package nkeys
-
-// Errors
-const (
-	ErrInvalidPrefixByte        = nkeysError("nkeys: invalid prefix byte")
-	ErrInvalidKey               = nkeysError("nkeys: invalid key")
-	ErrInvalidPublicKey         = nkeysError("nkeys: invalid public key")
-	ErrInvalidPrivateKey        = nkeysError("nkeys: invalid private key")
-	ErrInvalidSeedLen           = nkeysError("nkeys: invalid seed length")
-	ErrInvalidSeed              = nkeysError("nkeys: invalid seed")
-	ErrInvalidEncoding          = nkeysError("nkeys: invalid encoded key")
-	ErrInvalidSignature         = nkeysError("nkeys: signature verification failed")
-	ErrCannotSign               = nkeysError("nkeys: can not sign, no private key available")
-	ErrPublicKeyOnly            = nkeysError("nkeys: no seed or private key available")
-	ErrIncompatibleKey          = nkeysError("nkeys: incompatible key")
-	ErrInvalidChecksum          = nkeysError("nkeys: invalid checksum")
-	ErrNoSeedFound              = nkeysError("nkeys: no nkey seed found")
-	ErrInvalidNkeySeed          = nkeysError("nkeys: doesn't contain a seed nkey")
-	ErrInvalidUserSeed          = nkeysError("nkeys: doesn't contain an user seed nkey")
-	ErrInvalidRecipient         = nkeysError("nkeys: not a valid recipient public curve key")
-	ErrInvalidSender            = nkeysError("nkeys: not a valid sender public curve key")
-	ErrInvalidCurveKey          = nkeysError("nkeys: not a valid curve key")
-	ErrInvalidCurveSeed         = nkeysError("nkeys: not a valid curve seed")
-	ErrInvalidEncrypted         = nkeysError("nkeys: encrypted input is not valid")
-	ErrInvalidEncVersion        = nkeysError("nkeys: encrypted input wrong version")
-	ErrCouldNotDecrypt          = nkeysError("nkeys: could not decrypt input")
-	ErrInvalidCurveKeyOperation = nkeysError("nkeys: curve key is not valid for sign/verify")
-	ErrInvalidNKeyOperation     = nkeysError("nkeys: only curve key can seal/open")
-	ErrCannotOpen               = nkeysError("nkeys: cannot open no private curve key available")
-	ErrCannotSeal               = nkeysError("nkeys: cannot seal no private curve key available")
-)
-
-type nkeysError string
-
-func (e nkeysError) Error() string {
-	return string(e)
-}
--- a/gateway/vendor/github.com/nats-io/nkeys/keypair.go
+++ b/gateway/vendor/github.com/nats-io/nkeys/keypair.go
@ -1,4 +1,4 @@
-// Copyright 2018-2022 The NATS Authors
+// Copyright 2018 The NATS Authors
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
@ -26,25 +26,11 @@ type kp struct {
 	seed []byte
 }

-// All seeds are 32 bytes long.
-const seedLen = 32
-
-// CreatePair will create a KeyPair based on the rand entropy and a type/prefix byte.
+// CreatePair will create a KeyPair based on the rand entropy and a type/prefix byte. rand can be nil.
 func CreatePair(prefix PrefixByte) (KeyPair, error) {
-	return CreatePairWithRand(prefix, rand.Reader)
-}
+	var rawSeed [32]byte

-// CreatePair will create a KeyPair based on the rand reader and a type/prefix byte. rand can be nil.
-func CreatePairWithRand(prefix PrefixByte, rr io.Reader) (KeyPair, error) {
-	if prefix == PrefixByteCurve {
-		return CreateCurveKeysWithRand(rr)
-	}
-	if rr == nil {
-		rr = rand.Reader
-	}
-	var rawSeed [seedLen]byte
-
-	_, err := io.ReadFull(rr, rawSeed[:])
+	_, err := io.ReadFull(rand.Reader, rawSeed[:])
 	if err != nil {
 		return nil, err
 	}
@ -129,18 +115,3 @@ func (pair *kp) Verify(input []byte, sig []byte) error {
 	}
 	return nil
 }
-
-// Seal is only supported on CurveKeyPair
-func (pair *kp) Seal(input []byte, recipient string) ([]byte, error) {
-	return nil, ErrInvalidNKeyOperation
-}
-
-// SealWithRand is only supported on CurveKeyPair
-func (pair *kp) SealWithRand(input []byte, recipient string, rr io.Reader) ([]byte, error) {
-	return nil, ErrInvalidNKeyOperation
-}
-
-// Open is only supported on CurveKey
-func (pair *kp) Open(input []byte, sender string) ([]byte, error) {
-	return nil, ErrInvalidNKeyOperation
-}
--- a/gateway/vendor/github.com/nats-io/nkeys/nkeys.go
+++ b/gateway/vendor/github.com/nats-io/nkeys/nkeys.go
@ -13,30 +13,37 @@

 // Package nkeys is an Ed25519 based public-key signature system that simplifies keys and seeds
 // and performs signing and verification.
-// It also supports encryption via x25519 keys and is compatible with https://pkg.go.dev/golang.org/x/crypto/nacl/box.
 package nkeys

-import "io"
+import (
+	"errors"
+)

 // Version is our current version
-const Version = "0.4.5"
+const Version = "0.3.0"
+
+// Errors
+var (
+	ErrInvalidPrefixByte = errors.New("nkeys: invalid prefix byte")
+	ErrInvalidKey        = errors.New("nkeys: invalid key")
+	ErrInvalidPublicKey  = errors.New("nkeys: invalid public key")
+	ErrInvalidSeedLen    = errors.New("nkeys: invalid seed length")
+	ErrInvalidSeed       = errors.New("nkeys: invalid seed")
+	ErrInvalidEncoding   = errors.New("nkeys: invalid encoded key")
+	ErrInvalidSignature  = errors.New("nkeys: signature verification failed")
+	ErrCannotSign        = errors.New("nkeys: can not sign, no private key available")
+	ErrPublicKeyOnly     = errors.New("nkeys: no seed or private key available")
+	ErrIncompatibleKey   = errors.New("nkeys: incompatible key")
+)

 // KeyPair provides the central interface to nkeys.
 type KeyPair interface {
 	Seed() ([]byte, error)
 	PublicKey() (string, error)
 	PrivateKey() ([]byte, error)
-	// Sign is only supported on Non CurveKeyPairs
 	Sign(input []byte) ([]byte, error)
-	// Verify is only supported on Non CurveKeyPairs
 	Verify(input []byte, sig []byte) error
 	Wipe()
-	// Seal is only supported on CurveKeyPair
-	Seal(input []byte, recipient string) ([]byte, error)
-	// SealWithRand is only supported on CurveKeyPair
-	SealWithRand(input []byte, recipient string, rr io.Reader) ([]byte, error)
-	// Open is only supported on CurveKey
-	Open(input []byte, sender string) ([]byte, error)
 }

 // CreateUser will create a User typed KeyPair.
@ -79,13 +86,10 @@ func FromPublicKey(public string) (KeyPair, error) {

 // FromSeed will create a KeyPair capable of signing and verifying signatures.
 func FromSeed(seed []byte) (KeyPair, error) {
-	prefix, _, err := DecodeSeed(seed)
+	_, _, err := DecodeSeed(seed)
 	if err != nil {
 		return nil, err
 	}
-	if prefix == PrefixByteCurve {
-		return FromCurveSeed(seed)
-	}
 	copy := append([]byte{}, seed...)
 	return &kp{copy}, nil
 }
--- a/gateway/vendor/github.com/nats-io/nkeys/public.go
+++ b/gateway/vendor/github.com/nats-io/nkeys/public.go
@ -64,23 +64,3 @@ func (p *pub) Wipe() {
 	p.pre = '0'
 	io.ReadFull(rand.Reader, p.pub)
 }
-
-func (p *pub) Seal(input []byte, recipient string) ([]byte, error) {
-	if p.pre == PrefixByteCurve {
-		return nil, ErrCannotSeal
-	}
-	return nil, ErrInvalidNKeyOperation
-}
-func (p *pub) SealWithRand(input []byte, _recipient string, rr io.Reader) ([]byte, error) {
-	if p.pre == PrefixByteCurve {
-		return nil, ErrCannotSeal
-	}
-	return nil, ErrInvalidNKeyOperation
-}
-
-func (p *pub) Open(input []byte, sender string) ([]byte, error) {
-	if p.pre == PrefixByteCurve {
-		return nil, ErrCannotOpen
-	}
-	return nil, ErrInvalidNKeyOperation
-}
--- a/gateway/vendor/github.com/nats-io/nkeys/strkey.go
+++ b/gateway/vendor/github.com/nats-io/nkeys/strkey.go
@ -1,4 +1,4 @@
-// Copyright 2018-2023 The NATS Authors
+// Copyright 2018 The NATS Authors
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
@ -17,6 +17,7 @@ import (
 	"bytes"
 	"encoding/base32"
 	"encoding/binary"
+	"golang.org/x/crypto/ed25519"
 )

 // PrefixByte is a lead byte representing the type.
@ -44,11 +45,8 @@ const (
 	// PrefixByteUser is the version byte used for encoded NATS Users
 	PrefixByteUser PrefixByte = 20 << 3 // Base32-encodes to 'U...'

-	// PrefixByteCurve is the version byte used for encoded CurveKeys (X25519)
-	PrefixByteCurve PrefixByte = 23 << 3 // Base32-encodes to 'X...'
-
 	// PrefixByteUnknown is for unknown prefixes.
-	PrefixByteUnknown PrefixByte = 25 << 3 // Base32-encodes to 'Z...'
+	PrefixByteUnknown PrefixByte = 23 << 3 // Base32-encodes to 'X...'
 )

 // Set our encoding to not include padding '=='
@ -85,13 +83,12 @@ func Encode(prefix PrefixByte, src []byte) ([]byte, error) {
 }

 // EncodeSeed will encode a raw key with the prefix and then seed prefix and crc16 and then base32 encoded.
-// `src` must be 32 bytes long (ed25519.SeedSize).
 func EncodeSeed(public PrefixByte, src []byte) ([]byte, error) {
 	if err := checkValidPublicPrefixByte(public); err != nil {
 		return nil, err
 	}

-	if len(src) != seedLen {
+	if len(src) != ed25519.SeedSize {
 		return nil, ErrInvalidSeedLen
 	}

@ -137,18 +134,22 @@ func decode(src []byte) ([]byte, error) {
 	}
 	raw = raw[:n]

-	if n < 4 {
+	if len(raw) < 4 {
 		return nil, ErrInvalidEncoding
 	}

-	crc := binary.LittleEndian.Uint16(raw[n-2:])
-
-	// ensure checksum is valid
-	if err := validate(raw[0:n-2], crc); err != nil {
+	var crc uint16
+	checksum := bytes.NewReader(raw[len(raw)-2:])
+	if err := binary.Read(checksum, binary.LittleEndian, &crc); err != nil {
 		return nil, err
 	}

-	return raw[:n-2], nil
+	// ensure checksum is valid
+	if err := validate(raw[0:len(raw)-2], crc); err != nil {
+		return nil, err
+	}
+
+	return raw[:len(raw)-2], nil
 }

 // Decode will decode the base32 string and check crc16 and enforce the prefix is what is expected.
@ -160,8 +161,7 @@ func Decode(expectedPrefix PrefixByte, src []byte) ([]byte, error) {
 	if err != nil {
 		return nil, err
 	}
-	b1 := raw[0] & 248 // 248 = 11111000
-	if prefix := PrefixByte(b1); prefix != expectedPrefix {
+	if prefix := PrefixByte(raw[0]); prefix != expectedPrefix {
 		return nil, ErrInvalidPrefixByte
 	}
 	return raw[1:], nil
@ -248,18 +248,12 @@ func IsValidPublicOperatorKey(src string) bool {
 	return err == nil
 }

-// IsValidPublicCurveKey will decode and verify the string is a valid encoded Public Curve Key.
-func IsValidPublicCurveKey(src string) bool {
-	_, err := Decode(PrefixByteCurve, []byte(src))
-	return err == nil
-}
-
 // checkValidPrefixByte returns an error if the provided value
 // is not one of the defined valid prefix byte constants.
 func checkValidPrefixByte(prefix PrefixByte) error {
 	switch prefix {
 	case PrefixByteOperator, PrefixByteServer, PrefixByteCluster,
-		PrefixByteAccount, PrefixByteUser, PrefixByteSeed, PrefixBytePrivate, PrefixByteCurve:
+		PrefixByteAccount, PrefixByteUser, PrefixByteSeed, PrefixBytePrivate:
 		return nil
 	}
 	return ErrInvalidPrefixByte
@ -269,7 +263,7 @@ func checkValidPrefixByte(prefix PrefixByte) error {
 // is not one of the public defined valid prefix byte constants.
 func checkValidPublicPrefixByte(prefix PrefixByte) error {
 	switch prefix {
-	case PrefixByteOperator, PrefixByteServer, PrefixByteCluster, PrefixByteAccount, PrefixByteUser, PrefixByteCurve:
+	case PrefixByteServer, PrefixByteCluster, PrefixByteOperator, PrefixByteAccount, PrefixByteUser:
 		return nil
 	}
 	return ErrInvalidPrefixByte
@ -291,8 +285,6 @@ func (p PrefixByte) String() string {
 		return "seed"
 	case PrefixBytePrivate:
 		return "private"
-	case PrefixByteCurve:
-		return "x25519"
 	}
 	return "unknown"
 }
--- a/gateway/vendor/github.com/nats-io/nkeys/xkeys.go
+++ b/gateway/vendor/github.com/nats-io/nkeys/xkeys.go
@ -1,184 +0,0 @@
-// Copyright 2022 The NATS Authors
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package nkeys
-
-import (
-	"bytes"
-	"crypto/rand"
-	"encoding/binary"
-	"io"
-
-	"golang.org/x/crypto/curve25519"
-	"golang.org/x/crypto/nacl/box"
-)
-
-// This package will support safe use of X25519 keys for asymmetric encryption.
-// We will be compatible with nacl.Box, but generate random nonces automatically.
-// We may add more advanced options in the future for group recipients and better
-// end to end algorithms.
-
-const (
-	curveKeyLen    = 32
-	curveDecodeLen = 35
-	curveNonceLen  = 24
-)
-
-type ckp struct {
-	seed [curveKeyLen]byte // Private raw key.
-}
-
-// CreateUser will create a User typed KeyPair.
-func CreateCurveKeys() (KeyPair, error) {
-	return CreateCurveKeysWithRand(rand.Reader)
-}
-
-// CreateUser will create a User typed KeyPair with specified rand source.
-func CreateCurveKeysWithRand(rr io.Reader) (KeyPair, error) {
-	var kp ckp
-	_, err := io.ReadFull(rr, kp.seed[:])
-	if err != nil {
-		return nil, err
-	}
-	return &kp, nil
-}
-
-// Will create a curve key pair from seed.
-func FromCurveSeed(seed []byte) (KeyPair, error) {
-	pb, raw, err := DecodeSeed(seed)
-	if err != nil {
-		return nil, err
-	}
-	if pb != PrefixByteCurve || len(raw) != curveKeyLen {
-		return nil, ErrInvalidCurveSeed
-	}
-	var kp ckp
-	copy(kp.seed[:], raw)
-	return &kp, nil
-}
-
-// Seed will return the encoded seed.
-func (pair *ckp) Seed() ([]byte, error) {
-	return EncodeSeed(PrefixByteCurve, pair.seed[:])
-}
-
-// PublicKey will return the encoded public key.
-func (pair *ckp) PublicKey() (string, error) {
-	var pub [curveKeyLen]byte
-	curve25519.ScalarBaseMult(&pub, &pair.seed)
-	key, err := Encode(PrefixByteCurve, pub[:])
-	return string(key), err
-}
-
-// PrivateKey will return the encoded private key.
-func (pair *ckp) PrivateKey() ([]byte, error) {
-	return Encode(PrefixBytePrivate, pair.seed[:])
-}
-
-func decodePubCurveKey(src string, dest [curveKeyLen]byte) error {
-	var raw [curveDecodeLen]byte // should always be 35
-	n, err := b32Enc.Decode(raw[:], []byte(src))
-	if err != nil {
-		return err
-	}
-	if n != curveDecodeLen {
-		return ErrInvalidCurveKey
-	}
-	// Make sure it is what we expected.
-	if prefix := PrefixByte(raw[0]); prefix != PrefixByteCurve {
-		return ErrInvalidPublicKey
-	}
-	var crc uint16
-	end := n - 2
-	sum := raw[end:n]
-	checksum := bytes.NewReader(sum)
-	if err := binary.Read(checksum, binary.LittleEndian, &crc); err != nil {
-		return err
-	}
-
-	// ensure checksum is valid
-	if err := validate(raw[:end], crc); err != nil {
-		return err
-	}
-
-	// Copy over, ignore prefix byte.
-	copy(dest[:], raw[1:end])
-	return nil
-}
-
-// Only version for now, but could add in X3DH in the future, etc.
-const XKeyVersionV1 = "xkv1"
-const vlen = len(XKeyVersionV1)
-
-// Seal is compatible with nacl.Box.Seal() and can be used in similar situations for small messages.
-// We generate the nonce from crypto rand by default.
-func (pair *ckp) Seal(input []byte, recipient string) ([]byte, error) {
-	return pair.SealWithRand(input, recipient, rand.Reader)
-}
-
-func (pair *ckp) SealWithRand(input []byte, recipient string, rr io.Reader) ([]byte, error) {
-	var (
-		rpub  [curveKeyLen]byte
-		nonce [curveNonceLen]byte
-		out   [vlen + curveNonceLen]byte
-		err   error
-	)
-
-	if err = decodePubCurveKey(recipient, rpub); err != nil {
-		return nil, ErrInvalidRecipient
-	}
-	if _, err := io.ReadFull(rr, nonce[:]); err != nil {
-		return nil, err
-	}
-	copy(out[:vlen], []byte(XKeyVersionV1))
-	copy(out[vlen:], nonce[:])
-	return box.Seal(out[:], input, &nonce, &rpub, &pair.seed), nil
-}
-
-func (pair *ckp) Open(input []byte, sender string) ([]byte, error) {
-	if len(input) <= vlen+curveNonceLen {
-		return nil, ErrInvalidEncrypted
-	}
-	var (
-		spub  [curveKeyLen]byte
-		nonce [curveNonceLen]byte
-		err   error
-	)
-	if !bytes.Equal(input[:vlen], []byte(XKeyVersionV1)) {
-		return nil, ErrInvalidEncVersion
-	}
-	copy(nonce[:], input[vlen:vlen+curveNonceLen])
-
-	if err = decodePubCurveKey(sender, spub); err != nil {
-		return nil, ErrInvalidSender
-	}
-
-	decrypted, ok := box.Open(nil, input[vlen+curveNonceLen:], &nonce, &spub, &pair.seed)
-	if !ok {
-		return nil, ErrCouldNotDecrypt
-	}
-	return decrypted, nil
-}
-
-// Wipe will randomize the contents of the secret key
-func (pair *ckp) Wipe() {
-	io.ReadFull(rand.Reader, pair.seed[:])
-}
-
-func (pair *ckp) Sign(_ []byte) ([]byte, error) {
-	return nil, ErrInvalidCurveKeyOperation
-}
-
-func (pair *ckp) Verify(_ []byte, _ []byte) error {
-	return ErrInvalidCurveKeyOperation
-}
--- a/gateway/vendor/github.com/openfaas/faas-provider/types/config.go
+++ b/gateway/vendor/github.com/openfaas/faas-provider/types/config.go
@ -12,42 +12,27 @@ const (

 // FaaSHandlers provide handlers for OpenFaaS
 type FaaSHandlers struct {
-	// ListNamespace lists namespaces which are annotated for OpenFaaS
-	ListNamespaces http.HandlerFunc
-
-	// MutateNamespace mutates a namespace to be annotated for OpenFaaS
-	// each namespace must contain an annotation of "openfaas=1"
-	MutateNamespace http.HandlerFunc
-
 	// FunctionProxy provides the function invocation proxy logic.  Use proxy.NewHandlerFunc to
 	// use the standard OpenFaaS proxy implementation or provide completely custom proxy logic.
 	FunctionProxy http.HandlerFunc

-	// FunctionLister lists deployed functions within a namespace
-	FunctionLister http.HandlerFunc
+	FunctionReader http.HandlerFunc
+	DeployHandler  http.HandlerFunc

-	// DeployFunction deploys a function which doesn't exist
-	DeployFunction http.HandlerFunc
+	DeleteHandler  http.HandlerFunc
+	ReplicaReader  http.HandlerFunc
+	ReplicaUpdater http.HandlerFunc
+	SecretHandler  http.HandlerFunc
+	// LogHandler provides streaming json logs of functions
+	LogHandler http.HandlerFunc

-	// UpdateFunction updates an existing function
-	UpdateFunction http.HandlerFunc
-
-	DeleteFunction http.HandlerFunc
-
-	FunctionStatus http.HandlerFunc
-
-	ScaleFunction http.HandlerFunc
-
-	Secrets http.HandlerFunc
-
-	// Logs provides streaming json logs of functions
-	Logs http.HandlerFunc
-
-	// Health defines the default health endpoint bound to "/healthz
+	// UpdateHandler an existing function/service
+	UpdateHandler http.HandlerFunc
+	// HealthHandler defines the default health endpoint bound to "/healthz
 	// If the handler is not set, then the "/healthz" path will not be configured
-	Health http.HandlerFunc
-
-	Info http.HandlerFunc
+	HealthHandler        http.HandlerFunc
+	InfoHandler          http.HandlerFunc
+	ListNamespaceHandler http.HandlerFunc
 }

 // FaaSConfig set config for HTTP handlers
--- a/gateway/vendor/github.com/openfaas/faas-provider/types/queue.go
+++ b/gateway/vendor/github.com/openfaas/faas-provider/types/queue.go
@ -8,36 +8,32 @@ import (
 // Request for asynchronous processing
 type QueueRequest struct {
 	// Header from HTTP request
-	Header http.Header `json:"Header,omitempty"`
+	Header http.Header

 	// Host from HTTP request
-	Host string `json:"Host,omitempty"`
+	Host string

 	// Body from HTTP request to use for invocation
-	Body []byte `json:"Body,omitempty"`
+	Body []byte

 	// Method from HTTP request
-	Method string `json:"Method"`
+	Method string

 	// Path from HTTP request
-	Path string `json:"Path,omitempty"`
+	Path string

 	// QueryString from HTTP request
-	QueryString string `json:"QueryString,omitempty"`
+	QueryString string

 	// Function name to invoke
-	Function string `json:"Function"`
+	Function string

 	// QueueName to publish the request to, leave blank
 	// for default.
-	QueueName string `json:"QueueName,omitempty"`
-
-	// Annotations defines a collection of meta-data that can be used by
-	// the queue worker when processing the queued request.
-	Annotations map[string]string `json:"Annotations,omitempty"`
+	QueueName string

 	// Used by queue worker to submit a result
-	CallbackURL *url.URL `json:"CallbackUrl,omitempty"`
+	CallbackURL *url.URL `json:"CallbackUrl"`
 }

 // RequestQueuer can public a request to be executed asynchronously
--- a/gateway/vendor/github.com/openfaas/faas-provider/types/read_config.go
+++ b/gateway/vendor/github.com/openfaas/faas-provider/types/read_config.go
@ -1,7 +1,6 @@
 package types

 import (
-	"errors"
 	"fmt"
 	"os"
 	"strconv"
@ -56,26 +55,6 @@ func ParseIntOrDurationValue(val string, fallback time.Duration) time.Duration {
 	return duration
 }

-// ParseIntOrDurationValue interprets a string representing an int or duration and returns
-// an int as the number of seconds. An error is returned if val can not be parsed as int or duration.
-func ParseIntOrDuration(val string) (int, error) {
-	i, err := strconv.ParseInt(val, 10, 0)
-	if err == nil {
-		return int(i), nil
-	}
-
-	if err != nil && errors.Is(err, strconv.ErrRange) {
-		return int(i), err
-	}
-
-	d, err := time.ParseDuration(val)
-	if err != nil {
-		return 0, err
-	}
-
-	return int(d.Seconds()), nil
-}
-
 // ParseBoolValue parses the the boolean in val or, if there is an error, returns the
 // specified default value
 func ParseBoolValue(val string, fallback bool) bool {
--- a/gateway/vendor/github.com/openfaas/faas-provider/types/requests.go
+++ b/gateway/vendor/github.com/openfaas/faas-provider/types/requests.go
@ -3,17 +3,15 @@

 package types

-// ScaleServiceRequest scales the service to the requested replica count.
+// ScaleServiceRequest scales the service to the requested replcia count.
 type ScaleServiceRequest struct {
 	ServiceName string `json:"serviceName"`
 	Replicas    uint64 `json:"replicas"`
-	Namespace   string `json:"namespace,omitempty"`
 }

 // DeleteFunctionRequest delete a deployed function
 type DeleteFunctionRequest struct {
 	FunctionName string `json:"functionName"`
-	Namespace    string `json:"namespace,omitempty"`
 }

 // ProviderInfo provides information about the configured provider
@ -29,11 +27,3 @@ type VersionInfo struct {
 	SHA           string `json:"sha"`
 	Release       string `json:"release"`
 }
-
-// FunctionNamespace is the namespace for a function
-type FunctionNamespace struct {
-	Name string `json:"name"`
-
-	Annotations map[string]string `json:"annotations,omitempty"`
-	Labels      map[string]string `json:"labels,omitempty"`
-}
--- a/gateway/vendor/github.com/prometheus/client_golang/prometheus/counter.go
+++ b/gateway/vendor/github.com/prometheus/client_golang/prometheus/counter.go
@ -20,7 +20,6 @@ import (
 	"time"

 	dto "github.com/prometheus/client_model/go"
-	"google.golang.org/protobuf/types/known/timestamppb"
 )

 // Counter is a Metric that represents a single numerical value that only ever
@ -60,18 +59,6 @@ type ExemplarAdder interface {
 // CounterOpts is an alias for Opts. See there for doc comments.
 type CounterOpts Opts

-// CounterVecOpts bundles the options to create a CounterVec metric.
-// It is mandatory to set CounterOpts, see there for mandatory fields. VariableLabels
-// is optional and can safely be left to its default value.
-type CounterVecOpts struct {
-	CounterOpts
-
-	// VariableLabels are used to partition the metric vector by the given set
-	// of labels. Each label value will be constrained with the optional Constraint
-	// function, if provided.
-	VariableLabels ConstrainableLabels
-}
-
 // NewCounter creates a new Counter based on the provided CounterOpts.
 //
 // The returned implementation also implements ExemplarAdder. It is safe to
@ -91,12 +78,8 @@ func NewCounter(opts CounterOpts) Counter {
 		nil,
 		opts.ConstLabels,
 	)
-	if opts.now == nil {
-		opts.now = time.Now
-	}
-	result := &counter{desc: desc, labelPairs: desc.constLabelPairs, now: opts.now}
+	result := &counter{desc: desc, labelPairs: desc.constLabelPairs, now: time.Now}
 	result.init(result) // Init self-collection.
-	result.createdTs = timestamppb.New(opts.now())
 	return result
 }

@ -111,12 +94,10 @@ type counter struct {
 	selfCollector
 	desc *Desc

-	createdTs  *timestamppb.Timestamp
 	labelPairs []*dto.LabelPair
 	exemplar   atomic.Value // Containing nil or a *dto.Exemplar.

-	// now is for testing purposes, by default it's time.Now.
-	now func() time.Time
+	now func() time.Time // To mock out time.Now() for testing.
 }

 func (c *counter) Desc() *Desc {
@ -159,14 +140,14 @@ func (c *counter) get() float64 {
 }

 func (c *counter) Write(out *dto.Metric) error {
-	// Read the Exemplar first and the value second. This is to avoid a race condition
-	// where users see an exemplar for a not-yet-existing observation.
+	val := c.get()
+
 	var exemplar *dto.Exemplar
 	if e := c.exemplar.Load(); e != nil {
 		exemplar = e.(*dto.Exemplar)
 	}
-	val := c.get()
-	return populateMetric(CounterValue, val, c.labelPairs, exemplar, out, c.createdTs)
+
+	return populateMetric(CounterValue, val, c.labelPairs, exemplar, out)
 }

 func (c *counter) updateExemplar(v float64, l Labels) {
@ -192,31 +173,19 @@ type CounterVec struct {
 // NewCounterVec creates a new CounterVec based on the provided CounterOpts and
 // partitioned by the given label names.
 func NewCounterVec(opts CounterOpts, labelNames []string) *CounterVec {
-	return V2.NewCounterVec(CounterVecOpts{
-		CounterOpts:    opts,
-		VariableLabels: UnconstrainedLabels(labelNames),
-	})
-}
-
-// NewCounterVec creates a new CounterVec based on the provided CounterVecOpts.
-func (v2) NewCounterVec(opts CounterVecOpts) *CounterVec {
-	desc := V2.NewDesc(
+	desc := NewDesc(
 		BuildFQName(opts.Namespace, opts.Subsystem, opts.Name),
 		opts.Help,
-		opts.VariableLabels,
+		labelNames,
 		opts.ConstLabels,
 	)
-	if opts.now == nil {
-		opts.now = time.Now
-	}
 	return &CounterVec{
 		MetricVec: NewMetricVec(desc, func(lvs ...string) Metric {
-			if len(lvs) != len(desc.variableLabels.names) {
-				panic(makeInconsistentCardinalityError(desc.fqName, desc.variableLabels.names, lvs))
+			if len(lvs) != len(desc.variableLabels) {
+				panic(makeInconsistentCardinalityError(desc.fqName, desc.variableLabels, lvs))
 			}
-			result := &counter{desc: desc, labelPairs: MakeLabelPairs(desc, lvs), now: opts.now}
+			result := &counter{desc: desc, labelPairs: MakeLabelPairs(desc, lvs), now: time.Now}
 			result.init(result) // Init self-collection.
-			result.createdTs = timestamppb.New(opts.now())
 			return result
 		}),
 	}
@ -276,8 +245,7 @@ func (v *CounterVec) GetMetricWith(labels Labels) (Counter, error) {
 // WithLabelValues works as GetMetricWithLabelValues, but panics where
 // GetMetricWithLabelValues would have returned an error. Not returning an
 // error allows shortcuts like
-//
-//	myVec.WithLabelValues("404", "GET").Add(42)
+//     myVec.WithLabelValues("404", "GET").Add(42)
 func (v *CounterVec) WithLabelValues(lvs ...string) Counter {
 	c, err := v.GetMetricWithLabelValues(lvs...)
 	if err != nil {
@ -288,8 +256,7 @@ func (v *CounterVec) WithLabelValues(lvs ...string) Counter {

 // With works as GetMetricWith, but panics where GetMetricWithLabels would have
 // returned an error. Not returning an error allows shortcuts like
-//
-//	myVec.With(prometheus.Labels{"code": "404", "method": "GET"}).Add(42)
+//     myVec.With(prometheus.Labels{"code": "404", "method": "GET"}).Add(42)
 func (v *CounterVec) With(labels Labels) Counter {
 	c, err := v.GetMetricWith(labels)
 	if err != nil {
--- a/gateway/vendor/github.com/prometheus/client_golang/prometheus/desc.go
+++ b/gateway/vendor/github.com/prometheus/client_golang/prometheus/desc.go
@ -14,16 +14,20 @@
 package prometheus

 import (
+	"errors"
 	"fmt"
 	"sort"
 	"strings"

 	"github.com/cespare/xxhash/v2"
-	dto "github.com/prometheus/client_model/go"
-	"github.com/prometheus/common/model"
-	"google.golang.org/protobuf/proto"

 	"github.com/prometheus/client_golang/prometheus/internal"
+
+	//nolint:staticcheck // Ignore SA1019. Need to keep deprecated package for compatibility.
+	"github.com/golang/protobuf/proto"
+	"github.com/prometheus/common/model"
+
+	dto "github.com/prometheus/client_model/go"
 )

 // Desc is the descriptor used by every Prometheus Metric. It is essentially
@ -50,9 +54,9 @@ type Desc struct {
 	// constLabelPairs contains precalculated DTO label pairs based on
 	// the constant labels.
 	constLabelPairs []*dto.LabelPair
-	// variableLabels contains names of labels and normalization function for
-	// which the metric maintains variable values.
-	variableLabels *compiledLabels
+	// variableLabels contains names of labels for which the metric
+	// maintains variable values.
+	variableLabels []string
 	// id is a hash of the values of the ConstLabels and fqName. This
 	// must be unique among all registered descriptors and can therefore be
 	// used as an identifier of the descriptor.
@ -76,24 +80,10 @@ type Desc struct {
 // For constLabels, the label values are constant. Therefore, they are fully
 // specified in the Desc. See the Collector example for a usage pattern.
 func NewDesc(fqName, help string, variableLabels []string, constLabels Labels) *Desc {
-	return V2.NewDesc(fqName, help, UnconstrainedLabels(variableLabels), constLabels)
-}
-
-// NewDesc allocates and initializes a new Desc. Errors are recorded in the Desc
-// and will be reported on registration time. variableLabels and constLabels can
-// be nil if no such labels should be set. fqName must not be empty.
-//
-// variableLabels only contain the label names and normalization functions. Their
-// label values are variable and therefore not part of the Desc. (They are managed
-// within the Metric.)
-//
-// For constLabels, the label values are constant. Therefore, they are fully
-// specified in the Desc. See the Collector example for a usage pattern.
-func (v2) NewDesc(fqName, help string, variableLabels ConstrainableLabels, constLabels Labels) *Desc {
 	d := &Desc{
 		fqName:         fqName,
 		help:           help,
-		variableLabels: variableLabels.compile(),
+		variableLabels: variableLabels,
 	}
 	if !model.IsValidMetricName(model.LabelValue(fqName)) {
 		d.err = fmt.Errorf("%q is not a valid metric name", fqName)
@ -103,7 +93,7 @@ func (v2) NewDesc(fqName, help string, variableLabels ConstrainableLabels, const
 	// their sorted label names) plus the fqName (at position 0).
 	labelValues := make([]string, 1, len(constLabels)+1)
 	labelValues[0] = fqName
-	labelNames := make([]string, 0, len(constLabels)+len(d.variableLabels.names))
+	labelNames := make([]string, 0, len(constLabels)+len(variableLabels))
 	labelNameSet := map[string]struct{}{}
 	// First add only the const label names and sort them...
 	for labelName := range constLabels {
@ -128,16 +118,16 @@ func (v2) NewDesc(fqName, help string, variableLabels ConstrainableLabels, const
 	// Now add the variable label names, but prefix them with something that
 	// cannot be in a regular label name. That prevents matching the label
 	// dimension with a different mix between preset and variable labels.
-	for _, label := range d.variableLabels.names {
-		if !checkLabelName(label) {
-			d.err = fmt.Errorf("%q is not a valid label name for metric %q", label, fqName)
+	for _, labelName := range variableLabels {
+		if !checkLabelName(labelName) {
+			d.err = fmt.Errorf("%q is not a valid label name for metric %q", labelName, fqName)
 			return d
 		}
-		labelNames = append(labelNames, "$"+label)
-		labelNameSet[label] = struct{}{}
+		labelNames = append(labelNames, "$"+labelName)
+		labelNameSet[labelName] = struct{}{}
 	}
 	if len(labelNames) != len(labelNameSet) {
-		d.err = fmt.Errorf("duplicate label names in constant and variable labels for metric %q", fqName)
+		d.err = errors.New("duplicate label names")
 		return d
 	}

@ -189,19 +179,11 @@ func (d *Desc) String() string {
 			fmt.Sprintf("%s=%q", lp.GetName(), lp.GetValue()),
 		)
 	}
-	vlStrings := make([]string, 0, len(d.variableLabels.names))
-	for _, vl := range d.variableLabels.names {
-		if fn, ok := d.variableLabels.labelConstraints[vl]; ok && fn != nil {
-			vlStrings = append(vlStrings, fmt.Sprintf("c(%s)", vl))
-		} else {
-			vlStrings = append(vlStrings, vl)
-		}
-	}
 	return fmt.Sprintf(
-		"Desc{fqName: %q, help: %q, constLabels: {%s}, variableLabels: {%s}}",
+		"Desc{fqName: %q, help: %q, constLabels: {%s}, variableLabels: %v}",
 		d.fqName,
 		d.help,
 		strings.Join(lpStrings, ","),
-		strings.Join(vlStrings, ","),
+		d.variableLabels,
 	)
 }
--- a/gateway/vendor/github.com/prometheus/client_golang/prometheus/doc.go
+++ b/gateway/vendor/github.com/prometheus/client_golang/prometheus/doc.go
@ -21,66 +21,55 @@
 // All exported functions and methods are safe to be used concurrently unless
 // specified otherwise.
 //
-// # A Basic Example
+// A Basic Example
 //
 // As a starting point, a very basic usage example:
 //
-//	package main
+//    package main
 //
-//	import (
-//		"log"
-//		"net/http"
+//    import (
+//    	"log"
+//    	"net/http"
 //
-//		"github.com/prometheus/client_golang/prometheus"
-//		"github.com/prometheus/client_golang/prometheus/promhttp"
-//	)
+//    	"github.com/prometheus/client_golang/prometheus"
+//    	"github.com/prometheus/client_golang/prometheus/promhttp"
+//    )
 //
-//	type metrics struct {
-//		cpuTemp  prometheus.Gauge
-//		hdFailures *prometheus.CounterVec
-//	}
+//    var (
+//    	cpuTemp = prometheus.NewGauge(prometheus.GaugeOpts{
+//    		Name: "cpu_temperature_celsius",
+//    		Help: "Current temperature of the CPU.",
+//    	})
+//    	hdFailures = prometheus.NewCounterVec(
+//    		prometheus.CounterOpts{
+//    			Name: "hd_errors_total",
+//    			Help: "Number of hard-disk errors.",
+//    		},
+//    		[]string{"device"},
+//    	)
+//    )
 //
-//	func NewMetrics(reg prometheus.Registerer) *metrics {
-//		m := &metrics{
-//			cpuTemp: prometheus.NewGauge(prometheus.GaugeOpts{
-//				Name: "cpu_temperature_celsius",
-//				Help: "Current temperature of the CPU.",
-//			}),
-//			hdFailures: prometheus.NewCounterVec(
-//				prometheus.CounterOpts{
-//					Name: "hd_errors_total",
-//					Help: "Number of hard-disk errors.",
-//				},
-//				[]string{"device"},
-//			),
-//		}
-//		reg.MustRegister(m.cpuTemp)
-//		reg.MustRegister(m.hdFailures)
-//		return m
-//	}
+//    func init() {
+//    	// Metrics have to be registered to be exposed:
+//    	prometheus.MustRegister(cpuTemp)
+//    	prometheus.MustRegister(hdFailures)
+//    }
 //
-//	func main() {
-//		// Create a non-global registry.
-//		reg := prometheus.NewRegistry()
+//    func main() {
+//    	cpuTemp.Set(65.3)
+//    	hdFailures.With(prometheus.Labels{"device":"/dev/sda"}).Inc()
 //
-//		// Create new metrics and register them using the custom registry.
-//		m := NewMetrics(reg)
-//		// Set values for the new created metrics.
-//		m.cpuTemp.Set(65.3)
-//		m.hdFailures.With(prometheus.Labels{"device":"/dev/sda"}).Inc()
+//    	// The Handler function provides a default handler to expose metrics
+//    	// via an HTTP server. "/metrics" is the usual endpoint for that.
+//    	http.Handle("/metrics", promhttp.Handler())
+//    	log.Fatal(http.ListenAndServe(":8080", nil))
+//    }
 //
-//		// Expose metrics and custom registry via an HTTP server
-//		// using the HandleFor function. "/metrics" is the usual endpoint for that.
-//		http.Handle("/metrics", promhttp.HandlerFor(reg, promhttp.HandlerOpts{Registry: reg}))
-//		log.Fatal(http.ListenAndServe(":8080", nil))
-//	}
 //
 // This is a complete program that exports two metrics, a Gauge and a Counter,
 // the latter with a label attached to turn it into a (one-dimensional) vector.
-// It register the metrics using a custom registry and exposes them via an HTTP server
-// on the /metrics endpoint.
 //
-// # Metrics
+// Metrics
 //
 // The number of exported identifiers in this package might appear a bit
 // overwhelming. However, in addition to the basic plumbing shown in the example
@ -111,7 +100,7 @@
 // To create instances of Metrics and their vector versions, you need a suitable
 // …Opts struct, i.e. GaugeOpts, CounterOpts, SummaryOpts, or HistogramOpts.
 //
-// # Custom Collectors and constant Metrics
+// Custom Collectors and constant Metrics
 //
 // While you could create your own implementations of Metric, most likely you
 // will only ever implement the Collector interface on your own. At a first
@ -152,7 +141,7 @@
 // a metric, GaugeFunc, CounterFunc, or UntypedFunc might be interesting
 // shortcuts.
 //
-// # Advanced Uses of the Registry
+// Advanced Uses of the Registry
 //
 // While MustRegister is the by far most common way of registering a Collector,
 // sometimes you might want to handle the errors the registration might cause.
@ -187,23 +176,23 @@
 // NewProcessCollector). With a custom registry, you are in control and decide
 // yourself about the Collectors to register.
 //
-// # HTTP Exposition
+// HTTP Exposition
 //
 // The Registry implements the Gatherer interface. The caller of the Gather
 // method can then expose the gathered metrics in some way. Usually, the metrics
 // are served via HTTP on the /metrics endpoint. That's happening in the example
 // above. The tools to expose metrics via HTTP are in the promhttp sub-package.
 //
-// # Pushing to the Pushgateway
+// Pushing to the Pushgateway
 //
 // Function for pushing to the Pushgateway can be found in the push sub-package.
 //
-// # Graphite Bridge
+// Graphite Bridge
 //
 // Functions and examples to push metrics from a Gatherer to Graphite can be
 // found in the graphite sub-package.
 //
-// # Other Means of Exposition
+// Other Means of Exposition
 //
 // More ways of exposing metrics can easily be added by following the approaches
 // of the existing implementations.
--- a/gateway/vendor/github.com/prometheus/client_golang/prometheus/expvar_collector.go
+++ b/gateway/vendor/github.com/prometheus/client_golang/prometheus/expvar_collector.go
@ -48,7 +48,7 @@ func (e *expvarCollector) Collect(ch chan<- Metric) {
 			continue
 		}
 		var v interface{}
-		labels := make([]string, len(desc.variableLabels.names))
+		labels := make([]string, len(desc.variableLabels))
 		if err := json.Unmarshal([]byte(expVar.String()), &v); err != nil {
 			ch <- NewInvalidMetric(desc, err)
 			continue
--- a/Show More
+++ b/Show More