├── .editorconfig
├── .github
    └── workflows
    │   ├── coverage.yaml
    │   └── lint.yaml
├── .gitignore
├── .mocharc.yml
├── .npmrc
├── CONTRIBUTING.md
├── README.md
├── babel.config.js
├── eslint.config.mjs
├── package-lock.json
├── package.json
├── pony.sh
├── src
    ├── ackn.mjs
    ├── config.mjs
    ├── constants.mjs
    ├── cookies.mjs
    ├── errors.mjs
    ├── formdata.mjs
    ├── index.mjs
    ├── mediatypes.mjs
    ├── mixin.mjs
    ├── postflight.mjs
    ├── preflight.mjs
    ├── transfer.mjs
    ├── transform.mjs
    ├── utils.mjs
    └── validation.mjs
└── test
    ├── fixtures
        ├── index.mjs
        └── routes.mjs
    ├── index.h1.test.mjs
    ├── index.h2.test.mjs
    └── index.shared.mjs


/.editorconfig:
--------------------------------------------------------------------------------
 1 | root = true
 2 | 
 3 | [*]
 4 | charset = utf-8
 5 | end_of_line = lf
 6 | insert_final_newline = true
 7 | indent_size = 2
 8 | indent_style = space
 9 | trim_trailing_whitespace = true
10 | 
11 | [*.md]
12 | trim_trailing_whitespace = false
13 | 


--------------------------------------------------------------------------------
/.github/workflows/coverage.yaml:
--------------------------------------------------------------------------------
 1 | name: Coverage
 2 | on:
 3 |   push:
 4 |   pull_request:
 5 |   schedule:
 6 |     - cron: 0 5 1 */2 *
 7 | concurrency:
 8 |   cancel-in-progress: true
 9 |   group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
10 | env:
11 |   NODE_ENV: development
12 | jobs:
13 |   run:
14 |     name: Node ${{ matrix.node }} on ${{ matrix.os }}
15 |     runs-on: ${{ matrix.os }}
16 |     strategy:
17 |       fail-fast: false
18 |       matrix:
19 |         node: [ 20, 22, 24 ]
20 |         os: [ ubuntu-latest ]
21 |     steps:
22 |       - name: Clone repo
23 |         uses: actions/checkout@v4
24 |       - name: Setup Node.js
25 |         uses: actions/setup-node@v4
26 |         with:
27 |           node-version: ${{ matrix.node }}
28 |       - name: Install deps
29 |         run: npm install
30 |       - name: Run tests
31 |         run: npm run test:cover
32 | 


--------------------------------------------------------------------------------
/.github/workflows/lint.yaml:
--------------------------------------------------------------------------------
 1 | name: Lint
 2 | on: [ push, pull_request ]
 3 | concurrency:
 4 |   cancel-in-progress: true
 5 |   group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
 6 | env:
 7 |   NODE_ENV: development
 8 | jobs:
 9 |   run:
10 |     name: Node ${{ matrix.node }} on ${{ matrix.os }}
11 |     runs-on: ${{ matrix.os }}
12 |     strategy:
13 |       fail-fast: false
14 |       matrix:
15 |         node: [ current ]
16 |         os: [ ubuntu-latest ]
17 |     steps:
18 |       - name: Clone repo
19 |         uses: actions/checkout@v4
20 |       - name: Setup Node.js
21 |         uses: actions/setup-node@v4
22 |         with:
23 |           node-version: ${{ matrix.node }}
24 |       - name: Install deps
25 |         run: npm install
26 |       - name: Run lint
27 |         run: npm run lint
28 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | .idea/
2 | .vscode/
3 | coverage/
4 | dist/
5 | node_modules/
6 | /localhost.*
7 | 


--------------------------------------------------------------------------------
/.mocharc.yml:
--------------------------------------------------------------------------------
1 | exit: true
2 | ignore:
3 |   - test/**/fixtures/**
4 | require: test/fixtures/index.mjs
5 | recursive: true
6 | 


--------------------------------------------------------------------------------
/.npmrc:
--------------------------------------------------------------------------------
1 | install-strategy=linked
2 | 


--------------------------------------------------------------------------------
/CONTRIBUTING.md:
--------------------------------------------------------------------------------
 1 | Coding Rules
 2 | ---
 3 | 
 4 | Make sure your `IDE` uses [ESLint](https://eslint.org/) rules and applies [EditorConfig](https://editorconfig.org/)
 5 | coding styles.
 6 | 
 7 | ## Commit Guidelines
 8 | 
 9 | We have very precise rules over how our git commit messages can be formatted. This leads to **more readable messages**
10 | that are easy to follow when looking through the **project history**.
11 | 
12 | ### Commit Message Format
13 | 
14 | Each commit message consists of a **header**, a **body** and a **footer**. The header has a special format that includes
15 | a **type**, a **scope**, and a **subject**:
16 | 
17 | ```
18 | <type>(<scope>): <subject>
19 | <blank>
20 | <body>
21 | <blank>
22 | <footer>
23 | ```
24 | 
25 | The subject line of the commit message cannot be longer 80 characters. The second line is always blank and other lines
26 | should be wrapped at 80 characters. This allows the message to be easier to read.
27 | 
28 | The **type** and **scope** *(can be avoided)* should always be lowercase as shown above.
29 | 
30 | ### Type
31 | 
32 | Please use one of the following:
33 | 
34 | * **bump**: Manual increment of the application version.
35 | * **chore**: Update to task runner or build scripts, etc.
36 | * **feat**: New feature for the user, not a new feature for build scripts.
37 | * **fix**: Bugs fix for the user, not a fix to a build scripts.
38 | * **doc**: Change to the documentation.
39 | * **perf**: Change that improves code performance.
40 | * **refactor**: Change that neither fixes a bug nor adds a feature.
41 | * **style**: Change that do not affect the meaning of the code (formatting, missing semicolons, white-spaces, etc.).
42 | * **test**: Add new or missing tests, or tests refactoring.
43 | 
44 | ### Scope
45 | 
46 | The scope could be anything specifying the location of the commit change. For example `view` or `logger`.
47 | 
48 | ### Subject
49 | 
50 | The subject contains a succinct description of the change:
51 | 
52 | * Use the imperative, present tense: "change" not "changed" nor "changes".
53 | * Don't capitalize the first letter.
54 | * Do not add a dot (.) at the end.
55 | 
56 | ### Body
57 | 
58 | The body should include the motivation for the change and contrast this with previous behavior.
59 | 
60 | ### Footer
61 | 
62 | The footer should contain any information about breaking changes and is also the place to reference issues that this
63 | commit closes.
64 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | The robust request library that humanity deserves 🌐
  2 | ---
  3 | This package provides highly likely functional and **easy-to-use** abstraction atop of
  4 | native [http(s).request](https://nodejs.org/api/https.html#httpsrequesturl-options-callback)
  5 | and [http2.request](https://nodejs.org/api/http2.html#clienthttp2sessionrequestheaders-options).
  6 | 
  7 | ## Abstract
  8 | 
  9 | * Fetch-alike 🥏
 10 | * Cool-beans 🫐 config options (with defaults)
 11 | * Automatic HTTP/2 support (ALPN negotiation) 💼
 12 | * Automatic or opt-in body parse (with non-UTF-8 charset decoding) 🉑
 13 | * Automatic and simplistic `Cookies` treatment (with built-in **jar** & **ttl**) 🍪
 14 | * Automatic decompression (with opt-in body compression) 🗜️
 15 | * Built-in streamable `FormData` interface 🔌
 16 | * Support redirects & retries with fine-grained tune-ups 🪛
 17 | * Support all legit request body types (include blobs & streams) 📦
 18 | * Support both CJS and ESM module systems 🧩
 19 | * Fully promise-able and pipe-able 🔗
 20 | * Zero dependencies 🗽
 21 | 
 22 | ## Prerequisites
 23 | 
 24 | * Node.js `>= 20.0.0`
 25 | 
 26 | ## Installation
 27 | 
 28 | ```bash
 29 | npm install rekwest --save
 30 | ```
 31 | 
 32 | ### Usage
 33 | 
 34 | ```javascript
 35 | import rekwest, { constants } from 'rekwest';
 36 | 
 37 | const {
 38 |   HTTP2_HEADER_AUTHORIZATION,
 39 |   HTTP2_HEADER_CONTENT_ENCODING,
 40 |   HTTP2_METHOD_POST,
 41 |   HTTP_STATUS_OK,
 42 | } = constants;
 43 | 
 44 | const url = 'https://somewhe.re/somewhat/endpoint';
 45 | 
 46 | const res = await rekwest(url, {
 47 |   body: { celestial: 'payload' },
 48 |   headers: {
 49 |     [HTTP2_HEADER_AUTHORIZATION]: 'Bearer [token]',
 50 |     [HTTP2_HEADER_CONTENT_ENCODING]: 'br',  // enables: body compression
 51 |     /** [HTTP2_HEADER_CONTENT_TYPE]
 52 |      * is undue for
 53 |      * Array/Blob/File/FormData/Object/URLSearchParams body types
 54 |      * and will be set automatically, with an option to override it here
 55 |      */
 56 |   },
 57 |   method: HTTP2_METHOD_POST,
 58 | });
 59 | 
 60 | console.assert(res.statusCode === HTTP_STATUS_OK);
 61 | console.info(res.headers);
 62 | console.log(res.body);
 63 | ```
 64 | 
 65 | ---
 66 | 
 67 | ```javascript
 68 | import { Readable } from 'node:stream';
 69 | import rekwest, {
 70 |   constants,
 71 |   Blob,
 72 |   File,
 73 |   FormData,
 74 | } from 'rekwest';
 75 | 
 76 | const {
 77 |   HTTP2_HEADER_AUTHORIZATION,
 78 |   HTTP2_HEADER_CONTENT_ENCODING,
 79 |   HTTP2_METHOD_POST,
 80 |   HTTP_STATUS_OK,
 81 | } = constants;
 82 | 
 83 | const blob = new Blob(['bits']);
 84 | const file = new File(['bits'], 'file.dab');
 85 | const readable = Readable.from('bits');
 86 | 
 87 | const fd = new FormData({
 88 |   aux: Date.now(),  // either [[key, value]] or kv sequenceable
 89 | });
 90 | 
 91 | fd.append('celestial', 'payload');
 92 | fd.append('blob', blob, 'blob.dab');
 93 | fd.append('file', file);
 94 | fd.append('readable', readable, 'readable.dab');
 95 | 
 96 | const url = 'https://somewhe.re/somewhat/endpoint';
 97 | 
 98 | const res = await rekwest(url, {
 99 |   body: fd,
100 |   headers: {
101 |     [HTTP2_HEADER_AUTHORIZATION]: 'Bearer [token]',
102 |     [HTTP2_HEADER_CONTENT_ENCODING]: 'zstd',  // enables: body compression
103 |   },
104 |   method: HTTP2_METHOD_POST,
105 | });
106 | 
107 | console.assert(res.statusCode === HTTP_STATUS_OK);
108 | console.info(res.headers);
109 | console.log(res.body);
110 | ```
111 | 
112 | ### API
113 | 
114 | #### `rekwest(url[, options])`
115 | 
116 | * `url` **{string | URL}** The URL to send the request to
117 | * `options` **{Object}**
118 |   Extends [http(s).RequestOptions](https://nodejs.org/api/https.html#httpsrequesturl-options-callback) along with
119 |   extra [http2.ClientSessionOptions](https://nodejs.org/api/http2.html#http2connectauthority-options-listener)
120 |   & [http2.ClientSessionRequestOptions](https://nodejs.org/api/http2.html#clienthttp2sessionrequestheaders-options)
121 |   and [tls.ConnectionOptions](https://nodejs.org/api/tls.html#tlsconnectoptions-callback)
122 |   for HTTP/2 attunes
123 |   * `baseURL` **{string | URL}** The base URL to use in cases where `url` is a relative URL
124 |   * `body` **{string | Array | ArrayBuffer | ArrayBufferView | AsyncIterator | Blob | Buffer | DataView | File |
125 |     FormData | Iterator | Object | Readable | ReadableStream | SharedArrayBuffer | URLSearchParams}** The body to send
126 |     with the request
127 |   * `cookies` **{boolean | Array<[k, v]> | Array<string\> | Cookies | Object | URLSearchParams}** `Default: true` The
128 |     cookies to add to
129 |     the request
130 |   * `cookiesTTL` **{boolean}** `Default: false` Controls enablement of TTL for the cookies cache
131 |   * `credentials` **{include | omit | same-origin}** `Default: same-origin` Controls credentials in case of cross-origin
132 |     redirects
133 |   * `digest` **{boolean}** `Default: true` Controls whether to read the response stream or simply add a mixin
134 |   * `follow` **{number}** `Default: 20` The number of redirects to follow
135 |   * `h2` **{boolean}** `Default: false` Forces the use of HTTP/2 protocol
136 |   * `headers` **{Object}** The headers to add to the request
137 |   * `maxRetryAfter` **{number}** The upper limit of `retry-after` header. If unset, it will use `timeout` value
138 |   * `parse` **{boolean}** `Default: true` Controls whether to parse response body or simply return a buffer
139 |   * `redirect` **{error | follow | manual}** `Default: follow` Controls the redirect flows
140 |   * `retry` **{Object}** Represents the retry options
141 |     * `attempts` **{number}** `Default: 0` The number of retry attempts
142 |     * `backoffStrategy` **{string}** `Default: interval * Math.log(Math.random() * (Math.E * Math.E - Math.E) + Math.E)`
143 |       The backoff strategy algorithm that increases logarithmically. To fixate set value to `interval * 1`
144 |     * `errorCodes` **{string[]}**
145 |       `Default: ['EAI_AGAIN', 'ECONNREFUSED', 'ECONNRESET', 'EHOSTDOWN', 'EHOSTUNREACH', 'ENETDOWN', 'ENETUNREACH', 'ENOTFOUND', 'EPIPE', 'ERR_HTTP2_STREAM_ERROR']`
146 |       The list of error codes to retry on
147 |     * `interval` **{number}** `Default: 1e3` The initial retry interval
148 |     * `retryAfter` **{boolean}** `Default: true` Controls `retry-after` header receptiveness
149 |     * `statusCodes` **{number[]}** `Default: [429, 500, 502, 503, 504]` The list of status codes to retry on
150 |   * `stripTrailingSlash` **{boolean}** `Default: false` Controls whether to strip trailing slash at the end of the URL
151 |   * `thenable` **{boolean}** `Default: false` Controls the promise resolutions
152 |   * `timeout` **{number}** `Default: 3e5` The number of milliseconds a request can take before termination
153 |   * `trimTrailingSlashes` **{boolean}** `Default: false` Controls whether to trim trailing slashes within the URL
154 | * **Returns:** Promise that resolves to
155 |   extended [http.IncomingMessage](https://nodejs.org/api/http.html#class-httpincomingmessage)
156 |   or [http2.ClientHttp2Stream](https://nodejs.org/api/http2.html#class-clienthttp2stream) which is respectively
157 |   readable and duplex streams
158 |   * if `digest: true` & `parse: true`
159 |     * `body` **{string | Array | Buffer | Object}** The body based on its content type
160 |   * if `digest: false`
161 |     * `arrayBuffer` **{AsyncFunction}** Reads the response and returns **ArrayBuffer**
162 |     * `blob` **{AsyncFunction}** Reads the response and returns **Blob**
163 |     * `body` **{AsyncFunction}** Reads the response and returns **Buffer** if `parse: false`
164 |     * `bytes` **{AsyncFunction}** Reads the response and returns **Uint8Array**
165 |     * `json` **{AsyncFunction}** Reads the response and returns **Object**
166 |     * `text` **{AsyncFunction}** Reads the response and returns **String**
167 |   * `bodyUsed` **{boolean}** Indicates whether the response were read or not
168 |   * `cookies` **{undefined | Cookies}** The cookies sent and received with the response
169 |   * `headers` **{Object}** The headers received with the response
170 |   * `httpVersion` **{string}** Indicates protocol version negotiated with the server
171 |   * `ok` **{boolean}** Indicates if the response was successful (statusCode: **200-299**)
172 |   * `redirected` **{boolean}** Indicates if the response is the result of a redirect
173 |   * `statusCode` **{number}** Indicates the status code of the response
174 |   * `trailers` **{undefined | Object}** The trailer headers received with the response
175 | 
176 | ---
177 | 
178 | #### `rekwest.defaults`
179 | 
180 | The object to fulfill with default [options](#rekwesturl-options).
181 | 
182 | ---
183 | 
184 | #### `rekwest.extend(options)`
185 | 
186 | The method to extend default [options](#rekwesturl-options) per instance.
187 | 
188 | ```javascript
189 | import rekwest, { constants } from 'rekwest';
190 | 
191 | const {
192 |   HTTP_STATUS_OK,
193 | } = constants;
194 | 
195 | const rk = rekwest.extend({
196 |   baseURL: 'https://somewhe.re',
197 | });
198 | 
199 | const signal = AbortSignal.timeout(1e4);
200 | const url = '/somewhat/endpoint';
201 | 
202 | const res = await rk(url, {
203 |   signal,
204 | });
205 | 
206 | console.assert(res.statusCode === HTTP_STATUS_OK);
207 | console.info(res.headers);
208 | console.log(res.body);
209 | ```
210 | 
211 | ---
212 | 
213 | #### `rekwest.stream(url[, options])`
214 | 
215 | The method with limited functionality to use with streams and/or pipes.
216 | 
217 | * No automata (redirects & retries)
218 | * Pass `h2: true` in options to use HTTP/2 protocol
219 |   * Use `ackn({ url: URL })` method in advance to check the available protocols
220 | 
221 | ```javascript
222 | import fs from 'node:fs';
223 | import { pipeline } from 'node:stream/promises';
224 | import rekwest, {
225 |   ackn,
226 |   constants,
227 | } from 'rekwest';
228 | 
229 | const {
230 |   HTTP2_METHOD_POST,
231 | } = constants;
232 | 
233 | const url = new URL('https://somewhe.re/somewhat/endpoint');
234 | const options = await ackn({ url });
235 | 
236 | await pipeline(
237 |   fs.createReadStream('/path/to/read/inlet.xyz'),
238 |   rekwest.stream(url, { ...options, method: HTTP2_METHOD_POST }),
239 |   fs.createWriteStream('/path/to/write/outlet.xyz'),
240 | );
241 | ```
242 | 
243 | ---
244 | 
245 | For more details, please check tests (coverage: **>97%**) in the repository.
246 | 


--------------------------------------------------------------------------------
/babel.config.js:
--------------------------------------------------------------------------------
 1 | const { engines: { node } } = require('./package');
 2 | const version = Number.parseInt(node.replace(/\p{Symbol}/gu, ''));
 3 | 
 4 | module.exports = function (api) {
 5 |   api?.cache(false);
 6 | 
 7 |   return {
 8 |     plugins: [],
 9 |     presets: [
10 |       [
11 |         '@babel/preset-env',
12 |         {
13 |           bugfixes: true,
14 |           shippedProposals: true,
15 |           targets: { node: version },
16 |         },
17 |       ],
18 |     ],
19 |   };
20 | };
21 | 


--------------------------------------------------------------------------------
/eslint.config.mjs:
--------------------------------------------------------------------------------
1 | import ultraRefined from 'eslint-config-ultra-refined';
2 | 
3 | export default [
4 |   ...ultraRefined,
5 |   {
6 |     ignores: ['dist'],
7 |   },
8 | ];
9 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "author": {
 3 |     "name": "Yehor Sergeenko",
 4 |     "email": "yehor.sergeenko@gmail.com",
 5 |     "url": "https://github.com/bricss"
 6 |   },
 7 |   "bugs": {
 8 |     "url": "https://github.com/bricss/rekwest/issues"
 9 |   },
10 |   "devDependencies": {
11 |     "@babel/cli": "^7.27.2",
12 |     "@babel/core": "^7.27.1",
13 |     "@babel/eslint-parser": "^7.27.1",
14 |     "@babel/preset-env": "^7.27.2",
15 |     "c8": "^10.1.3",
16 |     "eslint": "^9.26.0",
17 |     "eslint-config-ultra-refined": "^3.4.8",
18 |     "mocha": "^11.2.2"
19 |   },
20 |   "description": "The robust request library that humanity deserves 🌐",
21 |   "engines": {
22 |     "node": ">=20.0.0"
23 |   },
24 |   "exports": {
25 |     "import": "./src/index.mjs",
26 |     "require": "./dist/index.js"
27 |   },
28 |   "files": [
29 |     "dist",
30 |     "src"
31 |   ],
32 |   "homepage": "https://github.com/bricss/rekwest#readme",
33 |   "keywords": [
34 |     "alpn",
35 |     "backoff",
36 |     "brotli",
37 |     "cookie",
38 |     "deflate",
39 |     "deflate-raw",
40 |     "fetch",
41 |     "formdata",
42 |     "gzip",
43 |     "http",
44 |     "https",
45 |     "h2",
46 |     "h2c",
47 |     "http2",
48 |     "multipart",
49 |     "request",
50 |     "redirect",
51 |     "retry",
52 |     "retry-after",
53 |     "stream",
54 |     "upload",
55 |     "zstd"
56 |   ],
57 |   "license": "MIT",
58 |   "name": "rekwest",
59 |   "repository": {
60 |     "type": "git",
61 |     "url": "git+https://github.com/bricss/rekwest.git"
62 |   },
63 |   "scripts": {
64 |     "build": "rm -rf dist && npx babel src -d dist",
65 |     "cert:gen": "openssl req -days 365 -keyout localhost.key -newkey ec -nodes -pkeyopt ec_paramgen_curve:prime256v1 -subj //SKIP=1/CN=localhost -out localhost.cert -x509",
66 |     "cert:ken": "openssl x509 -in localhost.cert -noout -text",
67 |     "lint": "eslint",
68 |     "prepack": "npm run build && sh pony.sh",
69 |     "pretest": "rm -rf coverage && npm run cert:gen",
70 |     "test": "mocha",
71 |     "test:bail": "mocha --bail",
72 |     "test:cover": "c8 --include=src --reporter=lcov --reporter=text npm test"
73 |   },
74 |   "version": "6.0.0"
75 | }
76 | 


--------------------------------------------------------------------------------
/pony.sh:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env bash
2 | # Transforms extensions within source files
3 | 
4 | for file in dist/*.js; do
5 |   echo "$file"
6 |   sed -e 's/.\bmjs\b//g' -i "$file"
7 | done
8 | 


--------------------------------------------------------------------------------
/src/ackn.mjs:
--------------------------------------------------------------------------------
 1 | import { connect } from 'node:tls';
 2 | 
 3 | export const ackn = (options) => new Promise((resolve, reject) => {
 4 |   const { url } = options;
 5 |   const socket = connect({
 6 |     ...options,
 7 |     ALPNProtocols: [
 8 |       'h2',
 9 |       'http/1.1',
10 |     ],
11 |     host: url.hostname,
12 |     port: parseInt(url.port) || 443,
13 |     servername: url.hostname,
14 |   }, () => {
15 |     socket.off('error', reject);
16 |     socket.off('timeout', reject);
17 | 
18 |     const { alpnProtocol } = socket;
19 | 
20 |     resolve({
21 |       ...options,
22 |       alpnProtocol,
23 |       createConnection() {
24 |         return socket;
25 |       },
26 |       h2: /h2c?/i.test(alpnProtocol),
27 |       protocol: url.protocol,
28 |     });
29 |   });
30 | 
31 |   socket.on('error', reject);
32 |   socket.on('timeout', reject);
33 | });
34 | 


--------------------------------------------------------------------------------
/src/config.mjs:
--------------------------------------------------------------------------------
 1 | import http2 from 'node:http2';
 2 | import zlib from 'node:zlib';
 3 | import {
 4 |   requestCredentials,
 5 |   requestRedirect,
 6 | } from './constants.mjs';
 7 | import {
 8 |   APPLICATION_JSON,
 9 |   TEXT_PLAIN,
10 |   WILDCARD,
11 | } from './mediatypes.mjs';
12 | import { maxRetryAfter } from './utils.mjs';
13 | 
14 | const {
15 |   HTTP2_HEADER_ACCEPT,
16 |   HTTP2_HEADER_ACCEPT_ENCODING,
17 |   HTTP2_METHOD_GET,
18 |   HTTP_STATUS_BAD_GATEWAY,
19 |   HTTP_STATUS_GATEWAY_TIMEOUT,
20 |   HTTP_STATUS_INTERNAL_SERVER_ERROR,
21 |   HTTP_STATUS_SERVICE_UNAVAILABLE,
22 |   HTTP_STATUS_TOO_MANY_REQUESTS,
23 | } = http2.constants;
24 | 
25 | export const isZstdSupported = !!zlib.constants.ZSTD_CLEVEL_DEFAULT;
26 | 
27 | const defaults = {
28 |   cookiesTTL: false,
29 |   credentials: requestCredentials.sameOrigin,
30 |   digest: true,
31 |   follow: 20,
32 |   h2: false,
33 |   headers: {
34 |     [HTTP2_HEADER_ACCEPT]: `${ APPLICATION_JSON }, ${ TEXT_PLAIN }, ${ WILDCARD }`,
35 |     [HTTP2_HEADER_ACCEPT_ENCODING]: `br,${ isZstdSupported ? ' zstd, ' : ' ' }gzip, deflate, deflate-raw`,
36 |   },
37 |   get maxRetryAfter() {
38 |     return this[maxRetryAfter] ?? this.timeout;
39 |   },
40 |   set maxRetryAfter(value) {
41 |     this[maxRetryAfter] = value;
42 |   },
43 |   method: HTTP2_METHOD_GET,
44 |   parse: true,
45 |   redirect: requestRedirect.follow,
46 |   redirected: false,
47 |   retry: {
48 |     attempts: 0,
49 |     backoffStrategy: 'interval * Math.log(Math.random() * (Math.E * Math.E - Math.E) + Math.E)',
50 |     errorCodes: [
51 |       'EAI_AGAIN',
52 |       'ECONNREFUSED',
53 |       'ECONNRESET',
54 |       'EHOSTDOWN',
55 |       'EHOSTUNREACH',
56 |       'ENETDOWN',
57 |       'ENETUNREACH',
58 |       'ENOTFOUND',
59 |       'EPIPE',
60 |       'ERR_HTTP2_STREAM_ERROR',
61 |     ],
62 |     interval: 1e3,
63 |     retryAfter: true,
64 |     statusCodes: [
65 |       HTTP_STATUS_TOO_MANY_REQUESTS,
66 |       HTTP_STATUS_INTERNAL_SERVER_ERROR,
67 |       HTTP_STATUS_BAD_GATEWAY,
68 |       HTTP_STATUS_SERVICE_UNAVAILABLE,
69 |       HTTP_STATUS_GATEWAY_TIMEOUT,
70 |     ],
71 |   },
72 |   stripTrailingSlash: false,
73 |   thenable: false,
74 |   timeout: 3e5,
75 |   trimTrailingSlashes: false,
76 | };
77 | 
78 | export default {
79 |   defaults,
80 | };
81 | 


--------------------------------------------------------------------------------
/src/constants.mjs:
--------------------------------------------------------------------------------
 1 | import http2 from 'node:http2';
 2 | 
 3 | const {
 4 |   HTTP_STATUS_FOUND,
 5 |   HTTP_STATUS_MOVED_PERMANENTLY,
 6 |   HTTP_STATUS_PERMANENT_REDIRECT,
 7 |   HTTP_STATUS_SEE_OTHER,
 8 |   HTTP_STATUS_TEMPORARY_REDIRECT,
 9 | } = http2.constants;
10 | 
11 | export const requestCredentials = {
12 |   include: 'include',
13 |   omit: 'omit',
14 |   sameOrigin: 'same-origin',
15 | };
16 | 
17 | export const requestRedirect = {
18 |   error: 'error',
19 |   follow: 'follow',
20 |   manual: 'manual',
21 | };
22 | 
23 | export const requestRedirectCodes = [
24 |   HTTP_STATUS_MOVED_PERMANENTLY,
25 |   HTTP_STATUS_FOUND,
26 |   HTTP_STATUS_SEE_OTHER,
27 |   HTTP_STATUS_TEMPORARY_REDIRECT,
28 |   HTTP_STATUS_PERMANENT_REDIRECT,
29 | ];
30 | 


--------------------------------------------------------------------------------
/src/cookies.mjs:
--------------------------------------------------------------------------------
  1 | import {
  2 |   brandCheck,
  3 |   toCamelCase,
  4 | } from './utils.mjs';
  5 | 
  6 | const lifetimeCap = 3456e7; // pragma: 400 days
  7 | 
  8 | export class Cookies extends URLSearchParams {
  9 | 
 10 |   static #finalizers = new Set();
 11 |   static jar = new Map();
 12 | 
 13 |   static #register(target, value) {
 14 |     const finalizer = new FinalizationRegistry((heldValue) => {
 15 |       clearTimeout(heldValue);
 16 |       this.#finalizers.delete(finalizer);
 17 |     });
 18 | 
 19 |     finalizer.register(target, value);
 20 |     this.#finalizers.add(finalizer);
 21 |   }
 22 | 
 23 |   #chronometry = new Map();
 24 | 
 25 |   get [Symbol.toStringTag]() {
 26 |     return this.constructor.name;
 27 |   }
 28 | 
 29 |   constructor(input, { cookiesTTL } = { cookiesTTL: false }) {
 30 |     if (Array.isArray(input) && input.every((it) => !Array.isArray(it))) {
 31 |       input = input.map((it) => {
 32 |         if (!cookiesTTL) {
 33 |           return [it.split(';').at(0).trim()];
 34 |         }
 35 | 
 36 |         const [cookie, ...attrs] = it.split(';').map((it) => it.trim());
 37 |         const ttl = {};
 38 | 
 39 |         for (const val of attrs) {
 40 |           if (/(?:Expires|Max-Age)=/i.test(val)) {
 41 |             const [key, value] = val.toLowerCase().split('=');
 42 |             const ms = Number.isFinite(Number(value)) ? value * 1e3 : Date.parse(value) - Date.now();
 43 | 
 44 |             ttl[toCamelCase(key)] = Math.min(ms, lifetimeCap);
 45 |           }
 46 |         }
 47 | 
 48 |         return [
 49 |           cookie.replace(/\u0022/g, ''),
 50 |           Object.keys(ttl).length ? ttl : null,
 51 |         ];
 52 |       });
 53 |     }
 54 | 
 55 |     super(Array.isArray(input) ? input.map((it) => it.at(0)).join('&') : input);
 56 | 
 57 |     if (Array.isArray(input) && cookiesTTL) {
 58 |       for (const [cookie, ttl] of input.filter((it) => it.at(1))) {
 59 |         const key = cookie.split('=').at(0);
 60 | 
 61 |         if (this.#chronometry.has(key)) {
 62 |           clearTimeout(this.#chronometry.get(key));
 63 |           this.#chronometry.delete(key);
 64 |         }
 65 | 
 66 |         const { expires, maxAge } = ttl;
 67 | 
 68 |         for (const ms of [
 69 |           maxAge,
 70 |           expires,
 71 |         ]) {
 72 |           if (!Number.isInteger(ms)) {
 73 |             continue;
 74 |           }
 75 | 
 76 |           const ref = new WeakRef(this);
 77 |           const tid = setTimeout(() => {
 78 |             const ctx = ref.deref();
 79 | 
 80 |             if (ctx) {
 81 |               ctx.#chronometry.delete(key);
 82 |               ctx.delete(key);
 83 |             }
 84 |           }, Math.max(ms, 0));
 85 | 
 86 |           this.constructor.#register(this, tid);
 87 |           this.#chronometry.set(key, tid);
 88 |           break;
 89 |         }
 90 |       }
 91 |     }
 92 |   }
 93 | 
 94 |   toString() {
 95 |     brandCheck(this, Cookies);
 96 | 
 97 |     return super.toString().split('&').join('; ').trim();
 98 |   }
 99 | 
100 | }
101 | 


--------------------------------------------------------------------------------
/src/errors.mjs:
--------------------------------------------------------------------------------
 1 | export class RequestError extends Error {
 2 | 
 3 |   get [Symbol.toStringTag]() {
 4 |     return this.constructor.name;
 5 |   }
 6 | 
 7 |   get name() {
 8 |     return this[Symbol.toStringTag];
 9 |   }
10 | 
11 |   constructor(...args) {
12 |     super(...args);
13 |     Error.captureStackTrace(this, this.constructor);
14 |   }
15 | 
16 | }
17 | 
18 | export class TimeoutError extends RequestError {}
19 | 


--------------------------------------------------------------------------------
/src/formdata.mjs:
--------------------------------------------------------------------------------
  1 | import { File } from 'node:buffer';
  2 | import { randomBytes } from 'node:crypto';
  3 | import http2 from 'node:http2';
  4 | import { toUSVString } from 'node:util';
  5 | import {
  6 |   APPLICATION_OCTET_STREAM,
  7 |   MULTIPART_FORM_DATA,
  8 | } from './mediatypes.mjs';
  9 | import {
 10 |   brandCheck,
 11 |   isFileLike,
 12 |   tap,
 13 | } from './utils.mjs';
 14 | 
 15 | const CRLF = '\r\n';
 16 | const {
 17 |   HTTP2_HEADER_CONTENT_DISPOSITION,
 18 |   HTTP2_HEADER_CONTENT_TYPE,
 19 | } = http2.constants;
 20 | 
 21 | export class FormData {
 22 | 
 23 |   static actuate(fd) {
 24 |     const boundary = randomBytes(24).toString('hex');
 25 |     const contentType = `${ MULTIPART_FORM_DATA }; boundary=${ boundary }`;
 26 |     const prefix = `--${ boundary }${ CRLF }${ HTTP2_HEADER_CONTENT_DISPOSITION }: form-data`;
 27 | 
 28 |     const escape = (str) => str.replace(/\n/g, '%0A').replace(/\r/g, '%0D').replace(/"/g, '%22');
 29 |     const redress = (str) => str.replace(/\r?\n|\r/g, CRLF);
 30 | 
 31 |     return {
 32 |       contentType,
 33 |       async* [Symbol.asyncIterator]() {
 34 |         const encoder = new TextEncoder();
 35 | 
 36 |         for (const [name, value] of fd) {
 37 |           if (value.constructor === String) {
 38 |             yield encoder.encode(`${ prefix }; name="${
 39 |               escape(redress(name))
 40 |             }"${ CRLF.repeat(2) }${ redress(value) }${ CRLF }`);
 41 |           } else {
 42 |             yield encoder.encode(`${ prefix }; name="${
 43 |               escape(redress(name))
 44 |             }"${ value.name ? `; filename="${ escape(value.name) }"` : '' }${ CRLF }${
 45 |               HTTP2_HEADER_CONTENT_TYPE
 46 |             }: ${
 47 |               value.type || APPLICATION_OCTET_STREAM
 48 |             }${ CRLF.repeat(2) }`);
 49 |             yield* tap(value);
 50 |             yield new Uint8Array([
 51 |               13,
 52 |               10,
 53 |             ]);
 54 |           }
 55 |         }
 56 | 
 57 |         yield encoder.encode(`--${ boundary }--`);
 58 |       },
 59 |     };
 60 |   }
 61 | 
 62 |   static alike(instance) {
 63 |     return FormData.name === instance?.[Symbol.toStringTag];
 64 |   }
 65 | 
 66 |   static #enfoldEntry(name, value, filename) {
 67 |     name = toUSVString(name);
 68 |     filename &&= toUSVString(filename);
 69 | 
 70 |     if (isFileLike(value)) {
 71 |       filename ??= value.name || 'blob';
 72 |       value = new File([value], filename, value);
 73 |     } else if (this.#ensureInstance(value)) {
 74 |       value.name = filename;
 75 |     } else {
 76 |       value = toUSVString(value);
 77 |     }
 78 | 
 79 |     return {
 80 |       name,
 81 |       value,
 82 |     };
 83 |   }
 84 | 
 85 |   static #ensureInstance(value) {
 86 |     return isFileLike(value) || (value === Object(value) && Reflect.has(value, Symbol.asyncIterator));
 87 |   }
 88 | 
 89 |   #entries = [];
 90 | 
 91 |   get [Symbol.toStringTag]() {
 92 |     return this.constructor.name;
 93 |   }
 94 | 
 95 |   constructor(input) {
 96 |     if (input === Object(input)
 97 |       && (input?.constructor === Object || Reflect.has(input, Symbol.iterator))) {
 98 | 
 99 |       if (input.constructor !== Object) {
100 |         input = Array.from(input);
101 |       }
102 | 
103 |       if (Array.isArray(input)) {
104 |         if (!input.every((it) => Array.isArray(it))) {
105 |           throw new TypeError(`Failed to construct '${
106 |             this[Symbol.toStringTag]
107 |           }': The provided value cannot be converted to a sequence.`);
108 |         } else if (!input.every((it) => it.length === 2)) {
109 |           throw new TypeError(`Failed to construct '${
110 |             this[Symbol.toStringTag]
111 |           }': Sequence initializer must only contain pair elements.`);
112 |         }
113 |       }
114 | 
115 |       if (input.constructor === Object) {
116 |         input = Object.entries(input);
117 |       }
118 | 
119 |       for (const [key, value] of input) {
120 |         this.append(key, value);
121 |       }
122 |     }
123 |   }
124 | 
125 |   #ensureArgs(args, expected, method) {
126 |     if (args.length < expected) {
127 |       throw new TypeError(`Failed to execute '${ method }' on '${
128 |         this[Symbol.toStringTag]
129 |       }': ${ expected } arguments required, but only ${ args.length } present.`);
130 |     }
131 | 
132 |     if ([
133 |       'append',
134 |       'set',
135 |     ].includes(method)) {
136 |       if (args.length === 3 && !this.constructor.#ensureInstance(args[1])) {
137 |         throw new TypeError(`Failed to execute '${ method }' on '${
138 |           this[Symbol.toStringTag]
139 |         }': parameter ${ expected } is not of type 'Blob'.`);
140 |       }
141 |     }
142 | 
143 |     if (method === 'forEach') {
144 |       if (args[0]?.constructor !== Function) {
145 |         throw new TypeError(`Failed to execute '${ method }' on '${
146 |           this[Symbol.toStringTag]
147 |         }': parameter ${ expected } is not of type 'Function'.`);
148 |       }
149 |     }
150 |   }
151 | 
152 |   append(...args) {
153 |     brandCheck(this, FormData);
154 |     this.#ensureArgs(args, 2, 'append');
155 |     this.#entries.push(this.constructor.#enfoldEntry(...args));
156 |   }
157 | 
158 |   delete(...args) {
159 |     brandCheck(this, FormData);
160 |     this.#ensureArgs(args, 1, 'delete');
161 |     const name = toUSVString(args[0]);
162 | 
163 |     this.#entries = this.#entries.filter((it) => it.name !== name);
164 |   }
165 | 
166 |   forEach(...args) {
167 |     brandCheck(this, FormData);
168 |     this.#ensureArgs(args, 1, 'forEach');
169 |     const [callback, thisArg] = args;
170 | 
171 |     for (const entry of this) {
172 |       Reflect.apply(callback, thisArg, [
173 |         ...entry.reverse(),
174 |         this,
175 |       ]);
176 |     }
177 |   }
178 | 
179 |   get(...args) {
180 |     brandCheck(this, FormData);
181 |     this.#ensureArgs(args, 1, 'get');
182 |     const name = toUSVString(args[0]);
183 | 
184 |     return (this.#entries.find((it) => it.name === name) ?? {}).value ?? null;
185 |   }
186 | 
187 |   getAll(...args) {
188 |     brandCheck(this, FormData);
189 |     this.#ensureArgs(args, 1, 'getAll');
190 |     const name = toUSVString(args[0]);
191 | 
192 |     return this.#entries.filter((it) => it.name === name).map((it) => it.value);
193 |   }
194 | 
195 |   has(...args) {
196 |     brandCheck(this, FormData);
197 |     this.#ensureArgs(args, 1, 'has');
198 |     const name = toUSVString(args[0]);
199 | 
200 |     return !!this.#entries.find((it) => it.name === name);
201 |   }
202 | 
203 |   set(...args) {
204 |     brandCheck(this, FormData);
205 |     this.#ensureArgs(args, 2, 'set');
206 |     const entry = this.constructor.#enfoldEntry(...args);
207 |     const idx = this.#entries.findIndex((it) => it.name === entry.name);
208 | 
209 |     if (idx !== -1) {
210 |       this.#entries.splice(idx, 1, entry);
211 |     } else {
212 |       this.#entries.push(entry);
213 |     }
214 |   }
215 | 
216 |   * entries() {
217 |     brandCheck(this, FormData);
218 |     for (const { name, value } of this.#entries) {
219 |       yield [
220 |         name,
221 |         value,
222 |       ];
223 |     }
224 |   }
225 | 
226 |   * keys() {
227 |     brandCheck(this, FormData);
228 |     for (const [name] of this) {
229 |       yield name;
230 |     }
231 |   }
232 | 
233 |   * values() {
234 |     brandCheck(this, FormData);
235 |     for (const [, value] of this) {
236 |       yield value;
237 |     }
238 |   }
239 | 
240 |   [Symbol.iterator]() {
241 |     brandCheck(this, FormData);
242 | 
243 |     return this.entries();
244 |   }
245 | 
246 | }
247 | 


--------------------------------------------------------------------------------
/src/index.mjs:
--------------------------------------------------------------------------------
 1 | import http from 'node:http';
 2 | import http2 from 'node:http2';
 3 | import https from 'node:https';
 4 | import config from './config.mjs';
 5 | import { requestRedirect } from './constants.mjs';
 6 | import { APPLICATION_OCTET_STREAM } from './mediatypes.mjs';
 7 | import { preflight } from './preflight.mjs';
 8 | import { transfer } from './transfer.mjs';
 9 | import {
10 |   admix,
11 |   affix,
12 |   copyWithMerge,
13 |   normalize,
14 | } from './utils.mjs';
15 | import { validation } from './validation.mjs';
16 | 
17 | export {
18 |   Blob,
19 |   File,
20 | } from 'node:buffer';
21 | export { constants } from 'node:http2';
22 | 
23 | export * from './ackn.mjs';
24 | export * from './constants.mjs';
25 | export * from './cookies.mjs';
26 | export * from './errors.mjs';
27 | export * from './formdata.mjs';
28 | export * as mediatypes from './mediatypes.mjs';
29 | export * from './mixin.mjs';
30 | export * from './utils.mjs';
31 | export * from './validation.mjs';
32 | 
33 | const {
34 |   HTTP2_HEADER_CONTENT_TYPE,
35 | } = http2.constants;
36 | 
37 | export default function rekwest(url, options) {
38 |   return transfer(validation(normalize(url, options)), rekwest);
39 | }
40 | 
41 | Reflect.defineProperty(rekwest, 'defaults', {
42 |   enumerable: true,
43 |   get() { return config.defaults; },
44 |   set(value) { config.defaults = copyWithMerge(config.defaults, value); },
45 | });
46 | 
47 | Reflect.defineProperty(rekwest, 'extend', {
48 |   enumerable: true,
49 |   value(options) {
50 |     return (url, opts) => rekwest(url, copyWithMerge(options, opts));
51 |   },
52 | });
53 | 
54 | Reflect.defineProperty(rekwest, 'stream', {
55 |   enumerable: true,
56 |   value(url, options) {
57 |     options = preflight(validation(normalize(url, copyWithMerge({}, options, {
58 |       headers: { [HTTP2_HEADER_CONTENT_TYPE]: APPLICATION_OCTET_STREAM },
59 |       redirect: requestRedirect.manual,
60 |     }))));
61 |     let client, req;
62 | 
63 |     if (options.h2) {
64 |       client = http2.connect(options.url.origin, options);
65 |       req = client.request(options.headers, options);
66 |     } else {
67 |       const { request } = options.url.protocol === 'http:' ? http : https;
68 | 
69 |       req = request(options.url, options);
70 |     }
71 | 
72 |     affix(client, req, options);
73 | 
74 |     req.once('response', (res) => {
75 |       let headers;
76 | 
77 |       if (options.h2) {
78 |         headers = res;
79 |         res = req;
80 |       }
81 | 
82 |       admix(res, headers, options);
83 |     });
84 | 
85 |     return req;
86 |   },
87 | });
88 | 


--------------------------------------------------------------------------------
/src/mediatypes.mjs:
--------------------------------------------------------------------------------
1 | export const APPLICATION_FORM_URLENCODED = 'application/x-www-form-urlencoded';
2 | export const APPLICATION_JSON = 'application/json';
3 | export const APPLICATION_OCTET_STREAM = 'application/octet-stream';
4 | export const MULTIPART_FORM_DATA = 'multipart/form-data';
5 | export const TEXT_PLAIN = 'text/plain';
6 | export const WILDCARD = '*/*';
7 | 


--------------------------------------------------------------------------------
/src/mixin.mjs:
--------------------------------------------------------------------------------
  1 | import { Blob } from 'node:buffer';
  2 | import http2 from 'node:http2';
  3 | import {
  4 |   brandCheck,
  5 |   decompress,
  6 | } from './utils.mjs';
  7 | 
  8 | const {
  9 |   HTTP2_HEADER_CONTENT_ENCODING,
 10 |   HTTP2_HEADER_CONTENT_TYPE,
 11 | } = http2.constants;
 12 | 
 13 | export const mixin = (res, { digest = false, parse = false } = {}) => {
 14 |   if (!digest) {
 15 |     Object.defineProperties(res, {
 16 |       arrayBuffer: {
 17 |         enumerable: true,
 18 |         value: async function () {
 19 |           brandCheck(this, res?.constructor);
 20 |           parse &&= false;
 21 |           const { buffer, byteLength, byteOffset } = await this.body();
 22 | 
 23 |           return buffer.slice(byteOffset, byteOffset + byteLength);
 24 |         },
 25 |       },
 26 |       blob: {
 27 |         enumerable: true,
 28 |         value: async function () {
 29 |           brandCheck(this, res?.constructor);
 30 |           const val = await this.arrayBuffer();
 31 | 
 32 |           return new Blob([val]);
 33 |         },
 34 |       },
 35 |       bytes: {
 36 |         enumerable: true,
 37 |         value: async function () {
 38 |           brandCheck(this, res?.constructor);
 39 | 
 40 |           return new Uint8Array(await this.arrayBuffer());
 41 |         },
 42 |       },
 43 |       json: {
 44 |         enumerable: true,
 45 |         value: async function () {
 46 |           brandCheck(this, res?.constructor);
 47 |           const val = await this.text();
 48 | 
 49 |           return JSON.parse(val);
 50 |         },
 51 |       },
 52 |       text: {
 53 |         enumerable: true,
 54 |         value: async function () {
 55 |           brandCheck(this, res?.constructor);
 56 |           const blob = await this.blob();
 57 | 
 58 |           return blob.text();
 59 |         },
 60 |       },
 61 |     });
 62 |   }
 63 | 
 64 |   return Object.defineProperties(res, {
 65 |     body: {
 66 |       enumerable: true,
 67 |       value: async function () {
 68 |         brandCheck(this, res?.constructor);
 69 | 
 70 |         if (this.bodyUsed) {
 71 |           throw new TypeError('Response stream already read');
 72 |         }
 73 | 
 74 |         let body = [];
 75 | 
 76 |         for await (const chunk of decompress(this, this.headers[HTTP2_HEADER_CONTENT_ENCODING])) {
 77 |           body.push(chunk);
 78 |         }
 79 | 
 80 |         body = Buffer.concat(body);
 81 | 
 82 |         if (!body.length && parse) {
 83 |           return null;
 84 |         }
 85 | 
 86 |         if (body.length && parse) {
 87 |           const contentType = this.headers[HTTP2_HEADER_CONTENT_TYPE] ?? '';
 88 |           const charset = contentType.split(';')
 89 |                                      .find((it) => /charset=/i.test(it))
 90 |                                      ?.toLowerCase()
 91 |                                      .replace('charset=', '')
 92 |                                      .replace('iso-8859-1', 'latin1')
 93 |                                      .trim() || 'utf-8';
 94 | 
 95 |           if (/\bjson\b/i.test(contentType)) {
 96 |             body = JSON.parse(body.toString(charset));
 97 |           } else if (/\b(?:text|xml)\b/i.test(contentType)) {
 98 |             if (/\b(?:latin1|ucs-2|utf-(?:8|16le))\b/i.test(charset)) {
 99 |               body = body.toString(charset);
100 |             } else {
101 |               body = new TextDecoder(charset).decode(body);
102 |             }
103 |           }
104 |         }
105 | 
106 |         return body;
107 |       },
108 |       writable: true,
109 |     },
110 |     bodyUsed: {
111 |       enumerable: true,
112 |       get() {
113 |         return this.readableEnded;
114 |       },
115 |     },
116 |   });
117 | };
118 | 


--------------------------------------------------------------------------------
/src/postflight.mjs:
--------------------------------------------------------------------------------
  1 | import http2 from 'node:http2';
  2 | import { setTimeout as setTimeoutPromise } from 'node:timers/promises';
  3 | import {
  4 |   requestCredentials,
  5 |   requestRedirect,
  6 |   requestRedirectCodes,
  7 | } from './constants.mjs';
  8 | import { Cookies } from './cookies.mjs';
  9 | import { RequestError } from './errors.mjs';
 10 | import rekwest from './index.mjs';
 11 | import { mixin } from './mixin.mjs';
 12 | import {
 13 |   admix,
 14 |   maxRetryAfterError,
 15 |   sameOrigin,
 16 | } from './utils.mjs';
 17 | 
 18 | const {
 19 |   HTTP2_HEADER_LOCATION,
 20 |   HTTP2_HEADER_RETRY_AFTER,
 21 |   HTTP2_HEADER_SET_COOKIE,
 22 |   HTTP2_METHOD_GET,
 23 |   HTTP2_METHOD_HEAD,
 24 |   HTTP2_METHOD_POST,
 25 |   HTTP_STATUS_BAD_REQUEST,
 26 |   HTTP_STATUS_FOUND,
 27 |   HTTP_STATUS_MOVED_PERMANENTLY,
 28 |   HTTP_STATUS_SEE_OTHER,
 29 | } = http2.constants;
 30 | 
 31 | export const postflight = (req, res, options, { reject, resolve }) => {
 32 |   const { cookies, credentials, follow, h2, redirect, url } = options;
 33 |   let headers;
 34 | 
 35 |   if (h2) {
 36 |     headers = res;
 37 |     res = req;
 38 |   } else {
 39 |     res.once('error', reject);
 40 |   }
 41 | 
 42 |   admix(res, headers, options);
 43 | 
 44 |   if (cookies !== false && res.headers[HTTP2_HEADER_SET_COOKIE]) {
 45 |     if (Cookies.jar.has(url.origin)) {
 46 |       const cookie = new Cookies(res.headers[HTTP2_HEADER_SET_COOKIE], options);
 47 | 
 48 |       Cookies.jar.get(url.origin).forEach((val, key) => {
 49 |         if (!cookie.has(key)) {
 50 |           cookie.set(key, val);
 51 |         }
 52 |       });
 53 |       Cookies.jar.set(url.origin, cookie);
 54 |     } else {
 55 |       Cookies.jar.set(url.origin, new Cookies(res.headers[HTTP2_HEADER_SET_COOKIE], options));
 56 |     }
 57 |   }
 58 | 
 59 |   Reflect.defineProperty(res, 'cookies', {
 60 |     enumerable: true,
 61 |     value: cookies !== false && Cookies.jar.has(url.origin)
 62 |            ? Cookies.jar.get(url.origin)
 63 |            : void 0,
 64 |   });
 65 | 
 66 |   const { statusCode } = res;
 67 | 
 68 |   if (follow && /3\d{2}/.test(statusCode) && res.headers[HTTP2_HEADER_LOCATION]) {
 69 |     if (!requestRedirectCodes.includes(statusCode)) {
 70 |       return res.emit('error', new RangeError(`Invalid status code: ${ statusCode }`));
 71 |     }
 72 | 
 73 |     if (redirect === requestRedirect.error) {
 74 |       return res.emit('error', new RequestError(`Unexpected redirect, redirect mode is set to '${ redirect }'.`));
 75 |     }
 76 | 
 77 |     if (redirect === requestRedirect.follow) {
 78 |       const location = new URL(res.headers[HTTP2_HEADER_LOCATION], url);
 79 | 
 80 |       if (!/^https?:/i.test(location.protocol)) {
 81 |         return res.emit('error', new RequestError('URL scheme must be "http" or "https".'));
 82 |       }
 83 | 
 84 |       if (!sameOrigin(location, url)) {
 85 |         if (credentials !== requestCredentials.include) {
 86 |           options.credentials = requestCredentials.omit;
 87 |         }
 88 | 
 89 |         options.h2 = false;
 90 |       }
 91 | 
 92 |       if (statusCode !== HTTP_STATUS_SEE_OTHER && options.body?.pipe?.constructor === Function) {
 93 |         return res.emit('error', new RequestError(`Unable to ${ redirect } redirect with streamable body.`));
 94 |       }
 95 | 
 96 |       if (([
 97 |         HTTP_STATUS_MOVED_PERMANENTLY,
 98 |         HTTP_STATUS_FOUND,
 99 |       ].includes(statusCode) && options.method === HTTP2_METHOD_POST) || (statusCode === HTTP_STATUS_SEE_OTHER && ![
100 |         HTTP2_METHOD_GET,
101 |         HTTP2_METHOD_HEAD,
102 |       ].includes(options.method))) {
103 |         for (const it of Object.keys(options.headers).filter((val) => /^content-/i.test(val))) {
104 |           Reflect.deleteProperty(options.headers, it);
105 |         }
106 | 
107 |         options.body = null;
108 |         options.method = HTTP2_METHOD_GET;
109 |       }
110 | 
111 |       options.follow--;
112 |       options.redirected = true;
113 |       options.url = location;
114 | 
115 |       if (statusCode === HTTP_STATUS_MOVED_PERMANENTLY && res.headers[HTTP2_HEADER_RETRY_AFTER]) {
116 |         let interval = res.headers[HTTP2_HEADER_RETRY_AFTER];
117 | 
118 |         interval = Number(interval) * 1e3 || new Date(interval) - Date.now();
119 | 
120 |         if (interval > options.maxRetryAfter) {
121 |           return res.emit('error', maxRetryAfterError(interval, { cause: mixin(res, options) }));
122 |         }
123 | 
124 |         return setTimeoutPromise(interval).then(() => rekwest(options.url, options).then(resolve, reject));
125 |       }
126 | 
127 |       return rekwest(options.url, options).then(resolve, reject);
128 |     }
129 |   }
130 | 
131 |   if (statusCode >= HTTP_STATUS_BAD_REQUEST) {
132 |     return reject(mixin(res, options));
133 |   }
134 | 
135 |   resolve(mixin(res, options));
136 | };
137 | 


--------------------------------------------------------------------------------
/src/preflight.mjs:
--------------------------------------------------------------------------------
 1 | import http2 from 'node:http2';
 2 | import { isZstdSupported } from './config.mjs';
 3 | import { requestCredentials } from './constants.mjs';
 4 | import { Cookies } from './cookies.mjs';
 5 | 
 6 | const {
 7 |   HTTP2_HEADER_ACCEPT_ENCODING,
 8 |   HTTP2_HEADER_AUTHORITY,
 9 |   HTTP2_HEADER_AUTHORIZATION,
10 |   HTTP2_HEADER_COOKIE,
11 |   HTTP2_HEADER_METHOD,
12 |   HTTP2_HEADER_PATH,
13 |   HTTP2_HEADER_SCHEME,
14 |   HTTP2_METHOD_GET,
15 |   HTTP2_METHOD_HEAD,
16 | } = http2.constants;
17 | 
18 | export const preflight = (options) => {
19 |   const { cookies, credentials, h2, headers, method, url } = options;
20 | 
21 |   if (h2) {
22 |     options.endStream = [
23 |       HTTP2_METHOD_GET,
24 |       HTTP2_METHOD_HEAD,
25 |     ].includes(method);
26 |   }
27 | 
28 |   if (cookies !== false && credentials !== requestCredentials.omit) {
29 |     let cookie = Cookies.jar.has(url.origin);
30 | 
31 |     if (cookies === Object(cookies) && [
32 |       requestCredentials.include,
33 |       requestCredentials.sameOrigin,
34 |     ].includes(credentials)) {
35 |       if (cookie) {
36 |         cookie = new Cookies(cookies, options);
37 | 
38 |         Cookies.jar.get(url.origin).forEach((val, key) => {
39 |           if (!cookie.has(key)) {
40 |             cookie.set(key, val);
41 |           }
42 |         });
43 |         Cookies.jar.set(url.origin, cookie);
44 |       } else {
45 |         cookie = new Cookies(cookies, options);
46 |         Cookies.jar.set(url.origin, cookie);
47 |       }
48 |     } else {
49 |       cookie &&= Cookies.jar.get(url.origin);
50 |     }
51 | 
52 |     options.headers = {
53 |       ...cookie && { [HTTP2_HEADER_COOKIE]: cookie },
54 |       ...headers,
55 |     };
56 |   }
57 | 
58 |   if (credentials === requestCredentials.omit) {
59 |     options.cookies = false;
60 |     for (const it of Object.keys(options.headers ?? {})
61 |                            .filter((val) => new RegExp(`^(${
62 |                               HTTP2_HEADER_AUTHORIZATION }|${ HTTP2_HEADER_COOKIE
63 |                             })$`, 'i').test(val))) { Reflect.deleteProperty(options.headers, it); }
64 | 
65 |     url.password = url.username = '';
66 |   }
67 | 
68 |   options.headers = {
69 |     ...Object.entries(options.headers ?? {})
70 |              .reduce((acc, [key, val]) => {
71 |                acc[key.toLowerCase()] = val;
72 | 
73 |                if (acc[HTTP2_HEADER_ACCEPT_ENCODING]?.match(/\bzstd\b/i) && !isZstdSupported) {
74 |                  acc[HTTP2_HEADER_ACCEPT_ENCODING] = val.replace(/\s?zstd,?/gi, '').trim();
75 |                  if (!acc[HTTP2_HEADER_ACCEPT_ENCODING]) {
76 |                    Reflect.deleteProperty(acc, HTTP2_HEADER_ACCEPT_ENCODING);
77 |                  }
78 |                }
79 | 
80 |                return acc;
81 |              }, {}),
82 |     ...h2 && {
83 |       [HTTP2_HEADER_AUTHORITY]: url.host,
84 |       [HTTP2_HEADER_METHOD]: method,
85 |       [HTTP2_HEADER_PATH]: `${ url.pathname }${ url.search }`,
86 |       [HTTP2_HEADER_SCHEME]: url.protocol.replace(/\p{Punctuation}/gu, ''),
87 |     },
88 |   };
89 | 
90 |   return options;
91 | };
92 | 


--------------------------------------------------------------------------------
/src/transfer.mjs:
--------------------------------------------------------------------------------
  1 | import http from 'node:http';
  2 | import http2 from 'node:http2';
  3 | import https from 'node:https';
  4 | import { setTimeout as setTimeoutPromise } from 'node:timers/promises';
  5 | import { ackn } from './ackn.mjs';
  6 | import { RequestError } from './errors.mjs';
  7 | import { postflight } from './postflight.mjs';
  8 | import { preflight } from './preflight.mjs';
  9 | import { transform } from './transform.mjs';
 10 | import {
 11 |   affix,
 12 |   dispatch,
 13 |   maxRetryAfterError,
 14 | } from './utils.mjs';
 15 | 
 16 | const {
 17 |   HTTP2_HEADER_RETRY_AFTER,
 18 | } = http2.constants;
 19 | 
 20 | export const transfer = async (options, overact) => {
 21 |   const { digest, redirected, thenable, url } = options;
 22 | 
 23 |   if (options.follow === 0) {
 24 |     throw new RequestError(`Maximum redirect reached at: ${ url.href }`);
 25 |   }
 26 | 
 27 |   if (url.protocol === 'https:') {
 28 |     options = !options.h2 ? await ackn(options) : {
 29 |       ...options,
 30 |       createConnection: null,
 31 |       protocol: url.protocol,
 32 |     };
 33 |   } else if (Reflect.has(options, 'alpnProtocol')) {
 34 |     for (const it of [
 35 |       'alpnProtocol',
 36 |       'createConnection',
 37 |       'h2',
 38 |       'protocol',
 39 |     ]) { Reflect.deleteProperty(options, it); }
 40 |   }
 41 | 
 42 |   try {
 43 |     options = await transform(preflight(options));
 44 |   } catch (ex) {
 45 |     options.createConnection?.().destroy();
 46 |     throw ex;
 47 |   }
 48 | 
 49 |   const promise = new Promise((resolve, reject) => {
 50 |     let client, req;
 51 | 
 52 |     if (options.h2) {
 53 |       client = http2.connect(url.origin, options);
 54 |       req = client.request(options.headers, options);
 55 |     } else {
 56 |       const { request } = url.protocol === 'http:' ? http : https;
 57 | 
 58 |       req = request(url, options);
 59 |     }
 60 | 
 61 |     affix(client, req, options);
 62 | 
 63 |     req.once('aborted', reject);
 64 |     req.once('error', reject);
 65 |     req.once('frameError', reject);
 66 |     req.once('goaway', reject);
 67 |     req.once('response', (res) => postflight(req, res, options, {
 68 |       reject,
 69 |       resolve,
 70 |     }));
 71 | 
 72 |     dispatch(options, req);
 73 |   });
 74 | 
 75 |   try {
 76 |     const res = await promise;
 77 | 
 78 |     if (digest && !redirected) {
 79 |       res.body = await res.body();
 80 |     }
 81 | 
 82 |     return res;
 83 |   } catch (ex) {
 84 |     const { maxRetryAfter, retry } = options;
 85 | 
 86 |     if (retry?.attempts > 0) {
 87 |       if (retry.errorCodes?.includes(ex.code) || retry.statusCodes?.includes(ex.statusCode)) {
 88 |         let { interval } = retry;
 89 | 
 90 |         if (retry.retryAfter && ex.headers?.[HTTP2_HEADER_RETRY_AFTER]) {
 91 |           interval = ex.headers[HTTP2_HEADER_RETRY_AFTER];
 92 |           interval = Number(interval) * 1e3 || new Date(interval) - Date.now();
 93 |           if (interval > maxRetryAfter) {
 94 |             throw maxRetryAfterError(interval, { cause: ex });
 95 |           }
 96 |         } else {
 97 |           interval = new Function('interval', `return Math.ceil(${ retry.backoffStrategy });`)(interval);
 98 |         }
 99 | 
100 |         if (interval < 0) {
101 |           interval = 0;
102 |         }
103 | 
104 |         retry.attempts--;
105 |         retry.interval = interval;
106 | 
107 |         return setTimeoutPromise(interval).then(() => overact(url, options));
108 |       }
109 |     }
110 | 
111 |     if (digest && !redirected && ex.body) {
112 |       ex.body = await ex.body();
113 |     }
114 | 
115 |     if (!thenable) {
116 |       throw ex;
117 |     } else {
118 |       return ex;
119 |     }
120 |   }
121 | };
122 | 


--------------------------------------------------------------------------------
/src/transform.mjs:
--------------------------------------------------------------------------------
 1 | import http2 from 'node:http2';
 2 | import {
 3 |   isReadable,
 4 |   Readable,
 5 | } from 'node:stream';
 6 | import { buffer } from 'node:stream/consumers';
 7 | import { types } from 'node:util';
 8 | import { FormData } from './formdata.mjs';
 9 | import {
10 |   APPLICATION_FORM_URLENCODED,
11 |   APPLICATION_JSON,
12 |   APPLICATION_OCTET_STREAM,
13 | } from './mediatypes.mjs';
14 | import {
15 |   compress,
16 |   isFileLike,
17 |   isReadableStream,
18 | } from './utils.mjs';
19 | 
20 | const {
21 |   HTTP2_HEADER_CONTENT_ENCODING,
22 |   HTTP2_HEADER_CONTENT_LENGTH,
23 |   HTTP2_HEADER_CONTENT_TYPE,
24 | } = http2.constants;
25 | 
26 | export const transform = async (options) => {
27 |   let { body, headers } = options;
28 | 
29 |   if (!body) {
30 |     return options;
31 |   }
32 | 
33 |   if (isFileLike(body)) {
34 |     headers = {
35 |       [HTTP2_HEADER_CONTENT_LENGTH]: body.size,
36 |       [HTTP2_HEADER_CONTENT_TYPE]: body.type || APPLICATION_OCTET_STREAM,
37 |     };
38 |     body = body.stream();
39 |   } else if (FormData.alike(body)) {
40 |     body = FormData.actuate(body);
41 |     headers = { [HTTP2_HEADER_CONTENT_TYPE]: body.contentType };
42 |   } else if (!Buffer.isBuffer(body)) {
43 |     if (types.isAnyArrayBuffer(body)) {
44 |       body = Buffer.from(body);
45 |     } else if (types.isArrayBufferView(body)) {
46 |       body = Buffer.from(body.buffer, body.byteOffset, body.byteLength);
47 |     } else if (body === Object(body) && !Reflect.has(body, Symbol.asyncIterator)) {
48 |       if (body.constructor === URLSearchParams) {
49 |         headers = { [HTTP2_HEADER_CONTENT_TYPE]: APPLICATION_FORM_URLENCODED };
50 |         body = body.toString();
51 |       } else if (!(!Array.isArray(body) && Reflect.has(body, Symbol.iterator))) {
52 |         headers = { [HTTP2_HEADER_CONTENT_TYPE]: APPLICATION_JSON };
53 |         body = JSON.stringify(body);
54 |       }
55 |     }
56 |   }
57 | 
58 |   const encodings = options.headers[HTTP2_HEADER_CONTENT_ENCODING];
59 | 
60 |   if (body === Object(body)
61 |     && (Reflect.has(body, Symbol.asyncIterator) || (!Array.isArray(body) && Reflect.has(body, Symbol.iterator)))) {
62 |     body = isReadable(body) ? (isReadableStream(body) ? Readable.fromWeb(body) : body) : Readable.from(body);
63 |     body = encodings ? compress(body, encodings) : body;
64 |   } else if (encodings) {
65 |     body = await buffer(compress(Readable.from(body), encodings));
66 |   }
67 | 
68 |   Object.assign(options.headers, {
69 |     ...headers,
70 |     ...!body[Symbol.asyncIterator] && {
71 |       [HTTP2_HEADER_CONTENT_LENGTH]: Buffer.byteLength(body),
72 |     },
73 |     ...options.headers[HTTP2_HEADER_CONTENT_TYPE] && {
74 |       [HTTP2_HEADER_CONTENT_TYPE]: options.headers[HTTP2_HEADER_CONTENT_TYPE],
75 |     },
76 |   });
77 | 
78 |   return {
79 |     ...options,
80 |     body,
81 |   };
82 | };
83 | 


--------------------------------------------------------------------------------
/src/utils.mjs:
--------------------------------------------------------------------------------
  1 | import {
  2 |   Blob,
  3 |   File,
  4 | } from 'node:buffer';
  5 | import http2 from 'node:http2';
  6 | import { pipeline } from 'node:stream';
  7 | import zlib from 'node:zlib';
  8 | import config, { isZstdSupported } from './config.mjs';
  9 | import {
 10 |   RequestError,
 11 |   TimeoutError,
 12 | } from './errors.mjs';
 13 | 
 14 | const {
 15 |   HTTP2_HEADER_RETRY_AFTER,
 16 |   HTTP2_HEADER_STATUS,
 17 | } = http2.constants;
 18 | 
 19 | export const admix = (res, headers, options) => {
 20 |   const { h2 } = options;
 21 | 
 22 |   if (h2) {
 23 |     Reflect.defineProperty(res, 'headers', {
 24 |       enumerable: true,
 25 |       value: headers,
 26 |     });
 27 | 
 28 |     Reflect.defineProperty(res, 'httpVersion', {
 29 |       enumerable: true,
 30 |       value: `${ h2 + 1 }.0`,
 31 |     });
 32 | 
 33 |     Reflect.defineProperty(res, 'statusCode', {
 34 |       enumerable: true,
 35 |       value: headers[HTTP2_HEADER_STATUS],
 36 |     });
 37 |   }
 38 | 
 39 |   Reflect.defineProperty(res, 'ok', {
 40 |     enumerable: true,
 41 |     value: /^2\d{2}$/.test(res.statusCode),
 42 |   });
 43 | 
 44 |   Reflect.defineProperty(res, 'redirected', {
 45 |     enumerable: true,
 46 |     value: !!options.redirected,
 47 |   });
 48 | };
 49 | 
 50 | export const affix = (client, req, options) => {
 51 |   req.once('close', () => client?.close());
 52 |   req.once('end', () => client?.close());
 53 |   req.once('timeout', () => req.destroy(new TimeoutError(`Timed out after ${ options.timeout } ms.`)));
 54 |   req.once('trailers', (trailers) => {
 55 |     Reflect.defineProperty(req, 'trailers', {
 56 |       enumerable: true,
 57 |       value: trailers,
 58 |     });
 59 |   });
 60 | };
 61 | 
 62 | export const brandCheck = (value, ctor) => {
 63 |   if (!(value instanceof ctor)) {
 64 |     throw new TypeError('Illegal invocation');
 65 |   }
 66 | };
 67 | 
 68 | export const compress = (readable, encodings = '') => {
 69 |   const encoders = [];
 70 | 
 71 |   encodings = unwind(encodings);
 72 | 
 73 |   for (const encoding of encodings) {
 74 |     if (/\bbr\b/i.test(encoding)) {
 75 |       encoders.push(zlib.createBrotliCompress());
 76 |     } else if (/\bdeflate(?!-(?:\w+)?)\b/i.test(encoding)) {
 77 |       encoders.push(zlib.createDeflate());
 78 |     } else if (/\bdeflate-raw\b/i.test(encoding)) {
 79 |       encoders.push(zlib.createDeflateRaw());
 80 |     } else if (/\bgzip\b/i.test(encoding)) {
 81 |       encoders.push(zlib.createGzip());
 82 |     } else if (isZstdSupported && /\bzstd\b/i.test(encoding)) {
 83 |       encoders.push(zlib.createZstdCompress());
 84 |     } else {
 85 |       return readable;
 86 |     }
 87 |   }
 88 | 
 89 |   return pipeline(readable, ...encoders, () => void 0);
 90 | };
 91 | 
 92 | export const copyWithMerge = (target, ...rest) => {
 93 |   target = structuredClone(target);
 94 |   if (!rest.length) {
 95 |     return target;
 96 |   }
 97 | 
 98 |   return merge(target, ...rest);
 99 | };
100 | 
101 | export const decompress = (readable, encodings = '') => {
102 |   const decoders = [];
103 | 
104 |   encodings = unwind(encodings);
105 | 
106 |   for (const encoding of encodings) {
107 |     if (/\bbr\b/i.test(encoding)) {
108 |       decoders.push(zlib.createBrotliDecompress());
109 |     } else if (/\bdeflate(?!-(?:\w+)?)\b/i.test(encoding)) {
110 |       decoders.push(zlib.createInflate());
111 |     } else if (/\bdeflate-raw\b/i.test(encoding)) {
112 |       decoders.push(zlib.createInflateRaw());
113 |     } else if (/\bgzip\b/i.test(encoding)) {
114 |       decoders.push(zlib.createGunzip());
115 |     } else if (isZstdSupported && /\bzstd\b/i.test(encoding)) {
116 |       decoders.push(zlib.createZstdDecompress());
117 |     } else {
118 |       return readable;
119 |     }
120 |   }
121 | 
122 |   return pipeline(readable, ...decoders, () => void 0);
123 | };
124 | 
125 | export const dispatch = ({ body }, req) => {
126 |   if (body?.pipe?.constructor === Function) {
127 |     body.pipe(req);
128 |   } else {
129 |     req.end(body);
130 |   }
131 | };
132 | 
133 | export const isFileLike = (instance) => {
134 |   return [
135 |     Blob.name,
136 |     File.name,
137 |   ].includes(instance?.[Symbol.toStringTag]);
138 | };
139 | 
140 | export const isReadableStream = (instance) => {
141 |   return ReadableStream.name === instance?.[Symbol.toStringTag];
142 | };
143 | 
144 | export const maxRetryAfter = Symbol('maxRetryAfter');
145 | 
146 | export const maxRetryAfterError = (
147 |   interval,
148 |   options,
149 | ) => new RequestError(`Maximum '${ HTTP2_HEADER_RETRY_AFTER }' limit exceeded: ${ interval } ms.`, options);
150 | 
151 | export const merge = (target, ...rest) => {
152 |   rest = rest.filter((it) => it === Object(it));
153 |   for (const source of rest) {
154 |     for (const key of Object.getOwnPropertyNames(source)) {
155 |       const sv = source[key];
156 |       const tv = target[key];
157 | 
158 |       if (Object(sv) === sv && Object(tv) === tv) {
159 |         target[key] = merge(tv, sv);
160 |         continue;
161 |       }
162 | 
163 |       target[key] = source[key];
164 |     }
165 |   }
166 | 
167 |   return target;
168 | };
169 | 
170 | export const normalize = (url, options = {}) => {
171 |   if (!options.redirected) {
172 |     options = copyWithMerge(config.defaults, options);
173 |   }
174 | 
175 |   if (options.trimTrailingSlashes) {
176 |     url = `${ url }`.replace(/(?<!:)\/+/g, '/');
177 |   }
178 | 
179 |   if (options.stripTrailingSlash) {
180 |     url = `${ url }`.replace(/\/$|\/(?=#)|\/(?=\?)/g, '');
181 |   }
182 | 
183 |   url = new URL(url, options.baseURL);
184 | 
185 |   return Object.assign(options, { url });
186 | };
187 | 
188 | export const sameOrigin = (a, b) => a.protocol === b.protocol && a.hostname === b.hostname && a.port === b.port;
189 | 
190 | export async function* tap(value) {
191 |   if (Reflect.has(value, Symbol.asyncIterator)) {
192 |     yield* value;
193 |   } else if (value.stream) {
194 |     yield* value.stream();
195 |   } else {
196 |     yield await value.arrayBuffer();
197 |   }
198 | }
199 | 
200 | export const toCamelCase = (str) => str?.toLowerCase().replace(
201 |   /\p{Punctuation}.|\p{White_Space}./gu,
202 |   (val) => val.replace(/\p{Punctuation}+|\p{White_Space}+/gu, '').toUpperCase(),
203 | );
204 | 
205 | export const unwind = (encodings) => encodings.split(',').map((it) => it.trim());
206 | 


--------------------------------------------------------------------------------
/src/validation.mjs:
--------------------------------------------------------------------------------
 1 | import http2 from 'node:http2';
 2 | import {
 3 |   requestCredentials,
 4 |   requestRedirect,
 5 | } from './constants.mjs';
 6 | 
 7 | const {
 8 |   HTTP2_METHOD_GET,
 9 |   HTTP2_METHOD_HEAD,
10 | } = http2.constants;
11 | 
12 | export const validation = (options = {}) => {
13 |   if (options.body && [
14 |     HTTP2_METHOD_GET,
15 |     HTTP2_METHOD_HEAD,
16 |   ].includes(options.method)) {
17 |     throw new TypeError(`Request with ${ HTTP2_METHOD_GET }/${ HTTP2_METHOD_HEAD } method cannot have body.`);
18 |   }
19 | 
20 |   if (!Object.values(requestCredentials).includes(options.credentials)) {
21 |     throw new TypeError(`Failed to read the 'credentials' property from 'options': The provided value '${
22 |       options.credentials
23 |     }' is not a valid enum value.`);
24 |   }
25 | 
26 |   if (!Reflect.has(requestRedirect, options.redirect)) {
27 |     throw new TypeError(`Failed to read the 'redirect' property from 'options': The provided value '${
28 |       options.redirect
29 |     }' is not a valid enum value.`);
30 |   }
31 | 
32 |   return options;
33 | };
34 | 


--------------------------------------------------------------------------------
/test/fixtures/index.mjs:
--------------------------------------------------------------------------------
 1 | import { once } from 'node:events';
 2 | import { readFileSync } from 'node:fs';
 3 | import { createServer } from 'node:http';
 4 | import { createSecureServer } from 'node:http2';
 5 | import routes from './routes.mjs';
 6 | 
 7 | const baseB1URL = new URL('http://localhost:1081');
 8 | const baseB2URL = new URL('https://localhost:1083');
 9 | const baseH1URL = new URL('http://localhost:3000');
10 | const baseH2URL = new URL('https://localhost:3443');
11 | 
12 | Object.assign(globalThis, {
13 |   baseB1URL,
14 |   baseB2URL,
15 |   baseH1URL,
16 |   baseH2URL,
17 | });
18 | 
19 | export async function mochaGlobalSetup() {
20 |   const cwd = process.cwd();
21 |   const cert = readFileSync(`${ cwd }/localhost.cert`);
22 |   const key = readFileSync(`${ cwd }/localhost.key`);
23 | 
24 |   this.b1server = createServer(routes(baseB1URL));
25 |   this.b2server = createSecureServer({ cert, key }, routes(baseB2URL));
26 |   this.h1server = createServer(routes(baseH1URL));
27 |   this.h2server = createSecureServer({ cert, key }, routes(baseH2URL));
28 | 
29 |   await Promise.all([
30 |     once(this.b1server.listen(baseB1URL.port), 'listening'),
31 |     once(this.b2server.listen(baseB2URL.port), 'listening'),
32 |     once(this.h1server.listen(baseH1URL.port), 'listening'),
33 |     once(this.h2server.listen(baseH2URL.port), 'listening'),
34 |   ]);
35 |   console.log('b1 server listening on', this.b1server.address());
36 |   console.log('b2 server listening on', this.b2server.address());
37 |   console.log('h1 server listening on', this.h1server.address());
38 |   console.log('h2 server listening on', this.h2server.address());
39 | }
40 | 
41 | export async function mochaGlobalTeardown() {
42 |   await Promise.all([
43 |     once(this.b1server.close(), 'close'),
44 |     once(this.b2server.close(), 'close'),
45 |     once(this.h1server.close(), 'close'),
46 |     once(this.h2server.close(), 'close'),
47 |   ]);
48 |   console.log('server(s) has been closed');
49 | }
50 | 


--------------------------------------------------------------------------------
/test/fixtures/routes.mjs:
--------------------------------------------------------------------------------
  1 | import { constants } from 'node:http2';
  2 | import { Transform } from 'node:stream';
  3 | import {
  4 |   APPLICATION_JSON,
  5 |   TEXT_PLAIN,
  6 | } from '../../src/mediatypes.mjs';
  7 | import {
  8 |   compress,
  9 |   decompress,
 10 | } from '../../src/utils.mjs';
 11 | 
 12 | const {
 13 |   HTTP2_HEADER_CONTENT_ENCODING,
 14 |   HTTP2_HEADER_CONTENT_TYPE,
 15 |   HTTP2_HEADER_DATE,
 16 |   HTTP2_HEADER_LOCATION,
 17 |   HTTP2_HEADER_RETRY_AFTER,
 18 |   HTTP2_HEADER_SET_COOKIE,
 19 |   HTTP2_METHOD_GET,
 20 |   HTTP2_METHOD_POST,
 21 |   HTTP2_METHOD_PUT,
 22 |   HTTP_STATUS_FOUND,
 23 |   HTTP_STATUS_INTERNAL_SERVER_ERROR,
 24 |   HTTP_STATUS_MOVED_PERMANENTLY,
 25 |   HTTP_STATUS_NO_CONTENT,
 26 |   HTTP_STATUS_NOT_FOUND,
 27 |   HTTP_STATUS_OK,
 28 |   HTTP_STATUS_SEE_OTHER,
 29 |   HTTP_STATUS_TOO_MANY_REQUESTS,
 30 |   HTTP_STATUS_UNAUTHORIZED,
 31 | } = constants;
 32 | 
 33 | const attempts = 'attempts';
 34 | const json = {
 35 |   message: 'json',
 36 | };
 37 | const sentinel = (date, lapse = '1') => new Date(date.getTime() + (lapse.split(':').pop() * 1e3)).toUTCString();
 38 | const stash = new Map();
 39 | 
 40 | export default (baseURL) => (req, res) => {
 41 |   const { href, pathname, searchParams } = new URL(req.url, baseURL);
 42 |   const retryAfter = searchParams.get(HTTP2_HEADER_RETRY_AFTER);
 43 | 
 44 |   if (searchParams.has(attempts)) {
 45 |     if (stash.has(href)) {
 46 |       stash.set(href, stash.get(href) - 1);
 47 |     } else {
 48 |       stash.set(href, +searchParams.get(attempts));
 49 |     }
 50 |   }
 51 | 
 52 |   res.addTrailers({
 53 |     [HTTP2_HEADER_DATE]: new Date(),
 54 |   });
 55 |   res.statusCode = HTTP_STATUS_NOT_FOUND;
 56 |   if (pathname.match(String.raw`^/gimme/cookies$`) && req.method === HTTP2_METHOD_GET) {
 57 |     const expires = searchParams.has('expires') && searchParams.get('expires');
 58 |     const maxAge = searchParams.has('maxAge') && searchParams.get('maxAge');
 59 | 
 60 |     res.writeHead(HTTP_STATUS_OK, [
 61 |       [
 62 |         HTTP2_HEADER_CONTENT_TYPE,
 63 |         `${ APPLICATION_JSON }; charset=utf-8`,
 64 |       ],
 65 |       [
 66 |         HTTP2_HEADER_SET_COOKIE,
 67 |         [
 68 |           ...expires ? [`ttl=puff; Expires=${ expires }`] : [],
 69 |           ...maxAge ? [`ttl=puff; Max-Age=${ maxAge }`] : [],
 70 |           'foo=bar; HttpOnly; SameSite=Lax; Secure',
 71 |           'qux=zap; Partitioned; Path=/; SameSite=None; Secure',
 72 |         ],
 73 |       ],
 74 |     ]);
 75 |     res.write(JSON.stringify(json));
 76 |     res.end();
 77 |   } else if (pathname.match(String.raw`^/gimme/encode$`) && req.method === HTTP2_METHOD_GET) {
 78 |     res.writeHead(HTTP_STATUS_OK, { [HTTP2_HEADER_CONTENT_TYPE]: `${ TEXT_PLAIN }; charset=utf-16be` });
 79 |     res.write(Buffer.from('\ufeff🙈🙉🙊', 'utf16le').swap16());
 80 |     res.end();
 81 |   } else if (pathname.match(String.raw`^/gimme/json$`) && req.method === HTTP2_METHOD_GET) {
 82 |     res.writeHead(HTTP_STATUS_OK, { [HTTP2_HEADER_CONTENT_TYPE]: APPLICATION_JSON });
 83 |     res.write(JSON.stringify(json));
 84 |     res.end();
 85 |   } else if (pathname.match(String.raw`^/gimme/kaboom$`) && req.method === HTTP2_METHOD_GET) {
 86 |     res.writeHead(HTTP_STATUS_INTERNAL_SERVER_ERROR, { [HTTP2_HEADER_CONTENT_TYPE]: APPLICATION_JSON });
 87 |     res.write(JSON.stringify({
 88 |       message: 'kaboom',
 89 |     }));
 90 |     res.end();
 91 |   } else if (pathname.match(String.raw`^/gimme/nothing$`) && req.method === HTTP2_METHOD_GET) {
 92 |     res.statusCode = HTTP_STATUS_NO_CONTENT;
 93 |     res.end();
 94 |   } else if (pathname.match(String.raw`^/gimme/redirect$`) && req.method === HTTP2_METHOD_GET) {
 95 |     const location = searchParams.has('location') ? searchParams.get('location') : '/gimme/json';
 96 |     const statusCode = searchParams.has('statusCode') ? +searchParams.get('statusCode') : HTTP_STATUS_MOVED_PERMANENTLY;
 97 | 
 98 |     res.writeHead(statusCode, {
 99 |       [HTTP2_HEADER_LOCATION]: location,
100 |       ...retryAfter ? Number(retryAfter) ? {
101 |         [HTTP2_HEADER_RETRY_AFTER]: JSON.parse(retryAfter),
102 |       } : {
103 |         [HTTP2_HEADER_RETRY_AFTER]: sentinel(new Date(), retryAfter),
104 |       } : {},
105 |       [HTTP2_HEADER_SET_COOKIE]: 'crack=duck; Partitioned; SameSite=Lax; Secure',
106 |     });
107 |     res.end();
108 |   } else if (pathname.match(String.raw`^/gimme/reset$`) && req.method === HTTP2_METHOD_GET) {
109 |     const retry = stash.get(href);
110 | 
111 |     if (!retry) {
112 |       res.writeHead(HTTP_STATUS_OK, { [HTTP2_HEADER_CONTENT_TYPE]: APPLICATION_JSON });
113 |       res.write(JSON.stringify(json));
114 |       stash.delete(href);
115 |     }
116 | 
117 |     if (retry) {
118 |       res.destroy(new Error('☠️'));
119 |     } else {
120 |       res.end();
121 |     }
122 |   } else if (pathname.match(String.raw`^/gimme/retry$`) && req.method === HTTP2_METHOD_GET) {
123 |     const retry = stash.get(href);
124 | 
125 |     res.writeHead(retry ? HTTP_STATUS_TOO_MANY_REQUESTS : HTTP_STATUS_OK, {
126 |       ...!retry && { [HTTP2_HEADER_CONTENT_TYPE]: APPLICATION_JSON },
127 |       ...retryAfter ? Number(retryAfter) ? {
128 |         [HTTP2_HEADER_RETRY_AFTER]: JSON.parse(retryAfter),
129 |       } : {
130 |         [HTTP2_HEADER_RETRY_AFTER]: sentinel(new Date(), retryAfter),
131 |       } : {},
132 |     });
133 |     if (!retry) {
134 |       res.write(JSON.stringify(json));
135 |       stash.delete(href);
136 |     }
137 | 
138 |     res.end();
139 |   } else if (pathname.match(String.raw`^/gimme/redirect$`) && req.method === HTTP2_METHOD_POST) {
140 |     res.writeHead(HTTP_STATUS_FOUND, {
141 |       [HTTP2_HEADER_LOCATION]: '/gimme/void',
142 |     });
143 |     res.end();
144 |   } else if (pathname.match(String.raw`^/gimme/redirect$`) && req.method === HTTP2_METHOD_PUT) {
145 |     res.writeHead(HTTP_STATUS_SEE_OTHER, {
146 |       [HTTP2_HEADER_LOCATION]: '/gimme/json',
147 |     });
148 |     res.end();
149 |   } else if (pathname.match(String.raw`^/gimme/refusal$`) && req.method === HTTP2_METHOD_GET) {
150 |     res.writeHead(HTTP_STATUS_UNAUTHORIZED, { [HTTP2_HEADER_CONTENT_TYPE]: APPLICATION_JSON });
151 |     res.write(JSON.stringify({
152 |       message: 'unauthorized',
153 |     }));
154 |     res.end();
155 |   } else if (pathname.match(String.raw`^/gimme/repulse$`) && req.method === HTTP2_METHOD_POST) {
156 |     res.statusCode = HTTP_STATUS_OK;
157 |     req.pipe(res);
158 |   } else if (pathname.match(String.raw`^/gimme/squash$`) && req.method === HTTP2_METHOD_POST) {
159 |     const encodings = req.headers[HTTP2_HEADER_CONTENT_ENCODING];
160 | 
161 |     res.writeHead(
162 |       HTTP_STATUS_OK,
163 |       Object.fromEntries(Object.entries(req.headers).filter(([key]) => !key.startsWith(':'))),
164 |     );
165 | 
166 |     compress(decompress(req, encodings)
167 |       .pipe(new Transform({
168 |         construct(cb) {
169 |           this.data = [];
170 |           cb();
171 |         },
172 |         flush(cb) {
173 |           try {
174 |             this.push(Buffer.concat(this.data).reverse());
175 |           } catch (ex) {
176 |             cb(ex);
177 |           } finally {
178 |             cb();
179 |           }
180 |         },
181 |         transform(chunk, encoding, cb) {
182 |           this.data.push(chunk);
183 |           cb();
184 |         },
185 |       })), encodings).pipe(res);
186 |   } else if (pathname.match(String.raw`^/gimme/text$`) && req.method === HTTP2_METHOD_GET) {
187 |     res.writeHead(HTTP_STATUS_OK, { [HTTP2_HEADER_CONTENT_TYPE]: TEXT_PLAIN });
188 |     res.write('message');
189 |     res.end();
190 |   } else {
191 |     res.end();
192 |   }
193 | };
194 | 


--------------------------------------------------------------------------------
/test/index.h1.test.mjs:
--------------------------------------------------------------------------------
 1 | import { strict as assert } from 'node:assert';
 2 | import { once } from 'node:events';
 3 | import { Readable } from 'node:stream';
 4 | import rekwest, {
 5 |   constants,
 6 |   mixin,
 7 | } from '../src/index.mjs';
 8 | import shared from './index.shared.mjs';
 9 | 
10 | const {
11 |   HTTP2_METHOD_POST,
12 |   HTTP_STATUS_OK,
13 | } = constants;
14 | 
15 | const baseURL = globalThis.baseH1URL;
16 | const httpVersion = '1.1';
17 | 
18 | describe('rekwest', () => {
19 | 
20 |   shared({ baseURL, httpVersion });
21 | 
22 |   describe('withal stream', () => {
23 | 
24 |     it(`should make ${ HTTP2_METHOD_POST } [${ HTTP_STATUS_OK }] request and must pipe throughout it`, async () => {
25 |       const url = new URL('/gimme/squash', baseURL);
26 |       const req = Readable.from('zqiygyxz').pipe(rekwest.stream(url, { method: HTTP2_METHOD_POST }));
27 |       const [res] = await once(req, 'response');
28 | 
29 |       assert.ok(res.ok);
30 |       assert.equal(res.statusCode, HTTP_STATUS_OK);
31 |       assert.equal((await mixin(res).body()).toString(), 'zqiygyxz'.split('').reverse().join(''));
32 |     });
33 | 
34 |   });
35 | 
36 | });
37 | 


--------------------------------------------------------------------------------
/test/index.h2.test.mjs:
--------------------------------------------------------------------------------
 1 | import { strict as assert } from 'node:assert';
 2 | import { once } from 'node:events';
 3 | import { Readable } from 'node:stream';
 4 | import rekwest, {
 5 |   ackn,
 6 |   constants,
 7 |   mixin,
 8 | } from '../src/index.mjs';
 9 | import shared from './index.shared.mjs';
10 | 
11 | const {
12 |   HTTP2_METHOD_POST,
13 |   HTTP_STATUS_OK,
14 | } = constants;
15 | 
16 | const baseURL = globalThis.baseH2URL;
17 | const httpVersion = '2.0';
18 | const rejectUnauthorized = false;
19 | 
20 | describe('rekwest { h2 } mode', () => {
21 | 
22 |   before(() => {
23 |     rekwest.defaults = {
24 |       rejectUnauthorized,
25 |     };
26 |   });
27 | 
28 |   after(() => Reflect.deleteProperty(rekwest.defaults, 'rejectUnauthorized'));
29 | 
30 |   shared({ baseURL, httpVersion });
31 | 
32 |   describe('withal stream', () => {
33 | 
34 |     it(`should make ${ HTTP2_METHOD_POST } [${ HTTP_STATUS_OK }] request and must pipe throughout it`, async () => {
35 |       const url = new URL('/gimme/squash', baseURL);
36 |       const options = await ackn({ rejectUnauthorized, url });
37 |       const req = Readable.from('zqiygyxz').pipe(rekwest.stream(url, { ...options, method: HTTP2_METHOD_POST }));
38 |       const [headers] = await once(req, 'response');
39 | 
40 |       assert.equal(req.headers, headers);
41 |       assert.equal(req.statusCode, HTTP_STATUS_OK);
42 |       assert.equal((await mixin(req).body()).toString(), 'zqiygyxz'.split('').reverse().join(''));
43 |     });
44 | 
45 |   });
46 | 
47 | });
48 | 


--------------------------------------------------------------------------------
/test/index.shared.mjs:
--------------------------------------------------------------------------------
   1 | import { strict as assert } from 'node:assert';
   2 | import { Blob } from 'node:buffer';
   3 | import { Readable } from 'node:stream';
   4 | import { scheduler } from 'node:timers/promises';
   5 | import { types } from 'node:util';
   6 | import {
   7 |   requestCredentials,
   8 |   requestRedirect,
   9 | } from '../src/constants.mjs';
  10 | import rekwest, {
  11 |   constants,
  12 |   Cookies,
  13 |   File,
  14 |   FormData,
  15 | } from '../src/index.mjs';
  16 | import { TEXT_PLAIN } from '../src/mediatypes.mjs';
  17 | 
  18 | const {
  19 |   HTTP2_HEADER_ACCEPT_ENCODING,
  20 |   HTTP2_HEADER_AUTHORIZATION,
  21 |   HTTP2_HEADER_CONTENT_DISPOSITION,
  22 |   HTTP2_HEADER_CONTENT_ENCODING,
  23 |   HTTP2_HEADER_CONTENT_TYPE,
  24 |   HTTP2_HEADER_RETRY_AFTER,
  25 |   HTTP2_HEADER_VARY,
  26 |   HTTP2_METHOD_GET,
  27 |   HTTP2_METHOD_HEAD,
  28 |   HTTP2_METHOD_POST,
  29 |   HTTP2_METHOD_PUT,
  30 |   HTTP_STATUS_FOUND,
  31 |   HTTP_STATUS_INTERNAL_SERVER_ERROR,
  32 |   HTTP_STATUS_MOVED_PERMANENTLY,
  33 |   HTTP_STATUS_NO_CONTENT,
  34 |   HTTP_STATUS_NOT_FOUND,
  35 |   HTTP_STATUS_OK,
  36 |   HTTP_STATUS_SEE_OTHER,
  37 |   HTTP_STATUS_TOO_MANY_REQUESTS,
  38 |   HTTP_STATUS_UNAUTHORIZED,
  39 |   HTTP_STATUS_USE_PROXY,
  40 | } = constants;
  41 | 
  42 | const logarithmic = 'logarithmic';
  43 | const encoder = new TextEncoder();
  44 | 
  45 | export default ({ baseURL, httpVersion }) => {
  46 |   describe('with { digest: true } & { parse: true } (defaults)', () => {
  47 | 
  48 |     after(() => Cookies.jar.clear());
  49 | 
  50 |     it(`should make ${ HTTP2_METHOD_GET } [${ HTTP_STATUS_OK }] request and must get a json`, async () => {
  51 |       const url = new URL('/gimme/json', baseURL);
  52 |       const res = await rekwest(url);
  53 | 
  54 |       assert.equal(res.body.message, 'json');
  55 |       assert.equal(res.bodyUsed, true);
  56 |       assert.equal(res.cookies, undefined);
  57 |       assert.equal(res.httpVersion, httpVersion);
  58 |       assert.equal(res.ok, true);
  59 |       assert.equal(res.redirected, false);
  60 |       assert.equal(res.statusCode, HTTP_STATUS_OK);
  61 |     });
  62 | 
  63 |     it(`should make ${ HTTP2_METHOD_GET } [${ HTTP_STATUS_OK }] request and must get a plain text`, async () => {
  64 |       const url = new URL('/gimme/text', baseURL);
  65 |       const res = await rekwest(url);
  66 | 
  67 |       assert.equal(res.body, 'message');
  68 |       assert.equal(res.bodyUsed, true);
  69 |       assert.equal(res.cookies, undefined);
  70 |       assert.equal(res.httpVersion, httpVersion);
  71 |       assert.equal(res.ok, true);
  72 |       assert.equal(res.redirected, false);
  73 |       assert.equal(res.statusCode, HTTP_STATUS_OK);
  74 |     });
  75 | 
  76 |     it(`should make ${ HTTP2_METHOD_GET } [${ HTTP_STATUS_OK }] request and must get an encoded text`, async () => {
  77 |       const url = new URL('/gimme/encode', baseURL);
  78 |       const res = await rekwest(url);
  79 | 
  80 |       assert.equal(res.body, '🙈🙉🙊');
  81 |       assert.equal(res.bodyUsed, true);
  82 |       assert.equal(res.httpVersion, httpVersion);
  83 |       assert.equal(res.ok, true);
  84 |       assert.equal(res.redirected, false);
  85 |       assert.equal(res.statusCode, HTTP_STATUS_OK);
  86 |     });
  87 | 
  88 |     it(
  89 |       `should make ${ HTTP2_METHOD_GET } [${ HTTP_STATUS_OK }] request with cookies and must get new cookies`,
  90 |       async () => {
  91 |         const url = new URL('/gimme/cookies', baseURL);
  92 |         const res = await rekwest(url, {
  93 |           cookies: {
  94 |             aux: 'baz',
  95 |           },
  96 |         });
  97 | 
  98 |         assert.equal(res.body.message, 'json');
  99 |         assert.equal(res.bodyUsed, true);
 100 |         assert.equal(res.cookies.get('aux'), 'baz');
 101 |         assert.equal(res.cookies.get('foo'), 'bar');
 102 |         assert.equal(res.cookies.get('qux'), 'zap');
 103 |         assert.equal(res.httpVersion, httpVersion);
 104 |         assert.equal(res.ok, true);
 105 |         assert.equal(res.redirected, false);
 106 |         assert.equal(res.statusCode, HTTP_STATUS_OK);
 107 |       },
 108 |     );
 109 | 
 110 |     it(
 111 |       `should make ${ HTTP2_METHOD_GET } [${
 112 |         HTTP_STATUS_OK
 113 |       }] request and must get new cookie with 'expires' attribute`,
 114 |       async () => {
 115 |         const url = new URL(`/gimme/cookies?expires=${ new Date(Date.now() + 1e3).toGMTString() }`, baseURL);
 116 |         const res = await rekwest(url, {
 117 |           cookiesTTL: true,
 118 |         });
 119 | 
 120 |         assert.equal(res.body.message, 'json');
 121 |         assert.equal(res.bodyUsed, true);
 122 |         assert.equal(res.cookies.get('ttl'), 'puff');
 123 |         await scheduler.wait(1.1e3);
 124 |         assert.equal(res.cookies.get('ttl'), null);
 125 |         assert.equal(res.httpVersion, httpVersion);
 126 |         assert.equal(res.ok, true);
 127 |         assert.equal(res.redirected, false);
 128 |         assert.equal(res.statusCode, HTTP_STATUS_OK);
 129 |       },
 130 |     );
 131 | 
 132 |     it(
 133 |       `should make ${ HTTP2_METHOD_GET } [${
 134 |         HTTP_STATUS_OK
 135 |       }] request and must get new cookie with positive (+) 'max-age' attribute`,
 136 |       async () => {
 137 |         const url = new URL(`/gimme/cookies?maxAge=${ 1 }`, baseURL);
 138 |         const res = await rekwest(url, {
 139 |           cookiesTTL: true,
 140 |         });
 141 | 
 142 |         assert.equal(res.body.message, 'json');
 143 |         assert.equal(res.bodyUsed, true);
 144 |         assert.equal(res.cookies.get('ttl'), 'puff');
 145 |         await scheduler.wait(1.1e3);
 146 |         assert.equal(res.cookies.get('ttl'), null);
 147 |         assert.equal(res.httpVersion, httpVersion);
 148 |         assert.equal(res.ok, true);
 149 |         assert.equal(res.redirected, false);
 150 |         assert.equal(res.statusCode, HTTP_STATUS_OK);
 151 |       },
 152 |     );
 153 | 
 154 |     it(
 155 |       `should make ${ HTTP2_METHOD_GET } [${
 156 |         HTTP_STATUS_OK
 157 |       }] request and must get new cookie with negative (-) 'max-age' attribute`,
 158 |       async () => {
 159 |         const url = new URL(`/gimme/cookies?maxAge=${ -1 }`, baseURL);
 160 |         const res = await rekwest(url, {
 161 |           cookiesTTL: true,
 162 |         });
 163 | 
 164 |         assert.equal(res.body.message, 'json');
 165 |         assert.equal(res.bodyUsed, true);
 166 |         await scheduler.wait(100);
 167 |         assert.equal(res.cookies.get('ttl'), null);
 168 |         assert.equal(res.httpVersion, httpVersion);
 169 |         assert.equal(res.ok, true);
 170 |         assert.equal(res.redirected, false);
 171 |         assert.equal(res.statusCode, HTTP_STATUS_OK);
 172 |       },
 173 |     );
 174 | 
 175 |     it(
 176 |       `should make ${ HTTP2_METHOD_GET } [${ HTTP_STATUS_NO_CONTENT }] request with new and preserved cookies`,
 177 |       async () => {
 178 |         const url = new URL('/gimme/nothing', baseURL);
 179 |         const res = await rekwest(url, {
 180 |           cookies: {
 181 |             xen: 'wix',
 182 |           },
 183 |         });
 184 | 
 185 |         assert.equal(res.body, null);
 186 |         assert.equal(res.bodyUsed, true);
 187 |         assert.equal(res.cookies.get('aux'), 'baz');
 188 |         assert.equal(res.cookies.get('foo'), 'bar');
 189 |         assert.equal(res.cookies.get('qux'), 'zap');
 190 |         assert.equal(res.cookies.get('ttl'), null);
 191 |         assert.equal(res.cookies.get('xen'), 'wix');
 192 |         assert.equal(res.httpVersion, httpVersion);
 193 |         assert.equal(res.ok, true);
 194 |         assert.equal(res.redirected, false);
 195 |         assert.equal(res.statusCode, HTTP_STATUS_NO_CONTENT);
 196 |       },
 197 |     );
 198 | 
 199 |     it(`should make ${ HTTP2_METHOD_GET } [${ HTTP_STATUS_NO_CONTENT }] request without cookies`, async () => {
 200 |       const url = new URL('/gimme/nothing', baseURL);
 201 |       const res = await rekwest(url, { cookies: false });
 202 | 
 203 |       assert.equal(res.body, null);
 204 |       assert.equal(res.bodyUsed, true);
 205 |       assert.equal(res.cookies, undefined);
 206 |       assert.equal(res.httpVersion, httpVersion);
 207 |       assert.equal(res.ok, true);
 208 |       assert.equal(res.redirected, false);
 209 |       assert.equal(res.statusCode, HTTP_STATUS_NO_CONTENT);
 210 |     });
 211 | 
 212 |     it(
 213 |       `should make ${ HTTP2_METHOD_GET } [${ HTTP_STATUS_OK }] request with body and must catch an error`,
 214 |       async () => {
 215 |         const url = new URL('/gimme/text', baseURL);
 216 | 
 217 |         await assert.throws(() => rekwest(url, { body: 'zqiygyxz' }), (err) => {
 218 |           assert.equal(
 219 |             err.message,
 220 |             `Request with ${ HTTP2_METHOD_GET }/${ HTTP2_METHOD_HEAD } method cannot have body.`,
 221 |           );
 222 |           assert.equal(err.name, 'TypeError');
 223 | 
 224 |           return true;
 225 |         });
 226 |       },
 227 |     );
 228 | 
 229 |     it(`should make ${ HTTP2_METHOD_GET } [${
 230 |       HTTP_STATUS_MOVED_PERMANENTLY
 231 |     }] request with redirect { credentials: false } and must catch an error`, async () => {
 232 |       const url = new URL('/gimme/redirect', baseURL);
 233 | 
 234 |       await assert.throws(() => rekwest(url, { credentials: false }), (err) => {
 235 |         assert.equal(
 236 |           err.message,
 237 |           'Failed to read the \'credentials\' property from \'options\': The provided value \'false\' is not a valid enum value.',
 238 |         );
 239 |         assert.equal(err.name, 'TypeError');
 240 | 
 241 |         return true;
 242 |       });
 243 |     });
 244 | 
 245 |     it(`should make ${
 246 |       HTTP2_METHOD_GET
 247 |     } [${ HTTP_STATUS_MOVED_PERMANENTLY }] request with redirect { follow: 0 } and must catch an error`, async () => {
 248 |       const url = new URL('/gimme/redirect', baseURL);
 249 | 
 250 |       await assert.rejects(rekwest(url, { follow: 0 }), (err) => {
 251 |         assert.match(err.message, /Maximum redirect reached at:/);
 252 |         assert.equal(err.name, 'RequestError');
 253 | 
 254 |         return true;
 255 |       });
 256 |     });
 257 | 
 258 |     it(`should make ${ HTTP2_METHOD_GET } [${
 259 |       HTTP_STATUS_MOVED_PERMANENTLY
 260 |     }] request with redirect { mode: ${ requestRedirect.error } } and must catch an error`, async () => {
 261 |       const url = new URL('/gimme/redirect', baseURL);
 262 | 
 263 |       await assert.rejects(rekwest(url, { redirect: requestRedirect.error }), (err) => {
 264 |         assert.equal(err.message, 'Unexpected redirect, redirect mode is set to \'error\'.');
 265 |         assert.equal(err.name, 'RequestError');
 266 | 
 267 |         return true;
 268 |       });
 269 |     });
 270 | 
 271 |     it(`should make ${ HTTP2_METHOD_GET } [${
 272 |       HTTP_STATUS_MOVED_PERMANENTLY
 273 |     }] request with redirect { mode: false } and must catch an error`, async () => {
 274 |       const url = new URL('/gimme/redirect', baseURL);
 275 | 
 276 |       await assert.throws(() => rekwest(url, { redirect: false }), (err) => {
 277 |         assert.equal(
 278 |           err.message,
 279 |           'Failed to read the \'redirect\' property from \'options\': The provided value \'false\' is not a valid enum value.',
 280 |         );
 281 |         assert.equal(err.name, 'TypeError');
 282 | 
 283 |         return true;
 284 |       });
 285 |     });
 286 | 
 287 |     it(
 288 |       `should make ${ HTTP2_METHOD_GET } [${
 289 |         HTTP_STATUS_MOVED_PERMANENTLY
 290 |       }] request with redirect { mode: ${ requestRedirect.follow } } and must retain a cookies`,
 291 |       async () => {
 292 |         const url = new URL('/gimme/redirect', baseURL);
 293 |         const res = await rekwest(url);
 294 | 
 295 |         assert.equal(res.body.message, 'json');
 296 |         assert.equal(res.bodyUsed, true);
 297 |         assert.equal(res.cookies.get('crack'), 'duck');
 298 |         assert.equal(res.httpVersion, httpVersion);
 299 |         assert.equal(res.ok, true);
 300 |         assert.equal(res.redirected, true);
 301 |         assert.equal(res.statusCode, HTTP_STATUS_OK);
 302 |       },
 303 |     );
 304 | 
 305 |     it(`should make ${ HTTP2_METHOD_GET } [${
 306 |       HTTP_STATUS_MOVED_PERMANENTLY
 307 |     }] request with redirect { mode: ${ requestRedirect.follow } } and must omit all cookies`, async () => {
 308 |       const base = baseURL.protocol === 'http:' ? globalThis.baseB1URL : globalThis.baseB2URL;
 309 |       const url = new URL(`/gimme/redirect?location=${ base.origin }/gimme/json`, baseURL);
 310 |       const res = await rekwest(url, {
 311 |         credentials: requestCredentials.omit,
 312 |         headers: {
 313 |           [HTTP2_HEADER_AUTHORIZATION]: 'token',
 314 |         },
 315 |         redirect: requestRedirect.follow,
 316 |       });
 317 | 
 318 |       assert.equal(res.body.message, 'json');
 319 |       assert.equal(res.bodyUsed, true);
 320 |       assert.equal(res.cookies, undefined);
 321 |       assert.equal(res.httpVersion, httpVersion);
 322 |       assert.equal(res.ok, true);
 323 |       assert.equal(res.redirected, true);
 324 |       assert.equal(res.statusCode, HTTP_STATUS_OK);
 325 |     });
 326 | 
 327 |     it(`should make ${ HTTP2_METHOD_GET } [${
 328 |       HTTP_STATUS_MOVED_PERMANENTLY
 329 |     }] request with redirect { mode: ${ requestRedirect.manual } } and must get new cookies`, async () => {
 330 |       const url = new URL('/gimme/redirect', baseURL);
 331 |       const res = await rekwest(url, { redirect: requestRedirect.manual });
 332 | 
 333 |       assert.equal(res.body, null);
 334 |       assert.equal(res.bodyUsed, true);
 335 |       assert.equal(res.cookies.get('crack'), 'duck');
 336 |       assert.equal(res.httpVersion, httpVersion);
 337 |       assert.equal(res.ok, false);
 338 |       assert.equal(res.redirected, false);
 339 |       assert.equal(res.statusCode, HTTP_STATUS_MOVED_PERMANENTLY);
 340 |     });
 341 | 
 342 |     it(`should make ${ HTTP2_METHOD_GET } [${
 343 |       HTTP_STATUS_SEE_OTHER
 344 |     }] request with redirect and must catch an error on invalid protocol`, async () => {
 345 |       const url = new URL(`/gimme/redirect?location=wss://${ baseURL.host }`, baseURL);
 346 | 
 347 |       await assert.rejects(rekwest(url), (err) => {
 348 |         assert.equal(err.message, 'URL scheme must be "http" or "https".');
 349 |         assert.equal(err.name, 'RequestError');
 350 | 
 351 |         return true;
 352 |       });
 353 |     });
 354 | 
 355 |     it(`should make ${ HTTP2_METHOD_GET } [${
 356 |       HTTP_STATUS_USE_PROXY
 357 |     }] request with redirect and must catch an error on inapt status code`, async () => {
 358 |       const url = new URL(`/gimme/redirect?statusCode=${ HTTP_STATUS_USE_PROXY }`, baseURL);
 359 | 
 360 |       await assert.rejects(rekwest(url), (err) => {
 361 |         assert.equal(err.message, `Invalid status code: ${ HTTP_STATUS_USE_PROXY }`);
 362 |         assert.equal(err.name, 'RangeError');
 363 | 
 364 |         return true;
 365 |       });
 366 |     });
 367 | 
 368 |     it(`should make ${ HTTP2_METHOD_GET } [${
 369 |       HTTP_STATUS_MOVED_PERMANENTLY
 370 |     }] request with redirect and must respect '${ HTTP2_HEADER_RETRY_AFTER }' header`, async () => {
 371 |       const url = new URL(`/gimme/redirect?${ HTTP2_HEADER_RETRY_AFTER }=0.25`, baseURL);
 372 |       const res = await rekwest(url);
 373 | 
 374 |       assert.equal(res.body.message, 'json');
 375 |       assert.equal(res.bodyUsed, true);
 376 |       assert.equal(res.cookies.get('crack'), 'duck');
 377 |       assert.equal(res.httpVersion, httpVersion);
 378 |       assert.equal(res.ok, true);
 379 |       assert.equal(res.redirected, true);
 380 |       assert.equal(res.statusCode, HTTP_STATUS_OK);
 381 |     });
 382 | 
 383 |     it(
 384 |       `should make ${ HTTP2_METHOD_GET } [${
 385 |         HTTP_STATUS_MOVED_PERMANENTLY
 386 |       }] request with redirect and must catch an error if max '${ HTTP2_HEADER_RETRY_AFTER }' limit is exceeded`,
 387 |       async () => {
 388 |         const url = new URL(`/gimme/redirect?${ HTTP2_HEADER_RETRY_AFTER }=3.5e5`, baseURL);
 389 | 
 390 |         await assert.rejects(rekwest(url), (err) => {
 391 |           assert.ok(err.cause);
 392 |           assert.match(err.message, new RegExp(`Maximum '${ HTTP2_HEADER_RETRY_AFTER }' limit exceeded:`));
 393 |           assert.equal(err.name, 'RequestError');
 394 | 
 395 |           return true;
 396 |         });
 397 |       },
 398 |     );
 399 | 
 400 |     it(`should make ${ HTTP2_METHOD_POST } [${
 401 |       HTTP_STATUS_FOUND
 402 |     }] request with redirect { body: stream } and must catch an error`, async () => {
 403 |       const url = new URL('/gimme/redirect', baseURL);
 404 | 
 405 |       await assert.rejects(rekwest(url, {
 406 |         body: Readable.from('zqiygyxz'),
 407 |         method: HTTP2_METHOD_POST,
 408 |       }), (err) => {
 409 |         assert.equal(err.message, 'Unable to follow redirect with streamable body.');
 410 |         assert.equal(err.name, 'RequestError');
 411 | 
 412 |         return true;
 413 |       });
 414 |     });
 415 | 
 416 |     it(`should make ${ HTTP2_METHOD_PUT } [${
 417 |       HTTP_STATUS_SEE_OTHER
 418 |     }] request with redirect { body: json }`, async () => {
 419 |       const url = new URL('/gimme/redirect', baseURL);
 420 |       const res = await rekwest(url, {
 421 |         body: { eldritch: 'symbols' },
 422 |         method: HTTP2_METHOD_PUT,
 423 |       });
 424 | 
 425 |       assert.equal(res.body.message, 'json');
 426 |       assert.equal(res.bodyUsed, true);
 427 |       assert.equal(res.cookies.get('crack'), 'duck');
 428 |       assert.equal(res.httpVersion, httpVersion);
 429 |       assert.equal(res.ok, true);
 430 |       assert.equal(res.redirected, true);
 431 |       assert.equal(res.statusCode, HTTP_STATUS_OK);
 432 |     });
 433 | 
 434 |     it(`should make ${ HTTP2_METHOD_GET } [${
 435 |       HTTP_STATUS_OK
 436 |     }] request and must succeed after connection reset`, async () => {
 437 |       const url = new URL(
 438 |         '/gimme/reset?attempts=2',
 439 |         baseURL,
 440 |       );
 441 |       const res = await rekwest(url, { retry: { attempts: 2, interval: 25 } });
 442 | 
 443 |       assert.equal(res.body.message, 'json');
 444 |       assert.equal(res.bodyUsed, true);
 445 |       assert.equal(res.cookies.get('crack'), 'duck');
 446 |       assert.equal(res.httpVersion, httpVersion);
 447 |       assert.equal(res.ok, true);
 448 |       assert.equal(res.redirected, false);
 449 |       assert.equal(res.statusCode, HTTP_STATUS_OK);
 450 |     });
 451 | 
 452 |     it(`should make ${ HTTP2_METHOD_GET } [${
 453 |       HTTP_STATUS_TOO_MANY_REQUESTS
 454 |     }] request and must succeed after '${ HTTP2_HEADER_RETRY_AFTER }' with date interval retry`, async () => {
 455 |       const url = new URL(
 456 |         `/gimme/retry?attempts=2&${ HTTP2_HEADER_RETRY_AFTER }=date:0.5&ver=${ httpVersion }`,
 457 |         baseURL,
 458 |       );
 459 |       const res = await rekwest(url, { retry: { attempts: 2 } });
 460 | 
 461 |       assert.equal(res.body.message, 'json');
 462 |       assert.equal(res.bodyUsed, true);
 463 |       assert.equal(res.cookies.get('crack'), 'duck');
 464 |       assert.equal(res.httpVersion, httpVersion);
 465 |       assert.equal(res.ok, true);
 466 |       assert.equal(res.redirected, false);
 467 |       assert.equal(res.statusCode, HTTP_STATUS_OK);
 468 |     });
 469 | 
 470 |     it(`should make ${ HTTP2_METHOD_GET } [${
 471 |       HTTP_STATUS_TOO_MANY_REQUESTS
 472 |     }] request and must succeed after '${ HTTP2_HEADER_RETRY_AFTER }' with seconds interval retry`, async () => {
 473 |       const url = new URL(
 474 |         `/gimme/retry?attempts=2&${ HTTP2_HEADER_RETRY_AFTER }=0.25&ver=${ httpVersion }`,
 475 |         baseURL,
 476 |       );
 477 |       const res = await rekwest(url, { retry: { attempts: 2 } });
 478 | 
 479 |       assert.equal(res.body.message, 'json');
 480 |       assert.equal(res.bodyUsed, true);
 481 |       assert.equal(res.cookies.get('crack'), 'duck');
 482 |       assert.equal(res.httpVersion, httpVersion);
 483 |       assert.equal(res.ok, true);
 484 |       assert.equal(res.redirected, false);
 485 |       assert.equal(res.statusCode, HTTP_STATUS_OK);
 486 |     });
 487 | 
 488 |     it(`should make ${ HTTP2_METHOD_GET } [${
 489 |       HTTP_STATUS_TOO_MANY_REQUESTS
 490 |     }] request and must catch an error if max '${ HTTP2_HEADER_RETRY_AFTER }' limit is exceeded`, async () => {
 491 |       const url = new URL(
 492 |         `/gimme/retry?attempts=2&${ HTTP2_HEADER_RETRY_AFTER }=3.5e5&ver=${ httpVersion }`,
 493 |         baseURL,
 494 |       );
 495 | 
 496 |       await assert.rejects(rekwest(url, { retry: { attempts: 2 } }), (err) => {
 497 |         assert.ok(err.cause);
 498 |         assert.match(err.message, new RegExp(`Maximum '${ HTTP2_HEADER_RETRY_AFTER }' limit exceeded:`));
 499 |         assert.equal(err.name, 'RequestError');
 500 | 
 501 |         return true;
 502 |       });
 503 |     });
 504 | 
 505 |     it(`should make ${ HTTP2_METHOD_GET } [${
 506 |       HTTP_STATUS_TOO_MANY_REQUESTS
 507 |     }] request and must succeed after a ${ logarithmic } interval retry`, async () => {
 508 |       const url = new URL(`/gimme/retry?attempts=2&${ logarithmic }=true&ver=${ httpVersion }`, baseURL);
 509 |       const res = await rekwest(url, { retry: { attempts: 2, interval: 100 } });
 510 | 
 511 |       assert.equal(res.body.message, 'json');
 512 |       assert.equal(res.bodyUsed, true);
 513 |       assert.equal(res.cookies.get('crack'), 'duck');
 514 |       assert.equal(res.httpVersion, httpVersion);
 515 |       assert.equal(res.ok, true);
 516 |       assert.equal(res.redirected, false);
 517 |       assert.equal(res.statusCode, HTTP_STATUS_OK);
 518 |     });
 519 | 
 520 |     it(
 521 |       `should make ${ HTTP2_METHOD_GET } [${ HTTP_STATUS_UNAUTHORIZED }] request and must catch an error`,
 522 |       async () => {
 523 |         const url = new URL('/gimme/refusal', baseURL);
 524 | 
 525 |         await assert.rejects(rekwest(url), (res) => {
 526 |           assert.equal(res.body.message, 'unauthorized');
 527 |           assert.equal(res.bodyUsed, true);
 528 |           assert.equal(res.cookies.get('crack'), 'duck');
 529 |           assert.equal(res.httpVersion, httpVersion);
 530 |           assert.equal(res.ok, false);
 531 |           assert.equal(res.redirected, false);
 532 |           assert.equal(res.statusCode, HTTP_STATUS_UNAUTHORIZED);
 533 | 
 534 |           return true;
 535 |         });
 536 |       },
 537 |     );
 538 | 
 539 |     it(`should make ${ HTTP2_METHOD_GET } [${ HTTP_STATUS_NOT_FOUND }] request and must catch an error`, async () => {
 540 |       const url = new URL('/gimme/not/found', baseURL);
 541 | 
 542 |       await assert.rejects(rekwest(url), (res) => {
 543 |         assert.equal(res.body, null);
 544 |         assert.equal(res.bodyUsed, true);
 545 |         assert.equal(res.cookies.get('crack'), 'duck');
 546 |         assert.equal(res.httpVersion, httpVersion);
 547 |         assert.equal(res.ok, false);
 548 |         assert.equal(res.redirected, false);
 549 |         assert.equal(res.statusCode, HTTP_STATUS_NOT_FOUND);
 550 | 
 551 |         return true;
 552 |       });
 553 |     });
 554 | 
 555 |     it(
 556 |       `should make ${ HTTP2_METHOD_GET } [${
 557 |         HTTP_STATUS_NO_CONTENT
 558 |       }] request and must strip & trim extra slashes from the URL`,
 559 |       async () => {
 560 |         const url = new URL('/gimme///nothing///#bang', baseURL);
 561 |         const res = await rekwest(url, {
 562 |           stripTrailingSlash: true,
 563 |           trimTrailingSlashes: true,
 564 |         });
 565 | 
 566 |         assert.equal(res.body, null);
 567 |         assert.equal(res.bodyUsed, true);
 568 |         assert.equal(res.cookies.get('crack'), 'duck');
 569 |         assert.equal(res.httpVersion, httpVersion);
 570 |         assert.equal(res.ok, true);
 571 |         assert.equal(res.redirected, false);
 572 |         assert.equal(res.statusCode, HTTP_STATUS_NO_CONTENT);
 573 |       },
 574 |     );
 575 | 
 576 |     [
 577 |       'br',
 578 |       'deflate',
 579 |       'deflate-raw',
 580 |       'gzip',
 581 |       'zstd',
 582 |     ].forEach((item) => {
 583 |       it(
 584 |         `should make ${ HTTP2_METHOD_POST } [${ HTTP_STATUS_OK }] request with '${ item }' compressed body`,
 585 |         async () => {
 586 |           const url = new URL('/gimme/squash', baseURL);
 587 |           const res = await rekwest(url, {
 588 |             body: 'zqiygyxz',
 589 |             headers: {
 590 |               [HTTP2_HEADER_ACCEPT_ENCODING]: item,
 591 |               [HTTP2_HEADER_CONTENT_ENCODING]: item,
 592 |               [HTTP2_HEADER_CONTENT_TYPE]: TEXT_PLAIN,
 593 |               [HTTP2_HEADER_VARY]: [HTTP2_HEADER_ACCEPT_ENCODING],
 594 |             },
 595 |             method: HTTP2_METHOD_POST,
 596 |           });
 597 | 
 598 |           assert.equal(res.body, 'zqiygyxz'.split('').reverse().join(''));
 599 |           assert.equal(res.bodyUsed, true);
 600 |           assert.equal(res.httpVersion, httpVersion);
 601 |           assert.equal(res.ok, true);
 602 |           assert.equal(res.redirected, false);
 603 |           assert.equal(res.statusCode, HTTP_STATUS_OK);
 604 |         },
 605 |       );
 606 |     });
 607 | 
 608 |     [
 609 |       'br',
 610 |       'deflate',
 611 |       'deflate-raw',
 612 |       'gzip',
 613 |       'zstd',
 614 |     ].forEach((item) => {
 615 |       it(
 616 |         `should make ${ HTTP2_METHOD_POST } [${ HTTP_STATUS_OK }] request with '${ item }' compressed body stream`,
 617 |         async () => {
 618 |           const url = new URL('/gimme/squash', baseURL);
 619 |           const res = await rekwest(url, {
 620 |             body: Readable.from('zqiygyxz'),
 621 |             headers: {
 622 |               [HTTP2_HEADER_ACCEPT_ENCODING]: item,
 623 |               [HTTP2_HEADER_CONTENT_ENCODING]: item,
 624 |               [HTTP2_HEADER_CONTENT_TYPE]: TEXT_PLAIN,
 625 |               [HTTP2_HEADER_VARY]: [HTTP2_HEADER_ACCEPT_ENCODING],
 626 |             },
 627 |             method: HTTP2_METHOD_POST,
 628 |           });
 629 | 
 630 |           assert.equal(res.body, 'zqiygyxz'.split('').reverse().join(''));
 631 |           assert.equal(res.bodyUsed, true);
 632 |           assert.equal(res.httpVersion, httpVersion);
 633 |           assert.equal(res.ok, true);
 634 |           assert.equal(res.redirected, false);
 635 |           assert.equal(res.statusCode, HTTP_STATUS_OK);
 636 |         },
 637 |       );
 638 |     });
 639 | 
 640 |     it(`should make ${ HTTP2_METHOD_POST } [${ HTTP_STATUS_OK }] request with nullish body`, async () => {
 641 |       const payload = null;
 642 |       const url = new URL('/gimme/repulse', baseURL);
 643 |       const res = await rekwest(url, {
 644 |         body: payload,
 645 |         method: HTTP2_METHOD_POST,
 646 |       });
 647 | 
 648 |       assert.equal(res.body, payload);
 649 |       assert.equal(res.bodyUsed, true);
 650 |       assert.equal(res.httpVersion, httpVersion);
 651 |       assert.equal(res.ok, true);
 652 |       assert.equal(res.redirected, false);
 653 |       assert.equal(res.statusCode, HTTP_STATUS_OK);
 654 |     });
 655 | 
 656 |     it(`should make ${ HTTP2_METHOD_POST } [${ HTTP_STATUS_OK }] request with body as an Array`, async () => {
 657 |       const payload = [{ eldritch: 'symbols' }];
 658 |       const url = new URL('/gimme/repulse', baseURL);
 659 |       const res = await rekwest(url, {
 660 |         body: payload,
 661 |         method: HTTP2_METHOD_POST,
 662 |       });
 663 | 
 664 |       assert.equal(res.body.toString(), JSON.stringify(payload));
 665 |       assert.equal(res.bodyUsed, true);
 666 |       assert.equal(res.httpVersion, httpVersion);
 667 |       assert.equal(res.ok, true);
 668 |       assert.equal(res.redirected, false);
 669 |       assert.equal(res.statusCode, HTTP_STATUS_OK);
 670 |     });
 671 | 
 672 |     it(`should make ${ HTTP2_METHOD_POST } [${ HTTP_STATUS_OK }] request with body as an ArrayBuffer`, async () => {
 673 |       const payload = 'message';
 674 |       const url = new URL('/gimme/repulse', baseURL);
 675 |       const res = await rekwest(url, {
 676 |         body: encoder.encode(payload).buffer,
 677 |         method: HTTP2_METHOD_POST,
 678 |       });
 679 | 
 680 |       assert.equal(res.body.toString(), payload);
 681 |       assert.equal(res.bodyUsed, true);
 682 |       assert.equal(res.httpVersion, httpVersion);
 683 |       assert.equal(res.ok, true);
 684 |       assert.equal(res.redirected, false);
 685 |       assert.equal(res.statusCode, HTTP_STATUS_OK);
 686 |     });
 687 | 
 688 |     it(`should make ${ HTTP2_METHOD_POST } [${ HTTP_STATUS_OK }] request with body as an ArrayBufferView`, async () => {
 689 |       const payload = 'message';
 690 |       const url = new URL('/gimme/repulse', baseURL);
 691 |       const res = await rekwest(url, {
 692 |         body: encoder.encode(payload),
 693 |         method: HTTP2_METHOD_POST,
 694 |       });
 695 | 
 696 |       assert.equal(res.body.toString(), payload);
 697 |       assert.equal(res.bodyUsed, true);
 698 |       assert.equal(res.httpVersion, httpVersion);
 699 |       assert.equal(res.ok, true);
 700 |       assert.equal(res.redirected, false);
 701 |       assert.equal(res.statusCode, HTTP_STATUS_OK);
 702 |     });
 703 | 
 704 |     it(`should make ${ HTTP2_METHOD_POST } [${ HTTP_STATUS_OK }] request with body as an AsyncIterator`, async () => {
 705 |       const payload = {
 706 |         async* [Symbol.asyncIterator]() {
 707 |           yield Promise.resolve('eldritch');
 708 |           yield Promise.resolve('symbols');
 709 |         },
 710 |       };
 711 |       const url = new URL('/gimme/repulse', baseURL);
 712 |       const res = await rekwest(url, {
 713 |         body: payload,
 714 |         method: HTTP2_METHOD_POST,
 715 |       });
 716 | 
 717 |       assert.equal(res.body.toString(), (await Array.fromAsync(payload)).join(''));
 718 |       assert.equal(res.bodyUsed, true);
 719 |       assert.equal(res.httpVersion, httpVersion);
 720 |       assert.equal(res.ok, true);
 721 |       assert.equal(res.redirected, false);
 722 |       assert.equal(res.statusCode, HTTP_STATUS_OK);
 723 |     });
 724 | 
 725 |     it(`should make ${ HTTP2_METHOD_POST } [${ HTTP_STATUS_OK }] request with body as a Blob`, async () => {
 726 |       const payload = new Blob(['bits']);
 727 |       const url = new URL('/gimme/repulse', baseURL);
 728 |       const res = await rekwest(url, {
 729 |         body: payload,
 730 |         method: HTTP2_METHOD_POST,
 731 |       });
 732 | 
 733 |       assert.equal(res.body.toString(), await payload.text());
 734 |       assert.equal(res.bodyUsed, true);
 735 |       assert.equal(res.httpVersion, httpVersion);
 736 |       assert.equal(res.ok, true);
 737 |       assert.equal(res.redirected, false);
 738 |       assert.equal(res.statusCode, HTTP_STATUS_OK);
 739 |     });
 740 | 
 741 |     it(`should make ${ HTTP2_METHOD_POST } [${ HTTP_STATUS_OK }] request with body as a Buffer`, async () => {
 742 |       const payload = Buffer.from('zqiygyxz');
 743 |       const url = new URL('/gimme/repulse', baseURL);
 744 |       const res = await rekwest(url, {
 745 |         body: payload,
 746 |         method: HTTP2_METHOD_POST,
 747 |       });
 748 | 
 749 |       assert.equal(res.body.toString(), payload.toString());
 750 |       assert.equal(res.bodyUsed, true);
 751 |       assert.equal(res.httpVersion, httpVersion);
 752 |       assert.equal(res.ok, true);
 753 |       assert.equal(res.redirected, false);
 754 |       assert.equal(res.statusCode, HTTP_STATUS_OK);
 755 |     });
 756 | 
 757 |     it(`should make ${ HTTP2_METHOD_POST } [${ HTTP_STATUS_OK }] request with body as a DataView`, async () => {
 758 |       const payload = 'message';
 759 |       const url = new URL('/gimme/repulse', baseURL);
 760 |       const res = await rekwest(url, {
 761 |         body: new DataView(encoder.encode(payload).buffer),
 762 |         method: HTTP2_METHOD_POST,
 763 |       });
 764 | 
 765 |       assert.equal(res.body.toString(), payload);
 766 |       assert.equal(res.bodyUsed, true);
 767 |       assert.equal(res.httpVersion, httpVersion);
 768 |       assert.equal(res.ok, true);
 769 |       assert.equal(res.redirected, false);
 770 |       assert.equal(res.statusCode, HTTP_STATUS_OK);
 771 |     });
 772 | 
 773 |     it(`should make ${ HTTP2_METHOD_POST } [${ HTTP_STATUS_OK }] request with body as a File`, async () => {
 774 |       const payload = new File(['bits'], 'file.dab');
 775 | 
 776 |       assert.throws(() => new File([]), TypeError);
 777 | 
 778 |       const url = new URL('/gimme/repulse', baseURL);
 779 |       const res = await rekwest(url, {
 780 |         body: payload,
 781 |         method: HTTP2_METHOD_POST,
 782 |       });
 783 | 
 784 |       assert.equal(res.body.toString(), await payload.text());
 785 |       assert.equal(res.bodyUsed, true);
 786 |       assert.equal(res.httpVersion, httpVersion);
 787 |       assert.equal(res.ok, true);
 788 |       assert.equal(res.redirected, false);
 789 |       assert.equal(res.statusCode, HTTP_STATUS_OK);
 790 |     });
 791 | 
 792 |     it(`should make ${ HTTP2_METHOD_POST } [${ HTTP_STATUS_OK }] request with body as a FormData`, async () => {
 793 |       const blob = new Blob(['bits']);
 794 |       const file = new File(['bits'], 'file.dab');
 795 |       const readable = Readable.from('bits');
 796 |       const payload = new FormData({
 797 |         aux: Date.now(),
 798 |       });
 799 | 
 800 |       payload.append('celestial', 'payload');
 801 |       payload.append('blob', blob, 'blob.dab');
 802 |       payload.append('file', file);
 803 |       payload.append('readable', readable, 'readable.dab');
 804 | 
 805 |       payload.set('celestial', 'goddess');
 806 |       assert.equal(payload.has('celestial'), true);
 807 |       assert.deepEqual(payload.getAll('celestial'), ['goddess']);
 808 | 
 809 |       payload.delete('celestial');
 810 |       assert.equal(payload.has('celestial'), false);
 811 | 
 812 |       payload.append('celestial', 'goddess');
 813 |       assert.equal(payload.get('celestial'), 'goddess');
 814 | 
 815 |       payload.set('celestial', 'payload');
 816 |       assert.equal(payload.get('celestial'), 'payload');
 817 | 
 818 |       const keys = [...payload.keys()];
 819 |       const values = [...payload.values()];
 820 | 
 821 |       payload.forEach((value, key) => {
 822 |         assert.equal(value, values.shift());
 823 |         assert.equal(key, keys.shift());
 824 |       });
 825 | 
 826 |       assert.throws(() => new FormData([null]), TypeError);
 827 |       assert.throws(() => new FormData([[]]), TypeError);
 828 |       assert.throws(() => payload.append(), TypeError);
 829 |       assert.throws(() => payload.append(null, null, null), TypeError);
 830 |       assert.throws(() => payload.delete(), TypeError);
 831 |       assert.throws(() => payload.forEach(), TypeError);
 832 |       assert.throws(() => payload.forEach(null), TypeError);
 833 |       assert.throws(() => payload.get(), TypeError);
 834 |       assert.throws(() => payload.getAll(), TypeError);
 835 |       assert.throws(() => payload.has(), TypeError);
 836 |       assert.throws(() => payload.set(), TypeError);
 837 |       assert.throws(() => payload.set(null, null, null), TypeError);
 838 | 
 839 |       const url = new URL('/gimme/repulse', baseURL);
 840 |       const res = await rekwest(url, {
 841 |         body: payload,
 842 |         method: HTTP2_METHOD_POST,
 843 |       });
 844 | 
 845 |       assert.deepEqual([
 846 |         ...res.body.toString()
 847 |               .matchAll(new RegExp(`${
 848 |                 HTTP2_HEADER_CONTENT_DISPOSITION
 849 |               }: form-data; name="([^"]*)"(?:; filename="([^"]*)")?`, 'g')),
 850 |       ].flatMap((it) => it.slice(1).filter(Boolean)), [
 851 |         'aux',
 852 |         'blob',
 853 |         'blob.dab',
 854 |         'file',
 855 |         'file.dab',
 856 |         'readable',
 857 |         'readable.dab',
 858 |         'celestial',
 859 |       ]);
 860 |       assert.equal(res.bodyUsed, true);
 861 |       assert.equal(res.httpVersion, httpVersion);
 862 |       assert.equal(res.ok, true);
 863 |       assert.equal(res.redirected, false);
 864 |       assert.equal(res.statusCode, HTTP_STATUS_OK);
 865 |     });
 866 | 
 867 |     it(`should make ${ HTTP2_METHOD_POST } [${ HTTP_STATUS_OK }] request with body as an Iterator`, async () => {
 868 |       const payload = {
 869 |         * [Symbol.iterator]() {
 870 |           yield 'eldritch';
 871 |           yield 'symbols';
 872 |         },
 873 |       };
 874 |       const url = new URL('/gimme/repulse', baseURL);
 875 |       const res = await rekwest(url, {
 876 |         body: payload,
 877 |         method: HTTP2_METHOD_POST,
 878 |       });
 879 | 
 880 |       assert.equal(res.body.toString(), [...payload].join(''));
 881 |       assert.equal(res.bodyUsed, true);
 882 |       assert.equal(res.httpVersion, httpVersion);
 883 |       assert.equal(res.ok, true);
 884 |       assert.equal(res.redirected, false);
 885 |       assert.equal(res.statusCode, HTTP_STATUS_OK);
 886 |     });
 887 | 
 888 |     it(`should make ${ HTTP2_METHOD_POST } [${ HTTP_STATUS_OK }] request with body as an Object`, async () => {
 889 |       const payload = { eldritch: 'symbols' };
 890 |       const url = new URL('/gimme/repulse', baseURL);
 891 |       const res = await rekwest(url, {
 892 |         body: payload,
 893 |         method: HTTP2_METHOD_POST,
 894 |       });
 895 | 
 896 |       assert.equal(res.body.toString(), JSON.stringify(payload));
 897 |       assert.equal(res.bodyUsed, true);
 898 |       assert.equal(res.httpVersion, httpVersion);
 899 |       assert.equal(res.ok, true);
 900 |       assert.equal(res.redirected, false);
 901 |       assert.equal(res.statusCode, HTTP_STATUS_OK);
 902 |     });
 903 | 
 904 |     it(`should make ${ HTTP2_METHOD_POST } [${ HTTP_STATUS_OK }] request with body as a String`, async () => {
 905 |       const payload = 'zqiygyxz';
 906 |       const url = new URL('/gimme/repulse', baseURL);
 907 |       const res = await rekwest(url, {
 908 |         body: payload,
 909 |         method: HTTP2_METHOD_POST,
 910 |       });
 911 | 
 912 |       assert.equal(res.body.toString(), payload);
 913 |       assert.equal(res.bodyUsed, true);
 914 |       assert.equal(res.httpVersion, httpVersion);
 915 |       assert.equal(res.ok, true);
 916 |       assert.equal(res.redirected, false);
 917 |       assert.equal(res.statusCode, HTTP_STATUS_OK);
 918 |     });
 919 | 
 920 |     it(`should make ${ HTTP2_METHOD_POST } [${ HTTP_STATUS_OK }] request with body as a Readable`, async () => {
 921 |       const payload = 'zqiygyxz';
 922 |       const url = new URL('/gimme/repulse', baseURL);
 923 |       const res = await rekwest(url, {
 924 |         body: Readable.from(payload),
 925 |         method: HTTP2_METHOD_POST,
 926 |       });
 927 | 
 928 |       assert.equal(res.body.toString(), payload);
 929 |       assert.equal(res.bodyUsed, true);
 930 |       assert.equal(res.httpVersion, httpVersion);
 931 |       assert.equal(res.ok, true);
 932 |       assert.equal(res.redirected, false);
 933 |       assert.equal(res.statusCode, HTTP_STATUS_OK);
 934 |     });
 935 | 
 936 |     it(`should make ${ HTTP2_METHOD_POST } [${ HTTP_STATUS_OK }] request with body as a ReadableStream`, async () => {
 937 |       const payload = 'zqiygyxz';
 938 |       const url = new URL('/gimme/repulse', baseURL);
 939 |       const res = await rekwest(url, {
 940 |         body: new ReadableStream({
 941 |           start(controller) {
 942 |             controller.enqueue(payload);
 943 |             controller.close();
 944 |           },
 945 |         }),
 946 |         method: HTTP2_METHOD_POST,
 947 |       });
 948 | 
 949 |       assert.equal(res.body.toString(), payload);
 950 |       assert.equal(res.bodyUsed, true);
 951 |       assert.equal(res.httpVersion, httpVersion);
 952 |       assert.equal(res.ok, true);
 953 |       assert.equal(res.redirected, false);
 954 |       assert.equal(res.statusCode, HTTP_STATUS_OK);
 955 |     });
 956 | 
 957 |     it(
 958 |       `should make ${ HTTP2_METHOD_POST } [${ HTTP_STATUS_OK }] request with body as a SharedArrayBuffer (Uint8Array)`,
 959 |       async () => {
 960 |         const payload = 'message';
 961 |         const data = encoder.encode(payload);
 962 |         const sab = new SharedArrayBuffer(data.length);
 963 |         const tie = new Uint8Array(sab);
 964 | 
 965 |         tie.set(data, 0);
 966 | 
 967 |         const url = new URL('/gimme/repulse', baseURL);
 968 |         const res = await rekwest(url, {
 969 |           body: sab,
 970 |           method: HTTP2_METHOD_POST,
 971 |         });
 972 | 
 973 |         assert.equal(res.body.toString(), payload);
 974 |         assert.equal(res.bodyUsed, true);
 975 |         assert.equal(res.httpVersion, httpVersion);
 976 |         assert.equal(res.ok, true);
 977 |         assert.equal(res.redirected, false);
 978 |         assert.equal(res.statusCode, HTTP_STATUS_OK);
 979 |       },
 980 |     );
 981 | 
 982 |     it(`should make ${ HTTP2_METHOD_POST } [${ HTTP_STATUS_OK }] request with body as a URLSearchParams`, async () => {
 983 |       const payload = new URLSearchParams('eldritch=symbols&ley=lines');
 984 |       const url = new URL('/gimme/repulse', baseURL);
 985 |       const res = await rekwest(url, {
 986 |         body: payload,
 987 |         method: HTTP2_METHOD_POST,
 988 |       });
 989 | 
 990 |       assert.equal(res.body.toString(), payload.toString());
 991 |       assert.equal(res.bodyUsed, true);
 992 |       assert.equal(res.httpVersion, httpVersion);
 993 |       assert.equal(res.ok, true);
 994 |       assert.equal(res.redirected, false);
 995 |       assert.equal(res.statusCode, HTTP_STATUS_OK);
 996 |     });
 997 | 
 998 |   });
 999 | 
1000 |   describe('with { digest: false } & { parse: false }', () => {
1001 | 
1002 |     const options = { digest: false, parse: false };
1003 | 
1004 |     it(
1005 |       `should make ${ HTTP2_METHOD_GET } [${ HTTP_STATUS_OK }] request and must read response via 'arrayBuffer' method`,
1006 |       async () => {
1007 |         const url = new URL('/gimme/text', baseURL);
1008 |         const res = await rekwest(url, options);
1009 | 
1010 |         assert.ok(types.isArrayBuffer(await res.arrayBuffer()));
1011 |         assert.equal(res.bodyUsed, true);
1012 |         assert.equal(res.cookies, undefined);
1013 |         assert.equal(res.httpVersion, httpVersion);
1014 |         assert.equal(res.ok, true);
1015 |         assert.equal(res.redirected, false);
1016 |         assert.equal(res.statusCode, HTTP_STATUS_OK);
1017 |       },
1018 |     );
1019 | 
1020 |     it(
1021 |       `should make ${ HTTP2_METHOD_GET } [${ HTTP_STATUS_OK }] request and must read response via 'blob' method`,
1022 |       async () => {
1023 |         const url = new URL('/gimme/text', baseURL);
1024 |         const res = await rekwest(url, options);
1025 | 
1026 |         assert.ok((await res.blob())?.constructor.name === 'Blob');
1027 |         assert.equal(res.bodyUsed, true);
1028 |         assert.equal(res.cookies, undefined);
1029 |         assert.equal(res.httpVersion, httpVersion);
1030 |         assert.equal(res.ok, true);
1031 |         assert.equal(res.redirected, false);
1032 |         assert.equal(res.statusCode, HTTP_STATUS_OK);
1033 |       },
1034 |     );
1035 | 
1036 |     it(
1037 |       `should make ${ HTTP2_METHOD_GET } [${ HTTP_STATUS_OK }] request and must read response via 'body' method`,
1038 |       async () => {
1039 |         const url = new URL('/gimme/text', baseURL);
1040 |         const res = await rekwest(url, options);
1041 | 
1042 |         assert.ok(Buffer.isBuffer(await res.body()));
1043 |         assert.equal(res.bodyUsed, true);
1044 |         assert.equal(res.cookies, undefined);
1045 |         assert.equal(res.httpVersion, httpVersion);
1046 |         assert.equal(res.ok, true);
1047 |         assert.equal(res.redirected, false);
1048 |         assert.equal(res.statusCode, HTTP_STATUS_OK);
1049 |       },
1050 |     );
1051 | 
1052 |     it(
1053 |       `should make ${ HTTP2_METHOD_GET } [${ HTTP_STATUS_OK }] request and must read response via 'bytes' method`,
1054 |       async () => {
1055 |         const url = new URL('/gimme/text', baseURL);
1056 |         const res = await rekwest(url, options);
1057 | 
1058 |         assert.ok(types.isUint8Array(await res.bytes()));
1059 |         assert.equal(res.bodyUsed, true);
1060 |         assert.equal(res.cookies, undefined);
1061 |         assert.equal(res.httpVersion, httpVersion);
1062 |         assert.equal(res.ok, true);
1063 |         assert.equal(res.redirected, false);
1064 |         assert.equal(res.statusCode, HTTP_STATUS_OK);
1065 |       },
1066 |     );
1067 | 
1068 | 
1069 |     it(
1070 |       `should make ${ HTTP2_METHOD_GET } [${ HTTP_STATUS_OK }] request and must read response via 'json' method`,
1071 |       async () => {
1072 |         const url = new URL('/gimme/json', baseURL);
1073 |         const res = await rekwest(url, options);
1074 | 
1075 |         assert.equal((await res.json()).message, 'json');
1076 |         assert.equal(res.bodyUsed, true);
1077 |         assert.equal(res.cookies, undefined);
1078 |         assert.equal(res.httpVersion, httpVersion);
1079 |         assert.equal(res.ok, true);
1080 |         assert.equal(res.redirected, false);
1081 |         assert.equal(res.statusCode, HTTP_STATUS_OK);
1082 |       },
1083 |     );
1084 | 
1085 |     it(
1086 |       `should make ${ HTTP2_METHOD_GET } [${ HTTP_STATUS_OK }] request and must read response via 'text' method`,
1087 |       async () => {
1088 |         const url = new URL('/gimme/text', baseURL);
1089 |         const res = await rekwest(url, options);
1090 | 
1091 |         assert.equal(await res.text(), 'message');
1092 |         assert.equal(res.bodyUsed, true);
1093 |         assert.equal(res.cookies, undefined);
1094 |         assert.equal(res.httpVersion, httpVersion);
1095 |         assert.equal(res.ok, true);
1096 |         assert.equal(res.redirected, false);
1097 |         assert.equal(res.statusCode, HTTP_STATUS_OK);
1098 |       },
1099 |     );
1100 | 
1101 |     it(
1102 |       `should make ${ HTTP2_METHOD_GET } [${
1103 |         HTTP_STATUS_OK
1104 |       }] request and must catch an error in attempt to re-read the response`,
1105 |       async () => {
1106 |         const url = new URL('/gimme/text', baseURL);
1107 |         const res = await rekwest(url, options);
1108 | 
1109 |         assert.ok(Buffer.isBuffer(await res.body()));
1110 | 
1111 |         await assert.rejects(res.body(), (err) => {
1112 |           assert.equal(err.message, 'Response stream already read');
1113 |           assert.equal(err.name, 'TypeError');
1114 | 
1115 |           return true;
1116 |         });
1117 |       },
1118 |     );
1119 | 
1120 |   });
1121 | 
1122 |   describe('with abort { signal }', () => {
1123 | 
1124 |     it(
1125 |       `should make ${ HTTP2_METHOD_GET } [${ HTTP_STATUS_OK }] request and must catch an error after the abort signal`,
1126 |       async () => {
1127 |         const ac = new AbortController();
1128 |         const url = new URL('/gimme/nothing', baseURL);
1129 | 
1130 |         setImmediate(() => ac.abort());
1131 | 
1132 |         await assert.rejects(rekwest(url, { signal: ac.signal }), (err) => {
1133 |           assert.equal(err.message, 'The operation was aborted');
1134 |           assert.equal(err.name, 'AbortError');
1135 | 
1136 |           return true;
1137 |         });
1138 |       },
1139 |     );
1140 | 
1141 |   });
1142 | 
1143 |   describe('with { thenable: true }', () => {
1144 | 
1145 |     it(
1146 |       `should make ${ HTTP2_METHOD_GET } [${ HTTP_STATUS_INTERNAL_SERVER_ERROR }] request and must slip an error`,
1147 |       async () => {
1148 |         const url = new URL('/gimme/kaboom', baseURL);
1149 |         const res = await rekwest(url, { thenable: true });
1150 | 
1151 |         assert.equal(res.body.message, 'kaboom');
1152 |         assert.equal(res.bodyUsed, true);
1153 |         assert.equal(res.cookies, undefined);
1154 |         assert.equal(res.httpVersion, httpVersion);
1155 |         assert.equal(res.ok, false);
1156 |         assert.equal(res.redirected, false);
1157 |         assert.equal(res.statusCode, HTTP_STATUS_INTERNAL_SERVER_ERROR);
1158 |       },
1159 |     );
1160 | 
1161 |   });
1162 | 
1163 | };
1164 | 


--------------------------------------------------------------------------------