rekwest 5.2.5 → 5.2.7

package/package.json

@@ -8,15 +8,15 @@
     "url": "https://github.com/bricss/rekwest/issues"
   },
   "devDependencies": {
-    "@babel/cli": "^7.24.7",
-    "@babel/core": "^7.24.7",
-    "@babel/eslint-parser": "^7.24.7",
-    "@babel/preset-env": "^7.24.7",
-    "@stylistic/eslint-plugin-js": "^2.1.0",
+    "@babel/cli": "^7.25.6",
+    "@babel/core": "^7.25.2",
+    "@babel/eslint-parser": "^7.25.1",
+    "@babel/preset-env": "^7.25.4",
+    "@stylistic/eslint-plugin-js": "^2.7.2",
     "c8": "^10.1.2",
-    "eslint": "^9.4.0",
-    "eslint-config-ultra-refined": "^3.1.2",
-    "mocha": "^10.4.0"
+    "eslint": "^9.10.0",
+    "eslint-config-ultra-refined": "^3.2.5",
+    "mocha": "^10.7.3"
   },
   "description": "The robust request library that humanity deserves 🌐",
   "engines": {
@@ -70,5 +70,5 @@
     "test:bail": "mocha --bail",
     "test:cover": "c8 --include=src --reporter=lcov --reporter=text npm test"
   },
-  "version": "5.2.5"
+  "version": "5.2.7"
 }

package/src/errors.mjs

@@ -1,18 +1,18 @@
-export class RequestError extends Error {
-
-  get [Symbol.toStringTag]() {
-    return this.constructor.name;
-  }
-
-  get name() {
-    return this[Symbol.toStringTag];
-  }
-
-  constructor(...args) {
-    super(...args);
-    Error.captureStackTrace(this, this.constructor);
-  }
-
-}
-
-export class TimeoutError extends RequestError {}
+export class RequestError extends Error {
+
+  get [Symbol.toStringTag]() {
+    return this.constructor.name;
+  }
+
+  get name() {
+    return this[Symbol.toStringTag];
+  }
+
+  constructor(...args) {
+    super(...args);
+    Error.captureStackTrace(this, this.constructor);
+  }
+
+}
+
+export class TimeoutError extends RequestError {}

package/src/index.mjs

@@ -1,87 +1,87 @@
-import http from 'node:http';
-import http2 from 'node:http2';
-import https from 'node:https';
-import { requestRedirect } from './constants.mjs';
-import defaults from './defaults.mjs';
-import { APPLICATION_OCTET_STREAM } from './mediatypes.mjs';
-import { preflight } from './preflight.mjs';
-import { transfer } from './transfer.mjs';
-import {
-  admix,
-  affix,
-  copyWithMerge,
-  normalize,
-} from './utils.mjs';
-import { validation } from './validation.mjs';
-
-export {
-  Blob,
-  File,
-} from 'node:buffer';
-export { constants } from 'node:http2';
-
-export * from './ackn.mjs';
-export * from './constants.mjs';
-export * from './cookies.mjs';
-export * from './errors.mjs';
-export * from './formdata.mjs';
-export * as mediatypes from './mediatypes.mjs';
-export * from './mixin.mjs';
-export * from './utils.mjs';
-export * from './validation.mjs';
-
-const {
-  HTTP2_HEADER_CONTENT_TYPE,
-} = http2.constants;
-
-export default function rekwest(url, options) {
-  return transfer(validation(normalize(url, options)), rekwest);
-}
-
-Reflect.defineProperty(rekwest, 'defaults', {
-  enumerable: true,
-  get() { return defaults.stash; },
-  set(value) { defaults.stash = copyWithMerge(defaults.stash, value); },
-});
-
-Reflect.defineProperty(rekwest, 'extend', {
-  enumerable: true,
-  value(options) {
-    return (url, opts) => rekwest(url, copyWithMerge(options, opts));
-  },
-});
-
-Reflect.defineProperty(rekwest, 'stream', {
-  enumerable: true,
-  value(url, options) {
-    options = preflight(validation(normalize(url, copyWithMerge({}, options, {
-      headers: { [HTTP2_HEADER_CONTENT_TYPE]: APPLICATION_OCTET_STREAM },
-      redirect: requestRedirect.manual,
-    }))));
-    let client, req;
-
-    if (options.h2) {
-      client = http2.connect(options.url.origin, options);
-      req = client.request(options.headers, options);
-    } else {
-      const { request } = options.url.protocol === 'http:' ? http : https;
-
-      req = request(options.url, options);
-    }
-
-    affix(client, req, options);
-
-    req.once('response', (res) => {
-      let headers;
-
-      if (options.h2) {
-        headers = res;
-        res = req;
-      }
-
-      admix(res, headers, options);
-    });
-
-    return req;
-  },
-});
+import http from 'node:http';
+import http2 from 'node:http2';
+import https from 'node:https';
+import { requestRedirect } from './constants.mjs';
+import defaults from './defaults.mjs';
+import { APPLICATION_OCTET_STREAM } from './mediatypes.mjs';
+import { preflight } from './preflight.mjs';
+import { transfer } from './transfer.mjs';
+import {
+  admix,
+  affix,
+  copyWithMerge,
+  normalize,
+} from './utils.mjs';
+import { validation } from './validation.mjs';
+
+export {
+  Blob,
+  File,
+} from 'node:buffer';
+export { constants } from 'node:http2';
+
+export * from './ackn.mjs';
+export * from './constants.mjs';
+export * from './cookies.mjs';
+export * from './errors.mjs';
+export * from './formdata.mjs';
+export * as mediatypes from './mediatypes.mjs';
+export * from './mixin.mjs';
+export * from './utils.mjs';
+export * from './validation.mjs';
+
+const {
+  HTTP2_HEADER_CONTENT_TYPE,
+} = http2.constants;
+
+export default function rekwest(url, options) {
+  return transfer(validation(normalize(url, options)), rekwest);
+}
+
+Reflect.defineProperty(rekwest, 'defaults', {
+  enumerable: true,
+  get() { return defaults.stash; },
+  set(value) { defaults.stash = copyWithMerge(defaults.stash, value); },
+});
+
+Reflect.defineProperty(rekwest, 'extend', {
+  enumerable: true,
+  value(options) {
+    return (url, opts) => rekwest(url, copyWithMerge(options, opts));
+  },
+});
+
+Reflect.defineProperty(rekwest, 'stream', {
+  enumerable: true,
+  value(url, options) {
+    options = preflight(validation(normalize(url, copyWithMerge({}, options, {
+      headers: { [HTTP2_HEADER_CONTENT_TYPE]: APPLICATION_OCTET_STREAM },
+      redirect: requestRedirect.manual,
+    }))));
+    let client, req;
+
+    if (options.h2) {
+      client = http2.connect(options.url.origin, options);
+      req = client.request(options.headers, options);
+    } else {
+      const { request } = options.url.protocol === 'http:' ? http : https;
+
+      req = request(options.url, options);
+    }
+
+    affix(client, req, options);
+
+    req.once('response', (res) => {
+      let headers;
+
+      if (options.h2) {
+        headers = res;
+        res = req;
+      }
+
+      admix(res, headers, options);
+    });
+
+    return req;
+  },
+});

package/src/postflight.mjs

@@ -1,136 +1,136 @@
-import http2 from 'node:http2';
-import { setTimeout as setTimeoutPromise } from 'node:timers/promises';
-import {
-  requestCredentials,
-  requestRedirect,
-  requestRedirectCodes,
-} from './constants.mjs';
-import { Cookies } from './cookies.mjs';
-import { RequestError } from './errors.mjs';
-import rekwest from './index.mjs';
-import { mixin } from './mixin.mjs';
-import {
-  admix,
-  maxRetryAfterError,
-  sameOrigin,
-} from './utils.mjs';
-
-const {
-  HTTP2_HEADER_LOCATION,
-  HTTP2_HEADER_RETRY_AFTER,
-  HTTP2_HEADER_SET_COOKIE,
-  HTTP2_METHOD_GET,
-  HTTP2_METHOD_HEAD,
-  HTTP2_METHOD_POST,
-  HTTP_STATUS_BAD_REQUEST,
-  HTTP_STATUS_FOUND,
-  HTTP_STATUS_MOVED_PERMANENTLY,
-  HTTP_STATUS_SEE_OTHER,
-} = http2.constants;
-
-export const postflight = (req, res, options, { reject, resolve }) => {
-  const { cookies, credentials, follow, h2, redirect, url } = options;
-  let headers;
-
-  if (h2) {
-    headers = res;
-    res = req;
-  } else {
-    res.once('error', reject);
-  }
-
-  admix(res, headers, options);
-
-  if (cookies !== false && res.headers[HTTP2_HEADER_SET_COOKIE]) {
-    if (Cookies.jar.has(url.origin)) {
-      const cookie = new Cookies(res.headers[HTTP2_HEADER_SET_COOKIE], options);
-
-      Cookies.jar.get(url.origin).forEach((val, key) => {
-        if (!cookie.has(key)) {
-          cookie.set(key, val);
-        }
-      });
-      Cookies.jar.set(url.origin, cookie);
-    } else {
-      Cookies.jar.set(url.origin, new Cookies(res.headers[HTTP2_HEADER_SET_COOKIE], options));
-    }
-  }
-
-  Reflect.defineProperty(res, 'cookies', {
-    enumerable: true,
-    value: cookies !== false && Cookies.jar.has(url.origin)
-           ? Cookies.jar.get(url.origin)
-           : void 0,
-  });
-
-  const { statusCode } = res;
-
-  if (follow && /3\d{2}/.test(statusCode) && res.headers[HTTP2_HEADER_LOCATION]) {
-    if (!requestRedirectCodes.includes(statusCode)) {
-      return res.emit('error', new RangeError(`Invalid status code: ${ statusCode }`));
-    }
-
-    if (redirect === requestRedirect.error) {
-      return res.emit('error', new RequestError(`Unexpected redirect, redirect mode is set to '${ redirect }'.`));
-    }
-
-    if (redirect === requestRedirect.follow) {
-      const location = new URL(res.headers[HTTP2_HEADER_LOCATION], url);
-
-      if (!/^https?:/i.test(location.protocol)) {
-        return res.emit('error', new RequestError('URL scheme must be "http" or "https".'));
-      }
-
-      if (!sameOrigin(location, url)) {
-        if (credentials !== requestCredentials.include) {
-          options.credentials = requestCredentials.omit;
-        }
-
-        options.h2 = false;
-      }
-
-      if (statusCode !== HTTP_STATUS_SEE_OTHER && options.body?.pipe?.constructor === Function) {
-        return res.emit('error', new RequestError(`Unable to ${ redirect } redirect with streamable body.`));
-      }
-
-      if (([
-        HTTP_STATUS_MOVED_PERMANENTLY,
-        HTTP_STATUS_FOUND,
-      ].includes(statusCode) && options.method === HTTP2_METHOD_POST) || (statusCode === HTTP_STATUS_SEE_OTHER && ![
-        HTTP2_METHOD_GET,
-        HTTP2_METHOD_HEAD,
-      ].includes(options.method))) {
-        for (const it of Object.keys(options.headers).filter((val) => /^content-/i.test(val))) {
-          Reflect.deleteProperty(options.headers, it);
-        }
-
-        options.body = null;
-        options.method = HTTP2_METHOD_GET;
-      }
-
-      options.follow--;
-      options.redirected = true;
-      options.url = location;
-
-      if (statusCode === HTTP_STATUS_MOVED_PERMANENTLY && res.headers[HTTP2_HEADER_RETRY_AFTER]) {
-        let interval = res.headers[HTTP2_HEADER_RETRY_AFTER];
-
-        interval = Number(interval) * 1e3 || new Date(interval) - Date.now();
-
-        if (interval > options.maxRetryAfter) {
-          return res.emit('error', maxRetryAfterError(interval, { cause: mixin(res, options) }));
-        }
-
-        return setTimeoutPromise(interval).then(() => rekwest(options.url, options).then(resolve, reject));
-      }
-
-      return rekwest(options.url, options).then(resolve, reject);
-    }
-  }
-
-  if (statusCode >= HTTP_STATUS_BAD_REQUEST) {
-    return reject(mixin(res, options));
-  }
-
-  resolve(mixin(res, options));
-};
+import http2 from 'node:http2';
+import { setTimeout as setTimeoutPromise } from 'node:timers/promises';
+import {
+  requestCredentials,
+  requestRedirect,
+  requestRedirectCodes,
+} from './constants.mjs';
+import { Cookies } from './cookies.mjs';
+import { RequestError } from './errors.mjs';
+import rekwest from './index.mjs';
+import { mixin } from './mixin.mjs';
+import {
+  admix,
+  maxRetryAfterError,
+  sameOrigin,
+} from './utils.mjs';
+
+const {
+  HTTP2_HEADER_LOCATION,
+  HTTP2_HEADER_RETRY_AFTER,
+  HTTP2_HEADER_SET_COOKIE,
+  HTTP2_METHOD_GET,
+  HTTP2_METHOD_HEAD,
+  HTTP2_METHOD_POST,
+  HTTP_STATUS_BAD_REQUEST,
+  HTTP_STATUS_FOUND,
+  HTTP_STATUS_MOVED_PERMANENTLY,
+  HTTP_STATUS_SEE_OTHER,
+} = http2.constants;
+
+export const postflight = (req, res, options, { reject, resolve }) => {
+  const { cookies, credentials, follow, h2, redirect, url } = options;
+  let headers;
+
+  if (h2) {
+    headers = res;
+    res = req;
+  } else {
+    res.once('error', reject);
+  }
+
+  admix(res, headers, options);
+
+  if (cookies !== false && res.headers[HTTP2_HEADER_SET_COOKIE]) {
+    if (Cookies.jar.has(url.origin)) {
+      const cookie = new Cookies(res.headers[HTTP2_HEADER_SET_COOKIE], options);
+
+      Cookies.jar.get(url.origin).forEach((val, key) => {
+        if (!cookie.has(key)) {
+          cookie.set(key, val);
+        }
+      });
+      Cookies.jar.set(url.origin, cookie);
+    } else {
+      Cookies.jar.set(url.origin, new Cookies(res.headers[HTTP2_HEADER_SET_COOKIE], options));
+    }
+  }
+
+  Reflect.defineProperty(res, 'cookies', {
+    enumerable: true,
+    value: cookies !== false && Cookies.jar.has(url.origin)
+           ? Cookies.jar.get(url.origin)
+           : void 0,
+  });
+
+  const { statusCode } = res;
+
+  if (follow && /3\d{2}/.test(statusCode) && res.headers[HTTP2_HEADER_LOCATION]) {
+    if (!requestRedirectCodes.includes(statusCode)) {
+      return res.emit('error', new RangeError(`Invalid status code: ${ statusCode }`));
+    }
+
+    if (redirect === requestRedirect.error) {
+      return res.emit('error', new RequestError(`Unexpected redirect, redirect mode is set to '${ redirect }'.`));
+    }
+
+    if (redirect === requestRedirect.follow) {
+      const location = new URL(res.headers[HTTP2_HEADER_LOCATION], url);
+
+      if (!/^https?:/i.test(location.protocol)) {
+        return res.emit('error', new RequestError('URL scheme must be "http" or "https".'));
+      }
+
+      if (!sameOrigin(location, url)) {
+        if (credentials !== requestCredentials.include) {
+          options.credentials = requestCredentials.omit;
+        }
+
+        options.h2 = false;
+      }
+
+      if (statusCode !== HTTP_STATUS_SEE_OTHER && options.body?.pipe?.constructor === Function) {
+        return res.emit('error', new RequestError(`Unable to ${ redirect } redirect with streamable body.`));
+      }
+
+      if (([
+        HTTP_STATUS_MOVED_PERMANENTLY,
+        HTTP_STATUS_FOUND,
+      ].includes(statusCode) && options.method === HTTP2_METHOD_POST) || (statusCode === HTTP_STATUS_SEE_OTHER && ![
+        HTTP2_METHOD_GET,
+        HTTP2_METHOD_HEAD,
+      ].includes(options.method))) {
+        for (const it of Object.keys(options.headers).filter((val) => /^content-/i.test(val))) {
+          Reflect.deleteProperty(options.headers, it);
+        }
+
+        options.body = null;
+        options.method = HTTP2_METHOD_GET;
+      }
+
+      options.follow--;
+      options.redirected = true;
+      options.url = location;
+
+      if (statusCode === HTTP_STATUS_MOVED_PERMANENTLY && res.headers[HTTP2_HEADER_RETRY_AFTER]) {
+        let interval = res.headers[HTTP2_HEADER_RETRY_AFTER];
+
+        interval = Number(interval) * 1e3 || new Date(interval) - Date.now();
+
+        if (interval > options.maxRetryAfter) {
+          return res.emit('error', maxRetryAfterError(interval, { cause: mixin(res, options) }));
+        }
+
+        return setTimeoutPromise(interval).then(() => rekwest(options.url, options).then(resolve, reject));
+      }
+
+      return rekwest(options.url, options).then(resolve, reject);
+    }
+  }
+
+  if (statusCode >= HTTP_STATUS_BAD_REQUEST) {
+    return reject(mixin(res, options));
+  }
+
+  resolve(mixin(res, options));
+};

package/src/transfer.mjs

@@ -1,117 +1,117 @@
-import http from 'node:http';
-import http2 from 'node:http2';
-import https from 'node:https';
-import { setTimeout as setTimeoutPromise } from 'node:timers/promises';
-import { ackn } from './ackn.mjs';
-import { RequestError } from './errors.mjs';
-import { postflight } from './postflight.mjs';
-import { preflight } from './preflight.mjs';
-import { transform } from './transform.mjs';
-import {
-  affix,
-  dispatch,
-  maxRetryAfterError,
-} from './utils.mjs';
-
-const {
-  HTTP2_HEADER_RETRY_AFTER,
-} = http2.constants;
-
-export const transfer = async (options, overact) => {
-  const { digest, redirected, thenable, url } = options;
-
-  if (options.follow === 0) {
-    throw new RequestError(`Maximum redirect reached at: ${ url.href }`);
-  }
-
-  if (url.protocol === 'https:') {
-    options = !options.h2 ? await ackn(options) : {
-      ...options,
-      createConnection: null,
-      protocol: url.protocol,
-    };
-  } else if (Reflect.has(options, 'alpnProtocol')) {
-    for (const it of [
-      'alpnProtocol',
-      'createConnection',
-      'h2',
-      'protocol',
-    ]) { Reflect.deleteProperty(options, it); }
-  }
-
-  try {
-    options = await transform(preflight(options));
-  } catch (ex) {
-    options.createConnection?.().destroy();
-    throw ex;
-  }
-
-  const promise = new Promise((resolve, reject) => {
-    let client, req;
-
-    if (options.h2) {
-      client = http2.connect(url.origin, options);
-      req = client.request(options.headers, options);
-    } else {
-      const { request } = url.protocol === 'http:' ? http : https;
-
-      req = request(url, options);
-    }
-
-    affix(client, req, options);
-
-    req.once('aborted', reject);
-    req.once('error', reject);
-    req.once('frameError', reject);
-    req.once('goaway', reject);
-    req.once('response', (res) => postflight(req, res, options, {
-      reject,
-      resolve,
-    }));
-
-    dispatch(options, req);
-  });
-
-  try {
-    const res = await promise;
-
-    if (digest && !redirected) {
-      res.body = await res.body();
-    }
-
-    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 maxRetryAfterError(interval, { cause: ex });
-          }
-        } else {
-          interval = new Function('interval', `return Math.ceil(${ retry.backoffStrategy });`)(interval);
-        }
-
-        retry.attempts--;
-        retry.interval = interval;
-
-        return setTimeoutPromise(interval).then(() => overact(url, options));
-      }
-    }
-
-    if (digest && !redirected && ex.body) {
-      ex.body = await ex.body();
-    }
-
-    if (!thenable) {
-      throw ex;
-    } else {
-      return ex;
-    }
-  }
-};
+import http from 'node:http';
+import http2 from 'node:http2';
+import https from 'node:https';
+import { setTimeout as setTimeoutPromise } from 'node:timers/promises';
+import { ackn } from './ackn.mjs';
+import { RequestError } from './errors.mjs';
+import { postflight } from './postflight.mjs';
+import { preflight } from './preflight.mjs';
+import { transform } from './transform.mjs';
+import {
+  affix,
+  dispatch,
+  maxRetryAfterError,
+} from './utils.mjs';
+
+const {
+  HTTP2_HEADER_RETRY_AFTER,
+} = http2.constants;
+
+export const transfer = async (options, overact) => {
+  const { digest, redirected, thenable, url } = options;
+
+  if (options.follow === 0) {
+    throw new RequestError(`Maximum redirect reached at: ${ url.href }`);
+  }
+
+  if (url.protocol === 'https:') {
+    options = !options.h2 ? await ackn(options) : {
+      ...options,
+      createConnection: null,
+      protocol: url.protocol,
+    };
+  } else if (Reflect.has(options, 'alpnProtocol')) {
+    for (const it of [
+      'alpnProtocol',
+      'createConnection',
+      'h2',
+      'protocol',
+    ]) { Reflect.deleteProperty(options, it); }
+  }
+
+  try {
+    options = await transform(preflight(options));
+  } catch (ex) {
+    options.createConnection?.().destroy();
+    throw ex;
+  }
+
+  const promise = new Promise((resolve, reject) => {
+    let client, req;
+
+    if (options.h2) {
+      client = http2.connect(url.origin, options);
+      req = client.request(options.headers, options);
+    } else {
+      const { request } = url.protocol === 'http:' ? http : https;
+
+      req = request(url, options);
+    }
+
+    affix(client, req, options);
+
+    req.once('aborted', reject);
+    req.once('error', reject);
+    req.once('frameError', reject);
+    req.once('goaway', reject);
+    req.once('response', (res) => postflight(req, res, options, {
+      reject,
+      resolve,
+    }));
+
+    dispatch(options, req);
+  });
+
+  try {
+    const res = await promise;
+
+    if (digest && !redirected) {
+      res.body = await res.body();
+    }
+
+    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 maxRetryAfterError(interval, { cause: ex });
+          }
+        } else {
+          interval = new Function('interval', `return Math.ceil(${ retry.backoffStrategy });`)(interval);
+        }
+
+        retry.attempts--;
+        retry.interval = interval;
+
+        return setTimeoutPromise(interval).then(() => overact(url, options));
+      }
+    }
+
+    if (digest && !redirected && ex.body) {
+      ex.body = await ex.body();
+    }
+
+    if (!thenable) {
+      throw ex;
+    } else {
+      return ex;
+    }
+  }
+};

package/src/utils.mjs

@@ -1,201 +1,201 @@
-import {
-  Blob,
-  File,
-} from 'node:buffer';
-import http2 from 'node:http2';
-import { pipeline } from 'node:stream';
-import zlib from 'node:zlib';
-import defaults from './defaults.mjs';
-import {
-  RequestError,
-  TimeoutError,
-} from './errors.mjs';
-
-const {
-  HTTP2_HEADER_RETRY_AFTER,
-  HTTP2_HEADER_STATUS,
-} = http2.constants;
-
-export const admix = (res, headers, options) => {
-  const { h2 } = options;
-
-  if (h2) {
-    Reflect.defineProperty(res, 'headers', {
-      enumerable: true,
-      value: headers,
-    });
-
-    Reflect.defineProperty(res, 'httpVersion', {
-      enumerable: true,
-      value: `${ h2 + 1 }.0`,
-    });
-
-    Reflect.defineProperty(res, 'statusCode', {
-      enumerable: true,
-      value: headers[HTTP2_HEADER_STATUS],
-    });
-  }
-
-  Reflect.defineProperty(res, 'ok', {
-    enumerable: true,
-    value: /^2\d{2}$/.test(res.statusCode),
-  });
-
-  Reflect.defineProperty(res, 'redirected', {
-    enumerable: true,
-    value: !!options.redirected,
-  });
-};
-
-export const affix = (client, req, options) => {
-  req.once('close', () => client?.close());
-  req.once('end', () => client?.close());
-  req.once('timeout', () => req.destroy(new TimeoutError(`Timed out after ${ options.timeout } ms.`)));
-  req.once('trailers', (trailers) => {
-    Reflect.defineProperty(req, 'trailers', {
-      enumerable: true,
-      value: trailers,
-    });
-  });
-};
-
-export const brandCheck = (value, ctor) => {
-  if (!(value instanceof ctor)) {
-    throw new TypeError('Illegal invocation');
-  }
-};
-
-export const compress = (readable, encodings = '') => {
-  const encoders = [];
-
-  encodings = unwind(encodings);
-
-  for (const encoding of encodings) {
-    if (/\bbr\b/i.test(encoding)) {
-      encoders.push(zlib.createBrotliCompress());
-    } else if (/\bdeflate(?!-(?:\w+)?)\b/i.test(encoding)) {
-      encoders.push(zlib.createDeflate());
-    } else if (/\bdeflate-raw\b/i.test(encoding)) {
-      encoders.push(zlib.createDeflateRaw());
-    } else if (/\bgzip\b/i.test(encoding)) {
-      encoders.push(zlib.createGzip());
-    } else {
-      return readable;
-    }
-  }
-
-  return pipeline(readable, ...encoders, () => void 0);
-};
-
-export const copyWithMerge = (target, ...rest) => {
-  target = structuredClone(target);
-  if (!rest.length) {
-    return target;
-  }
-
-  return merge(target, ...rest);
-};
-
-export const decompress = (readable, encodings = '') => {
-  const decoders = [];
-
-  encodings = unwind(encodings);
-
-  for (const encoding of encodings) {
-    if (/\bbr\b/i.test(encoding)) {
-      decoders.push(zlib.createBrotliDecompress());
-    } else if (/\bdeflate(?!-(?:\w+)?)\b/i.test(encoding)) {
-      decoders.push(zlib.createInflate());
-    } else if (/\bdeflate-raw\b/i.test(encoding)) {
-      decoders.push(zlib.createInflateRaw());
-    } else if (/\bgzip\b/i.test(encoding)) {
-      decoders.push(zlib.createGunzip());
-    } else {
-      return readable;
-    }
-  }
-
-  return pipeline(readable, ...decoders, () => void 0);
-};
-
-export const dispatch = ({ body }, req) => {
-  if (body?.pipe?.constructor === Function) {
-    body.pipe(req);
-  } else {
-    req.end(body);
-  }
-};
-
-export const isFileLike = (instance) => {
-  return [
-    Blob.name,
-    File.name,
-  ].includes(instance?.[Symbol.toStringTag]);
-};
-
-export const isReadableStream = (instance) => {
-  return ReadableStream.name === instance?.[Symbol.toStringTag];
-};
-
-export const maxRetryAfter = Symbol('maxRetryAfter');
-
-export const maxRetryAfterError = (
-  interval,
-  options,
-) => new RequestError(`Maximum '${ HTTP2_HEADER_RETRY_AFTER }' limit exceeded: ${ interval } ms.`, options);
-
-export const merge = (target, ...rest) => {
-  rest = rest.filter((it) => it === Object(it));
-  for (const source of rest) {
-    for (const key of Object.getOwnPropertyNames(source)) {
-      const sv = source[key];
-      const tv = target[key];
-
-      if (Object(sv) === sv && Object(tv) === tv) {
-        target[key] = merge(tv, sv);
-        continue;
-      }
-
-      target[key] = source[key];
-    }
-  }
-
-  return target;
-};
-
-export const normalize = (url, options = {}) => {
-  if (!options.redirected) {
-    options = copyWithMerge(defaults.stash, options);
-  }
-
-  if (options.trimTrailingSlashes) {
-    url = `${ url }`.replace(/(?<!:)\/+/g, '/');
-  }
-
-  if (options.stripTrailingSlash) {
-    url = `${ url }`.replace(/\/$|\/(?=#)|\/(?=\?)/g, '');
-  }
-
-  url = new URL(url, options.baseURL);
-
-  return Object.assign(options, { url });
-};
-
-export const sameOrigin = (a, b) => a.protocol === b.protocol && a.hostname === b.hostname && a.port === b.port;
-
-export async function* tap(value) {
-  if (Reflect.has(value, Symbol.asyncIterator)) {
-    yield* value;
-  } else if (value.stream) {
-    yield* value.stream();
-  } else {
-    yield await value.arrayBuffer();
-  }
-}
-
-export const toCamelCase = (str) => str?.toLowerCase().replace(
-  /\p{Punctuation}.|\p{White_Space}./gu,
-  (val) => val.replace(/\p{Punctuation}+|\p{White_Space}+/gu, '').toUpperCase(),
-);
-
-export const unwind = (encodings) => encodings.split(',').map((it) => it.trim());
+import {
+  Blob,
+  File,
+} from 'node:buffer';
+import http2 from 'node:http2';
+import { pipeline } from 'node:stream';
+import zlib from 'node:zlib';
+import defaults from './defaults.mjs';
+import {
+  RequestError,
+  TimeoutError,
+} from './errors.mjs';
+
+const {
+  HTTP2_HEADER_RETRY_AFTER,
+  HTTP2_HEADER_STATUS,
+} = http2.constants;
+
+export const admix = (res, headers, options) => {
+  const { h2 } = options;
+
+  if (h2) {
+    Reflect.defineProperty(res, 'headers', {
+      enumerable: true,
+      value: headers,
+    });
+
+    Reflect.defineProperty(res, 'httpVersion', {
+      enumerable: true,
+      value: `${ h2 + 1 }.0`,
+    });
+
+    Reflect.defineProperty(res, 'statusCode', {
+      enumerable: true,
+      value: headers[HTTP2_HEADER_STATUS],
+    });
+  }
+
+  Reflect.defineProperty(res, 'ok', {
+    enumerable: true,
+    value: /^2\d{2}$/.test(res.statusCode),
+  });
+
+  Reflect.defineProperty(res, 'redirected', {
+    enumerable: true,
+    value: !!options.redirected,
+  });
+};
+
+export const affix = (client, req, options) => {
+  req.once('close', () => client?.close());
+  req.once('end', () => client?.close());
+  req.once('timeout', () => req.destroy(new TimeoutError(`Timed out after ${ options.timeout } ms.`)));
+  req.once('trailers', (trailers) => {
+    Reflect.defineProperty(req, 'trailers', {
+      enumerable: true,
+      value: trailers,
+    });
+  });
+};
+
+export const brandCheck = (value, ctor) => {
+  if (!(value instanceof ctor)) {
+    throw new TypeError('Illegal invocation');
+  }
+};
+
+export const compress = (readable, encodings = '') => {
+  const encoders = [];
+
+  encodings = unwind(encodings);
+
+  for (const encoding of encodings) {
+    if (/\bbr\b/i.test(encoding)) {
+      encoders.push(zlib.createBrotliCompress());
+    } else if (/\bdeflate(?!-(?:\w+)?)\b/i.test(encoding)) {
+      encoders.push(zlib.createDeflate());
+    } else if (/\bdeflate-raw\b/i.test(encoding)) {
+      encoders.push(zlib.createDeflateRaw());
+    } else if (/\bgzip\b/i.test(encoding)) {
+      encoders.push(zlib.createGzip());
+    } else {
+      return readable;
+    }
+  }
+
+  return pipeline(readable, ...encoders, () => void 0);
+};
+
+export const copyWithMerge = (target, ...rest) => {
+  target = structuredClone(target);
+  if (!rest.length) {
+    return target;
+  }
+
+  return merge(target, ...rest);
+};
+
+export const decompress = (readable, encodings = '') => {
+  const decoders = [];
+
+  encodings = unwind(encodings);
+
+  for (const encoding of encodings) {
+    if (/\bbr\b/i.test(encoding)) {
+      decoders.push(zlib.createBrotliDecompress());
+    } else if (/\bdeflate(?!-(?:\w+)?)\b/i.test(encoding)) {
+      decoders.push(zlib.createInflate());
+    } else if (/\bdeflate-raw\b/i.test(encoding)) {
+      decoders.push(zlib.createInflateRaw());
+    } else if (/\bgzip\b/i.test(encoding)) {
+      decoders.push(zlib.createGunzip());
+    } else {
+      return readable;
+    }
+  }
+
+  return pipeline(readable, ...decoders, () => void 0);
+};
+
+export const dispatch = ({ body }, req) => {
+  if (body?.pipe?.constructor === Function) {
+    body.pipe(req);
+  } else {
+    req.end(body);
+  }
+};
+
+export const isFileLike = (instance) => {
+  return [
+    Blob.name,
+    File.name,
+  ].includes(instance?.[Symbol.toStringTag]);
+};
+
+export const isReadableStream = (instance) => {
+  return ReadableStream.name === instance?.[Symbol.toStringTag];
+};
+
+export const maxRetryAfter = Symbol('maxRetryAfter');
+
+export const maxRetryAfterError = (
+  interval,
+  options,
+) => new RequestError(`Maximum '${ HTTP2_HEADER_RETRY_AFTER }' limit exceeded: ${ interval } ms.`, options);
+
+export const merge = (target, ...rest) => {
+  rest = rest.filter((it) => it === Object(it));
+  for (const source of rest) {
+    for (const key of Object.getOwnPropertyNames(source)) {
+      const sv = source[key];
+      const tv = target[key];
+
+      if (Object(sv) === sv && Object(tv) === tv) {
+        target[key] = merge(tv, sv);
+        continue;
+      }
+
+      target[key] = source[key];
+    }
+  }
+
+  return target;
+};
+
+export const normalize = (url, options = {}) => {
+  if (!options.redirected) {
+    options = copyWithMerge(defaults.stash, options);
+  }
+
+  if (options.trimTrailingSlashes) {
+    url = `${ url }`.replace(/(?<!:)\/+/g, '/');
+  }
+
+  if (options.stripTrailingSlash) {
+    url = `${ url }`.replace(/\/$|\/(?=#)|\/(?=\?)/g, '');
+  }
+
+  url = new URL(url, options.baseURL);
+
+  return Object.assign(options, { url });
+};
+
+export const sameOrigin = (a, b) => a.protocol === b.protocol && a.hostname === b.hostname && a.port === b.port;
+
+export async function* tap(value) {
+  if (Reflect.has(value, Symbol.asyncIterator)) {
+    yield* value;
+  } else if (value.stream) {
+    yield* value.stream();
+  } else {
+    yield await value.arrayBuffer();
+  }
+}
+
+export const toCamelCase = (str) => str?.toLowerCase().replace(
+  /\p{Punctuation}.|\p{White_Space}./gu,
+  (val) => val.replace(/\p{Punctuation}+|\p{White_Space}+/gu, '').toUpperCase(),
+);
+
+export const unwind = (encodings) => encodings.split(',').map((it) => it.trim());