@whatwg-node/node-fetch 0.4.7 → 0.4.8-alpha-20230714134016-d696bc4

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,8 +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.getHeadersObj;
-        this.agent = requestInit?.agent;
+        this.headersSerializer = requestInit?.headersSerializer;
         this.url = url || '';
         this.destination = 'document';
         this.priority = 'auto';

package/cjs/fetch.js

@@ -2,24 +2,20 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchPonyfill = void 0;
 const fs_1 = require("fs");
-const http_1 = require("http");
-const https_1 = require("https");
-const stream_1 = require("stream");
 const url_1 = require("url");
-const zlib_1 = require("zlib");
-const AbortError_js_1 = require("./AbortError.js");
 const Blob_js_1 = require("./Blob.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');
@@ -38,112 +34,23 @@ function getResponseForDataUri(url) {
         },
     });
 }
-function getRequestFnForProtocol(protocol) {
-    switch (protocol) {
-        case 'http:':
-            return http_1.request;
-        case 'https:':
-            return https_1.request;
-    }
-    throw new Error(`Unsupported protocol: ${protocol}`);
-}
-const BASE64_SUFFIX = ';base64';
-function fetchPonyfill(info, init) {
+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;
-    return new Promise((resolve, reject) => {
-        try {
-            const url = new URL_js_1.PonyfillURL(fetchRequest.url, 'http://localhost');
-            if (url.protocol === 'data:') {
-                const response = getResponseForDataUri(url);
-                resolve(response);
-                return;
-            }
-            if (url.protocol === 'file:') {
-                const response = getResponseForFile(fetchRequest.url);
-                resolve(response);
-                return;
-            }
-            const requestFn = getRequestFnForProtocol(url.protocol);
-            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, url);
-                        const redirectResponse$ = fetchPonyfill(redirectedUrl, info);
-                        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: info.url,
-                });
-                resolve(ponyfillResponse);
-            });
-            nodeRequest.once('error', reject);
-            if (nodeReadable) {
-                nodeReadable.pipe(nodeRequest);
-            }
-            else {
-                nodeRequest.end();
-            }
-        }
-        catch (e) {
-            reject(e);
-        }
-    });
+    if (fetchRequest.url.startsWith('data:')) {
+        const response = getResponseForDataUri(fetchRequest.url);
+        return Promise.resolve(response);
+    }
+    if (fetchRequest.url.startsWith('file:')) {
+        const response = getResponseForFile(fetchRequest.url);
+        return Promise.resolve(response);
+    }
+    if (globalThis.libcurl) {
+        return (0, fetchCurl_js_1.fetchCurl)(fetchRequest);
+    }
+    return (0, fetchNodeHttp_js_1.fetchNodeHttp)(fetchRequest);
 }
 exports.fetchPonyfill = fetchPonyfill;

package/cjs/fetchCurl.js

@@ -0,0 +1,81 @@
+"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'];
+    if (fetchRequest['_signal']) {
+        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'] ?? undefined,
+                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/cjs/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.uint8ArrayToArrayBuffer = exports.getHeadersObj = void 0;
+exports.defaultHeadersSerializer = exports.uint8ArrayToArrayBuffer = exports.getHeadersObj = void 0;
 function getHeadersObj(headers) {
     if (headers == null || !('forEach' in headers)) {
         return headers;
@@ -16,3 +16,14 @@ function uint8ArrayToArrayBuffer(uint8array) {
     return uint8array.buffer.slice(uint8array.byteOffset, uint8array.byteOffset + uint8array.byteLength);
 }
 exports.uint8ArrayToArrayBuffer = uint8ArrayToArrayBuffer;
+function defaultHeadersSerializer(headers, onContentLength) {
+    const headerArray = [];
+    headers.forEach((value, key) => {
+        if (onContentLength && key === 'content-length') {
+            onContentLength(value);
+        }
+        headerArray.push(`${key}: ${value}`);
+    });
+    return headerArray;
+}
+exports.defaultHeadersSerializer = defaultHeadersSerializer;

package/esm/Request.js

@@ -1,6 +1,5 @@
 import { PonyfillBody } from './Body.js';
 import { isHeadersLike, PonyfillHeaders } from './Headers.js';
-import { getHeadersObj } from './utils.js';
 function isRequest(input) {
     return input[Symbol.toStringTag] === 'Request';
 }
@@ -39,8 +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 || getHeadersObj;
-        this.agent = requestInit?.agent;
+        this.headersSerializer = requestInit?.headersSerializer;
         this.url = url || '';
         this.destination = 'document';
         this.priority = 'auto';

package/esm/fetch.js

@@ -1,22 +1,18 @@
 import { createReadStream } from 'fs';
-import { request as httpRequest } from 'http';
-import { request as httpsRequest } from 'https';
-import { Readable } from 'stream';
 import { fileURLToPath } from 'url';
-import { createBrotliDecompress, createGunzip, createInflate } from 'zlib';
-import { PonyfillAbortError } from './AbortError.js';
 import { PonyfillBlob } from './Blob.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 { getHeadersObj } 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');
@@ -35,111 +31,22 @@ function getResponseForDataUri(url) {
         },
     });
 }
-function getRequestFnForProtocol(protocol) {
-    switch (protocol) {
-        case 'http:':
-            return httpRequest;
-        case 'https:':
-            return httpsRequest;
-    }
-    throw new Error(`Unsupported protocol: ${protocol}`);
-}
-const BASE64_SUFFIX = ';base64';
-export function fetchPonyfill(info, init) {
+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;
-    return new Promise((resolve, reject) => {
-        try {
-            const url = new PonyfillURL(fetchRequest.url, 'http://localhost');
-            if (url.protocol === 'data:') {
-                const response = getResponseForDataUri(url);
-                resolve(response);
-                return;
-            }
-            if (url.protocol === 'file:') {
-                const response = getResponseForFile(fetchRequest.url);
-                resolve(response);
-                return;
-            }
-            const requestFn = getRequestFnForProtocol(url.protocol);
-            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, url);
-                        const redirectResponse$ = fetchPonyfill(redirectedUrl, info);
-                        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: info.url,
-                });
-                resolve(ponyfillResponse);
-            });
-            nodeRequest.once('error', reject);
-            if (nodeReadable) {
-                nodeReadable.pipe(nodeRequest);
-            }
-            else {
-                nodeRequest.end();
-            }
-        }
-        catch (e) {
-            reject(e);
-        }
-    });
+    if (fetchRequest.url.startsWith('data:')) {
+        const response = getResponseForDataUri(fetchRequest.url);
+        return Promise.resolve(response);
+    }
+    if (fetchRequest.url.startsWith('file:')) {
+        const response = getResponseForFile(fetchRequest.url);
+        return Promise.resolve(response);
+    }
+    if (globalThis.libcurl) {
+        return fetchCurl(fetchRequest);
+    }
+    return fetchNodeHttp(fetchRequest);
 }

package/esm/fetchCurl.js

@@ -0,0 +1,77 @@
+/* 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'];
+    if (fetchRequest['_signal']) {
+        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'] ?? undefined,
+                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/esm/utils.js

@@ -11,3 +11,13 @@ export function getHeadersObj(headers) {
 export function uint8ArrayToArrayBuffer(uint8array) {
     return uint8array.buffer.slice(uint8array.byteOffset, uint8array.byteOffset + uint8array.byteLength);
 }
+export function defaultHeadersSerializer(headers, onContentLength) {
+    const headerArray = [];
+    headers.forEach((value, key) => {
+        if (onContentLength && key === 'content-length') {
+            onContentLength(value);
+        }
+        headerArray.push(`${key}: ${value}`);
+    });
+    return headerArray;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@whatwg-node/node-fetch",
-  "version": "0.4.7",
+  "version": "0.4.8-alpha-20230714134016-d696bc4",
   "description": "Fetch API implementation for Node",
   "sideEffects": false,
   "dependencies": {

package/typings/Request.d.cts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import type { Agent } from 'http';
+import { Agent } from 'http';
 import { BodyPonyfillInit, PonyfillBody, PonyfillBodyOptions } from './Body.cjs';
 import { PonyfillHeadersInit } from './Headers.cjs';
 export type RequestPonyfillInit = PonyfillBodyOptions & Omit<RequestInit, 'body' | 'headers'> & {
@@ -8,10 +8,10 @@ export type RequestPonyfillInit = PonyfillBodyOptions & Omit<RequestInit, 'body'
     headersSerializer?: HeadersSerializer;
     agent?: Agent;
 };
-type HeadersSerializer = (headers: Headers) => Record<string, string>;
+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;
@@ -25,9 +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;
-    agent?: Agent;
-    clone(): PonyfillRequest;
+    clone(): PonyfillRequest<TJSON>;
 }
 export {};

package/typings/Request.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import type { Agent } from 'http';
+import { Agent } from 'http';
 import { BodyPonyfillInit, PonyfillBody, PonyfillBodyOptions } from './Body.js';
 import { PonyfillHeadersInit } from './Headers.js';
 export type RequestPonyfillInit = PonyfillBodyOptions & Omit<RequestInit, 'body' | 'headers'> & {
@@ -8,10 +8,10 @@ export type RequestPonyfillInit = PonyfillBodyOptions & Omit<RequestInit, 'body'
     headersSerializer?: HeadersSerializer;
     agent?: Agent;
 };
-type HeadersSerializer = (headers: Headers) => Record<string, string>;
+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;
@@ -25,9 +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;
-    agent?: Agent;
-    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>>;

package/typings/utils.d.cts

@@ -1,2 +1,3 @@
 export declare function getHeadersObj(headers: Headers): Record<string, string>;
 export declare function uint8ArrayToArrayBuffer(uint8array: Uint8Array): ArrayBuffer;
+export declare function defaultHeadersSerializer(headers: Headers, onContentLength?: (value: string) => void): string[];

package/typings/utils.d.ts

@@ -1,2 +1,3 @@
 export declare function getHeadersObj(headers: Headers): Record<string, string>;
 export declare function uint8ArrayToArrayBuffer(uint8array: Uint8Array): ArrayBuffer;
+export declare function defaultHeadersSerializer(headers: Headers, onContentLength?: (value: string) => void): string[];