recker 1.0.26 → 1.0.27

package/dist/browser/transport/undici.js

@@ -0,0 +1,897 @@
+import { request as undiciRequest, errors as undiciErrors, ProxyAgent, Agent, Client } from 'undici';
+import { HttpResponse } from '../core/response.js';
+import { NetworkError, TimeoutError, MaxSizeExceededError } from '../core/errors.js';
+import { performance } from 'perf_hooks';
+import { AsyncLocalStorage } from 'async_hooks';
+import { channel } from 'node:diagnostics_channel';
+import { createLookupFunction } from '../utils/dns.js';
+import { AgentManager } from '../utils/agent-manager.js';
+import { createProgressStream } from '../utils/progress.js';
+import { nodeToWebStream } from '../utils/streaming.js';
+const undiciRequestChannel = channel('undici:request:create');
+const undiciBodySentChannel = channel('undici:request:bodySent');
+const undiciHeadersChannel = channel('undici:request:headers');
+const undiciConnectChannel = channel('undici:client:connect');
+const requestStorage = new AsyncLocalStorage();
+undiciRequestChannel.subscribe((message) => {
+    const store = requestStorage.getStore();
+    if (store) {
+        store.requestStartTime = performance.now();
+        store.timings = { queuing: 0, dns: 0, tcp: 0, tls: 0, firstByte: 0, content: 0, total: 0 };
+        store.connection = {};
+    }
+});
+undiciBodySentChannel.subscribe((message) => {
+    const store = requestStorage.getStore();
+    if (store?.hooks && store.hooks.onRequestSent) {
+        store.hooks.onRequestSent();
+    }
+});
+undiciHeadersChannel.subscribe((message) => {
+    const payload = message;
+    const store = requestStorage.getStore();
+    if (store && payload && payload.timing) {
+        const { timing } = payload;
+        store.timings.queuing = timing.queuing;
+        store.timings.dns = timing.dns;
+        store.timings.tcp = timing.tcp;
+        store.timings.tls = timing.tls;
+        store.timings.firstByte = timing.response;
+        store.timings.content = timing.body;
+        store.timings.total = timing.ended;
+        if (store.hooks) {
+            if (store.hooks.onDnsLookup && timing.dns > 0) {
+                store.hooks.onDnsLookup({ domain: payload.request.origin, duration: timing.dns });
+            }
+            if (store.hooks.onTcpConnect && timing.tcp > 0) {
+                store.hooks.onTcpConnect({ remoteAddress: '', duration: timing.tcp });
+            }
+            if (store.hooks.onTlsHandshake && timing.tls > 0) {
+                store.hooks.onTlsHandshake({ protocol: '', cipher: '', duration: timing.tls });
+            }
+            if (store.hooks.onResponseStart) {
+                const headers = new Headers();
+                for (let i = 0; i < payload.response.headers.length; i += 2) {
+                    headers.append(payload.response.headers[i], payload.response.headers[i + 1]);
+                }
+                store.hooks.onResponseStart({ status: payload.response.statusCode, headers });
+            }
+        }
+    }
+});
+undiciConnectChannel.subscribe((message) => {
+    const payload = message;
+    const store = requestStorage.getStore();
+    if (store && payload && payload.socket) {
+        const { socket } = payload;
+        store.connection.remoteAddress = socket.remoteAddress;
+        store.connection.remotePort = socket.remotePort;
+        store.connection.localAddress = socket.localAddress;
+        store.connection.localPort = socket.localPort;
+        const protocol = socket.alpnProtocol || (socket.tlsSocket ? socket.tlsSocket.getProtocol() : undefined);
+        store.connection.protocol = protocol;
+        store.connection.cipher = socket.tlsSocket ? socket.tlsSocket.getCipher()?.name : undefined;
+        if (store.hooks) {
+            if (store.hooks.onTcpConnect) {
+                store.hooks.onTcpConnect({ remoteAddress: socket.remoteAddress, duration: 0 });
+            }
+            if (store.hooks.onTlsHandshake && socket.tlsSocket) {
+                store.hooks.onTlsHandshake({
+                    protocol: protocol || 'unknown',
+                    cipher: socket.tlsSocket.getCipher()?.name || 'unknown',
+                    duration: 0
+                });
+            }
+        }
+        if (protocol === 'h2') {
+            const http2Session = socket.session || socket;
+            const http2State = http2Session.state;
+            const remoteSettings = http2Session.remoteSettings;
+            const localSettings = http2Session.localSettings;
+            store.connection.http2 = {
+                streamId: socket.streamId,
+                streamWeight: socket.weight,
+                streamDependency: socket.dependency,
+                serverPush: Boolean(socket.serverPush),
+                settingsReceived: Boolean(remoteSettings),
+                maxConcurrentStreams: remoteSettings?.maxConcurrentStreams,
+                currentStreams: http2State?.streamCount,
+                pendingStreams: http2State?.pendingStreamCount,
+                localWindowSize: http2State?.localWindowSize ?? http2State?.effectiveLocalWindowSize,
+                remoteWindowSize: http2State?.effectiveRecvDataLength,
+                localSettings: localSettings ? { ...localSettings } : undefined,
+                remoteSettings: remoteSettings ? { ...remoteSettings } : undefined
+            };
+        }
+        if (protocol === 'h3' || protocol?.startsWith('h3-')) {
+            const quicStats = socket.stats;
+            const handshakeConfirmed = socket.handshakeConfirmed;
+            store.connection.http3 = {
+                quicVersion: protocol,
+                zeroRTT: socket.zeroRTT || false,
+                maxStreams: socket.maxStreams,
+                handshakeConfirmed: typeof handshakeConfirmed === 'boolean' ? handshakeConfirmed : undefined
+            };
+            if (quicStats && typeof quicStats.rtt === 'number') {
+                store.connection.rtt = quicStats.rtt;
+            }
+        }
+        store.connection.reused = Boolean(socket.reused);
+    }
+});
+function mapTimeoutOptions(requestTimeout, transportDefaults) {
+    return {
+        connectTimeout: requestTimeout?.connect ??
+            requestTimeout?.secureConnect ??
+            transportDefaults?.connectTimeout,
+        headersTimeout: requestTimeout?.response ??
+            transportDefaults?.headersTimeout,
+        bodyTimeout: requestTimeout?.send ??
+            transportDefaults?.bodyTimeout,
+        totalTimeout: requestTimeout?.request
+    };
+}
+export class UndiciTransport {
+    static requestCounter = 0;
+    baseUrl;
+    options;
+    proxyAgent;
+    dnsAgent;
+    agentManager;
+    proxyBypassList;
+    tlsOptions;
+    socketClient;
+    observability;
+    constructor(baseUrl, options = {}) {
+        this.baseUrl = baseUrl || '';
+        this.options = options;
+        this.tlsOptions = options.tls;
+        this.observability = options.observability !== false;
+        if (options.proxy) {
+            const proxyConfig = typeof options.proxy === 'string'
+                ? { url: options.proxy }
+                : options.proxy;
+            const proxyUrl = new URL(proxyConfig.url);
+            const proxyType = proxyConfig.type || detectProxyType(proxyUrl.protocol);
+            if (proxyType?.startsWith('socks')) {
+                throw new NetworkError(`SOCKS proxy (${proxyType}) is not supported. Use an HTTP/HTTPS proxy or a SOCKS-to-HTTP bridge.`, 'ERR_UNSUPPORTED_PROXY_TYPE');
+            }
+            const proxyAuth = proxyConfig.auth
+                ? `${proxyConfig.auth.username}:${proxyConfig.auth.password}`
+                : undefined;
+            const finalProxyUrl = proxyAuth
+                ? proxyConfig.url.replace('://', `://${proxyAuth}@`)
+                : proxyConfig.url;
+            this.proxyBypassList = proxyConfig.bypass;
+            const proxyAgentOptions = {
+                uri: finalProxyUrl,
+                headers: proxyConfig.headers,
+                token: proxyConfig.token,
+                proxyTunnel: proxyConfig.tunnel,
+                requestTls: mapTlsOptions(proxyConfig.requestTls ?? options.tls),
+                proxyTls: mapTlsOptions(proxyConfig.proxyTls),
+            };
+            if (proxyConfig.connectTimeout) {
+                proxyAgentOptions.connectTimeout = proxyConfig.connectTimeout;
+            }
+            if (proxyConfig.http2) {
+                if (!proxyAgentOptions.requestTls) {
+                    proxyAgentOptions.requestTls = {};
+                }
+                proxyAgentOptions.requestTls.ALPNProtocols = ['h2', 'http/1.1'];
+            }
+            this.proxyAgent = new ProxyAgent(proxyAgentOptions);
+        }
+        this.agentManager = options.agent;
+        if (options.dns && !this.agentManager) {
+            const lookupFn = createLookupFunction(options.dns);
+            this.dnsAgent = new Agent({
+                connect: {
+                    lookup: lookupFn,
+                },
+            });
+        }
+        if (!this.agentManager) {
+            this.agentManager = new AgentManager({
+                connections: options.connections,
+                pipelining: options.pipelining,
+                keepAlive: options.keepAlive,
+                keepAliveTimeout: options.keepAliveTimeout,
+                keepAliveMaxTimeout: options.keepAliveMaxTimeout,
+                connectTimeout: options.connectTimeout,
+                perDomainPooling: options.perDomainPooling,
+                localAddress: options.localAddress,
+            });
+        }
+        if (options.socketPath && baseUrl) {
+            this.socketClient = new Client(baseUrl, {
+                socketPath: options.socketPath
+            });
+        }
+    }
+    async dispatch(req) {
+        const headers = Object.fromEntries(req.headers);
+        const contentLengthHeader = headers['content-length'];
+        const uploadTotal = contentLengthHeader ? parseInt(contentLengthHeader, 10) : undefined;
+        let currentUrl;
+        if (this.baseUrl) {
+            const path = req.url.startsWith(this.baseUrl) ? req.url.substring(this.baseUrl.length) : req.url;
+            currentUrl = new URL(path, this.baseUrl).toString();
+        }
+        else {
+            currentUrl = req.url;
+        }
+        const handleRedirectsManually = Boolean(req.beforeRedirect);
+        const maxRedirects = req.maxRedirects ?? 20;
+        const followRedirects = req.followRedirects !== false;
+        const timeouts = mapTimeoutOptions(req.timeout, {
+            connectTimeout: this.options.connectTimeout,
+            headersTimeout: this.options.headersTimeout,
+            bodyTimeout: this.options.bodyTimeout
+        });
+        let timeoutController;
+        let timeoutId;
+        if (!this.observability) {
+            return this.dispatchFast(req, headers, currentUrl, timeouts, handleRedirectsManually, maxRedirects, followRedirects, uploadTotal);
+        }
+        const requestContext = {
+            timings: {},
+            connection: {},
+            requestStartTime: 0,
+            requestCorrelationId: `r${++UndiciTransport.requestCounter}`,
+            hooks: req._hooks
+        };
+        return requestStorage.run(requestContext, async () => {
+            try {
+                const startTime = performance.now();
+                if (requestContext.requestStartTime === 0) {
+                    requestContext.requestStartTime = startTime;
+                }
+                let redirectCount = 0;
+                let currentMethod = req.method;
+                let currentBody = req.body;
+                let currentHeaders = { ...headers };
+                let effectiveSignal = req.signal;
+                if (timeouts.totalTimeout) {
+                    timeoutController = new AbortController();
+                    if (req.signal) {
+                        const originalSignal = req.signal;
+                        effectiveSignal = timeoutController.signal;
+                        const onOriginalAbort = () => {
+                            timeoutController.abort();
+                        };
+                        if (originalSignal.aborted) {
+                            timeoutController.abort();
+                        }
+                        else {
+                            originalSignal.addEventListener('abort', onOriginalAbort, { once: true });
+                        }
+                    }
+                    else {
+                        effectiveSignal = timeoutController.signal;
+                    }
+                    timeoutId = setTimeout(() => {
+                        timeoutController.abort();
+                    }, timeouts.totalTimeout);
+                }
+                while (true) {
+                    const dispatcher = this.socketClient || determineDispatcher({
+                        explicit: req._dispatcher,
+                        proxyAgent: this.proxyAgent,
+                        agentManager: this.agentManager,
+                        dnsAgent: this.dnsAgent,
+                        url: currentUrl,
+                        bypass: this.proxyBypassList
+                    });
+                    const bodyWithProgress = redirectCount === 0
+                        ? wrapUploadBody(currentBody, req.onUploadProgress, uploadTotal)
+                        : currentBody;
+                    let finalBody = bodyWithProgress;
+                    if (finalBody instanceof FormData) {
+                        const tempResponse = new Response(finalBody);
+                        finalBody = tempResponse.body;
+                        tempResponse.headers.forEach((value, key) => {
+                            if (key.toLowerCase() === 'content-type') {
+                                currentHeaders[key] = value;
+                                delete currentHeaders['Content-Type'];
+                            }
+                            else if (!currentHeaders[key]) {
+                                currentHeaders[key] = value;
+                            }
+                        });
+                    }
+                    const undiciOptions = {
+                        method: currentMethod,
+                        headers: currentHeaders,
+                        body: finalBody,
+                        signal: effectiveSignal,
+                        dispatcher: dispatcher,
+                        connectTimeout: timeouts.connectTimeout,
+                        headersTimeout: timeouts.headersTimeout,
+                        bodyTimeout: timeouts.bodyTimeout,
+                        maxRedirections: 0,
+                    };
+                    if (finalBody && (finalBody instanceof ReadableStream ||
+                        (typeof finalBody.pipe === 'function') ||
+                        finalBody[Symbol.asyncIterator])) {
+                        undiciOptions.duplex = 'half';
+                    }
+                    const tlsOptions = mapTlsOptions(this.tlsOptions);
+                    if (tlsOptions) {
+                        undiciOptions.tls = tlsOptions;
+                    }
+                    const http2Enabled = req.http2 !== undefined
+                        ? req.http2
+                        : this.options.http2?.enabled;
+                    if (http2Enabled) {
+                        undiciOptions.allowH2 = true;
+                    }
+                    else if (req.http2 === false) {
+                        undiciOptions.allowH2 = false;
+                    }
+                    if (http2Enabled && this.options.http2) {
+                        if (this.options.http2.maxConcurrentStreams !== undefined) {
+                            undiciOptions.maxConcurrentStreams = this.options.http2.maxConcurrentStreams;
+                        }
+                        if (this.options.http2.pipelining !== undefined) {
+                            undiciOptions.pipelining = this.options.http2.pipelining;
+                        }
+                    }
+                    let undiciResponse;
+                    if (this.socketClient) {
+                        const urlPath = new URL(currentUrl).pathname + new URL(currentUrl).search;
+                        undiciResponse = await this.socketClient.request({
+                            path: urlPath || '/',
+                            method: currentMethod,
+                            headers: currentHeaders,
+                            body: bodyWithProgress,
+                            signal: req.signal,
+                        });
+                    }
+                    else {
+                        undiciResponse = await undiciRequest(currentUrl, undiciOptions);
+                    }
+                    const statusCode = undiciResponse.statusCode;
+                    const isRedirect = statusCode >= 300 && statusCode < 400;
+                    if (isRedirect && followRedirects && redirectCount < maxRedirects) {
+                        const locationHeader = undiciResponse.headers['location'];
+                        const location = Array.isArray(locationHeader) ? locationHeader[0] : locationHeader;
+                        if (location) {
+                            const nextUrl = new URL(location, currentUrl).toString();
+                            if (handleRedirectsManually) {
+                                const responseHeaders = new Headers();
+                                for (const [key, value] of Object.entries(undiciResponse.headers)) {
+                                    if (value !== undefined) {
+                                        if (Array.isArray(value)) {
+                                            value.forEach(v => responseHeaders.append(key, v));
+                                        }
+                                        else {
+                                            responseHeaders.set(key, value);
+                                        }
+                                    }
+                                }
+                                const redirectInfo = {
+                                    from: currentUrl,
+                                    to: nextUrl,
+                                    status: statusCode,
+                                    headers: responseHeaders,
+                                };
+                                const hookResult = await req.beforeRedirect(redirectInfo);
+                                if (hookResult === false) {
+                                    const finalResponse = req.onDownloadProgress
+                                        ? wrapDownloadResponse(undiciResponse, req.onDownloadProgress)
+                                        : undiciResponse;
+                                    return new HttpResponse(finalResponse, {
+                                        timings: requestContext.timings,
+                                        connection: requestContext.connection
+                                    });
+                                }
+                                if (typeof hookResult === 'string') {
+                                    currentUrl = hookResult;
+                                }
+                                else {
+                                    currentUrl = nextUrl;
+                                }
+                            }
+                            else {
+                                currentUrl = nextUrl;
+                            }
+                            if (statusCode === 303 || ((statusCode === 301 || statusCode === 302) && currentMethod !== 'GET' && currentMethod !== 'HEAD')) {
+                                currentMethod = 'GET';
+                                currentBody = null;
+                                delete currentHeaders['content-type'];
+                                delete currentHeaders['content-length'];
+                                delete currentHeaders['Content-Type'];
+                                delete currentHeaders['Content-Length'];
+                            }
+                            await undiciResponse.body.arrayBuffer().catch(() => { });
+                            redirectCount++;
+                            continue;
+                        }
+                    }
+                    const finalResponse = req.onDownloadProgress
+                        ? wrapDownloadResponse(undiciResponse, req.onDownloadProgress)
+                        : undiciResponse;
+                    const ttfb = performance.now() - startTime;
+                    const totalTime = performance.now() - requestContext.requestStartTime;
+                    if (!requestContext.timings.firstByte) {
+                        requestContext.timings.firstByte = ttfb;
+                    }
+                    if (!requestContext.timings.total) {
+                        requestContext.timings.total = totalTime;
+                    }
+                    return new HttpResponse(finalResponse, {
+                        timings: requestContext.timings,
+                        connection: requestContext.connection
+                    });
+                }
+            }
+            catch (error) {
+                if (error instanceof undiciErrors.ConnectTimeoutError || error.code === 'UND_ERR_CONNECT_TIMEOUT') {
+                    throw new TimeoutError(req, {
+                        phase: 'connect',
+                        timeout: timeouts.connectTimeout
+                    });
+                }
+                if (error instanceof undiciErrors.HeadersTimeoutError || error.code === 'UND_ERR_HEADERS_TIMEOUT') {
+                    throw new TimeoutError(req, {
+                        phase: 'response',
+                        timeout: timeouts.headersTimeout
+                    });
+                }
+                if (error instanceof undiciErrors.BodyTimeoutError || error.code === 'UND_ERR_BODY_TIMEOUT') {
+                    throw new TimeoutError(req, {
+                        phase: 'send',
+                        timeout: timeouts.bodyTimeout
+                    });
+                }
+                if (error.name === 'AbortError' || error.code === 'ABORT_ERR') {
+                    throw new TimeoutError(req, {
+                        phase: 'request',
+                        timeout: timeouts.totalTimeout
+                    });
+                }
+                const code = error.code || error?.cause?.code;
+                if (code === 'UND_ERR_HEADERS_OVERFLOW') {
+                    throw new MaxSizeExceededError(16 * 1024, undefined, req);
+                }
+                throw new NetworkError(error.message, code, req);
+            }
+            finally {
+                if (timeoutId) {
+                    clearTimeout(timeoutId);
+                }
+            }
+        });
+    }
+    async dispatchFast(req, headers, currentUrl, timeouts, handleRedirectsManually, maxRedirects, followRedirects, uploadTotal) {
+        let timeoutController;
+        let timeoutId;
+        try {
+            let redirectCount = 0;
+            let currentMethod = req.method;
+            let currentBody = req.body;
+            let currentHeaders = { ...headers };
+            let effectiveSignal = req.signal;
+            if (timeouts.totalTimeout) {
+                timeoutController = new AbortController();
+                if (req.signal) {
+                    const originalSignal = req.signal;
+                    effectiveSignal = timeoutController.signal;
+                    const onOriginalAbort = () => {
+                        timeoutController.abort();
+                    };
+                    if (originalSignal.aborted) {
+                        timeoutController.abort();
+                    }
+                    else {
+                        originalSignal.addEventListener('abort', onOriginalAbort, { once: true });
+                    }
+                }
+                else {
+                    effectiveSignal = timeoutController.signal;
+                }
+                timeoutId = setTimeout(() => {
+                    timeoutController.abort();
+                }, timeouts.totalTimeout);
+            }
+            while (true) {
+                const dispatcher = this.socketClient || determineDispatcher({
+                    explicit: req._dispatcher,
+                    proxyAgent: this.proxyAgent,
+                    agentManager: this.agentManager,
+                    dnsAgent: this.dnsAgent,
+                    url: currentUrl,
+                    bypass: this.proxyBypassList
+                });
+                const bodyWithProgress = redirectCount === 0
+                    ? wrapUploadBody(currentBody, req.onUploadProgress, uploadTotal)
+                    : currentBody;
+                let finalBody = bodyWithProgress;
+                if (finalBody instanceof FormData) {
+                    const tempResponse = new Response(finalBody);
+                    finalBody = tempResponse.body;
+                    tempResponse.headers.forEach((value, key) => {
+                        if (key.toLowerCase() === 'content-type') {
+                            currentHeaders[key] = value;
+                            delete currentHeaders['Content-Type'];
+                        }
+                        else if (!currentHeaders[key]) {
+                            currentHeaders[key] = value;
+                        }
+                    });
+                }
+                const undiciOptions = {
+                    method: currentMethod,
+                    headers: currentHeaders,
+                    body: finalBody,
+                    signal: effectiveSignal,
+                    dispatcher: dispatcher,
+                    connectTimeout: timeouts.connectTimeout,
+                    headersTimeout: timeouts.headersTimeout,
+                    bodyTimeout: timeouts.bodyTimeout,
+                    maxRedirections: 0,
+                };
+                if (finalBody && (finalBody instanceof ReadableStream ||
+                    (typeof finalBody.pipe === 'function') ||
+                    finalBody[Symbol.asyncIterator])) {
+                    undiciOptions.duplex = 'half';
+                }
+                const tlsOptions = mapTlsOptions(this.tlsOptions);
+                if (tlsOptions) {
+                    undiciOptions.tls = tlsOptions;
+                }
+                const http2Enabled = req.http2 !== undefined
+                    ? req.http2
+                    : this.options.http2?.enabled;
+                if (http2Enabled) {
+                    undiciOptions.allowH2 = true;
+                }
+                else if (req.http2 === false) {
+                    undiciOptions.allowH2 = false;
+                }
+                if (http2Enabled && this.options.http2) {
+                    if (this.options.http2.maxConcurrentStreams !== undefined) {
+                        undiciOptions.maxConcurrentStreams = this.options.http2.maxConcurrentStreams;
+                    }
+                    if (this.options.http2.pipelining !== undefined) {
+                        undiciOptions.pipelining = this.options.http2.pipelining;
+                    }
+                }
+                let undiciResponse;
+                if (this.socketClient) {
+                    const urlPath = new URL(currentUrl).pathname + new URL(currentUrl).search;
+                    undiciResponse = await this.socketClient.request({
+                        path: urlPath || '/',
+                        method: currentMethod,
+                        headers: currentHeaders,
+                        body: bodyWithProgress,
+                        signal: req.signal,
+                    });
+                }
+                else {
+                    undiciResponse = await undiciRequest(currentUrl, undiciOptions);
+                }
+                const statusCode = undiciResponse.statusCode;
+                const isRedirect = statusCode >= 300 && statusCode < 400;
+                if (isRedirect && followRedirects && redirectCount < maxRedirects) {
+                    const locationHeader = undiciResponse.headers['location'];
+                    const location = Array.isArray(locationHeader) ? locationHeader[0] : locationHeader;
+                    if (location) {
+                        const nextUrl = new URL(location, currentUrl).toString();
+                        if (handleRedirectsManually) {
+                            const responseHeaders = new Headers();
+                            for (const [key, value] of Object.entries(undiciResponse.headers)) {
+                                if (value !== undefined) {
+                                    if (Array.isArray(value)) {
+                                        value.forEach(v => responseHeaders.append(key, v));
+                                    }
+                                    else {
+                                        responseHeaders.set(key, value);
+                                    }
+                                }
+                            }
+                            const redirectInfo = {
+                                from: currentUrl,
+                                to: nextUrl,
+                                status: statusCode,
+                                headers: responseHeaders,
+                            };
+                            const hookResult = await req.beforeRedirect(redirectInfo);
+                            if (hookResult === false) {
+                                const finalResponse = req.onDownloadProgress
+                                    ? wrapDownloadResponse(undiciResponse, req.onDownloadProgress)
+                                    : undiciResponse;
+                                return new HttpResponse(finalResponse, {
+                                    timings: {},
+                                    connection: {}
+                                });
+                            }
+                            if (typeof hookResult === 'string') {
+                                currentUrl = hookResult;
+                            }
+                            else {
+                                currentUrl = nextUrl;
+                            }
+                        }
+                        else {
+                            currentUrl = nextUrl;
+                        }
+                        if (statusCode === 303 || ((statusCode === 301 || statusCode === 302) && currentMethod !== 'GET' && currentMethod !== 'HEAD')) {
+                            currentMethod = 'GET';
+                            currentBody = null;
+                            delete currentHeaders['content-type'];
+                            delete currentHeaders['content-length'];
+                            delete currentHeaders['Content-Type'];
+                            delete currentHeaders['Content-Length'];
+                        }
+                        await undiciResponse.body.arrayBuffer().catch(() => { });
+                        redirectCount++;
+                        continue;
+                    }
+                }
+                const finalResponse = req.onDownloadProgress
+                    ? wrapDownloadResponse(undiciResponse, req.onDownloadProgress)
+                    : undiciResponse;
+                return new HttpResponse(finalResponse, {
+                    timings: {},
+                    connection: {}
+                });
+            }
+        }
+        catch (error) {
+            if (error instanceof undiciErrors.ConnectTimeoutError || error.code === 'UND_ERR_CONNECT_TIMEOUT') {
+                throw new TimeoutError(req, {
+                    phase: 'connect',
+                    timeout: timeouts.connectTimeout
+                });
+            }
+            if (error instanceof undiciErrors.HeadersTimeoutError || error.code === 'UND_ERR_HEADERS_TIMEOUT') {
+                throw new TimeoutError(req, {
+                    phase: 'response',
+                    timeout: timeouts.headersTimeout
+                });
+            }
+            if (error instanceof undiciErrors.BodyTimeoutError || error.code === 'UND_ERR_BODY_TIMEOUT') {
+                throw new TimeoutError(req, {
+                    phase: 'send',
+                    timeout: timeouts.bodyTimeout
+                });
+            }
+            if (error.name === 'AbortError' || error.code === 'ABORT_ERR') {
+                throw new TimeoutError(req, {
+                    phase: 'request',
+                    timeout: timeouts.totalTimeout
+                });
+            }
+            const code = error.code || error?.cause?.code;
+            if (code === 'UND_ERR_HEADERS_OVERFLOW') {
+                throw new MaxSizeExceededError(16 * 1024, undefined, req);
+            }
+            throw new NetworkError(error.message, code, req);
+        }
+        finally {
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+        }
+    }
+}
+function mapTlsOptions(options) {
+    if (!options)
+        return undefined;
+    const tls = {};
+    if (options.minVersion)
+        tls.minVersion = options.minVersion;
+    if (options.maxVersion)
+        tls.maxVersion = options.maxVersion;
+    if (options.ciphers)
+        tls.ciphers = options.ciphers;
+    if (options.honorCipherOrder !== undefined)
+        tls.honorCipherOrder = options.honorCipherOrder;
+    if (options.ca)
+        tls.ca = options.ca;
+    if (options.cert)
+        tls.cert = options.cert;
+    if (options.key)
+        tls.key = options.key;
+    if (options.passphrase)
+        tls.passphrase = options.passphrase;
+    if (options.rejectUnauthorized !== undefined)
+        tls.rejectUnauthorized = options.rejectUnauthorized;
+    if (options.alpnProtocols)
+        tls.ALPNProtocols = options.alpnProtocols;
+    if (options.sessionTimeout !== undefined)
+        tls.sessionTimeout = options.sessionTimeout;
+    if (options.sessionIdContext)
+        tls.sessionIdContext = options.sessionIdContext;
+    if (options.servername !== undefined) {
+        tls.servername = options.servername === false ? '' : options.servername;
+    }
+    return tls;
+}
+function determineDispatcher(params) {
+    if (params.explicit)
+        return params.explicit;
+    const { proxyAgent, agentManager, dnsAgent, url, bypass } = params;
+    const bypassProxy = shouldBypassProxy(url, bypass);
+    if (proxyAgent && !bypassProxy)
+        return proxyAgent;
+    if (agentManager)
+        return agentManager.getAgentForUrl(url);
+    if (dnsAgent)
+        return dnsAgent;
+    return undefined;
+}
+function detectProxyType(protocol) {
+    const p = protocol.toLowerCase().replace(':', '');
+    switch (p) {
+        case 'http':
+            return 'http';
+        case 'https':
+            return 'https';
+        case 'socks4':
+            return 'socks4';
+        case 'socks4a':
+            return 'socks4a';
+        case 'socks5':
+        case 'socks':
+            return 'socks5';
+        default:
+            return undefined;
+    }
+}
+function matchesCIDR(ip, cidr) {
+    const [range, bits] = cidr.split('/');
+    if (!bits)
+        return ip === range;
+    const mask = parseInt(bits, 10);
+    if (isNaN(mask))
+        return false;
+    const ipParts = ip.split('.').map(Number);
+    const rangeParts = range.split('.').map(Number);
+    if (ipParts.length !== 4 || rangeParts.length !== 4)
+        return false;
+    if (ipParts.some(isNaN) || rangeParts.some(isNaN))
+        return false;
+    const ipNum = (ipParts[0] << 24) | (ipParts[1] << 16) | (ipParts[2] << 8) | ipParts[3];
+    const rangeNum = (rangeParts[0] << 24) | (rangeParts[1] << 16) | (rangeParts[2] << 8) | rangeParts[3];
+    const maskNum = ~((1 << (32 - mask)) - 1);
+    return (ipNum & maskNum) === (rangeNum & maskNum);
+}
+function shouldBypassProxy(url, bypass) {
+    if (!bypass || bypass.length === 0)
+        return false;
+    let hostname = '';
+    let port = '';
+    try {
+        const parsed = new URL(url);
+        hostname = parsed.hostname;
+        port = parsed.port;
+    }
+    catch {
+        return false;
+    }
+    for (const rule of bypass) {
+        if (rule === '*')
+            return true;
+        if (rule.includes('/')) {
+            if (matchesCIDR(hostname, rule))
+                return true;
+            continue;
+        }
+        if (rule.includes(':') && !rule.includes('/')) {
+            const [hostRule, portRule] = rule.split(':');
+            if (hostname === hostRule && (!portRule || port === portRule))
+                return true;
+            continue;
+        }
+        if (rule.startsWith('*.')) {
+            const suffix = rule.slice(1);
+            if (hostname.endsWith(suffix))
+                return true;
+            continue;
+        }
+        if (rule.startsWith('.')) {
+            if (hostname.endsWith(rule))
+                return true;
+            continue;
+        }
+        if (hostname === rule) {
+            return true;
+        }
+    }
+    return false;
+}
+function parseContentLength(headers) {
+    if (!headers)
+        return undefined;
+    if (typeof headers.get === 'function') {
+        const raw = headers.get('content-length');
+        return raw ? parseInt(raw, 10) : undefined;
+    }
+    const raw = headers['content-length'] ?? headers['Content-Length'];
+    if (raw === undefined)
+        return undefined;
+    const parsed = parseInt(Array.isArray(raw) ? raw[0] : raw, 10);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function wrapDownloadResponse(response, onProgress) {
+    if (!onProgress)
+        return response;
+    if (typeof Response !== 'undefined' && response instanceof Response) {
+        if (!response.body)
+            return response;
+        const total = parseContentLength(response.headers);
+        const body = createProgressStream(response.body, onProgress, {
+            total,
+            direction: 'download'
+        });
+        return new Response(body, {
+            status: response.status,
+            statusText: response.statusText,
+            headers: response.headers
+        });
+    }
+    const total = parseContentLength(response.headers);
+    const nodeBody = response.body;
+    if (!nodeBody)
+        return response;
+    const webBody = createProgressStream(nodeToWebStream(nodeBody), onProgress, {
+        total,
+        direction: 'download'
+    });
+    return new Response(webBody, {
+        status: response.statusCode,
+        statusText: String(response.statusCode),
+        headers: response.headers
+    });
+}
+function wrapUploadBody(body, onProgress, total) {
+    if (body instanceof FormData) {
+        return body;
+    }
+    if (!onProgress || !body)
+        return body;
+    if (typeof ReadableStream !== 'undefined' && body instanceof ReadableStream) {
+        return createProgressStream(body, onProgress, { total, direction: 'upload' });
+    }
+    if (typeof Blob !== 'undefined' && body instanceof Blob) {
+        return createProgressStream(body.stream(), onProgress, { total: body.size, direction: 'upload' });
+    }
+    if (isNodeReadable(body)) {
+        const webStream = nodeToWebStream(body);
+        return createProgressStream(webStream, onProgress, { total, direction: 'upload' });
+    }
+    if (body instanceof ArrayBuffer || ArrayBuffer.isView(body)) {
+        const view = body instanceof ArrayBuffer
+            ? new Uint8Array(body)
+            : new Uint8Array(body.buffer, body.byteOffset, body.byteLength);
+        return bufferToProgressStream(view, onProgress);
+    }
+    if (typeof body === 'string') {
+        const encoder = new TextEncoder();
+        const view = encoder.encode(body);
+        return bufferToProgressStream(view, onProgress);
+    }
+    return body;
+}
+function bufferToProgressStream(buffer, onProgress, chunkSize = 64 * 1024) {
+    let offset = 0;
+    const total = buffer.byteLength;
+    const stream = new ReadableStream({
+        pull(controller) {
+            if (offset >= total) {
+                controller.close();
+                return;
+            }
+            const end = Math.min(offset + chunkSize, total);
+            controller.enqueue(buffer.slice(offset, end));
+            offset = end;
+        }
+    });
+    return createProgressStream(stream, onProgress, { total, direction: 'upload' });
+}
+function isNodeReadable(obj) {
+    return obj && typeof obj.pipe === 'function' && typeof obj.on === 'function';
+}