recker 1.0.2-0

package/dist/plugins/server-timing.js

@@ -0,0 +1,24 @@
+export function serverTiming() {
+    return (client) => {
+        client.afterResponse((req, res) => {
+            const header = res.headers.get('server-timing');
+            if (!header)
+                return;
+            const timings = header.split(',').map(entry => {
+                const parts = entry.split(';');
+                const name = parts[0].trim();
+                let duration;
+                let description;
+                for (let i = 1; i < parts.length; i++) {
+                    const [key, val] = parts[i].split('=').map(s => s.trim());
+                    if (key === 'dur')
+                        duration = parseFloat(val);
+                    if (key === 'desc')
+                        description = val?.replace(/"/g, '');
+                }
+                return { name, duration, description };
+            });
+            res.serverTimings = timings;
+        });
+    };
+}

package/dist/plugins/xsrf.d.ts

@@ -0,0 +1,10 @@
+import { Middleware } from '../types/index.js';
+export interface XSRFPluginOptions {
+    cookieName?: string;
+    headerName?: string;
+    token?: string;
+    cookies?: string;
+}
+export declare function xsrf(options?: XSRFPluginOptions): Middleware;
+export declare function createXSRFMiddleware(config: boolean | XSRFPluginOptions): Middleware | null;
+//# sourceMappingURL=xsrf.d.ts.map

package/dist/plugins/xsrf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xsrf.d.ts","sourceRoot":"","sources":["../../src/plugins/xsrf.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAE/C,MAAM,WAAW,iBAAiB;IAKhC,UAAU,CAAC,EAAE,MAAM,CAAC;IAKpB,UAAU,CAAC,EAAE,MAAM,CAAC;IAKpB,KAAK,CAAC,EAAE,MAAM,CAAC;IAKf,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAuED,wBAAgB,IAAI,CAAC,OAAO,GAAE,iBAAsB,GAAG,UAAU,CAsBhE;AAMD,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,OAAO,GAAG,iBAAiB,GAAG,UAAU,GAAG,IAAI,CAU3F"}

package/dist/plugins/xsrf.js

@@ -0,0 +1,48 @@
+function parseCookies(cookieString) {
+    const cookies = {};
+    if (!cookieString) {
+        return cookies;
+    }
+    const pairs = cookieString.split(';');
+    for (const pair of pairs) {
+        const [key, ...valueParts] = pair.split('=');
+        const trimmedKey = key?.trim();
+        const value = valueParts.join('=').trim();
+        if (trimmedKey) {
+            cookies[trimmedKey] = decodeURIComponent(value || '');
+        }
+    }
+    return cookies;
+}
+function getXSRFToken(cookieName, cookies) {
+    if (cookies) {
+        const parsed = parseCookies(cookies);
+        return parsed[cookieName] || null;
+    }
+    if (typeof document !== 'undefined' && document.cookie) {
+        const parsed = parseCookies(document.cookie);
+        return parsed[cookieName] || null;
+    }
+    return null;
+}
+export function xsrf(options = {}) {
+    const { cookieName = 'XSRF-TOKEN', headerName = 'X-XSRF-TOKEN', token: manualToken, cookies } = options;
+    return async (req, next) => {
+        const token = manualToken || getXSRFToken(cookieName, cookies);
+        if (token) {
+            if (!req.headers.has(headerName)) {
+                req.headers.set(headerName, token);
+            }
+        }
+        return next(req);
+    };
+}
+export function createXSRFMiddleware(config) {
+    if (!config) {
+        return null;
+    }
+    if (config === true) {
+        return xsrf();
+    }
+    return xsrf(config);
+}

package/dist/runner/request-runner.d.ts

@@ -0,0 +1,47 @@
+import { EventEmitter } from 'events';
+export interface RunnerOptions {
+    concurrency?: number;
+    retries?: number;
+    retryDelay?: number;
+}
+export interface RequestTask<T = any> {
+    id: string;
+    fn: () => Promise<T>;
+    priority: number;
+    retries?: number;
+}
+export interface RunnerResult<T = any> {
+    results: (T | Error)[];
+    stats: {
+        total: number;
+        successful: number;
+        failed: number;
+        duration: number;
+    };
+}
+export declare class RequestRunner extends EventEmitter {
+    private concurrency;
+    private queue;
+    private activeCount;
+    private paused;
+    private results;
+    private stats;
+    private startTime;
+    constructor(options?: RunnerOptions);
+    add<T>(fn: () => Promise<T>, options?: {
+        priority?: number;
+        id?: string;
+    }): void;
+    run<T>(items: any[], processor: (item: any, index: number) => Promise<T>, options?: {
+        priority?: number;
+    }): Promise<RunnerResult<T>>;
+    private processNext;
+    getProgress(): {
+        total: number;
+        completed: number;
+        pending: number;
+        active: number;
+        percent: number;
+    };
+}
+//# sourceMappingURL=request-runner.d.ts.map

package/dist/runner/request-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-runner.d.ts","sourceRoot":"","sources":["../../src/runner/request-runner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAItC,MAAM,WAAW,aAAa;IAC5B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,WAAW,CAAC,CAAC,GAAG,GAAG;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,YAAY,CAAC,CAAC,GAAG,GAAG;IACnC,OAAO,EAAE,CAAC,CAAC,GAAG,KAAK,CAAC,EAAE,CAAC;IACvB,KAAK,EAAE;QACL,KAAK,EAAE,MAAM,CAAC;QACd,UAAU,EAAE,MAAM,CAAC;QACnB,MAAM,EAAE,MAAM,CAAC;QACf,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC;CACH;AAED,qBAAa,aAAc,SAAQ,YAAY;IAC7C,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,KAAK,CAAqB;IAClC,OAAO,CAAC,WAAW,CAAa;IAChC,OAAO,CAAC,MAAM,CAAkB;IAChC,OAAO,CAAC,OAAO,CAA+B;IAC9C,OAAO,CAAC,KAAK,CAA0C;IACvD,OAAO,CAAC,SAAS,CAAa;gBAElB,OAAO,GAAE,aAAkB;IAKhC,GAAG,CAAC,CAAC,EACV,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACpB,OAAO,GAAE;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,EAAE,CAAC,EAAE,MAAM,CAAA;KAAO,GAC/C,IAAI;IAWM,GAAG,CAAC,CAAC,EAChB,KAAK,EAAE,GAAG,EAAE,EACZ,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,EACnD,OAAO,GAAE;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAO,GAClC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;YA+Bb,WAAW;IA8BlB,WAAW;;;;;;;CAUnB"}

package/dist/runner/request-runner.js

@@ -0,0 +1,89 @@
+import { EventEmitter } from 'events';
+export class RequestRunner extends EventEmitter {
+    concurrency;
+    queue = [];
+    activeCount = 0;
+    paused = false;
+    results = new Map();
+    stats = { total: 0, successful: 0, failed: 0 };
+    startTime = 0;
+    constructor(options = {}) {
+        super();
+        this.concurrency = options.concurrency || 5;
+    }
+    add(fn, options = {}) {
+        this.queue.push({
+            id: options.id || Math.random().toString(36).slice(2),
+            fn,
+            priority: options.priority || 0,
+        });
+        this.queue.sort((a, b) => b.priority - a.priority);
+        this.stats.total++;
+        this.processNext();
+    }
+    async run(items, processor, options = {}) {
+        this.startTime = Date.now();
+        this.stats = { total: items.length, successful: 0, failed: 0 };
+        this.results.clear();
+        const promises = items.map((item, index) => {
+            return new Promise((resolve) => {
+                this.add(async () => {
+                    try {
+                        const res = await processor(item, index);
+                        resolve(res);
+                        return res;
+                    }
+                    catch (err) {
+                        resolve(err);
+                        throw err;
+                    }
+                }, { priority: options.priority, id: String(index) });
+            });
+        });
+        const results = await Promise.all(promises);
+        return {
+            results,
+            stats: {
+                ...this.stats,
+                duration: Date.now() - this.startTime
+            }
+        };
+    }
+    async processNext() {
+        if (this.paused || this.activeCount >= this.concurrency || this.queue.length === 0) {
+            return;
+        }
+        const task = this.queue.shift();
+        if (!task)
+            return;
+        this.activeCount++;
+        this.emit('taskStart', task);
+        try {
+            const result = await task.fn();
+            this.stats.successful++;
+            this.emit('taskComplete', { task, result });
+        }
+        catch (error) {
+            this.stats.failed++;
+            this.emit('taskError', { task, error });
+        }
+        finally {
+            this.activeCount--;
+            this.emit('progress', this.getProgress());
+            if (this.activeCount === 0 && this.queue.length === 0) {
+                this.emit('drained');
+            }
+            this.processNext();
+        }
+    }
+    getProgress() {
+        const completed = this.stats.successful + this.stats.failed;
+        return {
+            total: this.stats.total,
+            completed,
+            pending: this.queue.length,
+            active: this.activeCount,
+            percent: this.stats.total > 0 ? (completed / this.stats.total) * 100 : 0
+        };
+    }
+}

package/dist/transport/fetch.d.ts

@@ -0,0 +1,6 @@
+import { ReckerRequest, ReckerResponse, Transport } from '../types/index.js';
+export declare class FetchTransport implements Transport {
+    constructor();
+    dispatch(req: ReckerRequest): Promise<ReckerResponse>;
+}
+//# sourceMappingURL=fetch.d.ts.map

package/dist/transport/fetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch.d.ts","sourceRoot":"","sources":["../../src/transport/fetch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,SAAS,EAAW,MAAM,mBAAmB,CAAC;AAEtF,qBAAa,cAAe,YAAW,SAAS;;IAGxC,QAAQ,CAAC,GAAG,EAAE,aAAa,GAAG,OAAO,CAAC,cAAc,CAAC;CA6G5D"}

package/dist/transport/fetch.js

@@ -0,0 +1,153 @@
+export class FetchTransport {
+    constructor() { }
+    async dispatch(req) {
+        const start = performance.now();
+        const requestInit = {
+            method: req.method,
+            headers: req.headers,
+            body: req.body,
+            signal: req.signal,
+            duplex: req.body ? 'half' : undefined
+        };
+        try {
+            const response = await globalThis.fetch(req.url, requestInit);
+            const totalTime = performance.now() - start;
+            const timings = {
+                total: totalTime,
+                firstByte: totalTime,
+            };
+            const reckerResponse = {
+                status: response.status,
+                statusText: response.statusText,
+                headers: response.headers,
+                ok: response.ok,
+                url: response.url,
+                timings,
+                raw: response,
+                json: () => response.json(),
+                text: () => response.text(),
+                blob: () => response.blob(),
+                cleanText: async () => {
+                    const text = await response.text();
+                    return text.replace(/<[^>]*>?/gm, '');
+                },
+                read: () => response.body,
+                clone: () => {
+                    const cloned = response.clone();
+                    return createReckerResponseWrapper(cloned, timings);
+                },
+                async *sse() {
+                    if (!response.body)
+                        return;
+                    const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
+                    while (true) {
+                        const { done, value } = await reader.read();
+                        if (done)
+                            break;
+                        const lines = value.split('\n');
+                        for (const line of lines) {
+                            if (line.startsWith('data: ')) {
+                                yield { data: line.slice(6) };
+                            }
+                        }
+                    }
+                },
+                async *download() {
+                    if (!response.body)
+                        return;
+                    const reader = response.body.getReader();
+                    let loaded = 0;
+                    const total = Number(response.headers.get('content-length')) || 0;
+                    while (true) {
+                        const { done, value } = await reader.read();
+                        if (done)
+                            break;
+                        loaded += value.length;
+                        yield {
+                            loaded,
+                            total,
+                            percent: total ? (loaded / total) * 100 : undefined
+                        };
+                    }
+                },
+                async *[Symbol.asyncIterator]() {
+                    if (!response.body)
+                        return;
+                    const reader = response.body.getReader();
+                    while (true) {
+                        const { done, value } = await reader.read();
+                        if (done)
+                            break;
+                        yield value;
+                    }
+                }
+            };
+            return reckerResponse;
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+}
+function createReckerResponseWrapper(response, timings) {
+    return new FetchResponseWrapper(response, timings);
+}
+class FetchResponseWrapper {
+    raw;
+    timings;
+    constructor(raw, timings) {
+        this.raw = raw;
+        this.timings = timings;
+    }
+    get status() { return this.raw.status; }
+    get statusText() { return this.raw.statusText; }
+    get headers() { return this.raw.headers; }
+    get ok() { return this.raw.ok; }
+    get url() { return this.raw.url; }
+    get connection() { return {}; }
+    json() { return this.raw.json(); }
+    text() { return this.raw.text(); }
+    blob() { return this.raw.blob(); }
+    async cleanText() { return (await this.text()).replace(/<[^>]*>?/gm, ''); }
+    read() { return this.raw.body; }
+    clone() { return new FetchResponseWrapper(this.raw.clone(), this.timings); }
+    async *sse() {
+        if (!this.raw.body)
+            return;
+        const stream = this.raw.body.pipeThrough(new TextDecoderStream());
+        const reader = stream.getReader();
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            if (value.startsWith('data: ')) {
+                yield { data: value.slice(6) };
+            }
+        }
+    }
+    async *download() {
+        if (!this.raw.body)
+            return;
+        const reader = this.raw.body.getReader();
+        let loaded = 0;
+        const total = Number(this.raw.headers.get('content-length')) || 0;
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            loaded += value.length;
+            yield { loaded, total, percent: total ? (loaded / total) * 100 : 0 };
+        }
+    }
+    async *[Symbol.asyncIterator]() {
+        if (!this.raw.body)
+            return;
+        const reader = this.raw.body.getReader();
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            yield value;
+        }
+    }
+}

package/dist/transport/undici.d.ts

@@ -0,0 +1,23 @@
+import { ReckerRequest, ReckerResponse, Transport, ProxyOptions, HTTP2Options, DNSOptions } from '../types/index.js';
+import { AgentManager } from '../utils/agent-manager.js';
+interface UndiciTransportOptions {
+    connectTimeout?: number;
+    headersTimeout?: number;
+    bodyTimeout?: number;
+    maxRedirections?: number;
+    proxy?: ProxyOptions | string;
+    http2?: HTTP2Options;
+    dns?: DNSOptions;
+    agent?: AgentManager;
+}
+export declare class UndiciTransport implements Transport {
+    private baseUrl;
+    private options;
+    private proxyAgent?;
+    private dnsAgent?;
+    private agentManager?;
+    constructor(baseUrl: string, options?: UndiciTransportOptions);
+    dispatch(req: ReckerRequest): Promise<ReckerResponse>;
+}
+export {};
+//# sourceMappingURL=undici.d.ts.map

package/dist/transport/undici.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"undici.d.ts","sourceRoot":"","sources":["../../src/transport/undici.ts"],"names":[],"mappings":"AACA,OAAO,EAAkB,aAAa,EAAE,cAAc,EAAW,SAAS,EAAE,YAAY,EAAE,YAAY,EAAE,UAAU,EAAgB,MAAM,mBAAmB,CAAC;AAO5J,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAsNzD,UAAU,sBAAsB;IAC9B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,KAAK,CAAC,EAAE,YAAY,GAAG,MAAM,CAAC;IAC9B,KAAK,CAAC,EAAE,YAAY,CAAC;IACrB,GAAG,CAAC,EAAE,UAAU,CAAC;IACjB,KAAK,CAAC,EAAE,YAAY,CAAC;CACtB;AAED,qBAAa,eAAgB,YAAW,SAAS;IAC/C,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,OAAO,CAAyB;IACxC,OAAO,CAAC,UAAU,CAAC,CAAa;IAChC,OAAO,CAAC,QAAQ,CAAC,CAAQ;IACzB,OAAO,CAAC,YAAY,CAAC,CAAe;gBAExB,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,sBAA2B;IAiC3D,QAAQ,CAAC,GAAG,EAAE,aAAa,GAAG,OAAO,CAAC,cAAc,CAAC;CAmF5D"}

package/dist/transport/undici.js

@@ -0,0 +1,218 @@
+import { request as undiciRequest, errors as undiciErrors, ProxyAgent, Agent } from 'undici';
+import { HttpResponse } from '../core/response.js';
+import { NetworkError, TimeoutError } 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';
+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 && 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);
+    }
+});
+export class UndiciTransport {
+    baseUrl;
+    options;
+    proxyAgent;
+    dnsAgent;
+    agentManager;
+    constructor(baseUrl, options = {}) {
+        this.baseUrl = baseUrl;
+        this.options = options;
+        if (options.proxy) {
+            const proxyUrl = typeof options.proxy === 'string' ? options.proxy : options.proxy.url;
+            const proxyAuth = typeof options.proxy === 'object' && options.proxy.auth
+                ? `${options.proxy.auth.username}:${options.proxy.auth.password}`
+                : undefined;
+            const finalProxyUrl = proxyAuth
+                ? proxyUrl.replace('://', `://${proxyAuth}@`)
+                : proxyUrl;
+            this.proxyAgent = new ProxyAgent(finalProxyUrl);
+        }
+        this.agentManager = options.agent;
+        if (options.dns && !this.agentManager) {
+            const lookupFn = createLookupFunction(options.dns);
+            this.dnsAgent = new Agent({
+                connect: {
+                    lookup: lookupFn,
+                },
+            });
+        }
+    }
+    async dispatch(req) {
+        const headers = {};
+        req.headers.forEach((value, key) => {
+            headers[key] = value;
+        });
+        const path = req.url.startsWith(this.baseUrl) ? req.url.substring(this.baseUrl.length) : req.url;
+        const fullUrl = new URL(path, this.baseUrl).toString();
+        const requestContext = {
+            timings: {},
+            connection: {},
+            requestStartTime: 0,
+            requestCorrelationId: Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15),
+            hooks: req._hooks
+        };
+        return requestStorage.run(requestContext, async () => {
+            try {
+                const startTime = performance.now();
+                if (requestContext.requestStartTime === 0) {
+                    requestContext.requestStartTime = startTime;
+                }
+                const dispatcher = req._dispatcher || this.proxyAgent || this.dnsAgent;
+                const undiciOptions = {
+                    method: req.method,
+                    headers: headers,
+                    body: req.body,
+                    signal: req.signal,
+                    dispatcher: dispatcher,
+                    connectTimeout: this.options.connectTimeout,
+                    headersTimeout: this.options.headersTimeout,
+                    bodyTimeout: this.options.bodyTimeout,
+                    maxRedirections: this.options.maxRedirections,
+                };
+                if (this.options.http2) {
+                    if (this.options.http2.enabled) {
+                        undiciOptions.allowH2 = true;
+                    }
+                    if (this.options.http2.maxConcurrentStreams !== undefined) {
+                        undiciOptions.maxConcurrentStreams = this.options.http2.maxConcurrentStreams;
+                    }
+                    if (this.options.http2.pipelining !== undefined) {
+                        undiciOptions.pipelining = this.options.http2.pipelining;
+                    }
+                }
+                const undiciResponse = await undiciRequest(fullUrl, undiciOptions);
+                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(undiciResponse, {
+                    timings: requestContext.timings,
+                    connection: requestContext.connection
+                });
+            }
+            catch (error) {
+                if (error instanceof undiciErrors.ConnectTimeoutError ||
+                    error instanceof undiciErrors.HeadersTimeoutError ||
+                    error instanceof undiciErrors.BodyTimeoutError) {
+                    throw new TimeoutError(req);
+                }
+                if (error.code === 'UND_ERR_CONNECT_TIMEOUT' || error.code === 'UND_ERR_HEADERS_TIMEOUT') {
+                    throw new TimeoutError(req);
+                }
+                throw new NetworkError(error.message, error.code, req);
+            }
+        });
+    }
+}