rekwest 6.2.1 → 7.0.1

package/dist/retries.cjs

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.retries = void 0;
+var _nodeHttp = _interopRequireDefault(require("node:http2"));
+var _nodeStream = require("node:stream");
+var _promises = require("node:timers/promises");
+var _errors = require("./errors.cjs");
+var _index = _interopRequireDefault(require("./index.cjs"));
+var _utils = require("./utils.cjs");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const {
+  HTTP2_HEADER_RETRY_AFTER,
+  HTTP2_METHOD_GET,
+  HTTP2_METHOD_HEAD
+} = _nodeHttp.default.constants;
+const retries = (ex, options) => {
+  const {
+    body,
+    maxRetryAfter,
+    method,
+    retry,
+    url
+  } = options;
+  if (retry?.attempts > 0) {
+    if (![HTTP2_METHOD_GET, HTTP2_METHOD_HEAD].includes(method) && (0, _utils.isPipeStream)(body) && !(0, _nodeStream.isReadable)(body)) {
+      throw new _errors.RequestError('Request stream already read.', {
+        cause: ex
+      });
+    }
+    if (retry.errorCodes?.includes(ex.code) || retry.statusCodes?.includes(ex.statusCode)) {
+      let {
+        interval
+      } = retry;
+      if (retry.retryAfter && ex.headers?.[HTTP2_HEADER_RETRY_AFTER]) {
+        interval = ex.headers[HTTP2_HEADER_RETRY_AFTER];
+        interval = Math.abs(Number(interval) * 1e3 || new Date(interval) - Date.now()) || 0;
+        if (interval > maxRetryAfter) {
+          throw new _errors.RequestError(`Maximum '${HTTP2_HEADER_RETRY_AFTER}' limit exceeded: ${interval} ms.`, {
+            cause: ex
+          });
+        }
+      } else {
+        interval = new Function('interval', `return Math.ceil(${retry.backoffStrategy});`)(interval);
+      }
+      if (interval < 0) {
+        interval = 0;
+      }
+      retry.attempts--;
+      retry.interval = interval;
+      return (0, _promises.setTimeout)(interval).then(() => (0, _index.default)(url, options));
+    }
+  }
+};
+exports.retries = retries;

package/dist/{transfer.js → transfer.cjs}

@@ -7,18 +7,15 @@ exports.transfer = void 0;
 var _nodeHttp = _interopRequireDefault(require("node:http"));
 var _nodeHttp2 = _interopRequireDefault(require("node:http2"));
 var _nodeHttps = _interopRequireDefault(require("node:https"));
-var _promises = require("node:timers/promises");
-var _ackn = require("./ackn");
-var _errors = require("./errors");
-var _postflight = require("./postflight");
-var _preflight = require("./preflight");
-var _transform = require("./transform");
-var _utils = require("./utils");
+var _ackn = require("./ackn.cjs");
+var _errors = require("./errors.cjs");
+var _postflight = require("./postflight.cjs");
+var _preflight = require("./preflight.cjs");
+var _retries = require("./retries.cjs");
+var _transform = require("./transform.cjs");
+var _utils = require("./utils.cjs");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const {
-  HTTP2_HEADER_RETRY_AFTER
-} = _nodeHttp2.default.constants;
-const transfer = async (options, overact) => {
+const transfer = async options => {
   const {
     digest,
     redirected,
@@ -56,7 +53,7 @@ const transfer = async (options, overact) => {
       } = url.protocol === 'http:' ? _nodeHttp.default : _nodeHttps.default;
       req = request(url, options);
     }
-    (0, _utils.affix)(client, req, options);
+    (0, _utils.snoop)(client, req, options);
     req.once('aborted', reject);
     req.once('error', reject);
     req.once('frameError', reject);
@@ -65,7 +62,7 @@ const transfer = async (options, overact) => {
       reject,
       resolve
     }));
-    (0, _utils.dispatch)(options, req);
+    (0, _utils.dispatch)(req, options);
   });
   try {
     const res = await promise;
@@ -74,33 +71,9 @@ const transfer = async (options, overact) => {
     }
     return res;
   } catch (ex) {
-    const {
-      maxRetryAfter,
-      retry
-    } = options;
-    if (retry?.attempts > 0) {
-      if (retry.errorCodes?.includes(ex.code) || retry.statusCodes?.includes(ex.statusCode)) {
-        let {
-          interval
-        } = retry;
-        if (retry.retryAfter && ex.headers?.[HTTP2_HEADER_RETRY_AFTER]) {
-          interval = ex.headers[HTTP2_HEADER_RETRY_AFTER];
-          interval = Number(interval) * 1e3 || new Date(interval) - Date.now();
-          if (interval > maxRetryAfter) {
-            throw (0, _utils.maxRetryAfterError)(interval, {
-              cause: ex
-            });
-          }
-        } else {
-          interval = new Function('interval', `return Math.ceil(${retry.backoffStrategy});`)(interval);
-        }
-        if (interval < 0) {
-          interval = 0;
-        }
-        retry.attempts--;
-        retry.interval = interval;
-        return (0, _promises.setTimeout)(interval).then(() => overact(url, options));
-      }
+    const willRetry = (0, _retries.retries)(ex, options);
+    if (willRetry) {
+      return willRetry;
     }
     if (digest && !redirected && ex.body) {
       ex.body = await ex.body();

package/dist/transform.cjs

@@ -0,0 +1,105 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.transform = void 0;
+var _nodeHttp = _interopRequireDefault(require("node:http2"));
+var _nodeStream = require("node:stream");
+var _consumers = require("node:stream/consumers");
+var _nodeUtil = require("node:util");
+var _codecs = require("./codecs.cjs");
+var _formdata = require("./formdata.cjs");
+var _mediatypes = require("./mediatypes.cjs");
+var _utils = require("./utils.cjs");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const {
+  HTTP2_HEADER_CONTENT_ENCODING,
+  HTTP2_HEADER_CONTENT_LENGTH,
+  HTTP2_HEADER_CONTENT_TYPE
+} = _nodeHttp.default.constants;
+const transform = async options => {
+  let {
+    body,
+    headers
+  } = options;
+  if (!body) {
+    return options;
+  }
+  if (!Buffer.isBuffer(body)) {
+    switch (true) {
+      case (0, _utils.isFileLike)(body):
+        {
+          headers = {
+            [HTTP2_HEADER_CONTENT_LENGTH]: body.size,
+            [HTTP2_HEADER_CONTENT_TYPE]: body.type || _mediatypes.APPLICATION_OCTET_STREAM
+          };
+          body = body.stream();
+          break;
+        }
+      case _formdata.FormData.alike(body):
+        {
+          body = _formdata.FormData.actuate(body);
+          headers = {
+            [HTTP2_HEADER_CONTENT_TYPE]: body.contentType
+          };
+          break;
+        }
+      case _nodeUtil.types.isAnyArrayBuffer(body):
+        {
+          body = Buffer.from(body);
+          break;
+        }
+      case _nodeUtil.types.isArrayBufferView(body):
+        {
+          body = Buffer.from(body.buffer, body.byteOffset, body.byteLength);
+          break;
+        }
+      case Object(body) === body && !Reflect.has(body, Symbol.asyncIterator):
+        {
+          if (body.constructor === URLSearchParams) {
+            headers = {
+              [HTTP2_HEADER_CONTENT_TYPE]: _mediatypes.APPLICATION_FORM_URLENCODED
+            };
+            body = body.toString();
+          } else if (!(!Array.isArray(body) && Reflect.has(body, Symbol.iterator))) {
+            headers = {
+              [HTTP2_HEADER_CONTENT_TYPE]: _mediatypes.APPLICATION_JSON
+            };
+            body = JSON.stringify(body);
+          }
+          break;
+        }
+      default:
+        break;
+    }
+  }
+  const encodings = options.headers[HTTP2_HEADER_CONTENT_ENCODING];
+  if (Object(body) === body && (Reflect.has(body, Symbol.asyncIterator) || !Array.isArray(body) && Reflect.has(body, Symbol.iterator))) {
+    body = (0, _nodeStream.isReadable)(body) ? (0, _utils.isReadableStream)(body) ? _nodeStream.Readable.fromWeb(body) : body : _nodeStream.Readable.from(body);
+    body = encodings ? (0, _codecs.encode)(body, encodings, options) : body;
+  } else if (encodings) {
+    body = await (0, _consumers.buffer)((0, _codecs.encode)(_nodeStream.Readable.from(body), encodings, options));
+  }
+  if (options.bufferBody && Object(body) === body) {
+    if ((0, _nodeStream.isReadable)(body)) {
+      body = await (0, _consumers.buffer)(body);
+    } else if (Reflect.has(body, Symbol.asyncIterator)) {
+      body = await (0, _consumers.buffer)(body);
+    }
+  }
+  Object.assign(options.headers, {
+    ...headers,
+    ...(!body[Symbol.asyncIterator] && {
+      [HTTP2_HEADER_CONTENT_LENGTH]: Buffer.byteLength(body)
+    }),
+    ...(options.headers[HTTP2_HEADER_CONTENT_TYPE] && {
+      [HTTP2_HEADER_CONTENT_TYPE]: options.headers[HTTP2_HEADER_CONTENT_TYPE]
+    })
+  });
+  return {
+    ...options,
+    body
+  };
+};
+exports.transform = transform;

package/dist/{utils.js → utils.cjs}

@@ -3,22 +3,21 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.sameOrigin = exports.normalize = exports.merge = exports.maxRetryAfterError = exports.maxRetryAfter = exports.isReadableStream = exports.isFileLike = exports.dispatch = exports.decompress = exports.copyWithMerge = exports.compress = exports.brandCheck = exports.affix = exports.admix = void 0;
+exports.stripHeaders = exports.snoop = exports.sameOrigin = exports.normalizeHeaders = exports.normalize = exports.merge = exports.isReadableStream = exports.isPipeStream = exports.isFileLike = exports.dispatch = exports.copyWithMerge = exports.brandCheck = exports.augment = void 0;
 exports.tap = tap;
 exports.unwind = exports.toCamelCase = void 0;
 var _nodeBuffer = require("node:buffer");
 var _nodeHttp = _interopRequireDefault(require("node:http2"));
 var _nodeStream = require("node:stream");
-var _nodeZlib = _interopRequireDefault(require("node:zlib"));
-var _config = _interopRequireWildcard(require("./config"));
-var _errors = require("./errors");
+var _config = _interopRequireWildcard(require("./config.cjs"));
+var _errors = require("./errors.cjs");
 function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const {
-  HTTP2_HEADER_RETRY_AFTER,
+  HTTP2_HEADER_ACCEPT_ENCODING,
   HTTP2_HEADER_STATUS
 } = _nodeHttp.default.constants;
-const admix = (res, headers, options) => {
+const augment = (res, headers, options) => {
   const {
     h2
   } = options;
@@ -45,48 +44,13 @@ const admix = (res, headers, options) => {
     value: !!options.redirected
   });
 };
-exports.admix = admix;
-const affix = (client, req, options) => {
-  req.once('close', () => client?.close());
-  req.once('end', () => client?.close());
-  req.once('timeout', () => req.destroy(new _errors.TimeoutError(`Timed out after ${options.timeout} ms.`)));
-  req.once('trailers', trailers => {
-    Reflect.defineProperty(req, 'trailers', {
-      enumerable: true,
-      value: trailers
-    });
-  });
-};
-exports.affix = affix;
+exports.augment = augment;
 const brandCheck = (value, ctor) => {
   if (!(value instanceof ctor)) {
-    throw new TypeError('Illegal invocation');
+    throw new TypeError('Illegal invocation.');
   }
 };
 exports.brandCheck = brandCheck;
-const compress = (readable, encodings = '', {
-  compression
-} = {}) => {
-  const encoders = [];
-  encodings = unwind(encodings);
-  for (const encoding of encodings) {
-    if (/\bbr\b/i.test(encoding)) {
-      encoders.push(_nodeZlib.default.createBrotliCompress(compression?.brotliOptions));
-    } else if (/\bdeflate(?!-(?:\w+)?)\b/i.test(encoding)) {
-      encoders.push(_nodeZlib.default.createDeflate(compression?.zlibOptions));
-    } else if (/\bdeflate-raw\b/i.test(encoding)) {
-      encoders.push(_nodeZlib.default.createDeflateRaw(compression?.zlibOptions));
-    } else if (/\bgzip\b/i.test(encoding)) {
-      encoders.push(_nodeZlib.default.createGzip(compression?.zlibOptions));
-    } else if (_config.isZstdSupported && /\bzstd\b/i.test(encoding)) {
-      encoders.push(_nodeZlib.default.createZstdCompress(compression?.zstdOptions));
-    } else {
-      return readable;
-    }
-  }
-  return (0, _nodeStream.pipeline)(readable, ...encoders, () => void 0);
-};
-exports.compress = compress;
 const copyWithMerge = (target, ...rest) => {
   target = structuredClone(target);
   if (!rest.length) {
@@ -95,52 +59,30 @@ const copyWithMerge = (target, ...rest) => {
   return merge(target, ...rest);
 };
 exports.copyWithMerge = copyWithMerge;
-const decompress = (readable, encodings = '', {
-  decompression
-} = {}) => {
-  const decoders = [];
-  encodings = unwind(encodings);
-  for (const encoding of encodings) {
-    if (/\bbr\b/i.test(encoding)) {
-      decoders.push(_nodeZlib.default.createBrotliDecompress(decompression?.brotliOptions));
-    } else if (/\bdeflate(?!-(?:\w+)?)\b/i.test(encoding)) {
-      decoders.push(_nodeZlib.default.createInflate(decompression?.zlibOptions));
-    } else if (/\bdeflate-raw\b/i.test(encoding)) {
-      decoders.push(_nodeZlib.default.createInflateRaw(decompression?.zlibOptions));
-    } else if (/\bgzip\b/i.test(encoding)) {
-      decoders.push(_nodeZlib.default.createGunzip(decompression?.zlibOptions));
-    } else if (_config.isZstdSupported && /\bzstd\b/i.test(encoding)) {
-      decoders.push(_nodeZlib.default.createZstdDecompress(decompression?.zstdOptions));
-    } else {
-      return readable;
-    }
-  }
-  return (0, _nodeStream.pipeline)(readable, ...decoders, () => void 0);
-};
-exports.decompress = decompress;
-const dispatch = ({
+const dispatch = (req, {
   body
-}, req) => {
-  if (body?.pipe?.constructor === Function) {
+}) => {
+  if ((0, _nodeStream.isReadable)(body)) {
     body.pipe(req);
   } else {
     req.end(body);
   }
 };
 exports.dispatch = dispatch;
-const isFileLike = instance => {
-  return [_nodeBuffer.Blob.name, _nodeBuffer.File.name].includes(instance?.[Symbol.toStringTag]);
+const isFileLike = value => {
+  return [_nodeBuffer.Blob, _nodeBuffer.File].some(it => value instanceof it);
 };
 exports.isFileLike = isFileLike;
-const isReadableStream = instance => {
-  return ReadableStream.name === instance?.[Symbol.toStringTag];
+const isPipeStream = value => {
+  return value instanceof _nodeStream.Readable;
+};
+exports.isPipeStream = isPipeStream;
+const isReadableStream = value => {
+  return value instanceof ReadableStream;
 };
 exports.isReadableStream = isReadableStream;
-const maxRetryAfter = exports.maxRetryAfter = Symbol('maxRetryAfter');
-const maxRetryAfterError = (interval, options) => new _errors.RequestError(`Maximum '${HTTP2_HEADER_RETRY_AFTER}' limit exceeded: ${interval} ms.`, options);
-exports.maxRetryAfterError = maxRetryAfterError;
 const merge = (target, ...rest) => {
-  rest = rest.filter(it => it === Object(it));
+  rest = rest.filter(it => Object(it) === it);
   for (const source of rest) {
     for (const key of Object.getOwnPropertyNames(source)) {
       const sv = source[key];
@@ -165,14 +107,49 @@ const normalize = (url, options = {}) => {
   if (options.stripTrailingSlash) {
     url = `${url}`.replace(/\/$|\/(?=#)|\/(?=\?)/g, '');
   }
-  url = new URL(url, options.baseURL);
   return Object.assign(options, {
-    url
+    headers: normalizeHeaders(options.headers),
+    method: options.method.toUpperCase(),
+    url: new URL(url, options.baseURL)
   });
 };
 exports.normalize = normalize;
+const normalizeHeaders = headers => {
+  const collector = {};
+  for (const [key, value] of Object.entries(headers ?? {})) {
+    const name = key.toLowerCase();
+    collector[key] = value;
+    if (key === HTTP2_HEADER_ACCEPT_ENCODING && !_config.isZstdSupported) {
+      const stripped = value.replace(/\s?zstd,?/gi, '').trim();
+      if (stripped) {
+        collector[key] = stripped;
+      } else {
+        Reflect.deleteProperty(collector, name);
+      }
+    }
+  }
+  return collector;
+};
+exports.normalizeHeaders = normalizeHeaders;
 const sameOrigin = (a, b) => a.protocol === b.protocol && a.hostname === b.hostname && a.port === b.port;
 exports.sameOrigin = sameOrigin;
+const snoop = (client, req, options) => {
+  req.once('close', () => client?.close());
+  req.once('end', () => client?.close());
+  req.once('timeout', () => req.destroy(new _errors.TimeoutError(`Timed out after ${options.timeout} ms.`)));
+  req.once('trailers', trailers => {
+    Reflect.defineProperty(req, 'trailers', {
+      enumerable: true,
+      value: trailers
+    });
+  });
+};
+exports.snoop = snoop;
+const stripHeaders = (headers = {}, names = []) => {
+  names = new Set(names);
+  return Object.fromEntries(Object.entries(headers).filter(([key]) => !names.has(key.toLowerCase())));
+};
+exports.stripHeaders = stripHeaders;
 async function* tap(value) {
   if (Reflect.has(value, Symbol.asyncIterator)) {
     yield* value;
@@ -184,5 +161,5 @@ async function* tap(value) {
 }
 const toCamelCase = str => str?.toLowerCase().replace(/\p{Punctuation}.|\p{White_Space}./gu, val => val.replace(/\p{Punctuation}+|\p{White_Space}+/gu, '').toUpperCase());
 exports.toCamelCase = toCamelCase;
-const unwind = encodings => encodings.split(',').map(it => it.trim());
+const unwind = encodings => encodings.split(',').map(it => it.toLowerCase().trim());
 exports.unwind = unwind;

package/dist/{validation.js → validation.cjs}

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.validation = void 0;
 var _nodeHttp = _interopRequireDefault(require("node:http2"));
-var _constants = require("./constants");
+var _constants = require("./constants.cjs");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const {
   HTTP2_METHOD_GET,

package/package.json

@@ -1,29 +1,29 @@
 {
   "author": {
-    "name": "Yehor Sergeenko",
     "email": "yehor.sergeenko@gmail.com",
+    "name": "Yehor Sergeenko",
     "url": "https://github.com/bricss"
   },
   "bugs": {
     "url": "https://github.com/bricss/rekwest/issues"
   },
+  "description": "The robust request library that humanity deserves 🌐",
   "devDependencies": {
-    "@babel/cli": "^7.28.3",
-    "@babel/core": "^7.28.5",
-    "@babel/eslint-parser": "^7.28.5",
-    "@babel/preset-env": "^7.28.5",
+    "@babel/cli": "^7.28.6",
+    "@babel/core": "^7.29.0",
+    "@babel/eslint-parser": "^7.28.6",
+    "@babel/preset-env": "^7.29.0",
     "c8": "^10.1.3",
     "eslint": "^9.39.2",
-    "eslint-config-ultra-refined": "^3.8.4",
+    "eslint-config-ultra-refined": "^3.8.5",
     "mocha": "^11.7.5"
   },
-  "description": "The robust request library that humanity deserves 🌐",
   "engines": {
     "node": ">=20.0.0"
   },
   "exports": {
-    "import": "./src/index.mjs",
-    "require": "./dist/index.js"
+    "import": "./src/index.js",
+    "require": "./dist/index.cjs"
   },
   "files": [
     "dist",
@@ -61,15 +61,16 @@
     "url": "git+https://github.com/bricss/rekwest.git"
   },
   "scripts": {
-    "build": "rm -rf dist && npx babel src -d dist",
+    "build": "rm -rf dist && npx babel src --out-dir dist --out-file-extension .cjs",
     "cert:gen": "openssl req -days 365 -keyout localhost.key -newkey ec -nodes -pkeyopt ec_paramgen_curve:prime256v1 -subj //SKIP=1/CN=localhost -out localhost.cert -x509",
     "cert:ken": "openssl x509 -in localhost.cert -noout -text",
-    "lint": "eslint",
-    "prepack": "npm run build && sh pony.sh",
+    "lint": "eslint --concurrency=auto",
+    "prepack": "npm run build && sh misc.sh && npm run lint",
     "pretest": "rm -rf coverage && npm run cert:gen",
     "test": "mocha",
     "test:bail": "mocha --bail",
     "test:cover": "c8 --include=src --reporter=lcov --reporter=text npm test"
   },
-  "version": "6.2.1"
+  "type": "module",
+  "version": "7.0.1"
 }

package/src/{ackn.mjs → ackn.js}

@@ -1,33 +1,33 @@
-import { connect } from 'node:tls';
-
-export const ackn = (options) => new Promise((resolve, reject) => {
-  const { url } = options;
-  const socket = connect({
-    ...options,
-    ALPNProtocols: [
-      'h2',
-      'http/1.1',
-    ],
-    host: url.hostname,
-    port: parseInt(url.port) || 443,
-    servername: url.hostname,
-  }, () => {
-    socket.off('error', reject);
-    socket.off('timeout', reject);
-
-    const { alpnProtocol } = socket;
-
-    resolve({
-      ...options,
-      alpnProtocol,
-      createConnection() {
-        return socket;
-      },
-      h2: /h2c?/i.test(alpnProtocol),
-      protocol: url.protocol,
-    });
-  });
-
-  socket.on('error', reject);
-  socket.on('timeout', reject);
-});
+import { connect } from 'node:tls';
+
+export const ackn = (options) => new Promise((resolve, reject) => {
+  const { url } = options;
+  const socket = connect({
+    ...options,
+    ALPNProtocols: [
+      'h2',
+      'http/1.1',
+    ],
+    host: url.hostname,
+    port: parseInt(url.port) || 443,
+    servername: url.hostname,
+  }, () => {
+    socket.off('error', reject);
+    socket.off('timeout', reject);
+
+    const { alpnProtocol } = socket;
+
+    resolve({
+      ...options,
+      alpnProtocol,
+      createConnection() {
+        return socket;
+      },
+      h2: /h2c?/i.test(alpnProtocol),
+      protocol: url.protocol,
+    });
+  });
+
+  socket.on('error', reject);
+  socket.on('timeout', reject);
+});

package/src/codecs.js

@@ -0,0 +1,55 @@
+import { pipeline } from 'node:stream';
+import zlib from 'node:zlib';
+import { isZstdSupported } from './config.js';
+import { unwind } from './utils.js';
+
+export const decodeCodecs = {
+  br: (opts) => zlib.createBrotliDecompress(opts?.brotli),
+  deflate: (opts) => zlib.createInflate(opts?.zlib),
+  'deflate-raw': (opts) => zlib.createInflateRaw(opts?.zlib),
+  gzip: (opts) => zlib.createGunzip(opts?.zlib),
+  zstd: (opts) => isZstdSupported && zlib.createZstdDecompress(opts?.zstd),
+};
+
+export const decode = (readable, encodings = '', { decodersOptions } = {}) => {
+  const decoders = [];
+
+  encodings = unwind(encodings).reverse();
+
+  for (const encoding of encodings) {
+    const decoder = decodeCodecs[encoding]?.(decodersOptions);
+
+    if (!decoder) {
+      return readable;
+    }
+
+    decoders.push(decoder);
+  }
+
+  return pipeline(readable, ...decoders, () => void 0);
+};
+
+export const encodeCodecs = {
+  br: (opts) => zlib.createBrotliCompress(opts?.brotli),
+  deflate: (opts) => zlib.createDeflate(opts?.zlib),
+  'deflate-raw': (opts) => zlib.createDeflateRaw(opts?.zlib),
+  gzip: (opts) => zlib.createGzip(opts?.zlib),
+  zstd: (opts) => isZstdSupported && zlib.createZstdCompress(opts?.zstd),
+};
+export const encode = (readable, encodings = '', { encodersOptions } = {}) => {
+  const encoders = [];
+
+  encodings = unwind(encodings);
+
+  for (const encoding of encodings) {
+    const encoder = encodeCodecs[encoding]?.(encodersOptions);
+
+    if (!encoder) {
+      return readable;
+    }
+
+    encoders.push(encoder);
+  }
+
+  return pipeline(readable, ...encoders, () => void 0);
+};