@whatwg-node/node-fetch 0.5.0-alpha-20230710154907-66260af → 0.5.0-alpha-20230710180612-32e574f

package/cjs/Request.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PonyfillRequest = void 0;
 const Body_js_1 = require("./Body.js");
 const Headers_js_1 = require("./Headers.js");
-const utils_js_1 = require("./utils.js");
 function isRequest(input) {
     return input[Symbol.toStringTag] === 'Request';
 }
@@ -42,7 +41,7 @@ class PonyfillRequest extends Body_js_1.PonyfillBody {
         this.referrer = requestInit?.referrer || 'about:client';
         this.referrerPolicy = requestInit?.referrerPolicy || 'no-referrer';
         this._signal = requestInit?.signal;
-        this.headersSerializer = requestInit?.headersSerializer || utils_js_1.defaultHeadersSerializer;
+        this.headersSerializer = requestInit?.headersSerializer;
         this.url = url || '';
         this.destination = 'document';
         this.priority = 'auto';

package/cjs/fetch.js

@@ -1,46 +1,21 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchPonyfill = void 0;
-/* eslint-disable @typescript-eslint/no-this-alias */
 const fs_1 = require("fs");
-const stream_1 = require("stream");
 const url_1 = require("url");
 const Blob_js_1 = require("./Blob.js");
-const Headers_js_1 = require("./Headers.js");
+const fetchCurl_js_1 = require("./fetchCurl.js");
+const fetchNodeHttp_js_1 = require("./fetchNodeHttp.js");
 const Request_js_1 = require("./Request.js");
 const Response_js_1 = require("./Response.js");
-const URL_js_1 = require("./URL.js");
-const utils_js_1 = require("./utils.js");
+const BASE64_SUFFIX = ';base64';
 function getResponseForFile(url) {
     const path = (0, url_1.fileURLToPath)(url);
     const readable = (0, fs_1.createReadStream)(path);
     return new Response_js_1.PonyfillResponse(readable);
 }
 function getResponseForDataUri(url) {
-    const [mimeType = 'text/plain', ...datas] = url.pathname.split(',');
+    const [mimeType = 'text/plain', ...datas] = url.split(',');
     const data = decodeURIComponent(datas.join(','));
     if (mimeType.endsWith(BASE64_SUFFIX)) {
         const buffer = Buffer.from(data, 'base64url');
@@ -59,89 +34,23 @@ function getResponseForDataUri(url) {
         },
     });
 }
-const BASE64_SUFFIX = ';base64';
 async function fetchPonyfill(info, init) {
     if (typeof info === 'string' || 'href' in info) {
         const ponyfillRequest = new Request_js_1.PonyfillRequest(info, init);
         return fetchPonyfill(ponyfillRequest);
     }
     const fetchRequest = info;
-    const url = new URL_js_1.PonyfillURL(fetchRequest.url, 'http://localhost');
-    if (url.protocol === 'data:') {
-        const response = getResponseForDataUri(url);
+    if (fetchRequest.url.startsWith('data:')) {
+        const response = getResponseForDataUri(fetchRequest.url);
         return Promise.resolve(response);
     }
-    if (url.protocol === 'file:') {
+    if (fetchRequest.url.startsWith('file:')) {
         const response = getResponseForFile(fetchRequest.url);
         return Promise.resolve(response);
     }
-    const nodeReadable = (fetchRequest.body != null
-        ? 'pipe' in fetchRequest.body
-            ? fetchRequest.body
-            : stream_1.Readable.from(fetchRequest.body)
-        : null);
-    const headersSerializer = fetchRequest.headersSerializer || utils_js_1.defaultHeadersSerializer;
-    let size;
-    const curlyHeaders = headersSerializer(fetchRequest.headers, value => {
-        size = Number(value);
-    });
-    let easyNativeBinding;
-    const curlyOptions = {
-        // we want the unparsed binary response to be returned as a stream to us
-        curlyStreamResponse: true,
-        curlyResponseBodyParser: false,
-        curlyProgressCallback() {
-            if (easyNativeBinding == null) {
-                easyNativeBinding = this;
-            }
-            return fetchRequest.signal.aborted ? 1 : 0;
-        },
-        upload: nodeReadable != null,
-        transferEncoding: false,
-        httpTransferDecoding: true,
-        followLocation: fetchRequest.redirect === 'follow',
-        maxRedirs: 20,
-        acceptEncoding: '',
-        curlyStreamUpload: nodeReadable,
-        // this will just make libcurl use their own progress function (which is pretty neat)
-        // curlyProgressCallback() { return CurlProgressFunc.Continue },
-        // verbose: true,
-        httpHeader: curlyHeaders,
-        customRequest: fetchRequest.method,
-    };
-    if (size != null) {
-        curlyOptions.inFileSize = size;
+    if (globalThis.libcurl) {
+        return (0, fetchCurl_js_1.fetchCurl)(fetchRequest);
     }
-    const { curly, CurlCode, CurlPause } = globalThis['libcurl'] || (await Promise.resolve().then(() => __importStar(require('node-libcurl'))));
-    fetchRequest.signal.onabort = () => {
-        if (easyNativeBinding != null) {
-            easyNativeBinding.pause(CurlPause.Recv);
-        }
-    };
-    const curlyResult = await curly(fetchRequest.url, curlyOptions);
-    const responseHeaders = new Headers_js_1.PonyfillHeaders();
-    curlyResult.headers.forEach(headerInfo => {
-        for (const key in headerInfo) {
-            if (key === 'location' || (key === 'Location' && fetchRequest.redirect === 'error')) {
-                throw new Error('redirects are not allowed');
-            }
-            if (key !== 'result') {
-                responseHeaders.append(key, headerInfo[key]);
-            }
-        }
-    });
-    curlyResult.data.on('error', (err) => {
-        if (err.isCurlError && err.code === CurlCode.CURLE_ABORTED_BY_CALLBACK) {
-            // this is expected
-        }
-        else {
-            throw err;
-        }
-    });
-    return new Response_js_1.PonyfillResponse(curlyResult.data, {
-        status: curlyResult.statusCode,
-        headers: responseHeaders,
-        url: info.url,
-    });
+    return (0, fetchNodeHttp_js_1.fetchNodeHttp)(fetchRequest);
 }
 exports.fetchPonyfill = fetchPonyfill;

package/cjs/fetchCurl.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchCurl = void 0;
+/* eslint-disable @typescript-eslint/no-this-alias */
+const stream_1 = require("stream");
+const Headers_js_1 = require("./Headers.js");
+const Response_js_1 = require("./Response.js");
+const utils_js_1 = require("./utils.js");
+async function fetchCurl(fetchRequest) {
+    const nodeReadable = (fetchRequest.body != null
+        ? 'pipe' in fetchRequest.body
+            ? fetchRequest.body
+            : stream_1.Readable.from(fetchRequest.body)
+        : null);
+    const headersSerializer = fetchRequest.headersSerializer || utils_js_1.defaultHeadersSerializer;
+    let size;
+    const curlyHeaders = headersSerializer(fetchRequest.headers, value => {
+        size = Number(value);
+    });
+    let easyNativeBinding;
+    const curlyOptions = {
+        // we want the unparsed binary response to be returned as a stream to us
+        curlyStreamResponse: true,
+        curlyResponseBodyParser: false,
+        curlyProgressCallback() {
+            if (easyNativeBinding == null) {
+                easyNativeBinding = this;
+            }
+            return fetchRequest.signal.aborted ? 1 : 0;
+        },
+        upload: nodeReadable != null,
+        transferEncoding: false,
+        httpTransferDecoding: true,
+        followLocation: fetchRequest.redirect === 'follow',
+        maxRedirs: 20,
+        acceptEncoding: '',
+        curlyStreamUpload: nodeReadable,
+        // this will just make libcurl use their own progress function (which is pretty neat)
+        // curlyProgressCallback() { return CurlProgressFunc.Continue },
+        // verbose: true,
+        httpHeader: curlyHeaders,
+        customRequest: fetchRequest.method,
+    };
+    if (size != null) {
+        curlyOptions.inFileSize = size;
+    }
+    const { curly, CurlCode, CurlPause } = globalThis['libcurl'];
+    fetchRequest.signal.onabort = () => {
+        if (easyNativeBinding != null) {
+            easyNativeBinding.pause(CurlPause.Recv);
+        }
+    };
+    const curlyResult = await curly(fetchRequest.url, curlyOptions);
+    const responseHeaders = new Headers_js_1.PonyfillHeaders();
+    curlyResult.headers.forEach(headerInfo => {
+        for (const key in headerInfo) {
+            if (key === 'location' || (key === 'Location' && fetchRequest.redirect === 'error')) {
+                throw new Error('redirects are not allowed');
+            }
+            if (key !== 'result') {
+                responseHeaders.append(key, headerInfo[key]);
+            }
+        }
+    });
+    curlyResult.data.on('error', (err) => {
+        if (err.isCurlError && err.code === CurlCode.CURLE_ABORTED_BY_CALLBACK) {
+            // this is expected
+        }
+        else {
+            throw err;
+        }
+    });
+    return new Response_js_1.PonyfillResponse(curlyResult.data, {
+        status: curlyResult.statusCode,
+        headers: responseHeaders,
+        url: fetchRequest.url,
+    });
+}
+exports.fetchCurl = fetchCurl;

package/cjs/fetchNodeHttp.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchNodeHttp = void 0;
+const http_1 = require("http");
+const https_1 = require("https");
+const stream_1 = require("stream");
+const zlib_1 = require("zlib");
+const AbortError_js_1 = require("./AbortError.js");
+const Request_js_1 = require("./Request.js");
+const Response_js_1 = require("./Response.js");
+const URL_js_1 = require("./URL.js");
+const utils_js_1 = require("./utils.js");
+function getRequestFnForProtocol(url) {
+    if (url.startsWith('http:')) {
+        return http_1.request;
+    }
+    else if (url.startsWith('https:')) {
+        return https_1.request;
+    }
+    throw new Error(`Unsupported protocol: ${url.split(':')[0] || url}`);
+}
+function fetchNodeHttp(fetchRequest) {
+    return new Promise((resolve, reject) => {
+        try {
+            const requestFn = getRequestFnForProtocol(fetchRequest.url);
+            const nodeReadable = (fetchRequest.body != null
+                ? 'pipe' in fetchRequest.body
+                    ? fetchRequest.body
+                    : stream_1.Readable.from(fetchRequest.body)
+                : null);
+            const headersSerializer = fetchRequest.headersSerializer || utils_js_1.getHeadersObj;
+            const nodeHeaders = headersSerializer(fetchRequest.headers);
+            const nodeRequest = requestFn(fetchRequest.url, {
+                method: fetchRequest.method,
+                headers: nodeHeaders,
+                signal: fetchRequest.signal,
+                agent: fetchRequest.agent,
+            });
+            // TODO: will be removed after v16 reaches EOL
+            fetchRequest.signal?.addEventListener('abort', () => {
+                if (!nodeRequest.aborted) {
+                    nodeRequest.abort();
+                }
+            });
+            // TODO: will be removed after v16 reaches EOL
+            nodeRequest.once('abort', (reason) => {
+                reject(new AbortError_js_1.PonyfillAbortError(reason));
+            });
+            nodeRequest.once('response', nodeResponse => {
+                let responseBody = nodeResponse;
+                const contentEncoding = nodeResponse.headers['content-encoding'];
+                switch (contentEncoding) {
+                    case 'x-gzip':
+                    case 'gzip':
+                        responseBody = nodeResponse.pipe((0, zlib_1.createGunzip)());
+                        break;
+                    case 'x-deflate':
+                    case 'deflate':
+                        responseBody = nodeResponse.pipe((0, zlib_1.createInflate)());
+                        break;
+                    case 'br':
+                        responseBody = nodeResponse.pipe((0, zlib_1.createBrotliDecompress)());
+                        break;
+                }
+                if (nodeResponse.headers.location) {
+                    if (fetchRequest.redirect === 'error') {
+                        const redirectError = new Error('Redirects are not allowed');
+                        reject(redirectError);
+                        nodeResponse.resume();
+                        return;
+                    }
+                    if (fetchRequest.redirect === 'follow') {
+                        const redirectedUrl = new URL_js_1.PonyfillURL(nodeResponse.headers.location, fetchRequest.url);
+                        const redirectResponse$ = fetchNodeHttp(new Request_js_1.PonyfillRequest(redirectedUrl, fetchRequest));
+                        resolve(redirectResponse$.then(redirectResponse => {
+                            redirectResponse.redirected = true;
+                            return redirectResponse;
+                        }));
+                        nodeResponse.resume();
+                        return;
+                    }
+                }
+                const ponyfillResponse = new Response_js_1.PonyfillResponse(responseBody, {
+                    status: nodeResponse.statusCode,
+                    statusText: nodeResponse.statusMessage,
+                    headers: nodeResponse.headers,
+                    url: fetchRequest.url,
+                });
+                resolve(ponyfillResponse);
+            });
+            nodeRequest.once('error', reject);
+            if (nodeReadable) {
+                nodeReadable.pipe(nodeRequest);
+            }
+            else {
+                nodeRequest.end();
+            }
+        }
+        catch (e) {
+            reject(e);
+        }
+    });
+}
+exports.fetchNodeHttp = fetchNodeHttp;

package/esm/Request.js

@@ -1,6 +1,5 @@
 import { PonyfillBody } from './Body.js';
 import { isHeadersLike, PonyfillHeaders } from './Headers.js';
-import { defaultHeadersSerializer } from './utils.js';
 function isRequest(input) {
     return input[Symbol.toStringTag] === 'Request';
 }
@@ -39,7 +38,7 @@ export class PonyfillRequest extends PonyfillBody {
         this.referrer = requestInit?.referrer || 'about:client';
         this.referrerPolicy = requestInit?.referrerPolicy || 'no-referrer';
         this._signal = requestInit?.signal;
-        this.headersSerializer = requestInit?.headersSerializer || defaultHeadersSerializer;
+        this.headersSerializer = requestInit?.headersSerializer;
         this.url = url || '';
         this.destination = 'document';
         this.priority = 'auto';

package/esm/fetch.js

@@ -1,20 +1,18 @@
-/* eslint-disable @typescript-eslint/no-this-alias */
 import { createReadStream } from 'fs';
-import { Readable } from 'stream';
 import { fileURLToPath } from 'url';
 import { PonyfillBlob } from './Blob.js';
-import { PonyfillHeaders } from './Headers.js';
+import { fetchCurl } from './fetchCurl.js';
+import { fetchNodeHttp } from './fetchNodeHttp.js';
 import { PonyfillRequest } from './Request.js';
 import { PonyfillResponse } from './Response.js';
-import { PonyfillURL } from './URL.js';
-import { defaultHeadersSerializer } from './utils.js';
+const BASE64_SUFFIX = ';base64';
 function getResponseForFile(url) {
     const path = fileURLToPath(url);
     const readable = createReadStream(path);
     return new PonyfillResponse(readable);
 }
 function getResponseForDataUri(url) {
-    const [mimeType = 'text/plain', ...datas] = url.pathname.split(',');
+    const [mimeType = 'text/plain', ...datas] = url.split(',');
     const data = decodeURIComponent(datas.join(','));
     if (mimeType.endsWith(BASE64_SUFFIX)) {
         const buffer = Buffer.from(data, 'base64url');
@@ -33,88 +31,22 @@ function getResponseForDataUri(url) {
         },
     });
 }
-const BASE64_SUFFIX = ';base64';
 export async function fetchPonyfill(info, init) {
     if (typeof info === 'string' || 'href' in info) {
         const ponyfillRequest = new PonyfillRequest(info, init);
         return fetchPonyfill(ponyfillRequest);
     }
     const fetchRequest = info;
-    const url = new PonyfillURL(fetchRequest.url, 'http://localhost');
-    if (url.protocol === 'data:') {
-        const response = getResponseForDataUri(url);
+    if (fetchRequest.url.startsWith('data:')) {
+        const response = getResponseForDataUri(fetchRequest.url);
         return Promise.resolve(response);
     }
-    if (url.protocol === 'file:') {
+    if (fetchRequest.url.startsWith('file:')) {
         const response = getResponseForFile(fetchRequest.url);
         return Promise.resolve(response);
     }
-    const nodeReadable = (fetchRequest.body != null
-        ? 'pipe' in fetchRequest.body
-            ? fetchRequest.body
-            : Readable.from(fetchRequest.body)
-        : null);
-    const headersSerializer = fetchRequest.headersSerializer || defaultHeadersSerializer;
-    let size;
-    const curlyHeaders = headersSerializer(fetchRequest.headers, value => {
-        size = Number(value);
-    });
-    let easyNativeBinding;
-    const curlyOptions = {
-        // we want the unparsed binary response to be returned as a stream to us
-        curlyStreamResponse: true,
-        curlyResponseBodyParser: false,
-        curlyProgressCallback() {
-            if (easyNativeBinding == null) {
-                easyNativeBinding = this;
-            }
-            return fetchRequest.signal.aborted ? 1 : 0;
-        },
-        upload: nodeReadable != null,
-        transferEncoding: false,
-        httpTransferDecoding: true,
-        followLocation: fetchRequest.redirect === 'follow',
-        maxRedirs: 20,
-        acceptEncoding: '',
-        curlyStreamUpload: nodeReadable,
-        // this will just make libcurl use their own progress function (which is pretty neat)
-        // curlyProgressCallback() { return CurlProgressFunc.Continue },
-        // verbose: true,
-        httpHeader: curlyHeaders,
-        customRequest: fetchRequest.method,
-    };
-    if (size != null) {
-        curlyOptions.inFileSize = size;
+    if (globalThis.libcurl) {
+        return fetchCurl(fetchRequest);
     }
-    const { curly, CurlCode, CurlPause } = globalThis['libcurl'] || (await import('node-libcurl'));
-    fetchRequest.signal.onabort = () => {
-        if (easyNativeBinding != null) {
-            easyNativeBinding.pause(CurlPause.Recv);
-        }
-    };
-    const curlyResult = await curly(fetchRequest.url, curlyOptions);
-    const responseHeaders = new PonyfillHeaders();
-    curlyResult.headers.forEach(headerInfo => {
-        for (const key in headerInfo) {
-            if (key === 'location' || (key === 'Location' && fetchRequest.redirect === 'error')) {
-                throw new Error('redirects are not allowed');
-            }
-            if (key !== 'result') {
-                responseHeaders.append(key, headerInfo[key]);
-            }
-        }
-    });
-    curlyResult.data.on('error', (err) => {
-        if (err.isCurlError && err.code === CurlCode.CURLE_ABORTED_BY_CALLBACK) {
-            // this is expected
-        }
-        else {
-            throw err;
-        }
-    });
-    return new PonyfillResponse(curlyResult.data, {
-        status: curlyResult.statusCode,
-        headers: responseHeaders,
-        url: info.url,
-    });
+    return fetchNodeHttp(fetchRequest);
 }

package/esm/fetchCurl.js

@@ -0,0 +1,75 @@
+/* eslint-disable @typescript-eslint/no-this-alias */
+import { Readable } from 'stream';
+import { PonyfillHeaders } from './Headers.js';
+import { PonyfillResponse } from './Response.js';
+import { defaultHeadersSerializer } from './utils.js';
+export async function fetchCurl(fetchRequest) {
+    const nodeReadable = (fetchRequest.body != null
+        ? 'pipe' in fetchRequest.body
+            ? fetchRequest.body
+            : Readable.from(fetchRequest.body)
+        : null);
+    const headersSerializer = fetchRequest.headersSerializer || defaultHeadersSerializer;
+    let size;
+    const curlyHeaders = headersSerializer(fetchRequest.headers, value => {
+        size = Number(value);
+    });
+    let easyNativeBinding;
+    const curlyOptions = {
+        // we want the unparsed binary response to be returned as a stream to us
+        curlyStreamResponse: true,
+        curlyResponseBodyParser: false,
+        curlyProgressCallback() {
+            if (easyNativeBinding == null) {
+                easyNativeBinding = this;
+            }
+            return fetchRequest.signal.aborted ? 1 : 0;
+        },
+        upload: nodeReadable != null,
+        transferEncoding: false,
+        httpTransferDecoding: true,
+        followLocation: fetchRequest.redirect === 'follow',
+        maxRedirs: 20,
+        acceptEncoding: '',
+        curlyStreamUpload: nodeReadable,
+        // this will just make libcurl use their own progress function (which is pretty neat)
+        // curlyProgressCallback() { return CurlProgressFunc.Continue },
+        // verbose: true,
+        httpHeader: curlyHeaders,
+        customRequest: fetchRequest.method,
+    };
+    if (size != null) {
+        curlyOptions.inFileSize = size;
+    }
+    const { curly, CurlCode, CurlPause } = globalThis['libcurl'];
+    fetchRequest.signal.onabort = () => {
+        if (easyNativeBinding != null) {
+            easyNativeBinding.pause(CurlPause.Recv);
+        }
+    };
+    const curlyResult = await curly(fetchRequest.url, curlyOptions);
+    const responseHeaders = new PonyfillHeaders();
+    curlyResult.headers.forEach(headerInfo => {
+        for (const key in headerInfo) {
+            if (key === 'location' || (key === 'Location' && fetchRequest.redirect === 'error')) {
+                throw new Error('redirects are not allowed');
+            }
+            if (key !== 'result') {
+                responseHeaders.append(key, headerInfo[key]);
+            }
+        }
+    });
+    curlyResult.data.on('error', (err) => {
+        if (err.isCurlError && err.code === CurlCode.CURLE_ABORTED_BY_CALLBACK) {
+            // this is expected
+        }
+        else {
+            throw err;
+        }
+    });
+    return new PonyfillResponse(curlyResult.data, {
+        status: curlyResult.statusCode,
+        headers: responseHeaders,
+        url: fetchRequest.url,
+    });
+}

package/esm/fetchNodeHttp.js

@@ -0,0 +1,100 @@
+import { request as httpRequest } from 'http';
+import { request as httpsRequest } from 'https';
+import { Readable } from 'stream';
+import { createBrotliDecompress, createGunzip, createInflate } from 'zlib';
+import { PonyfillAbortError } from './AbortError.js';
+import { PonyfillRequest } from './Request.js';
+import { PonyfillResponse } from './Response.js';
+import { PonyfillURL } from './URL.js';
+import { getHeadersObj } from './utils.js';
+function getRequestFnForProtocol(url) {
+    if (url.startsWith('http:')) {
+        return httpRequest;
+    }
+    else if (url.startsWith('https:')) {
+        return httpsRequest;
+    }
+    throw new Error(`Unsupported protocol: ${url.split(':')[0] || url}`);
+}
+export function fetchNodeHttp(fetchRequest) {
+    return new Promise((resolve, reject) => {
+        try {
+            const requestFn = getRequestFnForProtocol(fetchRequest.url);
+            const nodeReadable = (fetchRequest.body != null
+                ? 'pipe' in fetchRequest.body
+                    ? fetchRequest.body
+                    : Readable.from(fetchRequest.body)
+                : null);
+            const headersSerializer = fetchRequest.headersSerializer || getHeadersObj;
+            const nodeHeaders = headersSerializer(fetchRequest.headers);
+            const nodeRequest = requestFn(fetchRequest.url, {
+                method: fetchRequest.method,
+                headers: nodeHeaders,
+                signal: fetchRequest.signal,
+                agent: fetchRequest.agent,
+            });
+            // TODO: will be removed after v16 reaches EOL
+            fetchRequest.signal?.addEventListener('abort', () => {
+                if (!nodeRequest.aborted) {
+                    nodeRequest.abort();
+                }
+            });
+            // TODO: will be removed after v16 reaches EOL
+            nodeRequest.once('abort', (reason) => {
+                reject(new PonyfillAbortError(reason));
+            });
+            nodeRequest.once('response', nodeResponse => {
+                let responseBody = nodeResponse;
+                const contentEncoding = nodeResponse.headers['content-encoding'];
+                switch (contentEncoding) {
+                    case 'x-gzip':
+                    case 'gzip':
+                        responseBody = nodeResponse.pipe(createGunzip());
+                        break;
+                    case 'x-deflate':
+                    case 'deflate':
+                        responseBody = nodeResponse.pipe(createInflate());
+                        break;
+                    case 'br':
+                        responseBody = nodeResponse.pipe(createBrotliDecompress());
+                        break;
+                }
+                if (nodeResponse.headers.location) {
+                    if (fetchRequest.redirect === 'error') {
+                        const redirectError = new Error('Redirects are not allowed');
+                        reject(redirectError);
+                        nodeResponse.resume();
+                        return;
+                    }
+                    if (fetchRequest.redirect === 'follow') {
+                        const redirectedUrl = new PonyfillURL(nodeResponse.headers.location, fetchRequest.url);
+                        const redirectResponse$ = fetchNodeHttp(new PonyfillRequest(redirectedUrl, fetchRequest));
+                        resolve(redirectResponse$.then(redirectResponse => {
+                            redirectResponse.redirected = true;
+                            return redirectResponse;
+                        }));
+                        nodeResponse.resume();
+                        return;
+                    }
+                }
+                const ponyfillResponse = new PonyfillResponse(responseBody, {
+                    status: nodeResponse.statusCode,
+                    statusText: nodeResponse.statusMessage,
+                    headers: nodeResponse.headers,
+                    url: fetchRequest.url,
+                });
+                resolve(ponyfillResponse);
+            });
+            nodeRequest.once('error', reject);
+            if (nodeReadable) {
+                nodeReadable.pipe(nodeRequest);
+            }
+            else {
+                nodeRequest.end();
+            }
+        }
+        catch (e) {
+            reject(e);
+        }
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@whatwg-node/node-fetch",
-  "version": "0.5.0-alpha-20230710154907-66260af",
+  "version": "0.5.0-alpha-20230710180612-32e574f",
   "description": "Fetch API implementation for Node",
   "sideEffects": false,
   "dependencies": {
@@ -8,7 +8,6 @@
     "busboy": "^1.6.0",
     "fast-querystring": "^1.1.1",
     "fast-url-parser": "^1.1.3",
-    "node-libcurl": "^3.0.0",
     "tslib": "^2.3.1"
   },
   "repository": {

package/typings/Request.d.cts

@@ -1,14 +1,17 @@
+/// <reference types="node" />
+import { Agent } from 'http';
 import { BodyPonyfillInit, PonyfillBody, PonyfillBodyOptions } from './Body.cjs';
 import { PonyfillHeadersInit } from './Headers.cjs';
 export type RequestPonyfillInit = PonyfillBodyOptions & Omit<RequestInit, 'body' | 'headers'> & {
     body?: BodyPonyfillInit | null;
     headers?: PonyfillHeadersInit;
     headersSerializer?: HeadersSerializer;
+    agent?: Agent;
 };
 type HeadersSerializer = (headers: Headers, onContentLength?: (contentLength: string) => void) => string[];
 export declare class PonyfillRequest<TJSON = any> extends PonyfillBody<TJSON> implements Request {
     constructor(input: RequestInfo | URL, options?: RequestPonyfillInit);
-    headersSerializer: HeadersSerializer;
+    headersSerializer?: HeadersSerializer;
     cache: RequestCache;
     credentials: RequestCredentials;
     destination: RequestDestination;
@@ -22,8 +25,9 @@ export declare class PonyfillRequest<TJSON = any> extends PonyfillBody<TJSON> im
     referrer: string;
     referrerPolicy: ReferrerPolicy;
     url: string;
+    agent?: Agent;
     private _signal;
     get signal(): AbortSignal;
-    clone(): PonyfillRequest;
+    clone(): PonyfillRequest<TJSON>;
 }
 export {};

package/typings/Request.d.ts

@@ -1,14 +1,17 @@
+/// <reference types="node" />
+import { Agent } from 'http';
 import { BodyPonyfillInit, PonyfillBody, PonyfillBodyOptions } from './Body.js';
 import { PonyfillHeadersInit } from './Headers.js';
 export type RequestPonyfillInit = PonyfillBodyOptions & Omit<RequestInit, 'body' | 'headers'> & {
     body?: BodyPonyfillInit | null;
     headers?: PonyfillHeadersInit;
     headersSerializer?: HeadersSerializer;
+    agent?: Agent;
 };
 type HeadersSerializer = (headers: Headers, onContentLength?: (contentLength: string) => void) => string[];
 export declare class PonyfillRequest<TJSON = any> extends PonyfillBody<TJSON> implements Request {
     constructor(input: RequestInfo | URL, options?: RequestPonyfillInit);
-    headersSerializer: HeadersSerializer;
+    headersSerializer?: HeadersSerializer;
     cache: RequestCache;
     credentials: RequestCredentials;
     destination: RequestDestination;
@@ -22,8 +25,9 @@ export declare class PonyfillRequest<TJSON = any> extends PonyfillBody<TJSON> im
     referrer: string;
     referrerPolicy: ReferrerPolicy;
     url: string;
+    agent?: Agent;
     private _signal;
     get signal(): AbortSignal;
-    clone(): PonyfillRequest;
+    clone(): PonyfillRequest<TJSON>;
 }
 export {};

package/typings/fetchCurl.d.cts

@@ -0,0 +1,3 @@
+import { PonyfillRequest } from './Request.cjs';
+import { PonyfillResponse } from './Response.cjs';
+export declare function fetchCurl<TResponseJSON = any, TRequestJSON = any>(fetchRequest: PonyfillRequest<TRequestJSON>): Promise<PonyfillResponse<TResponseJSON>>;

package/typings/fetchCurl.d.ts

@@ -0,0 +1,3 @@
+import { PonyfillRequest } from './Request.js';
+import { PonyfillResponse } from './Response.js';
+export declare function fetchCurl<TResponseJSON = any, TRequestJSON = any>(fetchRequest: PonyfillRequest<TRequestJSON>): Promise<PonyfillResponse<TResponseJSON>>;

package/typings/fetchNodeHttp.d.cts

@@ -0,0 +1,3 @@
+import { PonyfillRequest } from './Request.cjs';
+import { PonyfillResponse } from './Response.cjs';
+export declare function fetchNodeHttp<TResponseJSON = any, TRequestJSON = any>(fetchRequest: PonyfillRequest<TRequestJSON>): Promise<PonyfillResponse<TResponseJSON>>;

package/typings/fetchNodeHttp.d.ts

@@ -0,0 +1,3 @@
+import { PonyfillRequest } from './Request.js';
+import { PonyfillResponse } from './Response.js';
+export declare function fetchNodeHttp<TResponseJSON = any, TRequestJSON = any>(fetchRequest: PonyfillRequest<TRequestJSON>): Promise<PonyfillResponse<TResponseJSON>>;