koa-compress 5.1.1 → 5.2.1

package/HISTORY.md

@@ -1,5 +1,46 @@
 SEE https://github.com/koajs/compress/releases
 
+5.2.1 / 2026-03-12
+==================
+
+* fixed TS typings and refactored them
+* minor bug fix
+* simplified code and removed unused code
+* improved docs and typo fixes
+* more tests
+* updated dependencies
+
+5.2.0 / 2026-02-10
+==================
+
+* add functional and local options
+* updated dependencies
+* copied the project setup from Koa
+* add zstd
+* use `negotiator` for content negotiation
+* add TypeScript typings and tests
+
+5.1.1 / 2023-04-08
+==================
+
+* minor refactoring + updated dependencies
+
+5.1.0 / 2021-08-17
+==================
+
+* change brotli defaults (compression level to 4)
+* updated dependencies
+
+5.0.1 / 2020-07-06
+==================
+
+* updated to accomodate Node changes: zlib constants were moved to a different namespace
+
+5.0.0 / 2020-07-05
+==================
+
+ * add `defaultEncoding`
+
 4.0.1 / 2020-04-29
 ==================
 

package/README.md

@@ -8,23 +8,28 @@ Compress middleware for Koa
 ## Example
 
 ```js
-const compress = require('koa-compress')
-const Koa = require('koa')
-
-const app = new Koa()
-app.use(compress({
-  filter (content_type) {
-  	return /text/i.test(content_type)
-  },
-  threshold: 2048,
-  gzip: {
-    flush: require('zlib').constants.Z_SYNC_FLUSH
-  },
-  deflate: {
-    flush: require('zlib').constants.Z_SYNC_FLUSH,
-  },
-  br: false // disable brotli
-}))
+const compress = require("koa-compress");
+const Koa = require("koa");
+
+const app = new Koa();
+app.use(
+  compress({
+    filter(content_type) {
+      return /text/i.test(content_type);
+    },
+    threshold: 2048,
+    gzip: {
+      flush: require("zlib").constants.Z_SYNC_FLUSH,
+    },
+    deflate: {
+      flush: require("zlib").constants.Z_SYNC_FLUSH,
+    },
+    zstd: {
+      flush: require("zlib").constants.Z_SYNC_FLUSH,
+    },
+    br: false, // disable brotli
+  }),
+);
 ```
 
 ## Maintainers
@@ -37,49 +42,82 @@ app.use(compress({
 ### filter\<Function\>
 
 ```ts
-function (mimeType: string): Boolean {
-
-}
+function (mimeType: string): boolean {}
 ```
 
-An optional function that checks the response content type to decide whether to compress.
-By default, it uses [compressible](https://github.com/jshttp/compressible).
+A predicate that checks the response MIME type to decide whether to compress.
+Default: [compressible](https://github.com/jshttp/compressible).
 
-### options.threshold\<String|Number\>
+### options.threshold\<String|Number|Function\>
 
 Minimum response size in bytes to compress.
-Default `1024` bytes or `1kb`.
+Can also be a string parsed by `bytes()` (e.g. `"1kb"`) or a function (see [Functional properties](#functional-properties)).
+Default: `1024`.
+
+### options[encoding]\<Object|Function\>
+
+Supported encodings in default preference order: `zstd`, `br`, `gzip`, `deflate`.
+Setting `options[encoding] = {}` passes those options to the corresponding `zlib` compressor.
+Setting `options[encoding] = false` disables that encoding.
+
+Can also be a function (see [Functional properties](#functional-properties)).
 
-### options[encoding]\<Object\>
+#### options.br
 
-The current encodings are, in order of preference: `br`, `gzip`, `deflate`.
-Setting `options[encoding] = {}` will pass those options to the encoding function.
-Setting `options[encoding] = false` will disable that encoding.
+[Brotli compression](https://en.wikipedia.org/wiki/Brotli) is available natively in all supported Node.js versions.
+The default quality level is 4 for performance reasons.
 
-#### options<span></span>.br
+#### options.zstd
 
-[Brotli compression](https://en.wikipedia.org/wiki/Brotli) is supported in node v11.7.0+, which includes it natively.
-As of v5.1.0, the default quality level is 4 for performance reasons.
+[Zstandard compression](https://en.wikipedia.org/wiki/Zstandard) is natively supported starting from Node.js v22.15.0 (LTS) and v23.8.0 (Current). The middleware detects `zlib.createZstdCompress` at runtime; if available, zstd is enabled automatically, otherwise it is skipped.
 
 ### options.defaultEncoding\<String\>
 
-An optional string, which specifies what encoders to use for requests without
-[Accept-Encoding](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Accept-Encoding).
-Default `identity`.
+Encoding assumed when the client sends no
+[Accept-Encoding](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Accept-Encoding) header.
+Default: `"identity"` (no compression).
 
-The standard dictates to treat such requests as `*` meaning that all compressions are permissible,
-yet it causes very practical problems when debugging servers with manual tools like `curl`, `wget`, and so on.
-If you want to enable the standard behavior, just set `defaultEncoding` to `*`.
+The HTTP spec treats a missing header as `*` (any encoding is acceptable),
+but that causes problems when debugging with tools like `curl` or `wget`.
+Set `defaultEncoding` to `"*"` to restore spec-compliant behavior.
 
 ## Manually turning compression on and off
 
-You can always enable compression by setting `ctx.compress = true`.
-You can always disable compression by setting `ctx.compress = false`.
-This bypasses the filter check.
+You can force compression by setting `ctx.compress = true` (bypasses the filter check).
+You can disable compression by setting `ctx.compress = false`.
 
 ```js
 app.use((ctx, next) => {
-  ctx.compress = true
-  ctx.body = fs.createReadStream(file)
-})
+  ctx.compress = true;
+  ctx.body = fs.createReadStream(file);
+});
+```
+
+`ctx.compress` can also be an options object (same shape as the middleware options).
+Its `threshold` and encoding properties override the global defaults for this response.
+Note: an options object does **not** bypass the filter check — only `true` does.
+
+## Functional properties
+
+The `threshold` and per-encoding options can be functions. They are called
+for every response with three arguments:
+
+- `type` &mdash; same as `ctx.response.type`
+- `size` &mdash; same as `ctx.response.length`
+- `ctx` &mdash; the full Koa context object
+
+The function should return a valid value for that property.
+Returning another function of the same shape is allowed — it will be called in turn.
+
+Example:
+
+```js
+app.use(
+  compress({
+    gzip: (type, size) => (size && size < 65536 ? { level: 9 } : false),
+    br: (type, size) => size && size >= 65536,
+  }),
+);
 ```
+
+See the Koa documentation for [`ctx`](https://koajs.com/#context) and [`ctx.response`](https://koajs.com/#response).

package/lib/index.d.ts

@@ -0,0 +1,162 @@
+import type { BrotliOptions, ZlibOptions, ZstdOptions } from "node:zlib";
+import type Koa = require("koa");
+
+declare namespace compress {
+  /**
+   * Calculates a threshold value dynamically from the MIME type,
+   * the response size, and the current context.
+   */
+  type ThresholdFunction = (
+    /** MIME type of the response */
+    type: string,
+    /** Size of the response in bytes */
+    size: number,
+    /** Context of the request */
+    ctx: Koa.Context,
+  ) => number | string | ThresholdFunction;
+
+  /**
+   * Computes `deflate`/`gzip` compression options from the MIME type,
+   * the response size, and the current context.
+   */
+  type ZlibOptionsFunction = (
+    /** MIME type of the response */
+    type: string,
+    /** Size of the response in bytes */
+    size: number,
+    /** Context of the request */
+    ctx: Koa.Context,
+  ) => boolean | null | ZlibOptions | ZlibOptionsFunction;
+
+  /**
+   * Computes `brotli` compression options from the MIME type,
+   * the response size, and the current context.
+   */
+  type BrotliOptionsFunction = (
+    /** MIME type of the response */
+    type: string,
+    /** Size of the response in bytes */
+    size: number,
+    /** Context of the request */
+    ctx: Koa.Context,
+  ) => boolean | null | BrotliOptions | BrotliOptionsFunction;
+
+  /**
+   * Computes `zstd` compression options from the MIME type,
+   * the response size, and the current context.
+   */
+  type ZstdOptionsFunction = (
+    /** MIME type of the response */
+    type: string,
+    /** Size of the response in bytes */
+    size: number,
+    /** Context of the request */
+    ctx: Koa.Context,
+  ) => boolean | null | ZstdOptions | ZstdOptionsFunction;
+
+  /**
+   * Options for the `koa-compress` middleware.
+   */
+  type CompressOptions = {
+    /**
+     * Predicate that decides whether a given MIME type should be compressed.
+     * Default: `compressible()`.
+     * @param type - MIME type of the response
+     * @returns `true` to compress, `false` to skip
+     */
+    filter?: (type: string) => boolean;
+    /**
+     * Minimum response size to compress. A number (bytes), a string
+     * parsed by `bytes()` (e.g. `"1mb"`), or a {@link ThresholdFunction}.
+     * Default: `1024`.
+     */
+    threshold?: number | string | ThresholdFunction;
+    /**
+     * Encoding assumed when the client sends no `Accept-Encoding` header.
+     * Set to `"*"` for spec-compliant behavior. Default: `"identity"`.
+     */
+    defaultEncoding?: string;
+    /**
+     * Encoding to use when `Accept-Encoding` is `"*"`. Default: `"gzip"`.
+     */
+    wildcardAcceptEncoding?: string;
+    /**
+     * Preferred encoding order used to break ties among equally weighted
+     * encodings. Lower index = higher priority.
+     * Default: `['zstd', 'br', 'gzip', 'deflate', 'identity']`.
+     */
+    encodingPreference?: string[];
+    /**
+     * Options passed to `zlib.createDeflate()`, or `false`/`null` to disable.
+     * Can be a {@link ZlibOptionsFunction} for per-response values.
+     * Default: `{}`.
+     */
+    deflate?: boolean | null | ZlibOptions | ZlibOptionsFunction;
+    /**
+     * Options passed to `zlib.createGzip()`, or `false`/`null` to disable.
+     * Can be a {@link ZlibOptionsFunction} for per-response values.
+     * Default: `{}`.
+     */
+    gzip?: boolean | null | ZlibOptions | ZlibOptionsFunction;
+    /**
+     * Options passed to `zlib.createBrotliCompress()`, or `false`/`null` to disable.
+     * Can be a {@link BrotliOptionsFunction} for per-response values.
+     * Default: `{params: {[zlib.constants.BROTLI_PARAM_QUALITY]: 4}}`.
+     */
+    br?: boolean | null | BrotliOptions | BrotliOptionsFunction;
+    /**
+     * Options passed to `zlib.createZstdCompress()`, or `false`/`null` to disable.
+     * Can be a {@link ZstdOptionsFunction} for per-response values.
+     * Default: `{}`.
+     */
+    zstd?: boolean | null | ZstdOptions | ZstdOptionsFunction;
+  };
+
+  /**
+   * Per-encoding options: built-in defaults merged with user-supplied values.
+   */
+  type EncodingOptions = {
+    [encoding: string]: BrotliOptions | ZlibOptions | ZstdOptions | undefined;
+  };
+
+  /**
+   * Koa middleware with additional properties for introspection.
+   */
+  interface CompressMiddleware extends Koa.Middleware {
+    /**
+     * Supported content encodings available in the current Node.js runtime,
+     * ordered by preference.
+     */
+    preferredEncodings: string[];
+    /**
+     * Resolved options for each supported encoding (built-in defaults
+     * merged with user-provided values).
+     */
+    encodingOptions: EncodingOptions;
+  }
+}
+
+/**
+ * Creates a Koa middleware that compresses response bodies via content
+ * negotiation. The returned function also exposes
+ * {@link compress.CompressMiddleware.preferredEncodings | preferredEncodings} and
+ * {@link compress.CompressMiddleware.encodingOptions | encodingOptions}.
+ *
+ * @param options - Compression options. See {@link compress.CompressOptions}.
+ * @returns Koa middleware with introspection properties.
+ */
+declare function compress(options?: compress.CompressOptions): compress.CompressMiddleware;
+
+declare module "koa" {
+  interface DefaultContext {
+    /**
+     * Per-response compression override.
+     * Set to `false` to disable compression, `true` to force it
+     * (bypassing the filter), or a `CompressOptions` object whose
+     * properties override the defaults for this response.
+     */
+    compress?: boolean | compress.CompressOptions;
+  }
+}
+
+export = compress;

package/lib/index.js

@@ -1,3 +1,5 @@
+// @ts-self-types="./index.d.ts"
+
 'use strict'
 
 /**
@@ -7,19 +9,43 @@
 const compressible = require('compressible')
 const isJSON = require('koa-is-json')
 const Stream = require('stream')
+const zlib = require('zlib')
 const bytes = require('bytes')
+const Negotiator = require('negotiator')
+
+const encodingMethods = {
+  zstd: zlib.createZstdCompress,
+  br: zlib.createBrotliCompress,
+  gzip: zlib.createGzip,
+  deflate: zlib.createDeflate
+}
+
+const encodingDefaultPreference = ['zstd', 'br', 'gzip', 'deflate', 'identity']
+
+const preferredEncodings = encodingDefaultPreference.filter(
+  (encoding) => encodingMethods[encoding] || encoding === 'identity'
+)
 
-const Encodings = require('./encodings')
+const encodingMethodDefaultOptions = {
+  gzip: {},
+  deflate: {},
+  br: {
+    params: {
+      [zlib.constants.BROTLI_PARAM_QUALITY]: 4
+    }
+  },
+  zstd: {}
+}
 
 /**
-* Regex to match no-transform directive in a cache-control header
-*/
+ * Regex to match no-transform directive in a cache-control header
+ */
 const NO_TRANSFORM_REGEX = /(?:^|,)\s*?no-transform\s*?(?:,|$)/
 
 /**
- * empty body statues.
+ * empty body statuses.
  */
-const emptyBodyStatues = new Set([204, 205, 304])
+const emptyBodyStatuses = new Set([204, 205, 304])
 
 /**
  * Compress middleware.
@@ -30,18 +56,29 @@ const emptyBodyStatues = new Set([204, 205, 304])
  */
 
 module.exports = (options = {}) => {
-  let { filter = compressible, threshold = 1024, defaultEncoding = 'identity' } = options
-  if (typeof threshold === 'string') threshold = bytes(threshold)
+  let {
+    filter = compressible,
+    defaultEncoding,
+    wildcardAcceptEncoding,
+    encodingPreference = encodingDefaultPreference
+  } = options
+  if (!wildcardAcceptEncoding || wildcardAcceptEncoding === '*') {
+    wildcardAcceptEncoding = 'gzip'
+  }
+  defaultEncoding =
+    defaultEncoding === '*'
+      ? wildcardAcceptEncoding
+      : !defaultEncoding
+          ? 'identity'
+          : defaultEncoding
 
-  // `options.br = false` would remove it as a preferred encoding
-  const preferredEncodings = Encodings.preferredEncodings.filter((encoding) => options[encoding] !== false && options[encoding] !== null)
   const encodingOptions = {}
-  preferredEncodings.forEach((encoding) => {
+  for (const encoding of preferredEncodings) {
     encodingOptions[encoding] = {
-      ...Encodings.encodingMethodDefaultOptions[encoding],
-      ...(options[encoding] || {})
+      ...encodingMethodDefaultOptions[encoding],
+      ...options[encoding]
     }
-  })
+  }
 
   Object.assign(compressMiddleware, {
     preferredEncodings,
@@ -56,27 +93,66 @@ module.exports = (options = {}) => {
     await next()
 
     let { body } = ctx
+    const { type, length: size } = ctx.response
     if (
       // early exit if there's no content body or the body is already encoded
       !body ||
-      ctx.res.headersSent || !ctx.writable ||
+      ctx.res.headersSent ||
+      !ctx.writable ||
       ctx.compress === false ||
       ctx.request.method === 'HEAD' ||
-      emptyBodyStatues.has(+ctx.response.status) ||
+      emptyBodyStatuses.has(+ctx.response.status) ||
       ctx.response.get('Content-Encoding') ||
       // forced compression or implied
-      !(ctx.compress === true || filter(ctx.response.type)) ||
+      !(ctx.compress === true || filter(type)) ||
       // don't compress for Cache-Control: no-transform
       // https://tools.ietf.org/html/rfc7234#section-5.2.1.6
-      NO_TRANSFORM_REGEX.test(ctx.response.get('Cache-Control')) ||
-      // don't compress if the current response is below the threshold
-      (threshold && ctx.response.length < threshold)
-    ) return
+      NO_TRANSFORM_REGEX.test(ctx.response.get('Cache-Control'))
+    ) {
+      return
+    }
+
+    // calculate "local" compression options
+    const responseOptions = { ...options, ...ctx.compress }
+    let { threshold = 1024 } = responseOptions
+    while (typeof threshold === 'function') {
+      threshold = threshold(type, size, ctx)
+    }
+    if (typeof threshold === 'string') threshold = bytes(threshold)
+
+    // don't compress if the current response is below the threshold
+    if (threshold && size < threshold) return
 
     // get the preferred content encoding
-    const encodings = new Encodings({ preferredEncodings })
-    encodings.parseAcceptEncoding(ctx.request.headers['accept-encoding'] || defaultEncoding)
-    const encoding = encodings.getPreferredContentEncoding()
+    for (const encoding of compressMiddleware.preferredEncodings) {
+      // calculate compressor options, if any
+      if (!(encoding in responseOptions)) continue
+      let compressor = responseOptions[encoding]
+      while (typeof compressor === 'function') {
+        compressor = compressor(type, size, ctx)
+      }
+      responseOptions[encoding] = compressor
+    }
+
+    const finalEncodings = compressMiddleware.preferredEncodings.filter(
+      (encoding) =>
+        responseOptions[encoding] !== false &&
+        responseOptions[encoding] !== null
+    )
+
+    const acceptEncoding = ctx.request.headers['accept-encoding']
+    let request = ctx.request
+    if (acceptEncoding === '*') {
+      request = { headers: { 'accept-encoding': wildcardAcceptEncoding } }
+    } else if (!acceptEncoding) {
+      request = { headers: { 'accept-encoding': defaultEncoding } }
+    }
+
+    const negotiator = new Negotiator(request)
+    // if no encodings are supported, negotiator returns 'identity'
+    const encoding = negotiator.encoding(finalEncodings, {
+      preferred: encodingPreference
+    })
 
     // identity === no compression
     if (encoding === 'identity') return
@@ -89,8 +165,9 @@ module.exports = (options = {}) => {
     ctx.set('Content-Encoding', encoding)
     ctx.res.removeHeader('Content-Length')
 
-    const compress = Encodings.encodingMethods[encoding]
-    const stream = ctx.body = compress(encodingOptions[encoding])
+    const compress = encodingMethods[encoding]
+    const compressOptions = { ...encodingMethodDefaultOptions[encoding], ...responseOptions[encoding] }
+    const stream = (ctx.body = compress(compressOptions))
 
     if (body instanceof Stream) return body.pipe(stream)
     stream.end(body)

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "koa-compress",
   "description": "Compress middleware for koa",
-  "version": "5.1.1",
+  "version": "5.2.1",
+  "type": "commonjs",
   "author": {
     "name": "Jonathan Ong",
     "email": "me@jongleberry.com",
@@ -13,6 +14,11 @@
       "name": "Imed Jaberi",
       "email": "imed-jaberi@outlook.com",
       "url": "https://www.3imed-jaberi.com/"
+    },
+    {
+      "name": "Eugene Lazutkin",
+      "email": "eugene.lazutkin@gmail.com",
+      "url": "https://www.lazutkin.com/"
     }
   ],
   "license": "MIT",
@@ -20,23 +26,29 @@
   "dependencies": {
     "bytes": "^3.1.2",
     "compressible": "^2.0.18",
-    "http-errors": "^1.8.1",
-    "koa-is-json": "^1.0.0"
+    "http-errors": "^2.0.1",
+    "koa-is-json": "^1.0.0",
+    "negotiator": "^1.0.0"
   },
   "devDependencies": {
-    "eslint": "^7.32.0",
-    "eslint-config-standard": "^16.0.3",
-    "eslint-plugin-import": "^2.26.0",
-    "eslint-plugin-node": "^11.1.0",
-    "eslint-plugin-promise": "^5.2.0",
-    "eslint-plugin-standard": "^5.0.0",
-    "jest": "^27.5.1",
-    "koa": "^2.13.4",
-    "supertest": "^6.2.4"
+    "@types/koa": "^3.0.1",
+    "@types/node": "^25.5.0",
+    "c8": "^11.0.0",
+    "jest": "^30.3.0",
+    "koa": "^3.1.2",
+    "snazzy": "^9.0.0",
+    "standard": "^17.1.2",
+    "supertest": "^7.2.2",
+    "typescript": "^5.9.3"
   },
   "scripts": {
-    "eslint": "eslint --ignore-path .gitignore .",
-    "test": "jest"
+    "test": "jest",
+    "test:coverage": "c8 --reporter=lcov --reporter=text-summary jest --coverage",
+    "lint": "standard",
+    "lint:fix": "standard --fix",
+    "lint:pretty": "standard | snazzy",
+    "ts-check": "tsc --noEmit",
+    "authors": "git log --format='%aN <%aE>' | sort -u > AUTHORS"
   },
   "files": [
     "lib",
@@ -44,7 +56,21 @@
     "HISTORY.md"
   ],
   "main": "lib",
+  "types": "lib/index.d.ts",
   "engines": {
     "node": ">= 12"
+  },
+  "standard": {
+    "globals": [
+      "afterAll",
+      "beforeAll",
+      "afterEach",
+      "jasmine",
+      "describe",
+      "test",
+      "jest",
+      "expect",
+      "it"
+    ]
   }
 }

package/lib/encodings.js

@@ -1,104 +0,0 @@
-
-// https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Accept-Encoding
-const errors = require('http-errors')
-const zlib = require('zlib')
-
-class Encodings {
-  constructor (options = {}) {
-    this.wildcardAcceptEncoding = options.wildcardAcceptEncoding || Encodings.wildcardAcceptEncoding
-    this.preferredEncodings = options.preferredEncodings || Encodings.preferredEncodings
-    this.reDirective = options.reDirective || Encodings.reDirective
-
-    this.encodingWeights = new Map()
-  }
-
-  parseAcceptEncoding (acceptEncoding = '*') {
-    const { encodingWeights, reDirective } = this
-
-    acceptEncoding.split(',').forEach((directive) => {
-      const match = reDirective.exec(directive)
-      if (!match) return // not a supported encoding above
-
-      const encoding = match[1]
-
-      // weight must be in [0, 1]
-      let weight = match[2] && !isNaN(match[2]) ? parseFloat(match[2], 10) : 1
-      weight = Math.max(weight, 0)
-      weight = Math.min(weight, 1)
-
-      if (encoding === '*') {
-        // set the weights for the default encodings
-        this.wildcardAcceptEncoding.forEach((enc) => {
-          if (!encodingWeights.has(enc)) encodingWeights.set(enc, weight)
-        })
-        return
-      }
-
-      encodingWeights.set(encoding, weight)
-    })
-  }
-
-  getPreferredContentEncoding () {
-    const {
-      encodingWeights,
-      preferredEncodings
-    } = this
-
-    // get ordered list of accepted encodings
-    const acceptedEncodings = Array.from(encodingWeights.keys())
-      // sort by weight
-      .sort((a, b) => encodingWeights.get(b) - encodingWeights.get(a))
-      // filter by supported encodings
-      .filter((encoding) => encoding === 'identity' || typeof Encodings.encodingMethods[encoding] === 'function')
-
-    // group them by weights
-    const weightClasses = new Map()
-    acceptedEncodings.forEach((encoding) => {
-      const weight = encodingWeights.get(encoding)
-      if (!weightClasses.has(weight)) weightClasses.set(weight, new Set())
-      weightClasses.get(weight).add(encoding)
-    })
-
-    // search by weight, descending
-    const weights = Array.from(weightClasses.keys()).sort((a, b) => b - a)
-    for (let i = 0; i < weights.length; i++) {
-      // encodings at this weight
-      const encodings = weightClasses.get(weights[i])
-      // return the first encoding in the preferred list
-      for (let j = 0; j < preferredEncodings.length; j++) {
-        const preferredEncoding = preferredEncodings[j]
-        if (encodings.has(preferredEncoding)) return preferredEncoding
-      }
-    }
-
-    // no encoding matches, check to see if the client set identity, q=0
-    if (encodingWeights.get('identity') === 0) throw errors(406, 'Please accept br, gzip, deflate, or identity.')
-
-    // by default, return nothing
-    return 'identity'
-  }
-}
-
-Encodings.encodingMethods = {
-  gzip: zlib.createGzip,
-  deflate: zlib.createDeflate,
-  br: zlib.createBrotliCompress
-}
-
-Encodings.encodingMethodDefaultOptions = {
-  gzip: {},
-  deflate: {},
-  br: {
-    params: {
-      [zlib.constants.BROTLI_PARAM_QUALITY]: 4
-    }
-  }
-}
-
-// how we treat `Accept-Encoding: *`
-Encodings.wildcardAcceptEncoding = ['gzip', 'deflate']
-// our preferred encodings
-Encodings.preferredEncodings = ['br', 'gzip', 'deflate']
-Encodings.reDirective = /^\s*(gzip|compress|deflate|br|identity|\*)\s*(?:;\s*q\s*=\s*(\d(?:\.\d)?))?\s*$/
-
-module.exports = Encodings