{"version":3,"file":"js/1592-a82a5f4b92e350eb4c56.js","mappings":"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","sources":["webpack://endrun/./node_modules/ky/distribution/errors/HTTPError.js","webpack://endrun/./node_modules/ky/distribution/errors/TimeoutError.js","webpack://endrun/./node_modules/ky/distribution/core/constants.js","webpack://endrun/./node_modules/ky/distribution/utils/body.js","webpack://endrun/./node_modules/ky/distribution/utils/is.js","webpack://endrun/./node_modules/ky/distribution/utils/merge.js","webpack://endrun/./node_modules/ky/distribution/utils/normalize.js","webpack://endrun/./node_modules/ky/distribution/core/Ky.js","webpack://endrun/./node_modules/ky/distribution/utils/delay.js","webpack://endrun/./node_modules/ky/distribution/utils/options.js","webpack://endrun/./node_modules/ky/distribution/utils/timeout.js","webpack://endrun/./node_modules/ky/distribution/index.js"],"sourcesContent":["export class HTTPError extends Error {\n    response;\n    request;\n    options;\n    constructor(response, request, options) {\n        const code = (response.status || response.status === 0) ? response.status : '';\n        const title = response.statusText || '';\n        const status = `${code} ${title}`.trim();\n        const reason = status ? `status code ${status}` : 'an unknown error';\n        super(`Request failed with ${reason}: ${request.method} ${request.url}`);\n        this.name = 'HTTPError';\n        this.response = response;\n        this.request = request;\n        this.options = options;\n    }\n}\n//# sourceMappingURL=HTTPError.js.map","export class TimeoutError extends Error {\n    request;\n    constructor(request) {\n        super(`Request timed out: ${request.method} ${request.url}`);\n        this.name = 'TimeoutError';\n        this.request = request;\n    }\n}\n//# sourceMappingURL=TimeoutError.js.map","export const supportsRequestStreams = (() => {\n    let duplexAccessed = false;\n    let hasContentType = false;\n    const supportsReadableStream = typeof globalThis.ReadableStream === 'function';\n    const supportsRequest = typeof globalThis.Request === 'function';\n    if (supportsReadableStream && supportsRequest) {\n        try {\n            hasContentType = new globalThis.Request('https://empty.invalid', {\n                body: new globalThis.ReadableStream(),\n                method: 'POST',\n                // @ts-expect-error - Types are outdated.\n                get duplex() {\n                    duplexAccessed = true;\n                    return 'half';\n                },\n            }).headers.has('Content-Type');\n        }\n        catch (error) {\n            // QQBrowser on iOS throws \"unsupported BodyInit type\" error (see issue #581)\n            if (error instanceof Error && error.message === 'unsupported BodyInit type') {\n                return false;\n            }\n            throw error;\n        }\n    }\n    return duplexAccessed && !hasContentType;\n})();\nexport const supportsAbortController = typeof globalThis.AbortController === 'function';\nexport const supportsResponseStreams = typeof globalThis.ReadableStream === 'function';\nexport const supportsFormData = typeof globalThis.FormData === 'function';\nexport const requestMethods = ['get', 'post', 'put', 'patch', 'head', 'delete'];\nconst validate = () => undefined;\nvalidate();\nexport const responseTypes = {\n    json: 'application/json',\n    text: 'text/*',\n    formData: 'multipart/form-data',\n    arrayBuffer: '*/*',\n    blob: '*/*',\n};\n// The maximum value of a 32bit int (see issue #117)\nexport const maxSafeTimeout = 2_147_483_647;\n// Size in bytes of a typical form boundary, used to help estimate upload size\nexport const usualFormBoundarySize = new TextEncoder().encode('------WebKitFormBoundaryaxpyiPgbbPti10Rw').length;\nexport const stop = Symbol('stop');\nexport const kyOptionKeys = {\n    json: true,\n    parseJson: true,\n    stringifyJson: true,\n    searchParams: true,\n    prefixUrl: true,\n    retry: true,\n    timeout: true,\n    hooks: true,\n    throwHttpErrors: true,\n    onDownloadProgress: true,\n    onUploadProgress: true,\n    fetch: true,\n};\nexport const requestOptionsRegistry = {\n    method: true,\n    headers: true,\n    body: true,\n    mode: true,\n    credentials: true,\n    cache: true,\n    redirect: true,\n    referrer: true,\n    referrerPolicy: true,\n    integrity: true,\n    keepalive: true,\n    signal: true,\n    window: true,\n    dispatcher: true,\n    duplex: true,\n    priority: true,\n};\n//# sourceMappingURL=constants.js.map","import { usualFormBoundarySize } from '../core/constants.js';\n// eslint-disable-next-line @typescript-eslint/ban-types\nexport const getBodySize = (body) => {\n    if (!body) {\n        return 0;\n    }\n    if (body instanceof FormData) {\n        // This is an approximation, as FormData size calculation is not straightforward\n        let size = 0;\n        for (const [key, value] of body) {\n            size += usualFormBoundarySize;\n            size += new TextEncoder().encode(`Content-Disposition: form-data; name=\"${key}\"`).length;\n            size += typeof value === 'string'\n                ? new TextEncoder().encode(value).length\n                : value.size;\n        }\n        return size;\n    }\n    if (body instanceof Blob) {\n        return body.size;\n    }\n    if (body instanceof ArrayBuffer) {\n        return body.byteLength;\n    }\n    if (typeof body === 'string') {\n        return new TextEncoder().encode(body).length;\n    }\n    if (body instanceof URLSearchParams) {\n        return new TextEncoder().encode(body.toString()).length;\n    }\n    if ('byteLength' in body) {\n        return (body).byteLength;\n    }\n    if (typeof body === 'object' && body !== null) {\n        try {\n            const jsonString = JSON.stringify(body);\n            return new TextEncoder().encode(jsonString).length;\n        }\n        catch {\n            return 0;\n        }\n    }\n    return 0; // Default case, unable to determine size\n};\nexport const streamResponse = (response, onDownloadProgress) => {\n    const totalBytes = Number(response.headers.get('content-length')) || 0;\n    let transferredBytes = 0;\n    if (response.status === 204) {\n        if (onDownloadProgress) {\n            onDownloadProgress({ percent: 1, totalBytes, transferredBytes }, new Uint8Array());\n        }\n        return new Response(null, {\n            status: response.status,\n            statusText: response.statusText,\n            headers: response.headers,\n        });\n    }\n    return new Response(new ReadableStream({\n        async start(controller) {\n            const reader = response.body.getReader();\n            if (onDownloadProgress) {\n                onDownloadProgress({ percent: 0, transferredBytes: 0, totalBytes }, new Uint8Array());\n            }\n            async function read() {\n                const { done, value } = await reader.read();\n                if (done) {\n                    controller.close();\n                    return;\n                }\n                if (onDownloadProgress) {\n                    transferredBytes += value.byteLength;\n                    const percent = totalBytes === 0 ? 0 : transferredBytes / totalBytes;\n                    onDownloadProgress({ percent, transferredBytes, totalBytes }, value);\n                }\n                controller.enqueue(value);\n                await read();\n            }\n            await read();\n        },\n    }), {\n        status: response.status,\n        statusText: response.statusText,\n        headers: response.headers,\n    });\n};\nexport const streamRequest = (request, onUploadProgress) => {\n    const totalBytes = getBodySize(request.body);\n    let transferredBytes = 0;\n    return new Request(request, {\n        // @ts-expect-error - Types are outdated.\n        duplex: 'half',\n        body: new ReadableStream({\n            async start(controller) {\n                const reader = request.body instanceof ReadableStream ? request.body.getReader() : new Response('').body.getReader();\n                async function read() {\n                    const { done, value } = await reader.read();\n                    if (done) {\n                        // Ensure 100% progress is reported when the upload is complete\n                        if (onUploadProgress) {\n                            onUploadProgress({ percent: 1, transferredBytes, totalBytes: Math.max(totalBytes, transferredBytes) }, new Uint8Array());\n                        }\n                        controller.close();\n                        return;\n                    }\n                    transferredBytes += value.byteLength;\n                    let percent = totalBytes === 0 ? 0 : transferredBytes / totalBytes;\n                    if (totalBytes < transferredBytes || percent === 1) {\n                        percent = 0.99;\n                    }\n                    if (onUploadProgress) {\n                        onUploadProgress({ percent: Number(percent.toFixed(2)), transferredBytes, totalBytes }, value);\n                    }\n                    controller.enqueue(value);\n                    await read();\n                }\n                await read();\n            },\n        }),\n    });\n};\n//# sourceMappingURL=body.js.map","// eslint-disable-next-line @typescript-eslint/ban-types\nexport const isObject = (value) => value !== null && typeof value === 'object';\n//# sourceMappingURL=is.js.map","import { isObject } from './is.js';\nexport const validateAndMerge = (...sources) => {\n    for (const source of sources) {\n        if ((!isObject(source) || Array.isArray(source)) && source !== undefined) {\n            throw new TypeError('The `options` argument must be an object');\n        }\n    }\n    return deepMerge({}, ...sources);\n};\nexport const mergeHeaders = (source1 = {}, source2 = {}) => {\n    const result = new globalThis.Headers(source1);\n    const isHeadersInstance = source2 instanceof globalThis.Headers;\n    const source = new globalThis.Headers(source2);\n    for (const [key, value] of source.entries()) {\n        if ((isHeadersInstance && value === 'undefined') || value === undefined) {\n            result.delete(key);\n        }\n        else {\n            result.set(key, value);\n        }\n    }\n    return result;\n};\nfunction newHookValue(original, incoming, property) {\n    return (Object.hasOwn(incoming, property) && incoming[property] === undefined)\n        ? []\n        : deepMerge(original[property] ?? [], incoming[property] ?? []);\n}\nexport const mergeHooks = (original = {}, incoming = {}) => ({\n    beforeRequest: newHookValue(original, incoming, 'beforeRequest'),\n    beforeRetry: newHookValue(original, incoming, 'beforeRetry'),\n    afterResponse: newHookValue(original, incoming, 'afterResponse'),\n    beforeError: newHookValue(original, incoming, 'beforeError'),\n});\n// TODO: Make this strongly-typed (no `any`).\nexport const deepMerge = (...sources) => {\n    let returnValue = {};\n    let headers = {};\n    let hooks = {};\n    for (const source of sources) {\n        if (Array.isArray(source)) {\n            if (!Array.isArray(returnValue)) {\n                returnValue = [];\n            }\n            returnValue = [...returnValue, ...source];\n        }\n        else if (isObject(source)) {\n            for (let [key, value] of Object.entries(source)) {\n                if (isObject(value) && key in returnValue) {\n                    value = deepMerge(returnValue[key], value);\n                }\n                returnValue = { ...returnValue, [key]: value };\n            }\n            if (isObject(source.hooks)) {\n                hooks = mergeHooks(hooks, source.hooks);\n                returnValue.hooks = hooks;\n            }\n            if (isObject(source.headers)) {\n                headers = mergeHeaders(headers, source.headers);\n                returnValue.headers = headers;\n            }\n        }\n    }\n    return returnValue;\n};\n//# sourceMappingURL=merge.js.map","import { requestMethods } from '../core/constants.js';\nexport const normalizeRequestMethod = (input) => requestMethods.includes(input) ? input.toUpperCase() : input;\nconst retryMethods = ['get', 'put', 'head', 'delete', 'options', 'trace'];\nconst retryStatusCodes = [408, 413, 429, 500, 502, 503, 504];\nconst retryAfterStatusCodes = [413, 429, 503];\nconst defaultRetryOptions = {\n    limit: 2,\n    methods: retryMethods,\n    statusCodes: retryStatusCodes,\n    afterStatusCodes: retryAfterStatusCodes,\n    maxRetryAfter: Number.POSITIVE_INFINITY,\n    backoffLimit: Number.POSITIVE_INFINITY,\n    delay: attemptCount => 0.3 * (2 ** (attemptCount - 1)) * 1000,\n};\nexport const normalizeRetryOptions = (retry = {}) => {\n    if (typeof retry === 'number') {\n        return {\n            ...defaultRetryOptions,\n            limit: retry,\n        };\n    }\n    if (retry.methods && !Array.isArray(retry.methods)) {\n        throw new Error('retry.methods must be an array');\n    }\n    if (retry.statusCodes && !Array.isArray(retry.statusCodes)) {\n        throw new Error('retry.statusCodes must be an array');\n    }\n    return {\n        ...defaultRetryOptions,\n        ...retry,\n    };\n};\n//# sourceMappingURL=normalize.js.map","import { HTTPError } from '../errors/HTTPError.js';\nimport { TimeoutError } from '../errors/TimeoutError.js';\nimport { streamRequest, streamResponse } from '../utils/body.js';\nimport { mergeHeaders, mergeHooks } from '../utils/merge.js';\nimport { normalizeRequestMethod, normalizeRetryOptions } from '../utils/normalize.js';\nimport timeout from '../utils/timeout.js';\nimport delay from '../utils/delay.js';\nimport { findUnknownOptions } from '../utils/options.js';\nimport { maxSafeTimeout, responseTypes, stop, supportsAbortController, supportsFormData, supportsResponseStreams, supportsRequestStreams, } from './constants.js';\nexport class Ky {\n    static create(input, options) {\n        const ky = new Ky(input, options);\n        const function_ = async () => {\n            if (typeof ky._options.timeout === 'number' && ky._options.timeout > maxSafeTimeout) {\n                throw new RangeError(`The \\`timeout\\` option cannot be greater than ${maxSafeTimeout}`);\n            }\n            // Delay the fetch so that body method shortcuts can set the Accept header\n            await Promise.resolve();\n            // Before using ky.request, _fetch clones it and saves the clone for future retries to use.\n            // If retry is not needed, close the cloned request's ReadableStream for memory safety.\n            let response = await ky._fetch();\n            for (const hook of ky._options.hooks.afterResponse) {\n                // eslint-disable-next-line no-await-in-loop\n                const modifiedResponse = await hook(ky.request, ky._options, ky._decorateResponse(response.clone()));\n                if (modifiedResponse instanceof globalThis.Response) {\n                    response = modifiedResponse;\n                }\n            }\n            ky._decorateResponse(response);\n            if (!response.ok && ky._options.throwHttpErrors) {\n                let error = new HTTPError(response, ky.request, ky._options);\n                for (const hook of ky._options.hooks.beforeError) {\n                    // eslint-disable-next-line no-await-in-loop\n                    error = await hook(error);\n                }\n                throw error;\n            }\n            // Now that we know a retry is not needed, close the ReadableStream of the cloned request.\n            if (!ky.request.bodyUsed) {\n                await ky.request.body?.cancel();\n            }\n            // If `onDownloadProgress` is passed, it uses the stream API internally\n            if (ky._options.onDownloadProgress) {\n                if (typeof ky._options.onDownloadProgress !== 'function') {\n                    throw new TypeError('The `onDownloadProgress` option must be a function');\n                }\n                if (!supportsResponseStreams) {\n                    throw new Error('Streams are not supported in your environment. `ReadableStream` is missing.');\n                }\n                return streamResponse(response.clone(), ky._options.onDownloadProgress);\n            }\n            return response;\n        };\n        const isRetriableMethod = ky._options.retry.methods.includes(ky.request.method.toLowerCase());\n        const result = (isRetriableMethod ? ky._retry(function_) : function_());\n        for (const [type, mimeType] of Object.entries(responseTypes)) {\n            result[type] = async () => {\n                // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing\n                ky.request.headers.set('accept', ky.request.headers.get('accept') || mimeType);\n                const response = await result;\n                if (type === 'json') {\n                    if (response.status === 204) {\n                        return '';\n                    }\n                    const arrayBuffer = await response.clone().arrayBuffer();\n                    const responseSize = arrayBuffer.byteLength;\n                    if (responseSize === 0) {\n                        return '';\n                    }\n                    if (options.parseJson) {\n                        return options.parseJson(await response.text());\n                    }\n                }\n                return response[type]();\n            };\n        }\n        return result;\n    }\n    request;\n    abortController;\n    _retryCount = 0;\n    _input;\n    _options;\n    // eslint-disable-next-line complexity\n    constructor(input, options = {}) {\n        this._input = input;\n        this._options = {\n            ...options,\n            headers: mergeHeaders(this._input.headers, options.headers),\n            hooks: mergeHooks({\n                beforeRequest: [],\n                beforeRetry: [],\n                beforeError: [],\n                afterResponse: [],\n            }, options.hooks),\n            method: normalizeRequestMethod(options.method ?? this._input.method ?? 'GET'),\n            // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing\n            prefixUrl: String(options.prefixUrl || ''),\n            retry: normalizeRetryOptions(options.retry),\n            throwHttpErrors: options.throwHttpErrors !== false,\n            timeout: options.timeout ?? 10_000,\n            fetch: options.fetch ?? globalThis.fetch.bind(globalThis),\n        };\n        if (typeof this._input !== 'string' && !(this._input instanceof URL || this._input instanceof globalThis.Request)) {\n            throw new TypeError('`input` must be a string, URL, or Request');\n        }\n        if (this._options.prefixUrl && typeof this._input === 'string') {\n            if (this._input.startsWith('/')) {\n                throw new Error('`input` must not begin with a slash when using `prefixUrl`');\n            }\n            if (!this._options.prefixUrl.endsWith('/')) {\n                this._options.prefixUrl += '/';\n            }\n            this._input = this._options.prefixUrl + this._input;\n        }\n        if (supportsAbortController) {\n            const originalSignal = this._options.signal ?? this._input.signal;\n            this.abortController = new globalThis.AbortController();\n            this._options.signal = originalSignal ? AbortSignal.any([originalSignal, this.abortController.signal]) : this.abortController.signal;\n        }\n        if (supportsRequestStreams) {\n            // @ts-expect-error - Types are outdated.\n            this._options.duplex = 'half';\n        }\n        if (this._options.json !== undefined) {\n            this._options.body = this._options.stringifyJson?.(this._options.json) ?? JSON.stringify(this._options.json);\n            this._options.headers.set('content-type', this._options.headers.get('content-type') ?? 'application/json');\n        }\n        this.request = new globalThis.Request(this._input, this._options);\n        if (this._options.searchParams) {\n            // eslint-disable-next-line unicorn/prevent-abbreviations\n            const textSearchParams = typeof this._options.searchParams === 'string'\n                ? this._options.searchParams.replace(/^\\?/, '')\n                : new URLSearchParams(this._options.searchParams).toString();\n            // eslint-disable-next-line unicorn/prevent-abbreviations\n            const searchParams = '?' + textSearchParams;\n            const url = this.request.url.replace(/(?:\\?.*?)?(?=#|$)/, searchParams);\n            // To provide correct form boundary, Content-Type header should be deleted each time when new Request instantiated from another one\n            if (((supportsFormData && this._options.body instanceof globalThis.FormData)\n                || this._options.body instanceof URLSearchParams) && !(this._options.headers && this._options.headers['content-type'])) {\n                this.request.headers.delete('content-type');\n            }\n            // The spread of `this.request` is required as otherwise it misses the `duplex` option for some reason and throws.\n            this.request = new globalThis.Request(new globalThis.Request(url, { ...this.request }), this._options);\n        }\n        // If `onUploadProgress` is passed, it uses the stream API internally\n        if (this._options.onUploadProgress) {\n            if (typeof this._options.onUploadProgress !== 'function') {\n                throw new TypeError('The `onUploadProgress` option must be a function');\n            }\n            if (!supportsRequestStreams) {\n                throw new Error('Request streams are not supported in your environment. The `duplex` option for `Request` is not available.');\n            }\n            const originalBody = this.request.body;\n            if (originalBody) {\n                this.request = streamRequest(this.request, this._options.onUploadProgress);\n            }\n        }\n    }\n    _calculateRetryDelay(error) {\n        this._retryCount++;\n        if (this._retryCount > this._options.retry.limit || error instanceof TimeoutError) {\n            throw error;\n        }\n        if (error instanceof HTTPError) {\n            if (!this._options.retry.statusCodes.includes(error.response.status)) {\n                throw error;\n            }\n            const retryAfter = error.response.headers.get('Retry-After')\n                ?? error.response.headers.get('RateLimit-Reset')\n                ?? error.response.headers.get('X-RateLimit-Reset') // GitHub\n                ?? error.response.headers.get('X-Rate-Limit-Reset'); // Twitter\n            if (retryAfter && this._options.retry.afterStatusCodes.includes(error.response.status)) {\n                let after = Number(retryAfter) * 1000;\n                if (Number.isNaN(after)) {\n                    after = Date.parse(retryAfter) - Date.now();\n                }\n                else if (after >= Date.parse('2024-01-01')) {\n                    // A large number is treated as a timestamp (fixed threshold protects against clock skew)\n                    after -= Date.now();\n                }\n                const max = this._options.retry.maxRetryAfter ?? after;\n                return after < max ? after : max;\n            }\n            if (error.response.status === 413) {\n                throw error;\n            }\n        }\n        const retryDelay = this._options.retry.delay(this._retryCount);\n        return Math.min(this._options.retry.backoffLimit, retryDelay);\n    }\n    _decorateResponse(response) {\n        if (this._options.parseJson) {\n            response.json = async () => this._options.parseJson(await response.text());\n        }\n        return response;\n    }\n    async _retry(function_) {\n        try {\n            return await function_();\n        }\n        catch (error) {\n            const ms = Math.min(this._calculateRetryDelay(error), maxSafeTimeout);\n            if (this._retryCount < 1) {\n                throw error;\n            }\n            await delay(ms, { signal: this._options.signal });\n            for (const hook of this._options.hooks.beforeRetry) {\n                // eslint-disable-next-line no-await-in-loop\n                const hookResult = await hook({\n                    request: this.request,\n                    options: this._options,\n                    error: error,\n                    retryCount: this._retryCount,\n                });\n                // If `stop` is returned from the hook, the retry process is stopped\n                if (hookResult === stop) {\n                    return;\n                }\n            }\n            return this._retry(function_);\n        }\n    }\n    async _fetch() {\n        for (const hook of this._options.hooks.beforeRequest) {\n            // eslint-disable-next-line no-await-in-loop\n            const result = await hook(this.request, this._options);\n            if (result instanceof Request) {\n                this.request = result;\n                break;\n            }\n            if (result instanceof Response) {\n                return result;\n            }\n        }\n        const nonRequestOptions = findUnknownOptions(this.request, this._options);\n        // Cloning is done here to prepare in advance for retries\n        const mainRequest = this.request;\n        this.request = mainRequest.clone();\n        if (this._options.timeout === false) {\n            return this._options.fetch(mainRequest, nonRequestOptions);\n        }\n        return timeout(mainRequest, nonRequestOptions, this.abortController, this._options);\n    }\n}\n//# sourceMappingURL=Ky.js.map","// https://github.com/sindresorhus/delay/tree/ab98ae8dfcb38e1593286c94d934e70d14a4e111\nexport default async function delay(ms, { signal }) {\n    return new Promise((resolve, reject) => {\n        if (signal) {\n            signal.throwIfAborted();\n            signal.addEventListener('abort', abortHandler, { once: true });\n        }\n        function abortHandler() {\n            clearTimeout(timeoutId);\n            reject(signal.reason);\n        }\n        const timeoutId = setTimeout(() => {\n            signal?.removeEventListener('abort', abortHandler);\n            resolve();\n        }, ms);\n    });\n}\n//# sourceMappingURL=delay.js.map","import { kyOptionKeys, requestOptionsRegistry } from '../core/constants.js';\nexport const findUnknownOptions = (request, options) => {\n    const unknownOptions = {};\n    for (const key in options) {\n        if (!(key in requestOptionsRegistry) && !(key in kyOptionKeys) && !(key in request)) {\n            unknownOptions[key] = options[key];\n        }\n    }\n    return unknownOptions;\n};\n//# sourceMappingURL=options.js.map","import { TimeoutError } from '../errors/TimeoutError.js';\n// `Promise.race()` workaround (#91)\nexport default async function timeout(request, init, abortController, options) {\n    return new Promise((resolve, reject) => {\n        const timeoutId = setTimeout(() => {\n            if (abortController) {\n                abortController.abort();\n            }\n            reject(new TimeoutError(request));\n        }, options.timeout);\n        void options\n            .fetch(request, init)\n            .then(resolve)\n            .catch(reject)\n            .then(() => {\n            clearTimeout(timeoutId);\n        });\n    });\n}\n//# sourceMappingURL=timeout.js.map","/*! MIT License © Sindre Sorhus */\nimport { Ky } from './core/Ky.js';\nimport { requestMethods, stop } from './core/constants.js';\nimport { validateAndMerge } from './utils/merge.js';\nconst createInstance = (defaults) => {\n    // eslint-disable-next-line @typescript-eslint/promise-function-async\n    const ky = (input, options) => Ky.create(input, validateAndMerge(defaults, options));\n    for (const method of requestMethods) {\n        // eslint-disable-next-line @typescript-eslint/promise-function-async\n        ky[method] = (input, options) => Ky.create(input, validateAndMerge(defaults, options, { method }));\n    }\n    ky.create = (newDefaults) => createInstance(validateAndMerge(newDefaults));\n    ky.extend = (newDefaults) => {\n        if (typeof newDefaults === 'function') {\n            newDefaults = newDefaults(defaults ?? {});\n        }\n        return createInstance(validateAndMerge(defaults, newDefaults));\n    };\n    ky.stop = stop;\n    return ky;\n};\nconst ky = createInstance();\nexport default ky;\nexport { HTTPError } from './errors/HTTPError.js';\nexport { TimeoutError } from './errors/TimeoutError.js';\n//# sourceMappingURL=index.js.map"],"names":["HTTPError","Error","response","request","options","constructor","status","statusText","trim","super","method","url","this","name","TimeoutError","supportsRequestStreams","duplexAccessed","hasContentType","supportsReadableStream","globalThis","ReadableStream","supportsRequest","Request","body","duplex","headers","has","error","message","supportsAbortController","AbortController","supportsResponseStreams","supportsFormData","FormData","requestMethods","responseTypes","json","text","formData","arrayBuffer","blob","maxSafeTimeout","usualFormBoundarySize","TextEncoder","encode","length","stop","Symbol","kyOptionKeys","parseJson","stringifyJson","searchParams","prefixUrl","retry","timeout","hooks","throwHttpErrors","onDownloadProgress","onUploadProgress","fetch","requestOptionsRegistry","mode","credentials","cache","redirect","referrer","referrerPolicy","integrity","keepalive","signal","window","dispatcher","priority","streamRequest","totalBytes","size","key","value","Blob","ArrayBuffer","byteLength","URLSearchParams","toString","jsonString","JSON","stringify","getBodySize","transferredBytes","start","controller","reader","getReader","Response","async","read","done","percent","Math","max","Uint8Array","close","Number","toFixed","enqueue","isObject","validateAndMerge","sources","source","Array","isArray","undefined","TypeError","deepMerge","mergeHeaders","source1","source2","result","Headers","isHeadersInstance","entries","delete","set","newHookValue","original","incoming","property","Object","hasOwn","mergeHooks","beforeRequest","beforeRetry","afterResponse","beforeError","returnValue","normalizeRequestMethod","input","includes","toUpperCase","defaultRetryOptions","limit","methods","statusCodes","afterStatusCodes","maxRetryAfter","POSITIVE_INFINITY","backoffLimit","delay","attemptCount","normalizeRetryOptions","Ky","create","ky","function_","_options","RangeError","Promise","resolve","_fetch","hook","modifiedResponse","_decorateResponse","clone","ok","bodyUsed","cancel","get","streamResponse","toLowerCase","_retry","type","mimeType","abortController","_retryCount","_input","String","bind","URL","startsWith","endsWith","originalSignal","AbortSignal","any","replace","_calculateRetryDelay","retryAfter","after","isNaN","Date","parse","now","retryDelay","min","ms","reject","abortHandler","clearTimeout","timeoutId","reason","throwIfAborted","addEventListener","once","setTimeout","removeEventListener","retryCount","nonRequestOptions","unknownOptions","findUnknownOptions","mainRequest","init","abort","then","catch","createInstance","defaults","newDefaults","extend"],"sourceRoot":""}