request-got-adapter 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Torii
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,152 @@
+# request-got-adapter
+
+A drop-in replacement for [`request-promise-native`](https://github.com/request/request-promise-native), backed by [`got`](https://github.com/sindresorhus/got) — with **zero request-family dependencies**.
+
+The [`request`](https://github.com/request/request) ecosystem was deprecated in 2020 but still powers a lot of production code. Rewriting every call site to a modern HTTP client is a big, risky migration. This package takes the other path: keep your code exactly as it is and swap the engine underneath.
+
+```diff
+- const request = require('request-promise-native')
++ const request = require('request-got-adapter')
+```
+
+That's the whole migration. Same options, same response shapes, same error classes, same TypeScript types.
+
+You can even do it without touching code, via an npm alias:
+
+```json
+{
+  "dependencies": {
+    "request-promise-native": "npm:request-got-adapter@^0.1.0"
+  }
+}
+```
+
+## Install
+
+```bash
+npm install request-got-adapter
+```
+
+Requires Node.js >= 22. Works from plain CommonJS (`require`) — the ESM-only `got` is loaded internally.
+
+## Usage
+
+Exactly like request-promise-native:
+
+```js
+const rp = require('request-got-adapter')
+
+// simple GET — resolves with the body
+const html = await rp('https://example.com')
+
+// options object
+const user = await rp({
+  uri: 'https://api.example.com/users/42',
+  qs: { include: 'profile' },
+  headers: { Authorization: 'Bearer token' },
+  json: true
+})
+
+// full response
+const response = await rp({
+  uri: 'https://api.example.com/health',
+  resolveWithFullResponse: true,
+  simple: false
+})
+console.log(response.statusCode, response.headers)
+
+// errors behave identically
+const { StatusCodeError, RequestError } = require('request-got-adapter/errors')
+try {
+  await rp({ uri: 'https://api.example.com/missing', json: true })
+} catch (err) {
+  if (err instanceof StatusCodeError) {
+    console.log(err.statusCode)   // 404
+    console.log(err.error)        // parsed body
+    console.log(err.message)      // '404 - {"error":"not found"}'
+  }
+}
+```
+
+TypeScript works the same way as with `@types/request-promise-native`:
+
+```ts
+import request, { type Options, type FullResponse } from 'request-got-adapter'
+import { StatusCodeError } from 'request-got-adapter/errors'
+```
+
+## Compatibility philosophy
+
+The contract is **observable behavior parity** with request-promise-native — down to error message formats, redirect semantics, and header behavior. A separate repo, [`request-got-adapter-parity-tests`](https://github.com/toriihq/request-got-adapter-parity-tests), runs one behavioral test suite against both the real `request-promise-native` and this adapter and expects identical results. If a test passes there for rpn and fails for this package, that's a bug here — no debate.
+
+Notable parity details handled for you:
+
+- No default `user-agent` header (got normally adds one)
+- No `accept-encoding` / decompression unless you pass `gzip: true` (got normally auto-negotiates)
+- No automatic retries (got defaults to 2)
+- `StatusCodeError.message` is `` `${statusCode} - ${JSON.stringify(body)}` `` — strings included
+- `RequestError.message` is `String(cause)`, e.g. `'Error: getaddrinfo ENOTFOUND nope.example'`
+- Timeouts map to `ETIMEDOUT` (connect phase, with `connect: true`) / `ESOCKETTIMEDOUT` (after connect)
+- Redirects: GET/HEAD followed by default, other methods only with `followAllRedirects: true`; non-307/308 redirects switch to GET like request does
+- `qs`-based query/form serialization (arrays as `a[0]=x&a[1]=y`, RFC 3986 escaping), `useQuerystring` supported
+- Option-validation errors reject the returned promise (and reach a provided callback) — never synchronous throws
+
+One deliberate improvement over the reference: passing an object `body` without `json: true` rejects cleanly with request's `Argument error, options.body.` — real request on Node >= 22 *also* crashes the process with an uncaught async TypeError in that case.
+
+## Supported options
+
+| Option | Status |
+|---|---|
+| `uri` / `url` / `baseUrl` / `method` | ✅ |
+| `qs` / `qsStringifyOptions` / `qsParseOptions` / `useQuerystring` | ✅ |
+| `headers` (case-preserving, case-insensitive lookup) | ✅ |
+| `body` / `json` (boolean or value) | ✅ |
+| `form` / `formData` (multipart via form-data) | ✅ |
+| `auth` — Basic, Bearer, `sendImmediately: false`, **Digest** | ✅ |
+| `oauth` — OAuth 1.0 (HMAC-SHA1/SHA256, RSA-SHA1, PLAINTEXT; header/query/body transports, body_hash) | ✅ |
+| `simple` / `resolveWithFullResponse` | ✅ |
+| `gzip` / `encoding` (incl. `null` → Buffer) | ✅ |
+| `followRedirect` / `followAllRedirects` / `followOriginalHttpMethod` / `maxRedirects` | ✅ |
+| `timeout` / `time` (elapsedTime, timingPhases) | ✅ |
+| `strictSSL` / `rejectUnauthorized` / `ca` / `cert` / `key` / `pfx` / `passphrase` | ✅ |
+| `agent` / `agentOptions` / `forever` / `.forever()` | ✅ |
+| `jar` / `request.jar()` / `request.cookie()` (tough-cookie) | ✅ |
+| `transform` / `transform2xxOnly` | ✅ |
+| `localAddress` / `family` / `lookup` | ✅ |
+| `.defaults()` (chainable) | ✅ |
+| Callback style `(err, response, body)` alongside promises | ✅ |
+| Verb helpers `.get/.post/.put/.patch/.del/.delete/.head/.options` | ✅ |
+
+## GAPS / TODO
+
+These request features are **not implemented**. Passing them throws a clear `not implemented` error rather than silently misbehaving (except where noted). PRs welcome.
+
+| Option / feature | Status |
+|---|---|
+| Stream mode — `.pipe()`, `.on('response')`, `.on('data')` on the returned object | ❌ TODO — the returned object is a promise, not a duplex stream |
+| `.cancel()` on the returned promise | ❌ not present (matches request-promise-**native**, which also lacks it) |
+| `har` | ❌ throws |
+| `aws` (AWS signing) | ❌ throws |
+| `httpSignature` | ❌ throws |
+| `proxy` / `tunnel` | ❌ throws — use an `agent` (e.g. [hpagent](https://github.com/delvedor/hpagent)) instead |
+| `multipart` / `preambleCRLF` / `postambleCRLF` (raw multipart, not formData) | ❌ throws |
+| `jsonReviver` / `jsonReplacer` | ❌ throws |
+| `pool` | ❌ throws — use `agent` |
+| `removeRefererHeader` | ❌ throws |
+| `followRedirect` as a function | ❌ throws |
+| `request.debug` / `request.initParams` | ❌ not present |
+| TypeScript: `rp.delete(...)` | runtime works; types expose `.del` (`delete` is a reserved word in the type namespace) |
+
+## How it works
+
+A thin, clean-room translation layer:
+
+1. **Translate** request-promise-native options into got options (`translate.ts`)
+2. **Execute** via got with parity settings (`throwHttpErrors: false`, `retry: {limit: 0}`, `decompress` off unless `gzip: true`)
+3. **Shape** got's response back into request's response shape, or throw re-implemented `StatusCodeError` / `RequestError` / `TransformError`
+
+Dependencies: `got`, `qs`, `tough-cookie`, `form-data`. OAuth 1.0 signing and Digest auth are implemented natively with `node:crypto`. CI fails if any request-family package sneaks into the dependency tree.
+
+## License
+
+MIT — see [LICENSE](LICENSE)

package/dist/args.d.ts

@@ -0,0 +1,7 @@
+import type { Callback, RpOptions } from './rp-options';
+export interface NormalizedArgs {
+    options: RpOptions;
+    callback?: Callback;
+}
+export declare function normalizeArgs(a: unknown, b?: unknown, c?: unknown): NormalizedArgs;
+export declare function mergeDefaults(defaults: RpOptions | undefined, options: RpOptions): RpOptions;

package/dist/args.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeArgs = normalizeArgs;
+exports.mergeDefaults = mergeDefaults;
+function normalizeArgs(a, b, c) {
+    let options;
+    let callback;
+    if (typeof a === 'string' || a instanceof URL) {
+        options = typeof b === 'object' && b !== null ? { ...b } : {};
+        options.uri = String(a);
+        delete options.url;
+        if (typeof b === 'function')
+            callback = b;
+        else if (typeof c === 'function')
+            callback = c;
+    }
+    else if (typeof a === 'object' && a !== null) {
+        options = { ...a };
+        if (typeof b === 'function')
+            callback = b;
+    }
+    else {
+        throw new Error(`${String(a)} is not a valid uri or options object.`);
+    }
+    if (!callback && typeof options.callback === 'function')
+        callback = options.callback;
+    delete options.callback;
+    return { options, callback };
+}
+function mergeDefaults(defaults, options) {
+    if (!defaults)
+        return options;
+    const merged = { ...defaults, ...options };
+    if (defaults.headers || options.headers)
+        merged.headers = { ...defaults.headers, ...options.headers };
+    if (defaults.qs || options.qs)
+        merged.qs = { ...defaults.qs, ...options.qs };
+    return merged;
+}

package/dist/auth.d.ts

@@ -0,0 +1,3 @@
+import type { Prepared } from './translate';
+export declare function buildDigestHeader(authHeader: string, method: string, path: string, user: string, pass: string): string;
+export declare function answerAuthChallenge(challenge: unknown, prepared: Prepared): string | undefined;

package/dist/auth.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildDigestHeader = buildDigestHeader;
+exports.answerAuthChallenge = answerAuthChallenge;
+const node_crypto_1 = require("node:crypto");
+const md5 = (value) => (0, node_crypto_1.createHash)('md5').update(value).digest('hex');
+function parseChallenge(header) {
+    const values = {};
+    for (const match of header.matchAll(/([a-z0-9_-]+)=(?:"([^"]*)"|([^,\s]+))/gi)) {
+        values[match[1].toLowerCase()] = match[2] ?? match[3];
+    }
+    return values;
+}
+// Mirrors request's lib/auth.js digest implementation (RFC 2617/7616, qop="auth").
+function buildDigestHeader(authHeader, method, path, user, pass) {
+    const challenge = parseChallenge(authHeader);
+    const qop = /(^|,)\s*auth\s*($|,)/.test(challenge.qop ?? '') ? 'auth' : undefined;
+    const nc = qop ? '00000001' : undefined;
+    const cnonce = qop ? (0, node_crypto_1.randomBytes)(16).toString('hex') : undefined;
+    let ha1 = md5(`${user}:${challenge.realm}:${pass}`);
+    if (challenge.algorithm?.toLowerCase() === 'md5-sess') {
+        ha1 = md5(`${ha1}:${challenge.nonce}:${cnonce}`);
+    }
+    const ha2 = md5(`${method}:${path}`);
+    const digestResponse = qop
+        ? md5(`${ha1}:${challenge.nonce}:${nc}:${cnonce}:${qop}:${ha2}`)
+        : md5(`${ha1}:${challenge.nonce}:${ha2}`);
+    const authValues = {
+        username: user,
+        realm: challenge.realm,
+        nonce: challenge.nonce,
+        uri: path,
+        qop,
+        response: digestResponse,
+        nc,
+        cnonce,
+        algorithm: challenge.algorithm,
+        opaque: challenge.opaque
+    };
+    const parts = [];
+    for (const [key, value] of Object.entries(authValues)) {
+        if (value === undefined)
+            continue;
+        if (key === 'qop' || key === 'nc' || key === 'algorithm')
+            parts.push(`${key}=${value}`);
+        else
+            parts.push(`${key}="${value.replace(/"/g, '\\"')}"`);
+    }
+    return `Digest ${parts.join(', ')}`;
+}
+function answerAuthChallenge(challenge, prepared) {
+    const auth = prepared.deferredAuth;
+    if (!auth)
+        return undefined;
+    const header = Array.isArray(challenge) ? challenge[0] : challenge;
+    if (typeof header !== 'string' || header.length === 0)
+        return undefined;
+    const verb = header.split(' ')[0].toLowerCase();
+    const user = auth.user ?? auth.username ?? '';
+    const pass = auth.pass ?? auth.password ?? '';
+    if (verb === 'basic')
+        return `Basic ${Buffer.from(`${user}:${pass}`).toString('base64')}`;
+    if (verb === 'bearer' && auth.bearer !== undefined) {
+        const token = typeof auth.bearer === 'function' ? auth.bearer() : auth.bearer;
+        return `Bearer ${token}`;
+    }
+    if (verb === 'digest') {
+        const parsed = new URL(prepared.url);
+        return buildDigestHeader(header, prepared.method, `${parsed.pathname}${parsed.search}`, user, pass);
+    }
+    return undefined;
+}

package/dist/cookies.d.ts

@@ -0,0 +1,10 @@
+import { Cookie, CookieJar } from 'tough-cookie';
+export interface RequestJar {
+    _jar: CookieJar;
+    setCookie: (cookieOrString: Cookie | string, uri: string, options?: Record<string, unknown>) => Cookie | undefined;
+    getCookieString: (uri: string) => string;
+    getCookies: (uri: string) => Cookie[];
+}
+export declare function jar(): RequestJar;
+export declare function cookie(str: string): Cookie | undefined;
+export declare function resolveCookieJar(option: unknown): CookieJar | undefined;

package/dist/cookies.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jar = jar;
+exports.cookie = cookie;
+exports.resolveCookieJar = resolveCookieJar;
+const tough_cookie_1 = require("tough-cookie");
+function jar() {
+    const cookieJar = new tough_cookie_1.CookieJar(undefined, { looseMode: true });
+    return {
+        _jar: cookieJar,
+        setCookie: (cookieOrString, uri, options = {}) => cookieJar.setCookieSync(cookieOrString, uri, { ignoreError: true, ...options }),
+        getCookieString: (uri) => cookieJar.getCookieStringSync(uri),
+        getCookies: (uri) => cookieJar.getCookiesSync(uri)
+    };
+}
+function cookie(str) {
+    return tough_cookie_1.Cookie.parse(str, { loose: true });
+}
+let globalJar;
+function resolveCookieJar(option) {
+    if (option === undefined || option === null || option === false)
+        return undefined;
+    if (option === true) {
+        globalJar ??= jar();
+        return globalJar._jar;
+    }
+    const candidate = option;
+    if (candidate._jar instanceof tough_cookie_1.CookieJar)
+        return candidate._jar;
+    if (option instanceof tough_cookie_1.CookieJar)
+        return option;
+    return undefined;
+}

package/dist/core.d.ts

@@ -0,0 +1,7 @@
+import type { Callback, RpOptions } from './rp-options';
+export interface RequestPromiseLike<T = unknown> extends PromiseLike<T> {
+    catch: (onRejected?: (reason: unknown) => unknown) => Promise<unknown>;
+    finally: (onFinally?: () => void) => Promise<T>;
+    promise: () => Promise<T>;
+}
+export declare function doRequest(rpOptions: RpOptions, callback?: Callback): RequestPromiseLike;

package/dist/core.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doRequest = doRequest;
+const auth_1 = require("./auth");
+const errors_1 = require("./errors");
+const got_loader_1 = require("./got-loader");
+const response_1 = require("./response");
+const translate_1 = require("./translate");
+class RequestPromiseImpl {
+    settled;
+    constructor(settled) {
+        this.settled = settled;
+    }
+    then(onFulfilled, onRejected) {
+        return this.settled.then(onFulfilled, onRejected);
+    }
+    catch(onRejected) {
+        return this.settled.catch(onRejected);
+    }
+    finally(onFinally) {
+        return this.settled.finally(onFinally);
+    }
+    promise() {
+        return this.settled;
+    }
+}
+function toRequestError(err, prepared) {
+    if (err instanceof errors_1.RequestError)
+        return err;
+    const gotError = err;
+    if (gotError?.name === 'MaxRedirectsError') {
+        const href = gotError.response?.url ?? prepared.url;
+        return new errors_1.RequestError(new Error(`Exceeded maxRedirects. Probably stuck in a redirect loop ${href}`), prepared.rpOptions, undefined);
+    }
+    if (gotError?.name === 'TimeoutError') {
+        const connectPhase = ['lookup', 'connect', 'secureConnect'].includes(gotError.event ?? '');
+        const code = connectPhase ? 'ETIMEDOUT' : 'ESOCKETTIMEDOUT';
+        const cause = Object.assign(new Error(code), { code, ...(connectPhase ? { connect: true } : {}) });
+        return new errors_1.RequestError(cause, prepared.rpOptions, undefined);
+    }
+    const original = (gotError?.cause ?? gotError);
+    const cause = new Error(original?.message ?? String(err));
+    for (const field of ['code', 'errno', 'syscall', 'address', 'port', 'hostname']) {
+        if (original?.[field] !== undefined)
+            cause[field] = original[field];
+    }
+    return new errors_1.RequestError(cause, prepared.rpOptions, undefined);
+}
+async function gotCall(prepared, extraHeaders) {
+    const gotModule = await (0, got_loader_1.loadGot)();
+    const got = gotModule.default;
+    const options = extraHeaders
+        ? {
+            ...prepared.gotOptions,
+            headers: { ...prepared.gotOptions.headers, ...extraHeaders }
+        }
+        : prepared.gotOptions;
+    try {
+        return await got(prepared.url, options);
+    }
+    catch (err) {
+        throw toRequestError(err, prepared);
+    }
+}
+function decodeBody(rawBody, prepared) {
+    // request's empty-body rule: undefined in json mode, '' (or empty Buffer) otherwise
+    if (rawBody.length === 0) {
+        if (prepared.jsonMode)
+            return undefined;
+        return prepared.encoding === null ? rawBody : '';
+    }
+    if (prepared.encoding === null)
+        return rawBody;
+    const text = rawBody.toString((prepared.encoding ?? 'utf8'));
+    if (prepared.jsonMode && text.length > 0) {
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return text;
+        }
+    }
+    return text;
+}
+async function run(prepared, state) {
+    let gotResponse = await gotCall(prepared);
+    if (gotResponse.statusCode === 401 && prepared.deferredAuth) {
+        const challenge = gotResponse.headers['www-authenticate'];
+        const answer = (0, auth_1.answerAuthChallenge)(challenge, prepared);
+        if (answer) {
+            prepared.requestHeaders.authorization = answer;
+            gotResponse = await gotCall(prepared, { authorization: answer });
+        }
+    }
+    const body = decodeBody(gotResponse.rawBody ?? Buffer.alloc(0), prepared);
+    const full = (0, response_1.buildFullResponse)(gotResponse, prepared, body);
+    state.full = full;
+    const is2xx = /^2/.test(String(full.statusCode));
+    const shouldTransform = prepared.transform !== undefined && (is2xx || !prepared.transform2xxOnly);
+    const applyTransform = async () => {
+        try {
+            return await prepared.transform?.(body, full, prepared.resolveWithFullResponse);
+        }
+        catch (err) {
+            throw new errors_1.TransformError(err, prepared.rpOptions, full);
+        }
+    };
+    if (prepared.simple && !is2xx) {
+        const responseForError = shouldTransform ? await applyTransform() : full;
+        throw new errors_1.StatusCodeError(full.statusCode, body, prepared.rpOptions, responseForError);
+    }
+    if (shouldTransform)
+        return applyTransform();
+    return prepared.resolveWithFullResponse ? full : body;
+}
+function doRequest(rpOptions, callback) {
+    const state = {};
+    // request-promise-native surfaces validation errors as rejections, never sync throws
+    const settled = (async () => run((0, translate_1.prepare)(rpOptions), state))();
+    if (callback) {
+        settled.then(() => callback(null, state.full, state.full?.body), (err) => {
+            if (state.full && err instanceof errors_1.StatusCodeError) {
+                callback(null, state.full, state.full.body);
+            }
+            else {
+                callback(err?.cause ?? err, state.full, state.full?.body);
+            }
+        });
+        // callback consumers rarely touch the returned promise — keep its rejection handled
+        settled.catch(() => { });
+    }
+    return new RequestPromiseImpl(settled);
+}

package/dist/errors.d.ts

@@ -0,0 +1,24 @@
+export declare class StatusCodeError extends Error {
+    name: "StatusCodeError";
+    statusCode: number;
+    error: unknown;
+    options: unknown;
+    response: unknown;
+    constructor(statusCode: number, body: unknown, options?: unknown, response?: unknown);
+}
+export declare class RequestError extends Error {
+    name: "RequestError";
+    cause: unknown;
+    error: unknown;
+    options: unknown;
+    response: unknown;
+    constructor(cause: unknown, options?: unknown, response?: unknown);
+}
+export declare class TransformError extends Error {
+    name: "TransformError";
+    cause: unknown;
+    error: unknown;
+    options: unknown;
+    response: unknown;
+    constructor(cause: unknown, options?: unknown, response?: unknown);
+}

package/dist/errors.js

@@ -0,0 +1,52 @@
+"use strict";
+// Error classes matching request-promise-core's errors 1:1 (names, fields, message formats).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransformError = exports.RequestError = exports.StatusCodeError = void 0;
+class StatusCodeError extends Error {
+    name = 'StatusCodeError';
+    statusCode;
+    error;
+    options;
+    response;
+    constructor(statusCode, body, options, response) {
+        super(`${statusCode} - ${JSON.stringify(body)}`);
+        this.statusCode = statusCode;
+        this.error = body;
+        this.options = options;
+        this.response = response;
+        Error.captureStackTrace(this, StatusCodeError);
+    }
+}
+exports.StatusCodeError = StatusCodeError;
+class RequestError extends Error {
+    name = 'RequestError';
+    cause;
+    error;
+    options;
+    response;
+    constructor(cause, options, response) {
+        super(String(cause));
+        this.cause = cause;
+        this.error = cause;
+        this.options = options;
+        this.response = response;
+        Error.captureStackTrace(this, RequestError);
+    }
+}
+exports.RequestError = RequestError;
+class TransformError extends Error {
+    name = 'TransformError';
+    cause;
+    error;
+    options;
+    response;
+    constructor(cause, options, response) {
+        super(String(cause));
+        this.cause = cause;
+        this.error = cause;
+        this.options = options;
+        this.response = response;
+        Error.captureStackTrace(this, TransformError);
+    }
+}
+exports.TransformError = TransformError;

package/dist/got-loader.d.ts

@@ -0,0 +1,3 @@
+type GotModule = typeof import('got', { with: { 'resolution-mode': 'import' } });
+export declare function loadGot(): Promise<GotModule>;
+export {};

package/dist/got-loader.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadGot = loadGot;
+const node_module_1 = require("node:module");
+// Node >= 20.19 / >= 22.12 can require() ESM directly. process.getBuiltinModule
+// yields the genuine node:module even inside sandboxed test runners (e.g. Jest)
+// whose own require/createRequire reject ESM.
+const builtinModule = process.getBuiltinModule?.('node:module');
+const nativeRequire = (builtinModule?.createRequire ?? node_module_1.createRequire)(__filename);
+// Fallback for older Node: tsc (CJS output) would rewrite a plain `import()` into
+// `require()`, which cannot load ESM there — route through native import via new Function.
+const dynamicImport = new Function('specifier', 'return import(specifier)');
+let cached;
+function loadSync() {
+    try {
+        const mod = nativeRequire('got');
+        return mod?.default === undefined ? undefined : mod;
+    }
+    catch {
+        return undefined;
+    }
+}
+function loadGot() {
+    if (!cached) {
+        const sync = loadSync();
+        cached = sync ? Promise.resolve(sync) : dynamicImport('got');
+    }
+    return cached;
+}

package/dist/headers.d.ts

@@ -0,0 +1,7 @@
+export type Headers = Record<string, unknown>;
+export declare function findHeaderKey(headers: Headers, name: string): string | undefined;
+export declare function hasHeader(headers: Headers, name: string): boolean;
+export declare function getHeader(headers: Headers, name: string): unknown;
+export declare function setHeader(headers: Headers, name: string, value: unknown): void;
+export declare function setHeaderIfAbsent(headers: Headers, name: string, value: unknown): void;
+export declare function deleteHeader(headers: Headers, name: string): void;

package/dist/headers.js

@@ -0,0 +1,34 @@
+"use strict";
+// request treats header names case-insensitively (via caseless) while preserving
+// the caller's original casing on the wire and on response.request.headers.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findHeaderKey = findHeaderKey;
+exports.hasHeader = hasHeader;
+exports.getHeader = getHeader;
+exports.setHeader = setHeader;
+exports.setHeaderIfAbsent = setHeaderIfAbsent;
+exports.deleteHeader = deleteHeader;
+function findHeaderKey(headers, name) {
+    const lower = name.toLowerCase();
+    return Object.keys(headers).find((key) => key.toLowerCase() === lower);
+}
+function hasHeader(headers, name) {
+    return findHeaderKey(headers, name) !== undefined;
+}
+function getHeader(headers, name) {
+    const key = findHeaderKey(headers, name);
+    return key === undefined ? undefined : headers[key];
+}
+function setHeader(headers, name, value) {
+    const key = findHeaderKey(headers, name) ?? name;
+    headers[key] = value;
+}
+function setHeaderIfAbsent(headers, name, value) {
+    if (!hasHeader(headers, name))
+        headers[name] = value;
+}
+function deleteHeader(headers, name) {
+    const key = findHeaderKey(headers, name);
+    if (key !== undefined)
+        delete headers[key];
+}