dep 1.0.0 → 1.1.0

package/node_modules/ky/distribution/types/ResponsePromise.d.ts

@@ -1,40 +0,0 @@
-/**
-Returns a `Response` object with `Body` methods added for convenience. So you can, for example, call `ky.get(input).json()` directly without having to await the `Response` first. When called like that, an appropriate `Accept` header will be set depending on the body method used. Unlike the `Body` methods of `window.Fetch`; these will throw an `HTTPError` if the response status is not in the range of `200...299`. Also, `.json()` will return an empty string if body is empty or the response status is `204` instead of throwing a parse error due to an empty body.
-*/
-import { type KyResponse } from './response.js';
-export type ResponsePromise<T = unknown> = {
-    arrayBuffer: () => Promise<ArrayBuffer>;
-    blob: () => Promise<Blob>;
-    formData: () => Promise<FormData>;
-    /**
-    Get the response body as raw bytes.
-
-    Note: This shortcut is only available when the runtime supports `Response.prototype.bytes()`.
-    */
-    bytes: () => Promise<Uint8Array>;
-    /**
-    Get the response body as JSON.
-
-    @example
-    ```
-    import ky from 'ky';
-
-    const json = await ky(…).json();
-    ```
-
-    @example
-    ```
-    import ky from 'ky';
-
-    interface Result {
-        value: number;
-    }
-
-    const result1 = await ky(…).json<Result>();
-    // or
-    const result2 = await ky<Result>(…).json();
-    ```
-    */
-    json: <J = T>() => Promise<J>;
-    text: () => Promise<string>;
-} & Promise<KyResponse<T>>;

package/node_modules/ky/distribution/types/ResponsePromise.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=ResponsePromise.js.map

package/node_modules/ky/distribution/types/ResponsePromise.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ResponsePromise.js","sourceRoot":"","sources":["../../source/types/ResponsePromise.ts"],"names":[],"mappings":"","sourcesContent":["/**\nReturns a `Response` object with `Body` methods added for convenience. So you can, for example, call `ky.get(input).json()` directly without having to await the `Response` first. When called like that, an appropriate `Accept` header will be set depending on the body method used. Unlike the `Body` methods of `window.Fetch`; these will throw an `HTTPError` if the response status is not in the range of `200...299`. Also, `.json()` will return an empty string if body is empty or the response status is `204` instead of throwing a parse error due to an empty body.\n*/\nimport {type KyResponse} from './response.js';\n\nexport type ResponsePromise<T = unknown> = {\n\tarrayBuffer: () => Promise<ArrayBuffer>;\n\n\tblob: () => Promise<Blob>;\n\n\tformData: () => Promise<FormData>;\n\n\t/**\n\tGet the response body as raw bytes.\n\n\tNote: This shortcut is only available when the runtime supports `Response.prototype.bytes()`.\n\t*/\n\tbytes: () => Promise<Uint8Array>;\n\n\t// TODO: Use `json<T extends JSONValue>(): Promise<T>;` when it's fixed in TS.\n\t// See https://github.com/microsoft/TypeScript/issues/15300 and https://github.com/sindresorhus/ky/pull/80\n\t/**\n\tGet the response body as JSON.\n\n\t@example\n\t```\n\timport ky from 'ky';\n\n\tconst json = await ky(…).json();\n\t```\n\n\t@example\n\t```\n\timport ky from 'ky';\n\n\tinterface Result {\n\t\tvalue: number;\n\t}\n\n\tconst result1 = await ky(…).json<Result>();\n\t// or\n\tconst result2 = await ky<Result>(…).json();\n\t```\n\t*/\n\tjson: <J = T>() => Promise<J>;\n\n\ttext: () => Promise<string>;\n} & Promise<KyResponse<T>>;\n"]}

package/node_modules/ky/distribution/types/common.d.ts

@@ -1,7 +0,0 @@
-export type Primitive = null | undefined | string | number | boolean | symbol | bigint;
-export type Required<T, K extends keyof T = keyof T> = T & {
-    [P in K]-?: T[P];
-};
-export type LiteralUnion<LiteralType extends BaseType, BaseType extends Primitive> = LiteralType | (BaseType & {
-    _?: never;
-});

package/node_modules/ky/distribution/types/common.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=common.js.map

package/node_modules/ky/distribution/types/common.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"common.js","sourceRoot":"","sources":["../../source/types/common.ts"],"names":[],"mappings":"","sourcesContent":["// eslint-disable-next-line @typescript-eslint/ban-types\nexport type Primitive = null | undefined | string | number | boolean | symbol | bigint;\n\nexport type Required<T, K extends keyof T = keyof T> = T & {[P in K]-?: T[P]};\n\nexport type LiteralUnion<LiteralType extends BaseType, BaseType extends Primitive> =\n\t| LiteralType\n\t| (BaseType & {_?: never});\n"]}

package/node_modules/ky/distribution/types/hooks.d.ts

@@ -1,247 +0,0 @@
-import { type stop, type RetryMarker } from '../core/constants.js';
-import type { KyRequest, KyResponse, HTTPError } from '../index.js';
-import type { NormalizedOptions } from './options.js';
-export type BeforeRequestState = {
-    /**
-    The number of retries attempted. `0` for the initial request, increments with each retry.
-
-    This allows you to distinguish between initial requests and retries, which is useful when you need different behavior for retries (e.g., avoiding overwriting headers set in `beforeRetry`).
-    */
-    retryCount: number;
-};
-export type BeforeRequestHook = (request: KyRequest, options: NormalizedOptions, state: BeforeRequestState) => Request | Response | void | Promise<Request | Response | void>;
-export type BeforeRetryState = {
-    request: KyRequest;
-    options: NormalizedOptions;
-    error: Error;
-    /**
-    The number of retries attempted. Always `>= 1` since this hook is only called during retries, not on the initial request.
-    */
-    retryCount: number;
-};
-export type BeforeRetryHook = (options: BeforeRetryState) => Request | Response | typeof stop | void | Promise<Request | Response | typeof stop | void>;
-export type AfterResponseState = {
-    /**
-    The number of retries attempted. `0` for the initial request, increments with each retry.
-
-    This allows you to distinguish between initial requests and retries, which is useful when you need different behavior for retries (e.g., showing a notification only on the final retry).
-    */
-    retryCount: number;
-};
-export type AfterResponseHook = (request: KyRequest, options: NormalizedOptions, response: KyResponse, state: AfterResponseState) => Response | RetryMarker | void | Promise<Response | RetryMarker | void>;
-export type BeforeErrorState = {
-    /**
-    The number of retries attempted. `0` for the initial request, increments with each retry.
-
-    This allows you to distinguish between the initial request and retries, which is useful when you need different error handling based on retry attempts (e.g., showing different error messages on the final attempt).
-    */
-    retryCount: number;
-};
-export type BeforeErrorHook = (error: HTTPError, state: BeforeErrorState) => HTTPError | Promise<HTTPError>;
-export type Hooks = {
-    /**
-    This hook enables you to modify the request right before it is sent. Ky will make no further changes to the request after this. The hook function receives the normalized request, options, and a state object. You could, for example, modify `request.headers` here.
-
-    The `state.retryCount` is `0` for the initial request and increments with each retry. This allows you to distinguish between initial requests and retries, which is useful when you need different behavior for retries (e.g., avoiding overwriting headers set in `beforeRetry`).
-
-    A [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response) can be returned from this hook to completely avoid making an HTTP request. This can be used to mock a request, check an internal cache, etc. An **important** consideration when returning a `Response` from this hook is that all the following hooks will be skipped, so **ensure you only return a `Response` from the last hook**.
-
-    @example
-    ```
-    import ky from 'ky';
-
-    const response = await ky('https://example.com', {
-        hooks: {
-            beforeRequest: [
-                (request, options, {retryCount}) => {
-                    // Only set default auth header on initial request, not on retries
-                    // (retries may have refreshed token set by beforeRetry)
-                    if (retryCount === 0) {
-                        request.headers.set('Authorization', 'token initial-token');
-                    }
-                }
-            ]
-        }
-    });
-    ```
-
-    @default []
-    */
-    beforeRequest?: BeforeRequestHook[];
-    /**
-    This hook enables you to modify the request right before retry. Ky will make no further changes to the request after this. The hook function receives an object with the normalized request and options, an error instance, and the retry count. You could, for example, modify `request.headers` here.
-
-    The hook can return a [`Request`](https://developer.mozilla.org/en-US/docs/Web/API/Request) to replace the outgoing retry request, or return a [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response) to skip the retry and use that response instead. **Note:** Returning a request or response skips remaining `beforeRetry` hooks.
-
-    If the request received a response, the error will be of type `HTTPError` and the `Response` object will be available at `error.response`. Be aware that some types of errors, such as network errors, inherently mean that a response was not received. In that case, the error will not be an instance of `HTTPError`.
-
-    You can prevent Ky from retrying the request by throwing an error. Ky will not handle it in any way and the error will be propagated to the request initiator. The rest of the `beforeRetry` hooks will not be called in this case. Alternatively, you can return the [`ky.stop`](#ky.stop) symbol to do the same thing but without propagating an error (this has some limitations, see `ky.stop` docs for details).
-
-    **Modifying headers:**
-
-    @example
-    ```
-    import ky from 'ky';
-
-    const response = await ky('https://example.com', {
-        hooks: {
-            beforeRetry: [
-                async ({request, options, error, retryCount}) => {
-                    const token = await ky('https://example.com/refresh-token');
-                    request.headers.set('Authorization', `token ${token}`);
-                }
-            ]
-        }
-    });
-    ```
-
-    **Modifying the request URL:**
-
-    @example
-    ```
-    import ky from 'ky';
-
-    const response = await ky('https://example.com/api', {
-        hooks: {
-            beforeRetry: [
-                async ({request, error}) => {
-                    // Add query parameters based on error response
-                    if (error.response) {
-                        const body = await error.response.json();
-                        const url = new URL(request.url);
-                        url.searchParams.set('processId', body.processId);
-                        return new Request(url, request);
-                    }
-                }
-            ]
-        }
-    });
-    ```
-
-    **Returning a cached response:**
-
-    @example
-    ```
-    import ky from 'ky';
-
-    const response = await ky('https://example.com/api', {
-        hooks: {
-            beforeRetry: [
-                ({error, retryCount}) => {
-                    // Use cached response instead of retrying
-                    if (retryCount > 1 && cachedResponse) {
-                        return cachedResponse;
-                    }
-                }
-            ]
-        }
-    });
-    ```
-
-    @default []
-    */
-    beforeRetry?: BeforeRetryHook[];
-    /**
-    This hook enables you to read and optionally modify the response. The hook function receives normalized request, options, a clone of the response, and a state object. The return value of the hook function will be used by Ky as the response object if it's an instance of [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response).
-
-    You can also force a retry by returning `ky.retry()` or `ky.retry(options)`. This is useful when you need to retry based on the response body content, even if the response has a successful status code. The retry will respect the retry limit and be observable in `beforeRetry` hooks.
-
-    @default []
-
-    @example
-    ```
-    import ky from 'ky';
-
-    const response = await ky('https://example.com', {
-        hooks: {
-            afterResponse: [
-                (_request, _options, response) => {
-                    // You could do something with the response, for example, logging.
-                    log(response);
-
-                    // Or return a `Response` instance to overwrite the response.
-                    return new Response('A different response', {status: 200});
-                },
-
-                // Or retry with a fresh token on a 401 error
-                async (request, _options, response, state) => {
-                    if (response.status === 401 && state.retryCount === 0) {
-                        // Only refresh on first 401, not on subsequent retries
-                        const {token} = await ky.post('https://example.com/auth/refresh').json();
-
-                        const headers = new Headers(request.headers);
-                        headers.set('Authorization', `Bearer ${token}`);
-
-                        return ky.retry({
-                            request: new Request(request, {headers}),
-                            code: 'TOKEN_REFRESHED'
-                        });
-                    }
-                },
-
-                // Or force retry based on response body content
-                async (request, options, response) => {
-                    if (response.status === 200) {
-                        const data = await response.clone().json();
-                        if (data.error?.code === 'RATE_LIMIT') {
-                            // Force retry with custom delay from API response
-                            return ky.retry({
-                                delay: data.error.retryAfter * 1000,
-                                code: 'RATE_LIMIT'
-                            });
-                        }
-                    }
-                },
-
-                // Or show a notification only on the last retry for 5xx errors
-                (request, options, response, {retryCount}) => {
-                    if (response.status >= 500 && response.status <= 599) {
-                        if (retryCount === options.retry.limit) {
-                            showNotification('Request failed after all retries');
-                        }
-                    }
-                }
-            ]
-        }
-    });
-    ```
-    */
-    afterResponse?: AfterResponseHook[];
-    /**
-    This hook enables you to modify the `HTTPError` right before it is thrown. The hook function receives an `HTTPError` and a state object as arguments and should return an instance of `HTTPError`.
-
-    @default []
-
-    @example
-    ```
-    import ky from 'ky';
-
-    await ky('https://example.com', {
-        hooks: {
-            beforeError: [
-                async error => {
-                    const {response} = error;
-                    if (response) {
-                        const body = await response.json();
-                        error.name = 'GitHubError';
-                        error.message = `${body.message} (${response.status})`;
-                    }
-
-                    return error;
-                },
-
-                // Or show different message based on retry count
-                (error, {retryCount}) => {
-                    if (retryCount === error.options.retry.limit) {
-                        error.message = `${error.message} (failed after ${retryCount} retries)`;
-                    }
-
-                    return error;
-                }
-            ]
-        }
-    });
-    ```
-    */
-    beforeError?: BeforeErrorHook[];
-};

package/node_modules/ky/distribution/types/hooks.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=hooks.js.map

package/node_modules/ky/distribution/types/hooks.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"hooks.js","sourceRoot":"","sources":["../../source/types/hooks.ts"],"names":[],"mappings":"","sourcesContent":["import {type stop, type RetryMarker} from '../core/constants.js';\nimport type {KyRequest, KyResponse, HTTPError} from '../index.js';\nimport type {NormalizedOptions} from './options.js';\n\nexport type BeforeRequestState = {\n\t/**\n\tThe number of retries attempted. `0` for the initial request, increments with each retry.\n\n\tThis allows you to distinguish between initial requests and retries, which is useful when you need different behavior for retries (e.g., avoiding overwriting headers set in `beforeRetry`).\n\t*/\n\tretryCount: number;\n};\n\nexport type BeforeRequestHook = (\n\trequest: KyRequest,\n\toptions: NormalizedOptions,\n\tstate: BeforeRequestState\n) => Request | Response | void | Promise<Request | Response | void>;\n\nexport type BeforeRetryState = {\n\trequest: KyRequest;\n\toptions: NormalizedOptions;\n\terror: Error;\n\n\t/**\n\tThe number of retries attempted. Always `>= 1` since this hook is only called during retries, not on the initial request.\n\t*/\n\tretryCount: number;\n};\nexport type BeforeRetryHook = (options: BeforeRetryState) => Request | Response | typeof stop | void | Promise<Request | Response | typeof stop | void>;\n\nexport type AfterResponseState = {\n\t/**\n\tThe number of retries attempted. `0` for the initial request, increments with each retry.\n\n\tThis allows you to distinguish between initial requests and retries, which is useful when you need different behavior for retries (e.g., showing a notification only on the final retry).\n\t*/\n\tretryCount: number;\n};\n\nexport type AfterResponseHook = (\n\trequest: KyRequest,\n\toptions: NormalizedOptions,\n\tresponse: KyResponse,\n\tstate: AfterResponseState\n) => Response | RetryMarker | void | Promise<Response | RetryMarker | void>;\n\nexport type BeforeErrorState = {\n\t/**\n\tThe number of retries attempted. `0` for the initial request, increments with each retry.\n\n\tThis allows you to distinguish between the initial request and retries, which is useful when you need different error handling based on retry attempts (e.g., showing different error messages on the final attempt).\n\t*/\n\tretryCount: number;\n};\n\nexport type BeforeErrorHook = (error: HTTPError, state: BeforeErrorState) => HTTPError | Promise<HTTPError>;\n\nexport type Hooks = {\n\t/**\n\tThis hook enables you to modify the request right before it is sent. Ky will make no further changes to the request after this. The hook function receives the normalized request, options, and a state object. You could, for example, modify `request.headers` here.\n\n\tThe `state.retryCount` is `0` for the initial request and increments with each retry. This allows you to distinguish between initial requests and retries, which is useful when you need different behavior for retries (e.g., avoiding overwriting headers set in `beforeRetry`).\n\n\tA [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response) can be returned from this hook to completely avoid making an HTTP request. This can be used to mock a request, check an internal cache, etc. An **important** consideration when returning a `Response` from this hook is that all the following hooks will be skipped, so **ensure you only return a `Response` from the last hook**.\n\n\t@example\n\t```\n\timport ky from 'ky';\n\n\tconst response = await ky('https://example.com', {\n\t\thooks: {\n\t\t\tbeforeRequest: [\n\t\t\t\t(request, options, {retryCount}) => {\n\t\t\t\t\t// Only set default auth header on initial request, not on retries\n\t\t\t\t\t// (retries may have refreshed token set by beforeRetry)\n\t\t\t\t\tif (retryCount === 0) {\n\t\t\t\t\t\trequest.headers.set('Authorization', 'token initial-token');\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t]\n\t\t}\n\t});\n\t```\n\n\t@default []\n\t*/\n\tbeforeRequest?: BeforeRequestHook[];\n\n\t/**\n\tThis hook enables you to modify the request right before retry. Ky will make no further changes to the request after this. The hook function receives an object with the normalized request and options, an error instance, and the retry count. You could, for example, modify `request.headers` here.\n\n\tThe hook can return a [`Request`](https://developer.mozilla.org/en-US/docs/Web/API/Request) to replace the outgoing retry request, or return a [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response) to skip the retry and use that response instead. **Note:** Returning a request or response skips remaining `beforeRetry` hooks.\n\n\tIf the request received a response, the error will be of type `HTTPError` and the `Response` object will be available at `error.response`. Be aware that some types of errors, such as network errors, inherently mean that a response was not received. In that case, the error will not be an instance of `HTTPError`.\n\n\tYou can prevent Ky from retrying the request by throwing an error. Ky will not handle it in any way and the error will be propagated to the request initiator. The rest of the `beforeRetry` hooks will not be called in this case. Alternatively, you can return the [`ky.stop`](#ky.stop) symbol to do the same thing but without propagating an error (this has some limitations, see `ky.stop` docs for details).\n\n\t**Modifying headers:**\n\n\t@example\n\t```\n\timport ky from 'ky';\n\n\tconst response = await ky('https://example.com', {\n\t\thooks: {\n\t\t\tbeforeRetry: [\n\t\t\t\tasync ({request, options, error, retryCount}) => {\n\t\t\t\t\tconst token = await ky('https://example.com/refresh-token');\n\t\t\t\t\trequest.headers.set('Authorization', `token ${token}`);\n\t\t\t\t}\n\t\t\t]\n\t\t}\n\t});\n\t```\n\n\t**Modifying the request URL:**\n\n\t@example\n\t```\n\timport ky from 'ky';\n\n\tconst response = await ky('https://example.com/api', {\n\t\thooks: {\n\t\t\tbeforeRetry: [\n\t\t\t\tasync ({request, error}) => {\n\t\t\t\t\t// Add query parameters based on error response\n\t\t\t\t\tif (error.response) {\n\t\t\t\t\t\tconst body = await error.response.json();\n\t\t\t\t\t\tconst url = new URL(request.url);\n\t\t\t\t\t\turl.searchParams.set('processId', body.processId);\n\t\t\t\t\t\treturn new Request(url, request);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t]\n\t\t}\n\t});\n\t```\n\n\t**Returning a cached response:**\n\n\t@example\n\t```\n\timport ky from 'ky';\n\n\tconst response = await ky('https://example.com/api', {\n\t\thooks: {\n\t\t\tbeforeRetry: [\n\t\t\t\t({error, retryCount}) => {\n\t\t\t\t\t// Use cached response instead of retrying\n\t\t\t\t\tif (retryCount > 1 && cachedResponse) {\n\t\t\t\t\t\treturn cachedResponse;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t]\n\t\t}\n\t});\n\t```\n\n\t@default []\n\t*/\n\tbeforeRetry?: BeforeRetryHook[];\n\n\t/**\n\tThis hook enables you to read and optionally modify the response. The hook function receives normalized request, options, a clone of the response, and a state object. The return value of the hook function will be used by Ky as the response object if it's an instance of [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response).\n\n\tYou can also force a retry by returning `ky.retry()` or `ky.retry(options)`. This is useful when you need to retry based on the response body content, even if the response has a successful status code. The retry will respect the retry limit and be observable in `beforeRetry` hooks.\n\n\t@default []\n\n\t@example\n\t```\n\timport ky from 'ky';\n\n\tconst response = await ky('https://example.com', {\n\t\thooks: {\n\t\t\tafterResponse: [\n\t\t\t\t(_request, _options, response) => {\n\t\t\t\t\t// You could do something with the response, for example, logging.\n\t\t\t\t\tlog(response);\n\n\t\t\t\t\t// Or return a `Response` instance to overwrite the response.\n\t\t\t\t\treturn new Response('A different response', {status: 200});\n\t\t\t\t},\n\n\t\t\t\t// Or retry with a fresh token on a 401 error\n\t\t\t\tasync (request, _options, response, state) => {\n\t\t\t\t\tif (response.status === 401 && state.retryCount === 0) {\n\t\t\t\t\t\t// Only refresh on first 401, not on subsequent retries\n\t\t\t\t\t\tconst {token} = await ky.post('https://example.com/auth/refresh').json();\n\n\t\t\t\t\t\tconst headers = new Headers(request.headers);\n\t\t\t\t\t\theaders.set('Authorization', `Bearer ${token}`);\n\n\t\t\t\t\t\treturn ky.retry({\n\t\t\t\t\t\t\trequest: new Request(request, {headers}),\n\t\t\t\t\t\t\tcode: 'TOKEN_REFRESHED'\n\t\t\t\t\t\t});\n\t\t\t\t\t}\n\t\t\t\t},\n\n\t\t\t\t// Or force retry based on response body content\n\t\t\t\tasync (request, options, response) => {\n\t\t\t\t\tif (response.status === 200) {\n\t\t\t\t\t\tconst data = await response.clone().json();\n\t\t\t\t\t\tif (data.error?.code === 'RATE_LIMIT') {\n\t\t\t\t\t\t\t// Force retry with custom delay from API response\n\t\t\t\t\t\t\treturn ky.retry({\n\t\t\t\t\t\t\t\tdelay: data.error.retryAfter * 1000,\n\t\t\t\t\t\t\t\tcode: 'RATE_LIMIT'\n\t\t\t\t\t\t\t});\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t},\n\n\t\t\t\t// Or show a notification only on the last retry for 5xx errors\n\t\t\t\t(request, options, response, {retryCount}) => {\n\t\t\t\t\tif (response.status >= 500 && response.status <= 599) {\n\t\t\t\t\t\tif (retryCount === options.retry.limit) {\n\t\t\t\t\t\t\tshowNotification('Request failed after all retries');\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t]\n\t\t}\n\t});\n\t```\n\t*/\n\tafterResponse?: AfterResponseHook[];\n\n\t/**\n\tThis hook enables you to modify the `HTTPError` right before it is thrown. The hook function receives an `HTTPError` and a state object as arguments and should return an instance of `HTTPError`.\n\n\t@default []\n\n\t@example\n\t```\n\timport ky from 'ky';\n\n\tawait ky('https://example.com', {\n\t\thooks: {\n\t\t\tbeforeError: [\n\t\t\t\tasync error => {\n\t\t\t\t\tconst {response} = error;\n\t\t\t\t\tif (response) {\n\t\t\t\t\t\tconst body = await response.json();\n\t\t\t\t\t\terror.name = 'GitHubError';\n\t\t\t\t\t\terror.message = `${body.message} (${response.status})`;\n\t\t\t\t\t}\n\n\t\t\t\t\treturn error;\n\t\t\t\t},\n\n\t\t\t\t// Or show different message based on retry count\n\t\t\t\t(error, {retryCount}) => {\n\t\t\t\t\tif (retryCount === error.options.retry.limit) {\n\t\t\t\t\t\terror.message = `${error.message} (failed after ${retryCount} retries)`;\n\t\t\t\t\t}\n\n\t\t\t\t\treturn error;\n\t\t\t\t}\n\t\t\t]\n\t\t}\n\t});\n\t```\n\t*/\n\tbeforeError?: BeforeErrorHook[];\n};\n"]}

package/node_modules/ky/distribution/types/ky.d.ts

@@ -1,175 +0,0 @@
-import { type stop, type retry } from '../core/constants.js';
-import type { Input, Options } from './options.js';
-import type { ResponsePromise } from './ResponsePromise.js';
-export type KyInstance = {
-    /**
-    Fetch the given `url`.
-
-    @param url - `Request` object, `URL` object, or URL string.
-    @returns A promise with `Body` method added.
-
-    @example
-    ```
-    import ky from 'ky';
-
-    const json = await ky('https://example.com', {json: {foo: true}}).json();
-
-    console.log(json);
-    //=> `{data: '🦄'}`
-    ```
-    */
-    <T>(url: Input, options?: Options): ResponsePromise<T>;
-    /**
-    Fetch the given `url` using the option `{method: 'get'}`.
-
-    @param url - `Request` object, `URL` object, or URL string.
-    @returns A promise with `Body` methods added.
-    */
-    get: <T>(url: Input, options?: Options) => ResponsePromise<T>;
-    /**
-    Fetch the given `url` using the option `{method: 'post'}`.
-
-    @param url - `Request` object, `URL` object, or URL string.
-    @returns A promise with `Body` methods added.
-    */
-    post: <T>(url: Input, options?: Options) => ResponsePromise<T>;
-    /**
-    Fetch the given `url` using the option `{method: 'put'}`.
-
-    @param url - `Request` object, `URL` object, or URL string.
-    @returns A promise with `Body` methods added.
-    */
-    put: <T>(url: Input, options?: Options) => ResponsePromise<T>;
-    /**
-    Fetch the given `url` using the option `{method: 'delete'}`.
-
-    @param url - `Request` object, `URL` object, or URL string.
-    @returns A promise with `Body` methods added.
-    */
-    delete: <T>(url: Input, options?: Options) => ResponsePromise<T>;
-    /**
-    Fetch the given `url` using the option `{method: 'patch'}`.
-
-    @param url - `Request` object, `URL` object, or URL string.
-    @returns A promise with `Body` methods added.
-    */
-    patch: <T>(url: Input, options?: Options) => ResponsePromise<T>;
-    /**
-    Fetch the given `url` using the option `{method: 'head'}`.
-
-    @param url - `Request` object, `URL` object, or URL string.
-    @returns A promise with `Body` methods added.
-    */
-    head: (url: Input, options?: Options) => ResponsePromise;
-    /**
-    Create a new Ky instance with complete new defaults.
-
-    @returns A new Ky instance.
-    */
-    create: (defaultOptions?: Options) => KyInstance;
-    /**
-    Create a new Ky instance with some defaults overridden with your own.
-
-    In contrast to `ky.create()`, `ky.extend()` inherits defaults from its parent.
-
-    You can also refer to parent defaults by providing a function to `.extend()`.
-
-    @example
-    ```
-    import ky from 'ky';
-
-    const api = ky.create({prefixUrl: 'https://example.com/api'});
-
-    const usersApi = api.extend((options) => ({prefixUrl: `${options.prefixUrl}/users`}));
-
-    const response = await usersApi.get('123');
-    //=> 'https://example.com/api/users/123'
-
-    const response = await api.get('version');
-    //=> 'https://example.com/api/version'
-    ```
-
-    @returns A new Ky instance.
-    */
-    extend: (defaultOptions: Options | ((parentOptions: Options) => Options)) => KyInstance;
-    /**
-    A `Symbol` that can be returned by a `beforeRetry` hook to stop the retry. This will also short circuit the remaining `beforeRetry` hooks.
-
-    Note: Returning this symbol makes Ky abort and return with an `undefined` response. Be sure to check for a response before accessing any properties on it or use [optional chaining](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Optional_chaining). It is also incompatible with body methods, such as `.json()` or `.text()`, because there is no response to parse. In general, we recommend throwing an error instead of returning this symbol, as that will cause Ky to abort and then throw, which avoids these limitations.
-
-    A valid use-case for `ky.stop` is to prevent retries when making requests for side effects, where the returned data is not important. For example, logging client activity to the server.
-
-    @example
-    ```
-    import ky from 'ky';
-
-    const options = {
-        hooks: {
-            beforeRetry: [
-                async ({request, options, error, retryCount}) => {
-                    const shouldStopRetry = await ky('https://example.com/api');
-                    if (shouldStopRetry) {
-                        return ky.stop;
-                    }
-                }
-            ]
-        }
-    };
-
-    // Note that response will be `undefined` in case `ky.stop` is returned.
-    const response = await ky.post('https://example.com', options);
-
-    // Using `.text()` or other body methods is not supported.
-    const text = await ky('https://example.com', options).text();
-    ```
-    */
-    readonly stop: typeof stop;
-    /**
-    Force a retry from an `afterResponse` hook.
-
-    This allows you to retry a request based on the response content, even if the response has a successful status code. The retry will respect the `retry.limit` option and skip the `shouldRetry` check. The forced retry is observable in `beforeRetry` hooks, where the error will be a `ForceRetryError`.
-
-    @example
-    ```
-    import ky, {isForceRetryError} from 'ky';
-
-    const api = ky.extend({
-        hooks: {
-            afterResponse: [
-                async (request, options, response) => {
-                    // Retry based on response body content
-                    if (response.status === 200) {
-                        const data = await response.clone().json();
-
-                        // Simple retry with default delay
-                        if (data.error?.code === 'TEMPORARY_ERROR') {
-                            return ky.retry();
-                        }
-
-                        // Retry with custom delay from API response
-                        if (data.error?.code === 'RATE_LIMIT') {
-                            return ky.retry({
-                                delay: data.error.retryAfter * 1000,
-                                code: 'RATE_LIMIT'
-                            });
-                        }
-                    }
-                }
-            ],
-            beforeRetry: [
-                ({error, retryCount}) => {
-                    // Observable in beforeRetry hooks
-                    if (isForceRetryError(error)) {
-                        console.log(`Forced retry #${retryCount}: ${error.message}`);
-                        // Example output: "Forced retry #1: Forced retry: RATE_LIMIT"
-                    }
-                }
-            ]
-        }
-    });
-
-    const response = await api.get('https://example.com/api');
-    ```
-    */
-    readonly retry: typeof retry;
-};

package/node_modules/ky/distribution/types/ky.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=ky.js.map

package/node_modules/ky/distribution/types/ky.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ky.js","sourceRoot":"","sources":["../../source/types/ky.ts"],"names":[],"mappings":"","sourcesContent":["import {type stop, type retry} from '../core/constants.js';\nimport type {Input, Options} from './options.js';\nimport type {ResponsePromise} from './ResponsePromise.js';\n\nexport type KyInstance = {\n\t/**\n\tFetch the given `url`.\n\n\t@param url - `Request` object, `URL` object, or URL string.\n\t@returns A promise with `Body` method added.\n\n\t@example\n\t```\n\timport ky from 'ky';\n\n\tconst json = await ky('https://example.com', {json: {foo: true}}).json();\n\n\tconsole.log(json);\n\t//=> `{data: '🦄'}`\n\t```\n\t*/\n\t<T>(url: Input, options?: Options): ResponsePromise<T>;\n\n\t/**\n\tFetch the given `url` using the option `{method: 'get'}`.\n\n\t@param url - `Request` object, `URL` object, or URL string.\n\t@returns A promise with `Body` methods added.\n\t*/\n\tget: <T>(url: Input, options?: Options) => ResponsePromise<T>;\n\n\t/**\n\tFetch the given `url` using the option `{method: 'post'}`.\n\n\t@param url - `Request` object, `URL` object, or URL string.\n\t@returns A promise with `Body` methods added.\n\t*/\n\tpost: <T>(url: Input, options?: Options) => ResponsePromise<T>;\n\n\t/**\n\tFetch the given `url` using the option `{method: 'put'}`.\n\n\t@param url - `Request` object, `URL` object, or URL string.\n\t@returns A promise with `Body` methods added.\n\t*/\n\tput: <T>(url: Input, options?: Options) => ResponsePromise<T>;\n\n\t/**\n\tFetch the given `url` using the option `{method: 'delete'}`.\n\n\t@param url - `Request` object, `URL` object, or URL string.\n\t@returns A promise with `Body` methods added.\n\t*/\n\tdelete: <T>(url: Input, options?: Options) => ResponsePromise<T>;\n\n\t/**\n\tFetch the given `url` using the option `{method: 'patch'}`.\n\n\t@param url - `Request` object, `URL` object, or URL string.\n\t@returns A promise with `Body` methods added.\n\t*/\n\tpatch: <T>(url: Input, options?: Options) => ResponsePromise<T>;\n\n\t/**\n\tFetch the given `url` using the option `{method: 'head'}`.\n\n\t@param url - `Request` object, `URL` object, or URL string.\n\t@returns A promise with `Body` methods added.\n\t*/\n\thead: (url: Input, options?: Options) => ResponsePromise;\n\n\t/**\n\tCreate a new Ky instance with complete new defaults.\n\n\t@returns A new Ky instance.\n\t*/\n\tcreate: (defaultOptions?: Options) => KyInstance;\n\n\t/**\n\tCreate a new Ky instance with some defaults overridden with your own.\n\n\tIn contrast to `ky.create()`, `ky.extend()` inherits defaults from its parent.\n\n\tYou can also refer to parent defaults by providing a function to `.extend()`.\n\n\t@example\n\t```\n\timport ky from 'ky';\n\n\tconst api = ky.create({prefixUrl: 'https://example.com/api'});\n\n\tconst usersApi = api.extend((options) => ({prefixUrl: `${options.prefixUrl}/users`}));\n\n\tconst response = await usersApi.get('123');\n\t//=> 'https://example.com/api/users/123'\n\n\tconst response = await api.get('version');\n\t//=> 'https://example.com/api/version'\n\t```\n\n\t@returns A new Ky instance.\n\t*/\n\textend: (defaultOptions: Options | ((parentOptions: Options) => Options)) => KyInstance;\n\n\t/**\n\tA `Symbol` that can be returned by a `beforeRetry` hook to stop the retry. This will also short circuit the remaining `beforeRetry` hooks.\n\n\tNote: Returning this symbol makes Ky abort and return with an `undefined` response. Be sure to check for a response before accessing any properties on it or use [optional chaining](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Optional_chaining). It is also incompatible with body methods, such as `.json()` or `.text()`, because there is no response to parse. In general, we recommend throwing an error instead of returning this symbol, as that will cause Ky to abort and then throw, which avoids these limitations.\n\n\tA valid use-case for `ky.stop` is to prevent retries when making requests for side effects, where the returned data is not important. For example, logging client activity to the server.\n\n\t@example\n\t```\n\timport ky from 'ky';\n\n\tconst options = {\n\t\thooks: {\n\t\t\tbeforeRetry: [\n\t\t\t\tasync ({request, options, error, retryCount}) => {\n\t\t\t\t\tconst shouldStopRetry = await ky('https://example.com/api');\n\t\t\t\t\tif (shouldStopRetry) {\n\t\t\t\t\t\treturn ky.stop;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t]\n\t\t}\n\t};\n\n\t// Note that response will be `undefined` in case `ky.stop` is returned.\n\tconst response = await ky.post('https://example.com', options);\n\n\t// Using `.text()` or other body methods is not supported.\n\tconst text = await ky('https://example.com', options).text();\n\t```\n\t*/\n\treadonly stop: typeof stop;\n\n\t/**\n\tForce a retry from an `afterResponse` hook.\n\n\tThis allows you to retry a request based on the response content, even if the response has a successful status code. The retry will respect the `retry.limit` option and skip the `shouldRetry` check. The forced retry is observable in `beforeRetry` hooks, where the error will be a `ForceRetryError`.\n\n\t@example\n\t```\n\timport ky, {isForceRetryError} from 'ky';\n\n\tconst api = ky.extend({\n\t\thooks: {\n\t\t\tafterResponse: [\n\t\t\t\tasync (request, options, response) => {\n\t\t\t\t\t// Retry based on response body content\n\t\t\t\t\tif (response.status === 200) {\n\t\t\t\t\t\tconst data = await response.clone().json();\n\n\t\t\t\t\t\t// Simple retry with default delay\n\t\t\t\t\t\tif (data.error?.code === 'TEMPORARY_ERROR') {\n\t\t\t\t\t\t\treturn ky.retry();\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Retry with custom delay from API response\n\t\t\t\t\t\tif (data.error?.code === 'RATE_LIMIT') {\n\t\t\t\t\t\t\treturn ky.retry({\n\t\t\t\t\t\t\t\tdelay: data.error.retryAfter * 1000,\n\t\t\t\t\t\t\t\tcode: 'RATE_LIMIT'\n\t\t\t\t\t\t\t});\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t],\n\t\t\tbeforeRetry: [\n\t\t\t\t({error, retryCount}) => {\n\t\t\t\t\t// Observable in beforeRetry hooks\n\t\t\t\t\tif (isForceRetryError(error)) {\n\t\t\t\t\t\tconsole.log(`Forced retry #${retryCount}: ${error.message}`);\n\t\t\t\t\t\t// Example output: \"Forced retry #1: Forced retry: RATE_LIMIT\"\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t]\n\t\t}\n\t});\n\n\tconst response = await api.get('https://example.com/api');\n\t```\n\t*/\n\treadonly retry: typeof retry;\n};\n"]}