@depup/got 14.6.6-depup.1

package/README.md

@@ -0,0 +1,36 @@
+# @depup/got
+
+> Dependency-bumped version of [got](https://www.npmjs.com/package/got)
+
+Generated by [DepUp](https://github.com/depup/npm) -- all production
+dependencies bumped to latest versions.
+
+## Installation
+
+```bash
+npm install @depup/got
+```
+
+| Field | Value |
+|-------|-------|
+| Original | [got](https://www.npmjs.com/package/got) @ 14.6.6 |
+| Processed | 2026-03-19 |
+| Smoke test | passed |
+| Deps updated | 6 |
+
+## Dependency Changes
+
+| Dependency | From | To |
+|------------|------|-----|
+| @sindresorhus/is | ^7.0.1 | ^7.2.0 |
+| cacheable-request | ^13.0.12 | ^13.0.18 |
+| form-data-encoder | ^4.0.2 | ^4.1.0 |
+| keyv | ^5.5.3 | ^5.6.0 |
+| lowercase-keys | ^3.0.0 | ^4.0.1 |
+| type-fest | ^4.26.1 | ^5.5.0 |
+
+---
+
+Source: https://github.com/depup/npm | Original: https://www.npmjs.com/package/got
+
+License inherited from the original package.

package/changes.json

@@ -0,0 +1,30 @@
+{
+  "bumped": {
+    "@sindresorhus/is": {
+      "from": "^7.0.1",
+      "to": "^7.2.0"
+    },
+    "cacheable-request": {
+      "from": "^13.0.12",
+      "to": "^13.0.18"
+    },
+    "form-data-encoder": {
+      "from": "^4.0.2",
+      "to": "^4.1.0"
+    },
+    "keyv": {
+      "from": "^5.5.3",
+      "to": "^5.6.0"
+    },
+    "lowercase-keys": {
+      "from": "^3.0.0",
+      "to": "^4.0.1"
+    },
+    "type-fest": {
+      "from": "^4.26.1",
+      "to": "^5.5.0"
+    }
+  },
+  "timestamp": "2026-03-19T08:19:48.316Z",
+  "totalUpdated": 6
+}

package/dist/source/as-promise/index.d.ts

@@ -0,0 +1,3 @@
+import Request from '../core/index.js';
+import { type CancelableRequest } from './types.js';
+export default function asPromise<T>(firstRequest?: Request): CancelableRequest<T>;

package/dist/source/as-promise/index.js

@@ -0,0 +1,204 @@
+import { EventEmitter } from 'node:events';
+import is from '@sindresorhus/is';
+import PCancelable from 'p-cancelable';
+import { HTTPError, RetryError, } from '../core/errors.js';
+import Request from '../core/index.js';
+import { parseBody, isResponseOk, ParseError, } from '../core/response.js';
+import proxyEvents from '../core/utils/proxy-events.js';
+import { CancelError } from './types.js';
+const proxiedRequestEvents = [
+    'request',
+    'response',
+    'redirect',
+    'uploadProgress',
+    'downloadProgress',
+];
+export default function asPromise(firstRequest) {
+    let globalRequest;
+    let globalResponse;
+    let normalizedOptions;
+    const emitter = new EventEmitter();
+    let promiseSettled = false;
+    const promise = new PCancelable((resolve, reject, onCancel) => {
+        onCancel(() => {
+            globalRequest.destroy();
+        });
+        onCancel.shouldReject = false;
+        onCancel(() => {
+            promiseSettled = true;
+            reject(new CancelError(globalRequest));
+        });
+        const makeRequest = (retryCount) => {
+            // Errors when a new request is made after the promise settles.
+            // Used to detect a race condition.
+            // See https://github.com/sindresorhus/got/issues/1489
+            onCancel(() => { });
+            const request = firstRequest ?? new Request(undefined, undefined, normalizedOptions);
+            request.retryCount = retryCount;
+            request._noPipe = true;
+            globalRequest = request;
+            request.once('response', async (response) => {
+                // Parse body
+                const contentEncoding = (response.headers['content-encoding'] ?? '').toLowerCase();
+                const isCompressed = contentEncoding === 'gzip' || contentEncoding === 'deflate' || contentEncoding === 'br' || contentEncoding === 'zstd';
+                const { options } = request;
+                if (isCompressed && !options.decompress) {
+                    response.body = response.rawBody;
+                }
+                else {
+                    try {
+                        response.body = parseBody(response, options.responseType, options.parseJson, options.encoding);
+                    }
+                    catch (error) {
+                        // Fall back to `utf8`
+                        try {
+                            response.body = response.rawBody.toString();
+                        }
+                        catch (error) {
+                            request._beforeError(new ParseError(error, response));
+                            return;
+                        }
+                        if (isResponseOk(response)) {
+                            request._beforeError(error);
+                            return;
+                        }
+                    }
+                }
+                try {
+                    const hooks = options.hooks.afterResponse;
+                    for (const [index, hook] of hooks.entries()) {
+                        // @ts-expect-error TS doesn't notice that CancelableRequest is a Promise
+                        // eslint-disable-next-line no-await-in-loop
+                        response = await hook(response, async (updatedOptions) => {
+                            const preserveHooks = updatedOptions.preserveHooks ?? false;
+                            options.merge(updatedOptions);
+                            options.prefixUrl = '';
+                            if (updatedOptions.url) {
+                                options.url = updatedOptions.url;
+                            }
+                            // Remove any further hooks for that request, because we'll call them anyway.
+                            // The loop continues. We don't want duplicates (asPromise recursion).
+                            // Unless preserveHooks is true, in which case we keep the remaining hooks.
+                            if (!preserveHooks) {
+                                options.hooks.afterResponse = options.hooks.afterResponse.slice(0, index);
+                            }
+                            throw new RetryError(request);
+                        });
+                        if (!(is.object(response) && is.number(response.statusCode) && 'body' in response)) {
+                            throw new TypeError('The `afterResponse` hook returned an invalid value');
+                        }
+                    }
+                }
+                catch (error) {
+                    request._beforeError(error);
+                    return;
+                }
+                globalResponse = response;
+                if (!isResponseOk(response)) {
+                    request._beforeError(new HTTPError(response));
+                    return;
+                }
+                request.destroy();
+                promiseSettled = true;
+                resolve(request.options.resolveBodyOnly ? response.body : response);
+            });
+            let handledFinalError = false;
+            const onError = (error) => {
+                if (promise.isCanceled) {
+                    return;
+                }
+                // Route errors emitted directly on the stream (e.g., EPIPE from Node.js)
+                // through retry logic first, then handle them here after retries are exhausted.
+                // See https://github.com/sindresorhus/got/issues/1995
+                if (!request._stopReading) {
+                    request._beforeError(error);
+                    return;
+                }
+                // Allow the manual re-emission from Request to land only once.
+                if (handledFinalError) {
+                    return;
+                }
+                handledFinalError = true;
+                promiseSettled = true;
+                const { options } = request;
+                if (error instanceof HTTPError && !options.throwHttpErrors) {
+                    const { response } = error;
+                    request.destroy();
+                    resolve(request.options.resolveBodyOnly ? response.body : response);
+                    return;
+                }
+                reject(error);
+            };
+            // Use .on() instead of .once() to keep the listener active across retries.
+            // When _stopReading is false, we return early and the error gets re-emitted
+            // after retry logic completes, so we need this listener to remain active.
+            // See https://github.com/sindresorhus/got/issues/1995
+            request.on('error', onError);
+            const previousBody = request.options?.body;
+            request.once('retry', (newRetryCount, error) => {
+                firstRequest = undefined;
+                // If promise already settled, don't retry
+                // This prevents the race condition in #1489 where a late error
+                // (e.g., ECONNRESET after successful response) triggers retry
+                // after the promise has already resolved/rejected
+                if (promiseSettled) {
+                    return;
+                }
+                const newBody = request.options.body;
+                if (previousBody === newBody && is.nodeStream(newBody)) {
+                    error.message = 'Cannot retry with consumed body stream';
+                    onError(error);
+                    return;
+                }
+                // This is needed! We need to reuse `request.options` because they can get modified!
+                // For example, by calling `promise.json()`.
+                normalizedOptions = request.options;
+                makeRequest(newRetryCount);
+            });
+            proxyEvents(request, emitter, proxiedRequestEvents);
+            if (is.undefined(firstRequest)) {
+                void request.flush();
+            }
+        };
+        makeRequest(0);
+    });
+    promise.on = (event, function_) => {
+        emitter.on(event, function_);
+        return promise;
+    };
+    promise.off = (event, function_) => {
+        emitter.off(event, function_);
+        return promise;
+    };
+    const shortcut = (promiseToAwait, responseType) => {
+        const newPromise = (async () => {
+            // Wait until downloading has ended
+            await promiseToAwait;
+            const { options } = globalResponse.request;
+            return parseBody(globalResponse, responseType, options.parseJson, options.encoding);
+        })();
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        Object.defineProperties(newPromise, Object.getOwnPropertyDescriptors(promiseToAwait));
+        return newPromise;
+    };
+    // Note: These use `function` syntax (not arrows) to access `this` context.
+    // When custom handlers wrap the promise to transform errors, these methods
+    // are copied to the handler's promise. Using `this` ensures we await the
+    // handler's wrapped promise, not the original, so errors propagate correctly.
+    promise.json = function () {
+        if (globalRequest.options) {
+            const { headers } = globalRequest.options;
+            if (!globalRequest.writableFinished && !('accept' in headers)) {
+                headers.accept = 'application/json';
+            }
+        }
+        return shortcut(this, 'json');
+    };
+    promise.buffer = function () {
+        return shortcut(this, 'buffer');
+    };
+    promise.text = function () {
+        return shortcut(this, 'text');
+    };
+    return promise;
+}

package/dist/source/as-promise/types.d.ts

@@ -0,0 +1,37 @@
+import type { Buffer } from 'node:buffer';
+import type PCancelable from 'p-cancelable';
+import { RequestError } from '../core/errors.js';
+import type Request from '../core/index.js';
+import { type RequestEvents } from '../core/index.js';
+import type { Response } from '../core/response.js';
+/**
+An error to be thrown when the request is aborted with `.cancel()`.
+*/
+export declare class CancelError extends RequestError {
+    readonly response: Response;
+    constructor(request: Request);
+    /**
+    Whether the promise is canceled.
+    */
+    get isCanceled(): boolean;
+}
+export interface CancelableRequest<T extends Response | Response['body'] = Response['body']> extends PCancelable<T>, RequestEvents<CancelableRequest<T>> {
+    /**
+    A shortcut method that gives a Promise returning a JSON object.
+
+    It is semantically the same as settings `options.resolveBodyOnly` to `true` and `options.responseType` to `'json'`.
+    */
+    json: <ReturnType>() => CancelableRequest<ReturnType>;
+    /**
+    A shortcut method that gives a Promise returning a [Buffer](https://nodejs.org/api/buffer.html).
+
+    It is semantically the same as settings `options.resolveBodyOnly` to `true` and `options.responseType` to `'buffer'`.
+    */
+    buffer: () => CancelableRequest<Buffer>;
+    /**
+    A shortcut method that gives a Promise returning a string.
+
+    It is semantically the same as settings `options.resolveBodyOnly` to `true` and `options.responseType` to `'text'`.
+    */
+    text: () => CancelableRequest<string>;
+}

package/dist/source/as-promise/types.js

@@ -0,0 +1,17 @@
+import { RequestError } from '../core/errors.js';
+/**
+An error to be thrown when the request is aborted with `.cancel()`.
+*/
+export class CancelError extends RequestError {
+    constructor(request) {
+        super('Promise was canceled', {}, request);
+        this.name = 'CancelError';
+        this.code = 'ERR_CANCELED';
+    }
+    /**
+    Whether the promise is canceled.
+    */
+    get isCanceled() {
+        return true;
+    }
+}

package/dist/source/core/calculate-retry-delay.d.ts

@@ -0,0 +1,4 @@
+import type { RetryFunction } from './options.js';
+type Returns<T extends (...arguments_: any) => unknown, V> = (...arguments_: Parameters<T>) => V;
+declare const calculateRetryDelay: Returns<RetryFunction, number>;
+export default calculateRetryDelay;

package/dist/source/core/calculate-retry-delay.js

@@ -0,0 +1,29 @@
+const calculateRetryDelay = ({ attemptCount, retryOptions, error, retryAfter, computedValue, }) => {
+    if (error.name === 'RetryError') {
+        return 1;
+    }
+    if (attemptCount > retryOptions.limit) {
+        return 0;
+    }
+    const hasMethod = retryOptions.methods.includes(error.options.method);
+    const hasErrorCode = retryOptions.errorCodes.includes(error.code);
+    const hasStatusCode = error.response && retryOptions.statusCodes.includes(error.response.statusCode);
+    if (!hasMethod || (!hasErrorCode && !hasStatusCode)) {
+        return 0;
+    }
+    if (error.response) {
+        if (retryAfter) {
+            // In this case `computedValue` is `options.request.timeout`
+            if (retryAfter > computedValue) {
+                return 0;
+            }
+            return retryAfter;
+        }
+        if (error.response.statusCode === 413) {
+            return 0;
+        }
+    }
+    const noise = Math.random() * retryOptions.noise;
+    return Math.min(((2 ** (attemptCount - 1)) * 1000), retryOptions.backoffLimit) + noise;
+};
+export default calculateRetryDelay;

package/dist/source/core/diagnostics-channel.d.ts

@@ -0,0 +1,89 @@
+import type { Timings } from './utils/timer.js';
+import type { RequestError } from './errors.js';
+export type RequestId = string;
+/**
+Message for the `got:request:create` diagnostic channel.
+
+Emitted when a request is created.
+*/
+export type DiagnosticRequestCreate = {
+    requestId: RequestId;
+    url: string;
+    method: string;
+};
+/**
+Message for the `got:request:start` diagnostic channel.
+
+Emitted before the native HTTP request is sent.
+*/
+export type DiagnosticRequestStart = {
+    requestId: RequestId;
+    url: string;
+    method: string;
+    headers: Record<string, string | string[] | undefined>;
+};
+/**
+Message for the `got:response:start` diagnostic channel.
+
+Emitted when response headers are received.
+*/
+export type DiagnosticResponseStart = {
+    requestId: RequestId;
+    url: string;
+    statusCode: number;
+    headers: Record<string, string | string[] | undefined>;
+    isFromCache: boolean;
+};
+/**
+Message for the `got:response:end` diagnostic channel.
+
+Emitted when the response completes.
+*/
+export type DiagnosticResponseEnd = {
+    requestId: RequestId;
+    url: string;
+    statusCode: number;
+    bodySize?: number;
+    timings?: Timings;
+};
+/**
+Message for the `got:request:retry` diagnostic channel.
+
+Emitted when retrying a request.
+*/
+export type DiagnosticRequestRetry = {
+    requestId: RequestId;
+    retryCount: number;
+    error: RequestError;
+    delay: number;
+};
+/**
+Message for the `got:request:error` diagnostic channel.
+
+Emitted when a request fails.
+*/
+export type DiagnosticRequestError = {
+    requestId: RequestId;
+    url: string;
+    error: RequestError;
+    timings?: Timings;
+};
+/**
+Message for the `got:response:redirect` diagnostic channel.
+
+Emitted when following a redirect.
+*/
+export type DiagnosticResponseRedirect = {
+    requestId: RequestId;
+    fromUrl: string;
+    toUrl: string;
+    statusCode: number;
+};
+export declare function generateRequestId(): RequestId;
+export declare function publishRequestCreate(message: DiagnosticRequestCreate): void;
+export declare function publishRequestStart(message: DiagnosticRequestStart): void;
+export declare function publishResponseStart(message: DiagnosticResponseStart): void;
+export declare function publishResponseEnd(message: DiagnosticResponseEnd): void;
+export declare function publishRetry(message: DiagnosticRequestRetry): void;
+export declare function publishError(message: DiagnosticRequestError): void;
+export declare function publishRedirect(message: DiagnosticResponseRedirect): void;

package/dist/source/core/diagnostics-channel.js

@@ -0,0 +1,49 @@
+import { randomUUID } from 'node:crypto';
+import diagnosticsChannel from 'node:diagnostics_channel';
+const channels = {
+    requestCreate: diagnosticsChannel.channel('got:request:create'),
+    requestStart: diagnosticsChannel.channel('got:request:start'),
+    responseStart: diagnosticsChannel.channel('got:response:start'),
+    responseEnd: diagnosticsChannel.channel('got:response:end'),
+    retry: diagnosticsChannel.channel('got:request:retry'),
+    error: diagnosticsChannel.channel('got:request:error'),
+    redirect: diagnosticsChannel.channel('got:response:redirect'),
+};
+export function generateRequestId() {
+    return randomUUID();
+}
+export function publishRequestCreate(message) {
+    if (channels.requestCreate.hasSubscribers) {
+        channels.requestCreate.publish(message);
+    }
+}
+export function publishRequestStart(message) {
+    if (channels.requestStart.hasSubscribers) {
+        channels.requestStart.publish(message);
+    }
+}
+export function publishResponseStart(message) {
+    if (channels.responseStart.hasSubscribers) {
+        channels.responseStart.publish(message);
+    }
+}
+export function publishResponseEnd(message) {
+    if (channels.responseEnd.hasSubscribers) {
+        channels.responseEnd.publish(message);
+    }
+}
+export function publishRetry(message) {
+    if (channels.retry.hasSubscribers) {
+        channels.retry.publish(message);
+    }
+}
+export function publishError(message) {
+    if (channels.error.hasSubscribers) {
+        channels.error.publish(message);
+    }
+}
+export function publishRedirect(message) {
+    if (channels.redirect.hasSubscribers) {
+        channels.redirect.publish(message);
+    }
+}

package/dist/source/core/errors.d.ts

@@ -0,0 +1,102 @@
+import type { Timings } from './utils/timer.js';
+import type Options from './options.js';
+import type { TimeoutError as TimedOutTimeoutError } from './timed-out.js';
+import type { PlainResponse, Response } from './response.js';
+import type Request from './index.js';
+type Error = NodeJS.ErrnoException;
+/**
+An error to be thrown when a request fails.
+Contains a `code` property with error class code, like `ECONNREFUSED`.
+*/
+export declare class RequestError<T = unknown> extends Error {
+    name: string;
+    code: string;
+    input?: string;
+    stack: string;
+    readonly options: Options;
+    readonly response?: Response<T>;
+    readonly request?: Request;
+    readonly timings?: Timings;
+    constructor(message: string, error: Partial<Error & {
+        code?: string;
+    }>, self: Request | Options);
+}
+/**
+An error to be thrown when the server redirects you more than ten times.
+Includes a `response` property.
+*/
+export declare class MaxRedirectsError extends RequestError {
+    name: string;
+    code: string;
+    readonly response: Response;
+    readonly request: Request;
+    readonly timings: Timings;
+    constructor(request: Request);
+}
+/**
+An error to be thrown when the server response code is not 2xx nor 3xx if `options.followRedirect` is `true`, but always except for 304.
+Includes a `response` property.
+*/
+export declare class HTTPError<T = any> extends RequestError<T> {
+    name: string;
+    code: string;
+    readonly response: Response<T>;
+    readonly request: Request;
+    readonly timings: Timings;
+    constructor(response: PlainResponse);
+}
+/**
+An error to be thrown when a cache method fails.
+For example, if the database goes down or there's a filesystem error.
+*/
+export declare class CacheError extends RequestError {
+    name: string;
+    readonly request: Request;
+    constructor(error: Error, request: Request);
+}
+/**
+An error to be thrown when the request body is a stream and an error occurs while reading from that stream.
+*/
+export declare class UploadError extends RequestError {
+    name: string;
+    readonly request: Request;
+    constructor(error: Error, request: Request);
+}
+/**
+An error to be thrown when the request is aborted due to a timeout.
+Includes an `event` and `timings` property.
+*/
+export declare class TimeoutError extends RequestError {
+    name: string;
+    readonly request: Request;
+    readonly timings: Timings;
+    readonly event: string;
+    constructor(error: TimedOutTimeoutError, timings: Timings, request: Request);
+}
+/**
+An error to be thrown when reading from response stream fails.
+*/
+export declare class ReadError extends RequestError {
+    name: string;
+    readonly request: Request;
+    readonly response: Response;
+    readonly timings: Timings;
+    constructor(error: Error, request: Request);
+}
+/**
+An error which always triggers a new retry when thrown.
+*/
+export declare class RetryError extends RequestError {
+    name: string;
+    code: string;
+    constructor(request: Request);
+}
+/**
+An error to be thrown when the request is aborted by AbortController.
+*/
+export declare class AbortError extends RequestError {
+    name: string;
+    code: string;
+    constructor(request: Request);
+}
+export {};