rekwest 4.4.5 → 4.5.0

package/README.md

@@ -1,8 +1,8 @@
 The robust request library that humanity deserves 🌐
 ---
 This package provides highly likely functional and **easy-to-use** abstraction atop of
-native [http(s).request](https://nodejs.org/api/https.html#https_https_request_url_options_callback)
-and [http2.request](https://nodejs.org/api/http2.html#http2_clienthttp2session_request_headers_options).
+native [http(s).request](https://nodejs.org/api/https.html#httpsrequesturl-options-callback)
+and [http2.request](https://nodejs.org/api/http2.html#clienthttp2sessionrequestheaders-options).
 
 ## Abstract
 
@@ -10,7 +10,7 @@ and [http2.request](https://nodejs.org/api/http2.html#http2_clienthttp2session_r
 * Cool-beans 🫐 config options (with defaults)
 * Automatic HTTP/2 support (ALPN negotiation)
 * Automatic or opt-in body parse (with non-UTF-8 charset decoding)
-* Automatic and simplistic `Cookies` treatment (with built-in jar)
+* Automatic and simplistic `Cookies` treatment (with built-in **jar** & **ttl**)
 * Automatic decompression (with opt-in body compression)
 * Built-in streamable `File` & `FormData` interfaces
 * Support redirects & retries with fine-grained tune-ups
@@ -115,17 +115,17 @@ console.log(res.body);
 
 * `url` **{string | URL}** The URL to send the request to
 * `options` **{Object}**
-  Extends [https.RequestOptions](https://nodejs.org/api/https.html#https_https_request_url_options_callback)
-  along with
-  extra [http2.ClientSessionOptions](https://nodejs.org/api/http2.html#http2_http2_connect_authority_options_listener)
-  & [http2.ClientSessionRequestOptions](https://nodejs.org/api/http2.html#http2_clienthttp2session_request_headers_options)
-  and [tls.ConnectionOptions](https://nodejs.org/api/tls.html#tls_tls_connect_options_callback)
+  Extends [http(s).RequestOptions](https://nodejs.org/api/https.html#httpsrequesturl-options-callback) along with
+  extra [http2.ClientSessionOptions](https://nodejs.org/api/http2.html#http2connectauthority-options-listener)
+  & [http2.ClientSessionRequestOptions](https://nodejs.org/api/http2.html#clienthttp2sessionrequestheaders-options)
+  and [tls.ConnectionOptions](https://nodejs.org/api/tls.html#tlsconnectoptions-callback)
   for HTTP/2 attunes
   * `baseURL` **{string | URL}** The base URL to use in cases where `url` is a relative URL
   * `body` **{string | Array | ArrayBuffer | ArrayBufferView | AsyncIterator | Blob | Buffer | DataView | File |
     FormData | Iterator | Object | Readable | SharedArrayBuffer | URLSearchParams}** The body to send with the request
   * `cookies` **{boolean | Array<[k, v]> | Cookies | Object | URLSearchParams}** `Default: true` The cookies to add to
     the request
+  * `cookiesTTL` **{boolean}** `Default: false` Controls enablement of TTL for the cookies cache
   * `credentials` **{include | omit | same-origin}** `Default: same-origin` Controls credentials in case of cross-origin
     redirects
   * `digest` **{boolean}** `Default: true` Controls whether to read the response stream or simply add a mixin
@@ -142,13 +142,13 @@ console.log(res.body);
     * `interval` **{number}** `Default: 1e3` The initial retry interval
     * `retryAfter` **{boolean}** `Default: true` Controls `retry-after` header receptiveness
     * `statusCodes` **{number[]}** `Default: [429, 503]` The list of status codes to retry on
+  * `stripTrailingSlash` **{boolean}** `Default: false` Controls whether to strip trailing slash at the end of the URL
   * `thenable` **{boolean}** `Default: false` Controls the promise resolutions
   * `timeout` **{number}** `Default: 3e5` The number of milliseconds a request can take before termination
-  * `trimTrailingSlashes` **{boolean}** `Default: false` Controls whether to trim trailing slashes in the URL before
-    proceed with the request
+  * `trimTrailingSlashes` **{boolean}** `Default: false` Controls whether to trim trailing slashes within the URL
 * **Returns:** Promise that resolves to
-  extended [http.IncomingMessage](https://nodejs.org/api/http.html#http_class_http_incomingmessage)
-  or [http2.ClientHttp2Stream](https://nodejs.org/api/http2.html#http2_class_clienthttp2stream) which is respectively
+  extended [http.IncomingMessage](https://nodejs.org/api/http.html#class-httpincomingmessage)
+  or [http2.ClientHttp2Stream](https://nodejs.org/api/http2.html#class-clienthttp2stream) which is respectively
   readable and duplex streams
   * if `degist: true` & `parse: true`
     * `body` **{string | Array | Buffer | Object}** The body based on its content type

package/dist/cookies.js

@@ -5,14 +5,52 @@ exports.Cookies = void 0;
 var _utils = require("./utils");
 class Cookies extends URLSearchParams {
   static jar = new Map();
+  #chronometry = new Map();
   get [Symbol.toStringTag]() {
     return this.constructor.name;
   }
-  constructor(input) {
+  constructor(input, {
+    cookiesTTL
+  } = {
+    cookiesTTL: false
+  }) {
     if (Array.isArray(input) && input.every(it => !Array.isArray(it))) {
-      input = input.join(';').split(';').filter(it => !/\b(?:Domain|Expires|HttpOnly|Max-Age|Path|SameParty|SameSite|Secure)\b/i.test(it)).map(it => it.trim()).join('&');
+      input = input.map(it => {
+        if (!cookiesTTL) {
+          return [it.split(';').at(0).trim()];
+        }
+        const [cookie, ...attrs] = it.split(';').map(it => it.trim());
+        const ttl = attrs.reduce((acc, val) => {
+          if (/(?:Expires|Max-Age)=/i.test(val)) {
+            const [key, value] = val.toLowerCase().split('=');
+            acc[(0, _utils.toCamelCase)(key)] = !Number.isNaN(Number(value)) ? value * 1e3 : Date.parse(value) - Date.now();
+          }
+          return acc;
+        }, {});
+        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) {
+      input.filter(it => it.at(1)).forEach(([cookie, ttl]) => {
+        cookie = cookie.split('=').at(0);
+        if (this.#chronometry.has(cookie)) {
+          clearTimeout(this.#chronometry.get(cookie));
+          this.#chronometry.delete(cookie);
+        }
+        const {
+          expires,
+          maxAge
+        } = ttl;
+        [maxAge, expires].filter(it => Number.isInteger(it)).some(ms => {
+          const tid = setTimeout(() => {
+            this.#chronometry.delete(cookie);
+            this.delete(cookie);
+          }, Math.max(ms, 0));
+          return this.#chronometry.set(cookie, tid);
+        });
+      });
     }
-    super(input);
   }
   toString() {
     (0, _utils.brandCheck)(this, Cookies);

package/dist/defaults.js

@@ -12,6 +12,7 @@ const {
   HTTP_STATUS_TOO_MANY_REQUESTS
 } = _nodeHttp.default.constants;
 const stash = {
+  cookiesTTL: false,
   credentials: _constants.requestCredentials.sameOrigin,
   digest: true,
   follow: 20,
@@ -33,6 +34,7 @@ const stash = {
     retryAfter: true,
     statusCodes: [HTTP_STATUS_TOO_MANY_REQUESTS, HTTP_STATUS_SERVICE_UNAVAILABLE]
   },
+  stripTrailingSlash: false,
   thenable: false,
   timeout: 3e5,
   trimTrailingSlashes: false

package/dist/index.js

@@ -23,6 +23,7 @@ var _defaults = _interopRequireDefault(require("./defaults"));
 var _mediatypes = _interopRequireWildcard(require("./mediatypes"));
 exports.mediatypes = _mediatypes;
 var _preflight = require("./preflight");
+var _transfer = require("./transfer");
 var _utils = require("./utils");
 Object.keys(_utils).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
@@ -86,7 +87,7 @@ const {
   HTTP2_HEADER_CONTENT_TYPE
 } = _nodeHttp2.default.constants;
 function rekwest(url, options) {
-  return (0, _utils.transfer)((0, _validation.validation)((0, _utils.normalize)(url, options)), rekwest);
+  return (0, _transfer.transfer)((0, _validation.validation)((0, _utils.normalize)(url, options)), rekwest);
 }
 Reflect.defineProperty(rekwest, 'defaults', {
   enumerable: true,

package/dist/postflight.js

@@ -46,11 +46,15 @@ const postflight = (req, res, options, {
   (0, _utils.admix)(res, headers, options);
   if (cookies !== false && res.headers[HTTP2_HEADER_SET_COOKIE]) {
     if (_cookies.Cookies.jar.has(url.origin)) {
-      new _cookies.Cookies(res.headers[HTTP2_HEADER_SET_COOKIE]).forEach(function (val, key) {
-        this.set(key, val);
-      }, _cookies.Cookies.jar.get(url.origin));
+      const cookie = new _cookies.Cookies(res.headers[HTTP2_HEADER_SET_COOKIE], options);
+      _cookies.Cookies.jar.get(url.origin).forEach((val, key) => {
+        if (!cookie.has(key)) {
+          cookie.set(key, val);
+        }
+      });
+      _cookies.Cookies.jar.set(url.origin, cookie);
     } else {
-      _cookies.Cookies.jar.set(url.origin, new _cookies.Cookies(res.headers[HTTP2_HEADER_SET_COOKIE]));
+      _cookies.Cookies.jar.set(url.origin, new _cookies.Cookies(res.headers[HTTP2_HEADER_SET_COOKIE], options));
     }
   }
   Reflect.defineProperty(res, 'cookies', {

package/dist/preflight.js

@@ -31,14 +31,18 @@ const preflight = options => {
     options.endStream = [HTTP2_METHOD_GET, HTTP2_METHOD_HEAD].includes(method);
   }
   if (cookies !== false) {
-    let cookie = _cookies.Cookies.jar.get(url.origin);
+    let cookie = _cookies.Cookies.jar.has(url.origin);
     if (cookies === Object(cookies) && [_constants.requestCredentials.include, _constants.requestCredentials.sameOrigin].includes(credentials)) {
       if (cookie) {
-        new _cookies.Cookies(cookies).forEach(function (val, key) {
-          this.set(key, val);
-        }, cookie);
+        cookie = new _cookies.Cookies(cookies, options);
+        _cookies.Cookies.jar.get(url.origin).forEach((val, key) => {
+          if (!cookie.has(key)) {
+            cookie.set(key, val);
+          }
+        });
+        _cookies.Cookies.jar.set(url.origin, cookie);
       } else {
-        cookie = new _cookies.Cookies(cookies);
+        cookie = new _cookies.Cookies(cookies, options);
         _cookies.Cookies.jar.set(url.origin, cookie);
       }
     }

package/dist/transfer.js

@@ -0,0 +1,105 @@
+"use strict";
+
+exports.__esModule = true;
+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");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const {
+  HTTP2_HEADER_RETRY_AFTER
+} = _nodeHttp2.default.constants;
+const transfer = async (options, overact) => {
+  const {
+    digest,
+    redirected,
+    thenable,
+    url
+  } = options;
+  if (options.follow === 0) {
+    throw new _errors.RequestError(`Maximum redirect reached at: ${url.href}`);
+  }
+  if (url.protocol === 'https:') {
+    options = !options.h2 ? await (0, _ackn.ackn)(options) : {
+      ...options,
+      createConnection: null,
+      protocol: url.protocol
+    };
+  } else if (Reflect.has(options, 'alpnProtocol')) {
+    ['alpnProtocol', 'createConnection', 'h2', 'protocol'].forEach(it => Reflect.deleteProperty(options, it));
+  }
+  try {
+    options = await (0, _transform.transform)((0, _preflight.preflight)(options));
+  } catch (ex) {
+    options.createConnection?.().destroy();
+    throw ex;
+  }
+  const promise = new Promise((resolve, reject) => {
+    let client, req;
+    if (options.h2) {
+      client = _nodeHttp2.default.connect(url.origin, options);
+      req = client.request(options.headers, options);
+    } else {
+      const {
+        request
+      } = url.protocol === 'http:' ? _nodeHttp.default : _nodeHttps.default;
+      req = request(url, options);
+    }
+    (0, _utils.affix)(client, req, options);
+    req.once('error', reject);
+    req.once('frameError', reject);
+    req.once('goaway', reject);
+    req.once('response', res => (0, _postflight.postflight)(req, res, options, {
+      reject,
+      resolve
+    }));
+    (0, _utils.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 && 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) * 1000 || 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);
+      }
+      retry.attempts--;
+      retry.interval = interval;
+      return (0, _promises.setTimeout)(interval).then(() => overact(url, options));
+    }
+    if (digest && !redirected && ex.body) {
+      ex.body = await ex.body();
+    }
+    if (!thenable) {
+      throw ex;
+    } else {
+      return ex;
+    }
+  }
+};
+exports.transfer = transfer;

package/dist/transform.js

@@ -0,0 +1,77 @@
+"use strict";
+
+exports.__esModule = 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 _file = require("./file");
+var _formdata = require("./formdata");
+var _mediatypes = require("./mediatypes");
+var _utils = require("./utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+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 (_file.File.alike(body)) {
+    headers = {
+      [HTTP2_HEADER_CONTENT_LENGTH]: body.size,
+      [HTTP2_HEADER_CONTENT_TYPE]: body.type || _mediatypes.APPLICATION_OCTET_STREAM
+    };
+    body = body.stream();
+  } else if (_formdata.FormData.alike(body)) {
+    body = _formdata.FormData.actuate(body);
+    headers = {
+      [HTTP2_HEADER_CONTENT_TYPE]: body.contentType
+    };
+  } else if (!Buffer.isBuffer(body)) {
+    if (_nodeUtil.types.isAnyArrayBuffer(body)) {
+      body = Buffer.from(body);
+    } else if (_nodeUtil.types.isArrayBufferView(body)) {
+      body = Buffer.from(body.buffer, body.byteOffset, body.byteLength);
+    } else if (body === Object(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);
+      }
+    }
+  }
+  const encodings = options.headers[HTTP2_HEADER_CONTENT_ENCODING];
+  if (body === Object(body) && (Reflect.has(body, Symbol.asyncIterator) || !Array.isArray(body) && Reflect.has(body, Symbol.iterator))) {
+    body = encodings ? (0, _utils.compress)(_nodeStream.Readable.from(body), encodings) : _nodeStream.Readable.from(body);
+  } else if (encodings) {
+    body = await (0, _consumers.buffer)((0, _utils.compress)(_nodeStream.Readable.from(body), encodings));
+  }
+  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

@@ -3,31 +3,17 @@
 exports.__esModule = true;
 exports.sameOrigin = exports.normalize = exports.merge = exports.maxRetryAfterError = exports.maxRetryAfter = exports.dispatch = exports.decompress = exports.compress = exports.brandCheck = exports.affix = exports.admix = void 0;
 exports.tap = tap;
-exports.unwind = exports.transform = exports.transfer = void 0;
-var _nodeHttp = _interopRequireDefault(require("node:http"));
-var _nodeHttp2 = _interopRequireDefault(require("node:http2"));
-var _nodeHttps = _interopRequireDefault(require("node:https"));
+exports.unwind = exports.toCamelCase = void 0;
+var _nodeHttp = _interopRequireDefault(require("node:http2"));
 var _nodeStream = require("node:stream");
-var _consumers = require("node:stream/consumers");
-var _promises = require("node:timers/promises");
-var _nodeUtil = require("node:util");
 var _nodeZlib = _interopRequireDefault(require("node:zlib"));
-var _ackn = require("./ackn");
 var _defaults = _interopRequireDefault(require("./defaults"));
 var _errors = require("./errors");
-var _file = require("./file");
-var _formdata = require("./formdata");
-var _mediatypes = require("./mediatypes");
-var _postflight = require("./postflight");
-var _preflight = require("./preflight");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 const {
-  HTTP2_HEADER_CONTENT_ENCODING,
-  HTTP2_HEADER_CONTENT_LENGTH,
-  HTTP2_HEADER_CONTENT_TYPE,
   HTTP2_HEADER_RETRY_AFTER,
   HTTP2_HEADER_STATUS
-} = _nodeHttp2.default.constants;
+} = _nodeHttp.default.constants;
 const admix = (res, headers, options) => {
   const {
     h2
@@ -154,6 +140,9 @@ const normalize = (url, 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
@@ -171,151 +160,7 @@ async function* tap(value) {
     yield await value.arrayBuffer();
   }
 }
-const transfer = async (options, overact) => {
-  const {
-    digest,
-    redirected,
-    thenable,
-    url
-  } = options;
-  if (options.follow === 0) {
-    throw new _errors.RequestError(`Maximum redirect reached at: ${url.href}`);
-  }
-  if (url.protocol === 'https:') {
-    options = !options.h2 ? await (0, _ackn.ackn)(options) : {
-      ...options,
-      createConnection: null,
-      protocol: url.protocol
-    };
-  } else if (Reflect.has(options, 'alpnProtocol')) {
-    ['alpnProtocol', 'createConnection', 'h2', 'protocol'].forEach(it => Reflect.deleteProperty(options, it));
-  }
-  try {
-    options = await transform((0, _preflight.preflight)(options));
-  } catch (ex) {
-    options.createConnection?.().destroy();
-    throw ex;
-  }
-  const promise = new Promise((resolve, reject) => {
-    let client, req;
-    if (options.h2) {
-      client = _nodeHttp2.default.connect(url.origin, options);
-      req = client.request(options.headers, options);
-    } else {
-      const {
-        request
-      } = url.protocol === 'http:' ? _nodeHttp.default : _nodeHttps.default;
-      req = request(url, options);
-    }
-    affix(client, req, options);
-    req.once('error', reject);
-    req.once('frameError', reject);
-    req.once('goaway', reject);
-    req.once('response', res => (0, _postflight.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 && 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) * 1000 || 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 (0, _promises.setTimeout)(interval).then(() => overact(url, options));
-    }
-    if (digest && !redirected && ex.body) {
-      ex.body = await ex.body();
-    }
-    if (!thenable) {
-      throw ex;
-    } else {
-      return ex;
-    }
-  }
-};
-exports.transfer = transfer;
-const transform = async options => {
-  let {
-    body,
-    headers
-  } = options;
-  if (!body) {
-    return options;
-  }
-  if (_file.File.alike(body)) {
-    headers = {
-      [HTTP2_HEADER_CONTENT_LENGTH]: body.size,
-      [HTTP2_HEADER_CONTENT_TYPE]: body.type || _mediatypes.APPLICATION_OCTET_STREAM
-    };
-    body = body.stream();
-  } else if (_formdata.FormData.alike(body)) {
-    body = _formdata.FormData.actuate(body);
-    headers = {
-      [HTTP2_HEADER_CONTENT_TYPE]: body.contentType
-    };
-  } else if (!Buffer.isBuffer(body)) {
-    if (_nodeUtil.types.isAnyArrayBuffer(body)) {
-      body = Buffer.from(body);
-    } else if (_nodeUtil.types.isArrayBufferView(body)) {
-      body = Buffer.from(body.buffer, body.byteOffset, body.byteLength);
-    } else if (body === Object(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);
-      }
-    }
-  }
-  const encodings = options.headers[HTTP2_HEADER_CONTENT_ENCODING];
-  if (body === Object(body) && (Reflect.has(body, Symbol.asyncIterator) || !Array.isArray(body) && Reflect.has(body, Symbol.iterator))) {
-    body = encodings ? compress(_nodeStream.Readable.from(body), encodings) : _nodeStream.Readable.from(body);
-  } else if (encodings) {
-    body = await (0, _consumers.buffer)(compress(_nodeStream.Readable.from(body), encodings));
-  }
-  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;
+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());
 exports.unwind = unwind;

package/package.json

@@ -11,8 +11,8 @@
     "@babel/cli": "^7.21.5",
     "@babel/core": "^7.22.1",
     "@babel/eslint-parser": "^7.21.8",
-    "@babel/preset-env": "^7.22.2",
-    "c8": "^7.13.0",
+    "@babel/preset-env": "^7.22.4",
+    "c8": "^7.14.0",
     "eslint": "^8.41.0",
     "eslint-config-ultra-refined": "^2.15.0",
     "mocha": "^10.2.0"
@@ -67,5 +67,5 @@
     "test:bail": "mocha --bail",
     "test:cover": "c8 --include=src --reporter=lcov --reporter=text npm test"
   },
-  "version": "4.4.5"
+  "version": "4.5.0"
 }

package/src/cookies.mjs

@@ -1,22 +1,68 @@
-import { brandCheck } from './utils.mjs';
+import {
+  brandCheck,
+  toCamelCase,
+} from './utils.mjs';
 
 export class Cookies extends URLSearchParams {
 
   static jar = new Map();
 
+  #chronometry = new Map();
+
   get [Symbol.toStringTag]() {
     return this.constructor.name;
   }
 
-  constructor(input) {
+  constructor(input, { cookiesTTL } = { cookiesTTL: false }) {
     if (Array.isArray(input) && input.every((it) => !Array.isArray(it))) {
-      input = input.join(';').split(';')
-                   .filter((it) => !/\b(?:Domain|Expires|HttpOnly|Max-Age|Path|SameParty|SameSite|Secure)\b/i.test(it))
-                   .map((it) => it.trim())
-                   .join('&');
+      input = input.map((it) => {
+        if (!cookiesTTL) {
+          return [it.split(';').at(0).trim()];
+        }
+
+        const [cookie, ...attrs] = it.split(';').map((it) => it.trim());
+        const ttl = attrs.reduce((acc, val) => {
+          if (/(?:Expires|Max-Age)=/i.test(val)) {
+            const [key, value] = val.toLowerCase().split('=');
+
+            acc[toCamelCase(key)] = !Number.isNaN(Number(value)) ? value * 1e3 : Date.parse(value) - Date.now();
+          }
+
+          return acc;
+        }, {});
+
+        return [
+          cookie.replace(/\u0022/g, ''),
+          Object.keys(ttl).length ? ttl : null,
+        ];
+      });
     }
 
-    super(input);
+    super(Array.isArray(input) ? input.map((it) => it.at(0)).join('&') : input);
+
+    if (Array.isArray(input) && cookiesTTL) {
+      input.filter((it) => it.at(1)).forEach(([cookie, ttl]) => {
+        cookie = cookie.split('=').at(0);
+        if (this.#chronometry.has(cookie)) {
+          clearTimeout(this.#chronometry.get(cookie));
+          this.#chronometry.delete(cookie);
+        }
+
+        const { expires, maxAge } = ttl;
+
+        [
+          maxAge,
+          expires,
+        ].filter((it) => Number.isInteger(it)).some((ms) => {
+          const tid = setTimeout(() => {
+            this.#chronometry.delete(cookie);
+            this.delete(cookie);
+          }, Math.max(ms, 0));
+
+          return this.#chronometry.set(cookie, tid);
+        });
+      });
+    }
   }
 
   toString() {

package/src/defaults.mjs

@@ -12,6 +12,7 @@ const {
 } = http2.constants;
 
 const stash = {
+  cookiesTTL: false,
   credentials: requestCredentials.sameOrigin,
   digest: true,
   follow: 20,
@@ -36,6 +37,7 @@ const stash = {
       HTTP_STATUS_SERVICE_UNAVAILABLE,
     ],
   },
+  stripTrailingSlash: false,
   thenable: false,
   timeout: 3e5,
   trimTrailingSlashes: false,

package/src/index.mjs

@@ -5,12 +5,12 @@ 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,
   merge,
   normalize,
-  transfer,
 } from './utils.mjs';
 import { validation } from './validation.mjs';
 

package/src/postflight.mjs

@@ -44,11 +44,16 @@ export const postflight = (req, res, options, { reject, resolve }) => {
 
   if (cookies !== false && res.headers[HTTP2_HEADER_SET_COOKIE]) {
     if (Cookies.jar.has(url.origin)) {
-      new Cookies(res.headers[HTTP2_HEADER_SET_COOKIE]).forEach(function (val, key) {
-        this.set(key, val);
-      }, Cookies.jar.get(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]));
+      Cookies.jar.set(url.origin, new Cookies(res.headers[HTTP2_HEADER_SET_COOKIE], options));
     }
   }
 

package/src/preflight.mjs

@@ -30,18 +30,23 @@ export const preflight = (options) => {
   }
 
   if (cookies !== false) {
-    let cookie = Cookies.jar.get(url.origin);
+    let cookie = Cookies.jar.has(url.origin);
 
     if (cookies === Object(cookies) && [
       requestCredentials.include,
       requestCredentials.sameOrigin,
     ].includes(credentials)) {
       if (cookie) {
-        new Cookies(cookies).forEach(function (val, key) {
-          this.set(key, val);
-        }, 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);
+        cookie = new Cookies(cookies, options);
         Cookies.jar.set(url.origin, cookie);
       }
     }

package/src/transfer.mjs

@@ -0,0 +1,114 @@
+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')) {
+    [
+      'alpnProtocol',
+      'createConnection',
+      'h2',
+      'protocol',
+    ].forEach((it) => 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('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 && 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) * 1000 || 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/transform.mjs

@@ -0,0 +1,75 @@
+import http2 from 'node:http2';
+import { Readable } from 'node:stream';
+import { buffer } from 'node:stream/consumers';
+import { types } from 'node:util';
+import { File } from './file.mjs';
+import { FormData } from './formdata.mjs';
+import {
+  APPLICATION_FORM_URLENCODED,
+  APPLICATION_JSON,
+  APPLICATION_OCTET_STREAM,
+} from './mediatypes.mjs';
+import { compress } from './utils.mjs';
+
+const {
+  HTTP2_HEADER_CONTENT_ENCODING,
+  HTTP2_HEADER_CONTENT_LENGTH,
+  HTTP2_HEADER_CONTENT_TYPE,
+} = http2.constants;
+
+export const transform = async (options) => {
+  let { body, headers } = options;
+
+  if (!body) {
+    return options;
+  }
+
+  if (File.alike(body)) {
+    headers = {
+      [HTTP2_HEADER_CONTENT_LENGTH]: body.size,
+      [HTTP2_HEADER_CONTENT_TYPE]: body.type || APPLICATION_OCTET_STREAM,
+    };
+    body = body.stream();
+  } else if (FormData.alike(body)) {
+    body = FormData.actuate(body);
+    headers = { [HTTP2_HEADER_CONTENT_TYPE]: body.contentType };
+  } else if (!Buffer.isBuffer(body)) {
+    if (types.isAnyArrayBuffer(body)) {
+      body = Buffer.from(body);
+    } else if (types.isArrayBufferView(body)) {
+      body = Buffer.from(body.buffer, body.byteOffset, body.byteLength);
+    } else if (body === Object(body) && !Reflect.has(body, Symbol.asyncIterator)) {
+      if (body.constructor === URLSearchParams) {
+        headers = { [HTTP2_HEADER_CONTENT_TYPE]: APPLICATION_FORM_URLENCODED };
+        body = body.toString();
+      } else if (!(!Array.isArray(body) && Reflect.has(body, Symbol.iterator))) {
+        headers = { [HTTP2_HEADER_CONTENT_TYPE]: APPLICATION_JSON };
+        body = JSON.stringify(body);
+      }
+    }
+  }
+
+  const encodings = options.headers[HTTP2_HEADER_CONTENT_ENCODING];
+
+  if (body === Object(body)
+    && (Reflect.has(body, Symbol.asyncIterator) || (!Array.isArray(body) && Reflect.has(body, Symbol.iterator)))) {
+    body = encodings ? compress(Readable.from(body), encodings) : Readable.from(body);
+  } else if (encodings) {
+    body = await buffer(compress(Readable.from(body), encodings));
+  }
+
+  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,
+  };
+};

package/src/utils.mjs

@@ -1,34 +1,13 @@
-import http from 'node:http';
 import http2 from 'node:http2';
-import https from 'node:https';
-import {
-  pipeline,
-  Readable,
-} from 'node:stream';
-import { buffer } from 'node:stream/consumers';
-import { setTimeout as setTimeoutPromise } from 'node:timers/promises';
-import { types } from 'node:util';
+import { pipeline } from 'node:stream';
 import zlib from 'node:zlib';
-import { ackn } from './ackn.mjs';
 import defaults from './defaults.mjs';
 import {
   RequestError,
   TimeoutError,
 } from './errors.mjs';
-import { File } from './file.mjs';
-import { FormData } from './formdata.mjs';
-import {
-  APPLICATION_FORM_URLENCODED,
-  APPLICATION_JSON,
-  APPLICATION_OCTET_STREAM,
-} from './mediatypes.mjs';
-import { postflight } from './postflight.mjs';
-import { preflight } from './preflight.mjs';
 
 const {
-  HTTP2_HEADER_CONTENT_ENCODING,
-  HTTP2_HEADER_CONTENT_LENGTH,
-  HTTP2_HEADER_CONTENT_TYPE,
   HTTP2_HEADER_RETRY_AFTER,
   HTTP2_HEADER_STATUS,
 } = http2.constants;
@@ -180,6 +159,10 @@ export const normalize = (url, options = {}) => {
     url = `${ url }`.replace(/(?<!:)\/+/g, '/');
   }
 
+  if (options.stripTrailingSlash) {
+    url = `${ url }`.replace(/\/$|\/(?=#)|\/(?=\?)/g, '');
+  }
+
   url = new URL(url, options.baseURL);
 
   return Object.assign(options, { url });
@@ -197,157 +180,9 @@ export async function* tap(value) {
   }
 }
 
-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')) {
-    [
-      'alpnProtocol',
-      'createConnection',
-      'h2',
-      'protocol',
-    ].forEach((it) => 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('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 && 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) * 1000 || 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;
-    }
-  }
-};
-
-export const transform = async (options) => {
-  let { body, headers } = options;
-
-  if (!body) {
-    return options;
-  }
-
-  if (File.alike(body)) {
-    headers = {
-      [HTTP2_HEADER_CONTENT_LENGTH]: body.size,
-      [HTTP2_HEADER_CONTENT_TYPE]: body.type || APPLICATION_OCTET_STREAM,
-    };
-    body = body.stream();
-  } else if (FormData.alike(body)) {
-    body = FormData.actuate(body);
-    headers = { [HTTP2_HEADER_CONTENT_TYPE]: body.contentType };
-  } else if (!Buffer.isBuffer(body)) {
-    if (types.isAnyArrayBuffer(body)) {
-      body = Buffer.from(body);
-    } else if (types.isArrayBufferView(body)) {
-      body = Buffer.from(body.buffer, body.byteOffset, body.byteLength);
-    } else if (body === Object(body) && !Reflect.has(body, Symbol.asyncIterator)) {
-      if (body.constructor === URLSearchParams) {
-        headers = { [HTTP2_HEADER_CONTENT_TYPE]: APPLICATION_FORM_URLENCODED };
-        body = body.toString();
-      } else if (!(!Array.isArray(body) && Reflect.has(body, Symbol.iterator))) {
-        headers = { [HTTP2_HEADER_CONTENT_TYPE]: APPLICATION_JSON };
-        body = JSON.stringify(body);
-      }
-    }
-  }
-
-  const encodings = options.headers[HTTP2_HEADER_CONTENT_ENCODING];
-
-  if (body === Object(body)
-    && (Reflect.has(body, Symbol.asyncIterator) || (!Array.isArray(body) && Reflect.has(body, Symbol.iterator)))) {
-    body = encodings ? compress(Readable.from(body), encodings) : Readable.from(body);
-  } else if (encodings) {
-    body = await buffer(compress(Readable.from(body), encodings));
-  }
-
-  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,
-  };
-};
+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());