rekwest 5.0.3 → 5.2.0

package/src/mixin.mjs

@@ -1,109 +1,109 @@
-import { Blob } from 'node:buffer';
-import http2 from 'node:http2';
-import {
-  brandCheck,
-  decompress,
-} from './utils.mjs';
-
-const {
-  HTTP2_HEADER_CONTENT_ENCODING,
-  HTTP2_HEADER_CONTENT_TYPE,
-} = http2.constants;
-
-export const mixin = (res, { digest = false, parse = false } = {}) => {
-  if (!digest) {
-    Object.defineProperties(res, {
-      arrayBuffer: {
-        enumerable: true,
-        value: async function () {
-          brandCheck(this, res?.constructor);
-          parse &&= false;
-          const { buffer, byteLength, byteOffset } = await this.body();
-
-          return buffer.slice(byteOffset, byteOffset + byteLength);
-        },
-      },
-      blob: {
-        enumerable: true,
-        value: async function () {
-          brandCheck(this, res?.constructor);
-          const val = await this.arrayBuffer();
-
-          return new Blob([val]);
-        },
-      },
-      json: {
-        enumerable: true,
-        value: async function () {
-          brandCheck(this, res?.constructor);
-          const val = await this.text();
-
-          return JSON.parse(val);
-        },
-      },
-      text: {
-        enumerable: true,
-        value: async function () {
-          brandCheck(this, res?.constructor);
-          const blob = await this.blob();
-
-          return blob.text();
-        },
-      },
-    });
-  }
-
-  return Object.defineProperties(res, {
-    body: {
-      enumerable: true,
-      value: async function () {
-        brandCheck(this, res?.constructor);
-
-        if (this.bodyUsed) {
-          throw new TypeError('Response stream already read');
-        }
-
-        let body = [];
-
-        for await (const chunk of decompress(this, this.headers[HTTP2_HEADER_CONTENT_ENCODING])) {
-          body.push(chunk);
-        }
-
-        body = Buffer.concat(body);
-
-        if (!body.length && parse) {
-          return null;
-        }
-
-        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);
-            } else {
-              body = new TextDecoder(charset).decode(body);
-            }
-          }
-        }
-
-        return body;
-      },
-      writable: true,
-    },
-    bodyUsed: {
-      enumerable: true,
-      get() {
-        return this.readableEnded;
-      },
-    },
-  });
-};
+import { Blob } from 'node:buffer';
+import http2 from 'node:http2';
+import {
+  brandCheck,
+  decompress,
+} from './utils.mjs';
+
+const {
+  HTTP2_HEADER_CONTENT_ENCODING,
+  HTTP2_HEADER_CONTENT_TYPE,
+} = http2.constants;
+
+export const mixin = (res, { digest = false, parse = false } = {}) => {
+  if (!digest) {
+    Object.defineProperties(res, {
+      arrayBuffer: {
+        enumerable: true,
+        value: async function () {
+          brandCheck(this, res?.constructor);
+          parse &&= false;
+          const { buffer, byteLength, byteOffset } = await this.body();
+
+          return buffer.slice(byteOffset, byteOffset + byteLength);
+        },
+      },
+      blob: {
+        enumerable: true,
+        value: async function () {
+          brandCheck(this, res?.constructor);
+          const val = await this.arrayBuffer();
+
+          return new Blob([val]);
+        },
+      },
+      json: {
+        enumerable: true,
+        value: async function () {
+          brandCheck(this, res?.constructor);
+          const val = await this.text();
+
+          return JSON.parse(val);
+        },
+      },
+      text: {
+        enumerable: true,
+        value: async function () {
+          brandCheck(this, res?.constructor);
+          const blob = await this.blob();
+
+          return blob.text();
+        },
+      },
+    });
+  }
+
+  return Object.defineProperties(res, {
+    body: {
+      enumerable: true,
+      value: async function () {
+        brandCheck(this, res?.constructor);
+
+        if (this.bodyUsed) {
+          throw new TypeError('Response stream already read');
+        }
+
+        let body = [];
+
+        for await (const chunk of decompress(this, this.headers[HTTP2_HEADER_CONTENT_ENCODING])) {
+          body.push(chunk);
+        }
+
+        body = Buffer.concat(body);
+
+        if (!body.length && parse) {
+          return null;
+        }
+
+        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);
+            } else {
+              body = new TextDecoder(charset).decode(body);
+            }
+          }
+        }
+
+        return body;
+      },
+      writable: true,
+    },
+    bodyUsed: {
+      enumerable: true,
+      get() {
+        return this.readableEnded;
+      },
+    },
+  });
+};

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) * 1000 || 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/preflight.mjs

@@ -1,87 +1,87 @@
-import http2 from 'node:http2';
-import { requestCredentials } from './constants.mjs';
-import { Cookies } from './cookies.mjs';
-import {
-  APPLICATION_JSON,
-  TEXT_PLAIN,
-  WILDCARD,
-} from './mediatypes.mjs';
-
-const {
-  HTTP2_HEADER_ACCEPT,
-  HTTP2_HEADER_ACCEPT_ENCODING,
-  HTTP2_HEADER_AUTHORITY,
-  HTTP2_HEADER_AUTHORIZATION,
-  HTTP2_HEADER_COOKIE,
-  HTTP2_HEADER_METHOD,
-  HTTP2_HEADER_PATH,
-  HTTP2_HEADER_SCHEME,
-  HTTP2_METHOD_GET,
-  HTTP2_METHOD_HEAD,
-} = http2.constants;
-
-export const preflight = (options) => {
-  const { cookies, credentials, h2, headers, method, url } = options;
-
-  if (h2) {
-    options.endStream = [
-      HTTP2_METHOD_GET,
-      HTTP2_METHOD_HEAD,
-    ].includes(method);
-  }
-
-  if (cookies !== false && credentials !== requestCredentials.omit) {
-    let cookie = Cookies.jar.has(url.origin);
-
-    if (cookies === Object(cookies) && [
-      requestCredentials.include,
-      requestCredentials.sameOrigin,
-    ].includes(credentials)) {
-      if (cookie) {
-        cookie = new Cookies(cookies, options);
-
-        Cookies.jar.get(url.origin).forEach((val, key) => {
-          if (!cookie.has(key)) {
-            cookie.set(key, val);
-          }
-        });
-        Cookies.jar.set(url.origin, cookie);
-      } else {
-        cookie = new Cookies(cookies, options);
-        Cookies.jar.set(url.origin, cookie);
-      }
-    } else {
-      cookie &&= Cookies.jar.get(url.origin);
-    }
-
-    options.headers = {
-      ...cookie && { [HTTP2_HEADER_COOKIE]: cookie },
-      ...headers,
-    };
-  }
-
-  if (credentials === requestCredentials.omit) {
-    options.cookies = false;
-    for (const it of Object.keys(options.headers ?? {})
-                           .filter((val) => new RegExp(`^(${
-                              HTTP2_HEADER_AUTHORIZATION }|${ HTTP2_HEADER_COOKIE
-                            })$`, 'i').test(val))) { Reflect.deleteProperty(options.headers, it); }
-
-    url.password = url.username = '';
-  }
-
-  options.headers = {
-    [HTTP2_HEADER_ACCEPT]: `${ APPLICATION_JSON }, ${ TEXT_PLAIN }, ${ WILDCARD }`,
-    [HTTP2_HEADER_ACCEPT_ENCODING]: 'br, deflate, deflate-raw, gzip, identity',
-    ...Object.entries(options.headers ?? {})
-             .reduce((acc, [key, val]) => (acc[key.toLowerCase()] = val, acc), {}),
-    ...h2 && {
-      [HTTP2_HEADER_AUTHORITY]: url.host,
-      [HTTP2_HEADER_METHOD]: method,
-      [HTTP2_HEADER_PATH]: `${ url.pathname }${ url.search }`,
-      [HTTP2_HEADER_SCHEME]: url.protocol.replace(/\p{Punctuation}/gu, ''),
-    },
-  };
-
-  return options;
-};
+import http2 from 'node:http2';
+import { requestCredentials } from './constants.mjs';
+import { Cookies } from './cookies.mjs';
+import {
+  APPLICATION_JSON,
+  TEXT_PLAIN,
+  WILDCARD,
+} from './mediatypes.mjs';
+
+const {
+  HTTP2_HEADER_ACCEPT,
+  HTTP2_HEADER_ACCEPT_ENCODING,
+  HTTP2_HEADER_AUTHORITY,
+  HTTP2_HEADER_AUTHORIZATION,
+  HTTP2_HEADER_COOKIE,
+  HTTP2_HEADER_METHOD,
+  HTTP2_HEADER_PATH,
+  HTTP2_HEADER_SCHEME,
+  HTTP2_METHOD_GET,
+  HTTP2_METHOD_HEAD,
+} = http2.constants;
+
+export const preflight = (options) => {
+  const { cookies, credentials, h2, headers, method, url } = options;
+
+  if (h2) {
+    options.endStream = [
+      HTTP2_METHOD_GET,
+      HTTP2_METHOD_HEAD,
+    ].includes(method);
+  }
+
+  if (cookies !== false && credentials !== requestCredentials.omit) {
+    let cookie = Cookies.jar.has(url.origin);
+
+    if (cookies === Object(cookies) && [
+      requestCredentials.include,
+      requestCredentials.sameOrigin,
+    ].includes(credentials)) {
+      if (cookie) {
+        cookie = new Cookies(cookies, options);
+
+        Cookies.jar.get(url.origin).forEach((val, key) => {
+          if (!cookie.has(key)) {
+            cookie.set(key, val);
+          }
+        });
+        Cookies.jar.set(url.origin, cookie);
+      } else {
+        cookie = new Cookies(cookies, options);
+        Cookies.jar.set(url.origin, cookie);
+      }
+    } else {
+      cookie &&= Cookies.jar.get(url.origin);
+    }
+
+    options.headers = {
+      ...cookie && { [HTTP2_HEADER_COOKIE]: cookie },
+      ...headers,
+    };
+  }
+
+  if (credentials === requestCredentials.omit) {
+    options.cookies = false;
+    for (const it of Object.keys(options.headers ?? {})
+                           .filter((val) => new RegExp(`^(${
+                              HTTP2_HEADER_AUTHORIZATION }|${ HTTP2_HEADER_COOKIE
+                            })$`, 'i').test(val))) { Reflect.deleteProperty(options.headers, it); }
+
+    url.password = url.username = '';
+  }
+
+  options.headers = {
+    [HTTP2_HEADER_ACCEPT]: `${ APPLICATION_JSON }, ${ TEXT_PLAIN }, ${ WILDCARD }`,
+    [HTTP2_HEADER_ACCEPT_ENCODING]: 'br, deflate, deflate-raw, gzip, identity',
+    ...Object.entries(options.headers ?? {})
+             .reduce((acc, [key, val]) => (acc[key.toLowerCase()] = val, acc), {}),
+    ...h2 && {
+      [HTTP2_HEADER_AUTHORITY]: url.host,
+      [HTTP2_HEADER_METHOD]: method,
+      [HTTP2_HEADER_PATH]: `${ url.pathname }${ url.search }`,
+      [HTTP2_HEADER_SCHEME]: url.protocol.replace(/\p{Punctuation}/gu, ''),
+    },
+  };
+
+  return options;
+};