rekwest 6.2.0 → 7.0.0

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

@@ -1,93 +1,88 @@
-import http2 from 'node:http2';
-import zlib from 'node:zlib';
-import {
-  requestCredentials,
-  requestRedirect,
-} from './constants.mjs';
-import {
-  APPLICATION_JSON,
-  TEXT_PLAIN,
-  WILDCARD,
-} from './mediatypes.mjs';
-import { maxRetryAfter } from './utils.mjs';
-
-const {
-  HTTP2_HEADER_ACCEPT,
-  HTTP2_HEADER_ACCEPT_ENCODING,
-  HTTP2_METHOD_GET,
-  HTTP_STATUS_BAD_GATEWAY,
-  HTTP_STATUS_GATEWAY_TIMEOUT,
-  HTTP_STATUS_INTERNAL_SERVER_ERROR,
-  HTTP_STATUS_SERVICE_UNAVAILABLE,
-  HTTP_STATUS_TOO_MANY_REQUESTS,
-} = http2.constants;
-
-export const isZstdSupported = !!zlib.constants.ZSTD_CLEVEL_DEFAULT;
-
-const defaults = {
-  compression: {
-    brotliOptions: {
-      params: {
-        [zlib.constants.BROTLI_PARAM_QUALITY]: 4,
-      },
-    },
-    zstdOptions: {
-      params: {
-        [zlib.constants.ZSTD_c_compressionLevel]: 6,
-      },
-    },
-  },
-  cookiesTTL: false,
-  credentials: requestCredentials.sameOrigin,
-  decompression: {},
-  digest: true,
-  follow: 20,
-  h2: false,
-  headers: {
-    [HTTP2_HEADER_ACCEPT]: `${ APPLICATION_JSON }, ${ TEXT_PLAIN }, ${ WILDCARD }`,
-    [HTTP2_HEADER_ACCEPT_ENCODING]: `br,${ isZstdSupported ? ' zstd, ' : ' ' }gzip, deflate, deflate-raw`,
-  },
-  get maxRetryAfter() {
-    return this[maxRetryAfter] ?? this.timeout;
-  },
-  set maxRetryAfter(value) {
-    this[maxRetryAfter] = value;
-  },
-  method: HTTP2_METHOD_GET,
-  parse: true,
-  redirect: requestRedirect.follow,
-  redirected: false,
-  retry: {
-    attempts: 0,
-    backoffStrategy: 'interval * Math.log(Math.random() * (Math.E * Math.E - Math.E) + Math.E)',
-    errorCodes: [
-      'EAI_AGAIN',
-      'ECONNREFUSED',
-      'ECONNRESET',
-      'EHOSTDOWN',
-      'EHOSTUNREACH',
-      'ENETDOWN',
-      'ENETUNREACH',
-      'ENOTFOUND',
-      'EPIPE',
-      'ERR_HTTP2_STREAM_ERROR',
-    ],
-    interval: 1e3,
-    retryAfter: true,
-    statusCodes: [
-      HTTP_STATUS_TOO_MANY_REQUESTS,
-      HTTP_STATUS_INTERNAL_SERVER_ERROR,
-      HTTP_STATUS_BAD_GATEWAY,
-      HTTP_STATUS_SERVICE_UNAVAILABLE,
-      HTTP_STATUS_GATEWAY_TIMEOUT,
-    ],
-  },
-  stripTrailingSlash: false,
-  thenable: false,
-  timeout: 3e5,
-  trimTrailingSlashes: false,
-};
-
-export default {
-  defaults,
-};
+import http2 from 'node:http2';
+import zlib from 'node:zlib';
+import {
+  requestCredentials,
+  requestRedirect,
+} from './constants.js';
+import {
+  APPLICATION_JSON,
+  TEXT_PLAIN,
+  WILDCARD,
+} from './mediatypes.js';
+
+export const isZstdSupported = !!zlib.constants.ZSTD_CLEVEL_DEFAULT;
+
+const {
+  HTTP2_HEADER_ACCEPT,
+  HTTP2_HEADER_ACCEPT_ENCODING,
+  HTTP2_METHOD_GET,
+  HTTP_STATUS_BAD_GATEWAY,
+  HTTP_STATUS_GATEWAY_TIMEOUT,
+  HTTP_STATUS_INTERNAL_SERVER_ERROR,
+  HTTP_STATUS_SERVICE_UNAVAILABLE,
+  HTTP_STATUS_TOO_MANY_REQUESTS,
+} = http2.constants;
+
+const timeout = 3e5;
+
+const defaults = {
+  bufferBody: false,
+  cookiesTTL: false,
+  credentials: requestCredentials.sameOrigin,
+  decodersOptions: {},
+  digest: true,
+  encodersOptions: {
+    brotli: {
+      params: {
+        [zlib.constants.BROTLI_PARAM_QUALITY]: 4,
+      },
+    },
+    zstd: {
+      params: {
+        [zlib.constants.ZSTD_c_compressionLevel]: 6,
+      },
+    },
+  },
+  follow: 20,
+  h2: false,
+  headers: {
+    [HTTP2_HEADER_ACCEPT]: `${ APPLICATION_JSON }, ${ TEXT_PLAIN }, ${ WILDCARD }`,
+    [HTTP2_HEADER_ACCEPT_ENCODING]: `br,${ isZstdSupported ? ' zstd, ' : ' ' }gzip, deflate, deflate-raw`,
+  },
+  maxRetryAfter: timeout,
+  method: HTTP2_METHOD_GET,
+  parse: true,
+  redirect: requestRedirect.follow,
+  redirected: false,
+  retry: {
+    attempts: 0,
+    backoffStrategy: 'interval * Math.log(Math.random() * (Math.E * Math.E - Math.E) + Math.E)',
+    errorCodes: [
+      'ECONNREFUSED',
+      'ECONNRESET',
+      'EHOSTDOWN',
+      'EHOSTUNREACH',
+      'ENETDOWN',
+      'ENETUNREACH',
+      'ENOTFOUND',
+      'ERR_HTTP2_STREAM_ERROR',
+    ],
+    interval: 1e3,
+    retryAfter: true,
+    statusCodes: [
+      HTTP_STATUS_TOO_MANY_REQUESTS,
+      HTTP_STATUS_INTERNAL_SERVER_ERROR,
+      HTTP_STATUS_BAD_GATEWAY,
+      HTTP_STATUS_SERVICE_UNAVAILABLE,
+      HTTP_STATUS_GATEWAY_TIMEOUT,
+    ],
+  },
+  stripTrailingSlash: false,
+  thenable: false,
+  timeout,
+  trimTrailingSlashes: false,
+};
+
+export default {
+  defaults,
+};

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

@@ -1,29 +1,29 @@
-import http2 from 'node:http2';
-
-const {
-  HTTP_STATUS_FOUND,
-  HTTP_STATUS_MOVED_PERMANENTLY,
-  HTTP_STATUS_PERMANENT_REDIRECT,
-  HTTP_STATUS_SEE_OTHER,
-  HTTP_STATUS_TEMPORARY_REDIRECT,
-} = http2.constants;
-
-export const requestCredentials = {
-  include: 'include',
-  omit: 'omit',
-  sameOrigin: 'same-origin',
-};
-
-export const requestRedirect = {
-  error: 'error',
-  follow: 'follow',
-  manual: 'manual',
-};
-
-export const requestRedirectCodes = [
-  HTTP_STATUS_MOVED_PERMANENTLY,
-  HTTP_STATUS_FOUND,
-  HTTP_STATUS_SEE_OTHER,
-  HTTP_STATUS_TEMPORARY_REDIRECT,
-  HTTP_STATUS_PERMANENT_REDIRECT,
-];
+import http2 from 'node:http2';
+
+const {
+  HTTP_STATUS_FOUND,
+  HTTP_STATUS_MOVED_PERMANENTLY,
+  HTTP_STATUS_PERMANENT_REDIRECT,
+  HTTP_STATUS_SEE_OTHER,
+  HTTP_STATUS_TEMPORARY_REDIRECT,
+} = http2.constants;
+
+export const requestCredentials = {
+  include: 'include',
+  omit: 'omit',
+  sameOrigin: 'same-origin',
+};
+
+export const requestRedirect = {
+  error: 'error',
+  follow: 'follow',
+  manual: 'manual',
+};
+
+export const requestRedirectCodes = [
+  HTTP_STATUS_MOVED_PERMANENTLY,
+  HTTP_STATUS_FOUND,
+  HTTP_STATUS_SEE_OTHER,
+  HTTP_STATUS_TEMPORARY_REDIRECT,
+  HTTP_STATUS_PERMANENT_REDIRECT,
+];

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

@@ -1,100 +1,100 @@
-import {
-  brandCheck,
-  toCamelCase,
-} from './utils.mjs';
-
-const lifetimeCap = 3456e7; // pragma: 400 days
-
-export class Cookies extends URLSearchParams {
-
-  static #finalizers = new Set();
-  static jar = new Map();
-
-  static #register(target, value) {
-    const finalizer = new FinalizationRegistry((heldValue) => {
-      clearTimeout(heldValue);
-      this.#finalizers.delete(finalizer);
-    });
-
-    finalizer.register(target, value);
-    this.#finalizers.add(finalizer);
-  }
-
-  #chronometry = new Map();
-
-  get [Symbol.toStringTag]() {
-    return this.constructor.name;
-  }
-
-  constructor(input, { cookiesTTL } = { cookiesTTL: false }) {
-    if (Array.isArray(input) && input.every((it) => !Array.isArray(it))) {
-      input = input.map((it) => {
-        if (!cookiesTTL) {
-          return [it.split(';').at(0).trim()];
-        }
-
-        const [cookie, ...attrs] = it.split(';').map((it) => it.trim());
-        const ttl = {};
-
-        for (const val of attrs) {
-          if (/(?:Expires|Max-Age)=/i.test(val)) {
-            const [key, value] = val.toLowerCase().split('=');
-            const ms = Number.isFinite(Number(value)) ? value * 1e3 : Date.parse(value) - Date.now();
-
-            ttl[toCamelCase(key)] = Math.min(ms, lifetimeCap);
-          }
-        }
-
-        return [
-          cookie.replace(/\u0022/g, ''),
-          Object.keys(ttl).length ? ttl : null,
-        ];
-      });
-    }
-
-    super(Array.isArray(input) ? input.map((it) => it.at(0)).join('&') : input);
-
-    if (Array.isArray(input) && cookiesTTL) {
-      for (const [cookie, ttl] of input.filter((it) => it.at(1))) {
-        const key = cookie.split('=').at(0);
-
-        if (this.#chronometry.has(key)) {
-          clearTimeout(this.#chronometry.get(key));
-          this.#chronometry.delete(key);
-        }
-
-        const { expires, maxAge } = ttl;
-
-        for (const ms of [
-          maxAge,
-          expires,
-        ]) {
-          if (!Number.isInteger(ms)) {
-            continue;
-          }
-
-          const ref = new WeakRef(this);
-          const tid = setTimeout(() => {
-            const ctx = ref.deref();
-
-            if (ctx) {
-              ctx.#chronometry.delete(key);
-              ctx.delete(key);
-            }
-          }, Math.max(ms, 0));
-
-          this.constructor.#register(this, tid);
-          this.#chronometry.set(key, tid);
-          break;
-        }
-      }
-    }
-  }
-
-  toString() {
-    brandCheck(this, Cookies);
-
-    return super.toString().split('&').join('; ').trim();
-  }
-
-}
+import {
+  brandCheck,
+  toCamelCase,
+} from './utils.js';
+
+const lifetimeCap = 3456e7; // pragma: 400 days
+
+export class Cookies extends URLSearchParams {
+
+  static #finalizers = new Set();
+  static jar = new Map();
+
+  static #register(target, value) {
+    const finalizer = new FinalizationRegistry((heldValue) => {
+      clearTimeout(heldValue);
+      this.#finalizers.delete(finalizer);
+    });
+
+    finalizer.register(target, value);
+    this.#finalizers.add(finalizer);
+  }
+
+  #chronometry = new Map();
+
+  get [Symbol.toStringTag]() {
+    return this.constructor.name;
+  }
+
+  constructor(input, { cookiesTTL } = { cookiesTTL: false }) {
+    if (Array.isArray(input) && input.every((it) => !Array.isArray(it))) {
+      input = input.map((it) => {
+        if (!cookiesTTL) {
+          return [it.split(';').at(0).trim()];
+        }
+
+        const [cookie, ...attrs] = it.split(';').map((it) => it.trim());
+        const ttl = {};
+
+        for (const val of attrs) {
+          if (/(?:expires|max-age)=/i.test(val)) {
+            const [key, value] = val.toLowerCase().split('=');
+            const ms = Number.isFinite(Number(value)) ? value * 1e3 : Date.parse(value) - Date.now();
+
+            ttl[toCamelCase(key)] = Math.min(ms, lifetimeCap);
+          }
+        }
+
+        return [
+          cookie.replace(/\u0022/g, ''),
+          Object.keys(ttl).length ? ttl : null,
+        ];
+      });
+    }
+
+    super(Array.isArray(input) ? input.map((it) => it.at(0)).join('&') : input);
+
+    if (Array.isArray(input) && cookiesTTL) {
+      for (const [cookie, ttl] of input.filter((it) => it.at(1))) {
+        const key = cookie.split('=').at(0);
+
+        if (this.#chronometry.has(key)) {
+          clearTimeout(this.#chronometry.get(key));
+          this.#chronometry.delete(key);
+        }
+
+        const { expires, maxAge } = ttl;
+
+        for (const ms of [
+          maxAge,
+          expires,
+        ]) {
+          if (!Number.isInteger(ms)) {
+            continue;
+          }
+
+          const ref = new WeakRef(this);
+          const tid = setTimeout(() => {
+            const ctx = ref.deref();
+
+            if (ctx) {
+              ctx.#chronometry.delete(key);
+              ctx.delete(key);
+            }
+          }, Math.max(ms, 0));
+
+          this.constructor.#register(this, tid);
+          this.#chronometry.set(key, tid);
+          break;
+        }
+      }
+    }
+  }
+
+  toString() {
+    brandCheck(this, Cookies);
+
+    return super.toString().split('&').join('; ').trim();
+  }
+
+}

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

@@ -5,12 +5,12 @@ import { toUSVString } from 'node:util';
 import {
   APPLICATION_OCTET_STREAM,
   MULTIPART_FORM_DATA,
-} from './mediatypes.mjs';
+} from './mediatypes.js';
 import {
   brandCheck,
   isFileLike,
   tap,
-} from './utils.mjs';
+} from './utils.js';
 
 const CRLF = '\r\n';
 const {
@@ -59,8 +59,8 @@ export class FormData {
     };
   }
 
-  static alike(instance) {
-    return FormData.name === instance?.[Symbol.toStringTag];
+  static alike(value) {
+    return FormData.name === value?.[Symbol.toStringTag];
   }
 
   static #enfoldEntry(name, value, filename) {
@@ -83,7 +83,7 @@ export class FormData {
   }
 
   static #ensureInstance(value) {
-    return isFileLike(value) || (value === Object(value) && Reflect.has(value, Symbol.asyncIterator));
+    return isFileLike(value) || (Object(value) === value && Reflect.has(value, Symbol.asyncIterator));
   }
 
   #entries = [];
@@ -93,13 +93,7 @@ export class FormData {
   }
 
   constructor(input) {
-    if (input === Object(input)
-      && (input?.constructor === Object || Reflect.has(input, Symbol.iterator))) {
-
-      if (input.constructor !== Object) {
-        input = Array.from(input);
-      }
-
+    if (Object(input) === input) {
       if (Array.isArray(input)) {
         if (!input.every((it) => Array.isArray(it))) {
           throw new TypeError(`Failed to construct '${
@@ -110,9 +104,9 @@ export class FormData {
             this[Symbol.toStringTag]
           }': Sequence initializer must only contain pair elements.`);
         }
-      }
 
-      if (input.constructor === Object) {
+        input = Array.from(input);
+      } else if (!Reflect.has(input, Symbol.iterator)) {
         input = Object.entries(input);
       }
 

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

@@ -1,41 +1,41 @@
 import http from 'node:http';
 import http2 from 'node:http2';
 import https from 'node:https';
-import config from './config.mjs';
-import { requestRedirect } from './constants.mjs';
-import { APPLICATION_OCTET_STREAM } from './mediatypes.mjs';
-import { preflight } from './preflight.mjs';
-import { transfer } from './transfer.mjs';
+import config from './config.js';
+import { requestRedirect } from './constants.js';
+import { APPLICATION_OCTET_STREAM } from './mediatypes.js';
+import { preflight } from './preflight.js';
+import { transfer } from './transfer.js';
 import {
-  admix,
-  affix,
+  augment,
   copyWithMerge,
   normalize,
-} from './utils.mjs';
-import { validation } from './validation.mjs';
+  snoop,
+} from './utils.js';
+import { validation } from './validation.js';
 
 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';
+export * from './ackn.js';
+export * from './codecs.js';
+export * from './constants.js';
+export * from './cookies.js';
+export * from './errors.js';
+export * from './formdata.js';
+export * as mediatypes from './mediatypes.js';
+export * from './mixin.js';
+export * from './utils.js';
+export * from './validation.js';
 
 const {
   HTTP2_HEADER_CONTENT_TYPE,
 } = http2.constants;
 
 export default function rekwest(url, options) {
-  return transfer(validation(normalize(url, options)), rekwest);
+  return transfer(validation(normalize(url, options)));
 }
 
 Reflect.defineProperty(rekwest, 'defaults', {
@@ -69,7 +69,7 @@ Reflect.defineProperty(rekwest, 'stream', {
       req = request(options.url, options);
     }
 
-    affix(client, req, options);
+    snoop(client, req, options);
 
     req.once('response', (res) => {
       let headers;
@@ -79,7 +79,7 @@ Reflect.defineProperty(rekwest, 'stream', {
         res = req;
       }
 
-      admix(res, headers, options);
+      augment(res, headers, options);
     });
 
     return req;

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

@@ -1,6 +1,6 @@
-export const APPLICATION_FORM_URLENCODED = 'application/x-www-form-urlencoded';
-export const APPLICATION_JSON = 'application/json';
-export const APPLICATION_OCTET_STREAM = 'application/octet-stream';
-export const MULTIPART_FORM_DATA = 'multipart/form-data';
-export const TEXT_PLAIN = 'text/plain';
-export const WILDCARD = '*/*';
+export const APPLICATION_FORM_URLENCODED = 'application/x-www-form-urlencoded';
+export const APPLICATION_JSON = 'application/json';
+export const APPLICATION_OCTET_STREAM = 'application/octet-stream';
+export const MULTIPART_FORM_DATA = 'multipart/form-data';
+export const TEXT_PLAIN = 'text/plain';
+export const WILDCARD = '*/*';

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

@@ -1,16 +1,16 @@
 import { Blob } from 'node:buffer';
 import http2 from 'node:http2';
-import {
-  brandCheck,
-  decompress,
-} from './utils.mjs';
+import { buffer } from 'node:stream/consumers';
+import { MIMEType } from 'node:util';
+import { decode } from './codecs.js';
+import { brandCheck } from './utils.js';
 
 const {
   HTTP2_HEADER_CONTENT_ENCODING,
   HTTP2_HEADER_CONTENT_TYPE,
 } = http2.constants;
 
-export const mixin = (res, { decompression, digest = false, parse = false } = {}) => {
+export const mixin = (res, { decodersOptions, digest = false, parse = false } = {}) => {
   if (!digest) {
     Object.defineProperties(res, {
       arrayBuffer: {
@@ -68,16 +68,10 @@ export const mixin = (res, { decompression, digest = false, parse = false } = {}
         brandCheck(this, res?.constructor);
 
         if (this.bodyUsed) {
-          throw new TypeError('Response stream already read');
+          throw new TypeError('Response stream already read.');
         }
 
-        let body = [];
-
-        for await (const chunk of decompress(this, this.headers[HTTP2_HEADER_CONTENT_ENCODING], { decompression })) {
-          body.push(chunk);
-        }
-
-        body = Buffer.concat(body);
+        let body = await buffer(decode(this, this.headers[HTTP2_HEADER_CONTENT_ENCODING], { decodersOptions }));
 
         if (!body.length && parse) {
           return null;
@@ -85,20 +79,25 @@ export const mixin = (res, { decompression, digest = false, parse = false } = {}
 
         if (body.length && parse) {
           const contentType = this.headers[HTTP2_HEADER_CONTENT_TYPE] ?? '';
-          const charset = contentType.split(';')
-                                     .find((it) => /charset=/i.test(it))
-                                     ?.toLowerCase()
-                                     .replace('charset=', '')
-                                     .replace('iso-8859-1', 'latin1')
-                                     .trim() || 'utf-8';
-
-          if (/\bjson\b/i.test(contentType)) {
-            body = JSON.parse(body.toString(charset));
-          } else if (/\b(?:text|xml)\b/i.test(contentType)) {
-            if (/\b(?:latin1|ucs-2|utf-(?:8|16le))\b/i.test(charset)) {
-              body = body.toString(charset);
+          let isTextual, mimeType;
+
+          try {
+            mimeType = contentType ? new MIMEType(contentType) : null;
+          } finally {
+            isTextual = mimeType && (
+              mimeType.type === 'text'
+              || mimeType.subtype.match(/\bcsv\b|\bjson\b|\bxml\b|\byaml\b/)
+              || mimeType.essence.match(/\becmascript\b|\bjavascript\b|\bx-www-form-urlencoded\b/)
+            );
+          }
+
+          if (isTextual) {
+            if (/\bjson\b/i.test(contentType)) {
+              body = JSON.parse(body.toString());
             } else {
-              body = new TextDecoder(charset).decode(body);
+              const charset = mimeType.params.get('charset')?.toLowerCase() ?? 'utf-8';
+
+              body = new TextDecoder(charset, { fatal: true }).decode(body);
             }
           }
         }