@whatwg-node/node-fetch 0.8.0-alpha-20241212160430-140b66f028923f44368e67598b6b66f47f690454 → 0.8.0-alpha-20250917012053-36c9ccdc3e94ee8d0961f17398a9053fa55df37b

package/cjs/FormData.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PonyfillFormData = void 0;
 exports.getStreamFromFormData = getStreamFromFormData;
+const node_buffer_1 = require("node:buffer");
 const IteratorObject_js_1 = require("./IteratorObject.js");
 const ReadableStream_js_1 = require("./ReadableStream.js");
 class PonyfillFormData {
@@ -73,54 +74,66 @@ class PonyfillFormData {
 }
 exports.PonyfillFormData = PonyfillFormData;
 function getStreamFromFormData(formData, boundary = '---') {
-    const entries = [];
+    let entriesIterator;
     let sentInitialHeader = false;
-    return new ReadableStream_js_1.PonyfillReadableStream({
-        start: controller => {
-            formData.forEach((value, key) => {
-                if (!sentInitialHeader) {
-                    controller.enqueue(Buffer.from(`--${boundary}\r\n`));
-                    sentInitialHeader = true;
+    let currentAsyncIterator;
+    let hasBefore = false;
+    function handleNextEntry(controller) {
+        const { done, value } = entriesIterator.next();
+        if (done) {
+            controller.enqueue(node_buffer_1.Buffer.from(`\r\n--${boundary}--\r\n`));
+            return controller.close();
+        }
+        if (hasBefore) {
+            controller.enqueue(node_buffer_1.Buffer.from(`\r\n--${boundary}\r\n`));
+        }
+        if (value) {
+            const [key, blobOrString] = value;
+            if (typeof blobOrString === 'string') {
+                controller.enqueue(node_buffer_1.Buffer.from(`Content-Disposition: form-data; name="${key}"\r\n\r\n`));
+                controller.enqueue(node_buffer_1.Buffer.from(blobOrString));
+            }
+            else {
+                let filenamePart = '';
+                if (blobOrString.name) {
+                    filenamePart = `; filename="${blobOrString.name}"`;
                 }
-                entries.push([key, value]);
-            });
-            if (!sentInitialHeader) {
-                controller.enqueue(Buffer.from(`--${boundary}--\r\n`));
-                controller.close();
+                controller.enqueue(node_buffer_1.Buffer.from(`Content-Disposition: form-data; name="${key}"${filenamePart}\r\n`));
+                controller.enqueue(node_buffer_1.Buffer.from(`Content-Type: ${blobOrString.type || 'application/octet-stream'}\r\n\r\n`));
+                const entryStream = blobOrString.stream();
+                // @ts-expect-error - ReadableStream is async iterable
+                currentAsyncIterator = entryStream[Symbol.asyncIterator]();
             }
+            hasBefore = true;
+        }
+    }
+    return new ReadableStream_js_1.PonyfillReadableStream({
+        start: () => {
+            entriesIterator = formData.entries();
         },
-        pull: async (controller) => {
-            const entry = entries.shift();
-            if (entry) {
-                const [key, value] = entry;
-                if (typeof value === 'string') {
-                    controller.enqueue(Buffer.from(`Content-Disposition: form-data; name="${key}"\r\n\r\n`));
-                    controller.enqueue(Buffer.from(value));
-                }
-                else {
-                    let filenamePart = '';
-                    if (value.name) {
-                        filenamePart = `; filename="${value.name}"`;
+        pull: controller => {
+            if (!sentInitialHeader) {
+                sentInitialHeader = true;
+                return controller.enqueue(node_buffer_1.Buffer.from(`--${boundary}\r\n`));
+            }
+            if (currentAsyncIterator) {
+                return currentAsyncIterator.next().then(({ done, value }) => {
+                    if (done) {
+                        currentAsyncIterator = undefined;
                     }
-                    controller.enqueue(Buffer.from(`Content-Disposition: form-data; name="${key}"${filenamePart}\r\n`));
-                    controller.enqueue(Buffer.from(`Content-Type: ${value.type || 'application/octet-stream'}\r\n\r\n`));
-                    const entryStream = value.stream();
-                    for await (const chunk of entryStream) {
-                        controller.enqueue(chunk);
+                    if (value) {
+                        return controller.enqueue(value);
                     }
-                }
-                if (entries.length === 0) {
-                    controller.enqueue(Buffer.from(`\r\n--${boundary}--\r\n`));
-                    controller.close();
-                }
-                else {
-                    controller.enqueue(Buffer.from(`\r\n--${boundary}\r\n`));
-                }
-            }
-            else {
-                controller.enqueue(Buffer.from(`\r\n--${boundary}--\r\n`));
-                controller.close();
+                    else {
+                        return handleNextEntry(controller);
+                    }
+                });
             }
+            return handleNextEntry(controller);
+        },
+        cancel: err => {
+            entriesIterator?.return?.(err);
+            currentAsyncIterator?.return?.(err);
         },
     });
 }

package/cjs/Headers.js

@@ -12,14 +12,14 @@ class PonyfillHeaders {
     _map;
     objectNormalizedKeysOfHeadersInit = [];
     objectOriginalKeysOfHeadersInit = [];
-    _setCookies = [];
+    _setCookies;
     constructor(headersInit) {
         this.headersInit = headersInit;
     }
     // perf: we don't need to build `this.map` for Requests, as we can access the headers directly
     _get(key) {
         const normalized = key.toLowerCase();
-        if (normalized === 'set-cookie') {
+        if (normalized === 'set-cookie' && this._setCookies?.length) {
             return this._setCookies.join(', ');
         }
         // If the map is built, reuse it
@@ -31,7 +31,14 @@ class PonyfillHeaders {
             return null;
         }
         if (Array.isArray(this.headersInit)) {
-            return this.headersInit.find(header => header[0].toLowerCase() === normalized)?.[1] || null;
+            const found = this.headersInit.filter(([headerKey]) => headerKey.toLowerCase() === normalized);
+            if (found.length === 0) {
+                return null;
+            }
+            if (found.length === 1) {
+                return found[0][1];
+            }
+            return found.map(([, value]) => value).join(', ');
         }
         else if (isHeadersLike(this.headersInit)) {
             return this.headersInit.get(normalized);
@@ -59,22 +66,24 @@ class PonyfillHeaders {
     // I could do a getter here, but I'm too lazy to type `getter`.
     getMap() {
         if (!this._map) {
+            this._setCookies ||= [];
             if (this.headersInit != null) {
                 if (Array.isArray(this.headersInit)) {
                     this._map = new Map();
-                    this.headersInit.forEach(([key, value]) => {
+                    for (const [key, value] of this.headersInit) {
                         const normalizedKey = key.toLowerCase();
                         if (normalizedKey === 'set-cookie') {
                             this._setCookies.push(value);
-                            return;
+                            continue;
                         }
                         this._map.set(normalizedKey, value);
-                    });
+                    }
                 }
                 else if (isHeadersLike(this.headersInit)) {
                     this._map = new Map();
                     this.headersInit.forEach((value, key) => {
                         if (key === 'set-cookie') {
+                            this._setCookies ||= [];
                             this._setCookies.push(value);
                             return;
                         }
@@ -88,6 +97,7 @@ class PonyfillHeaders {
                         if (initValue != null) {
                             const normalizedKey = initKey.toLowerCase();
                             if (normalizedKey === 'set-cookie') {
+                                this._setCookies ||= [];
                                 this._setCookies.push(initValue);
                                 continue;
                             }
@@ -105,6 +115,7 @@ class PonyfillHeaders {
     append(name, value) {
         const key = name.toLowerCase();
         if (key === 'set-cookie') {
+            this._setCookies ||= [];
             this._setCookies.push(value);
             return;
         }
@@ -117,11 +128,12 @@ class PonyfillHeaders {
         if (value == null) {
             return null;
         }
-        return value;
+        return value.toString();
     }
     has(name) {
-        if (name === 'set-cookie') {
-            return this._setCookies.length > 0;
+        const key = name.toLowerCase();
+        if (key === 'set-cookie') {
+            return !!this._setCookies?.length;
         }
         return !!this._get(name); // we might need to check if header exists and not just check if it's not nullable
     }
@@ -131,6 +143,26 @@ class PonyfillHeaders {
             this._setCookies = [value];
             return;
         }
+        if (!this._map && this.headersInit != null) {
+            if (Array.isArray(this.headersInit)) {
+                const found = this.headersInit.find(([headerKey]) => headerKey.toLowerCase() === key);
+                if (found) {
+                    found[1] = value;
+                }
+                else {
+                    this.headersInit.push([key, value]);
+                }
+                return;
+            }
+            else if (isHeadersLike(this.headersInit)) {
+                this.headersInit.set(key, value);
+                return;
+            }
+            else {
+                this.headersInit[key] = value;
+                return;
+            }
+        }
         this.getMap().set(key, value);
     }
     delete(name) {
@@ -142,7 +174,7 @@ class PonyfillHeaders {
         this.getMap().delete(key);
     }
     forEach(callback) {
-        this._setCookies.forEach(setCookie => {
+        this._setCookies?.forEach(setCookie => {
             callback(setCookie, 'set-cookie', this);
         });
         if (!this._map) {
@@ -170,7 +202,7 @@ class PonyfillHeaders {
         });
     }
     *_keys() {
-        if (this._setCookies.length) {
+        if (this._setCookies?.length) {
             yield 'set-cookie';
         }
         if (!this._map) {
@@ -193,7 +225,9 @@ class PonyfillHeaders {
         return new IteratorObject_js_1.PonyfillIteratorObject(this._keys(), 'HeadersIterator');
     }
     *_values() {
-        yield* this._setCookies;
+        if (this._setCookies?.length) {
+            yield* this._setCookies;
+        }
         if (!this._map) {
             if (this.headersInit) {
                 if (Array.isArray(this.headersInit)) {
@@ -214,7 +248,9 @@ class PonyfillHeaders {
         return new IteratorObject_js_1.PonyfillIteratorObject(this._values(), 'HeadersIterator');
     }
     *_entries() {
-        yield* this._setCookies.map(cookie => ['set-cookie', cookie]);
+        if (this._setCookies?.length) {
+            yield* this._setCookies.map(cookie => ['set-cookie', cookie]);
+        }
         if (!this._map) {
             if (this.headersInit) {
                 if (Array.isArray(this.headersInit)) {
@@ -235,6 +271,9 @@ class PonyfillHeaders {
         return new IteratorObject_js_1.PonyfillIteratorObject(this._entries(), 'HeadersIterator');
     }
     getSetCookie() {
+        if (!this._setCookies) {
+            this.getMap();
+        }
         return this._setCookies;
     }
     [Symbol.iterator]() {
@@ -244,10 +283,10 @@ class PonyfillHeaders {
         const record = {};
         this.forEach((value, key) => {
             if (key === 'set-cookie') {
-                record['set-cookie'] = this._setCookies;
+                record['set-cookie'] = this._setCookies || [];
             }
             else {
-                record[key] = value.includes(',') ? value.split(',').map(el => el.trim()) : value;
+                record[key] = value?.includes(',') ? value.split(',').map(el => el.trim()) : value;
             }
         });
         return `Headers ${(0, node_util_1.inspect)(record)}`;

package/cjs/ReadableStream.js

@@ -1,7 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PonyfillReadableStream = void 0;
-const stream_1 = require("stream");
+const node_buffer_1 = require("node:buffer");
+const node_events_1 = require("node:events");
+const node_stream_1 = require("node:stream");
+const promises_1 = require("node:stream/promises");
+const promise_helpers_1 = require("@whatwg-node/promise-helpers");
 const utils_js_1 = require("./utils.js");
 function createController(desiredSize, readable) {
     let chunks = [];
@@ -10,7 +14,7 @@ function createController(desiredSize, readable) {
     return {
         desiredSize,
         enqueue(chunk) {
-            const buf = typeof chunk === 'string' ? Buffer.from(chunk) : chunk;
+            const buf = typeof chunk === 'string' ? node_buffer_1.Buffer.from(chunk) : chunk;
             if (!flushed) {
                 chunks.push(buf);
             }
@@ -37,7 +41,7 @@ function createController(desiredSize, readable) {
         _flush() {
             flushed = true;
             if (chunks.length > 0) {
-                const concatenated = chunks.length > 1 ? Buffer.concat(chunks) : chunks[0];
+                const concatenated = chunks.length > 1 ? node_buffer_1.Buffer.concat(chunks) : chunks[0];
                 readable.push(concatenated);
                 chunks = [];
             }
@@ -60,27 +64,38 @@ class PonyfillReadableStream {
             this.readable = underlyingSource;
         }
         else if (isReadableStream(underlyingSource)) {
-            this.readable = stream_1.Readable.fromWeb(underlyingSource);
+            this.readable = node_stream_1.Readable.fromWeb(underlyingSource);
         }
         else {
             let started = false;
             let ongoing = false;
-            const readImpl = async (desiredSize) => {
+            const handleStart = (desiredSize) => {
                 if (!started) {
                     const controller = createController(desiredSize, this.readable);
                     started = true;
-                    await underlyingSource?.start?.(controller);
-                    controller._flush();
-                    if (controller._closed) {
+                    return (0, promise_helpers_1.handleMaybePromise)(() => underlyingSource?.start?.(controller), () => {
+                        controller._flush();
+                        if (controller._closed) {
+                            return false;
+                        }
+                        return true;
+                    });
+                }
+                return true;
+            };
+            const readImpl = (desiredSize) => {
+                return (0, promise_helpers_1.handleMaybePromise)(() => handleStart(desiredSize), shouldContinue => {
+                    if (!shouldContinue) {
                         return;
                     }
-                }
-                const controller = createController(desiredSize, this.readable);
-                await underlyingSource?.pull?.(controller);
-                controller._flush();
-                ongoing = false;
+                    const controller = createController(desiredSize, this.readable);
+                    return (0, promise_helpers_1.handleMaybePromise)(() => underlyingSource?.pull?.(controller), () => {
+                        controller._flush();
+                        ongoing = false;
+                    });
+                });
             };
-            this.readable = new stream_1.Readable({
+            this.readable = new node_stream_1.Readable({
                 read(desiredSize) {
                     if (ongoing) {
                         return;
@@ -112,12 +127,14 @@ class PonyfillReadableStream {
     }
     cancel(reason) {
         this.readable.destroy(reason);
-        return new Promise(resolve => this.readable.once('end', resolve));
+        // @ts-expect-error - we know it is void
+        return (0, node_events_1.once)(this.readable, 'close');
     }
     locked = false;
     getReader(_options) {
         const iterator = this.readable[Symbol.asyncIterator]();
         this.locked = true;
+        const thisReadable = this.readable;
         return {
             read() {
                 return iterator.next();
@@ -144,16 +161,36 @@ class PonyfillReadableStream {
                     }
                 }
                 this.locked = false;
-                return (0, utils_js_1.fakePromise)(undefined);
+                return (0, utils_js_1.fakePromise)();
+            },
+            get closed() {
+                return Promise.race([
+                    (0, node_events_1.once)(thisReadable, 'end'),
+                    (0, node_events_1.once)(thisReadable, 'error').then(err => Promise.reject(err)),
+                ]);
             },
-            closed: new Promise((resolve, reject) => {
-                this.readable.once('end', resolve);
-                this.readable.once('error', reject);
-            }),
         };
     }
     [Symbol.asyncIterator]() {
-        return this.readable[Symbol.asyncIterator]();
+        const iterator = this.readable[Symbol.asyncIterator]();
+        return {
+            [Symbol.asyncIterator]() {
+                return this;
+            },
+            next: () => iterator.next(),
+            return: () => {
+                if (!this.readable.destroyed) {
+                    this.readable.destroy();
+                }
+                return iterator.return?.() || (0, utils_js_1.fakePromise)({ done: true, value: undefined });
+            },
+            throw: (err) => {
+                if (!this.readable.destroyed) {
+                    this.readable.destroy(err);
+                }
+                return iterator.throw?.(err) || (0, utils_js_1.fakePromise)({ done: true, value: undefined });
+            },
+        };
     }
     tee() {
         throw new Error('Not implemented');
@@ -171,10 +208,8 @@ class PonyfillReadableStream {
     }
     pipeTo(destination) {
         if (isPonyfillWritableStream(destination)) {
-            return new Promise((resolve, reject) => {
-                this.readable.pipe(destination.writable);
-                destination.writable.once('finish', resolve);
-                destination.writable.once('error', reject);
+            return (0, promises_1.pipeline)(this.readable, destination.writable, {
+                end: true,
             });
         }
         else {
@@ -197,8 +232,9 @@ class PonyfillReadableStream {
         return isReadableStream(instance);
     }
     static from(iterable) {
-        return new PonyfillReadableStream(stream_1.Readable.from(iterable));
+        return new PonyfillReadableStream(node_stream_1.Readable.from(iterable));
     }
+    [Symbol.toStringTag] = 'ReadableStream';
 }
 exports.PonyfillReadableStream = PonyfillReadableStream;
 function isPonyfillReadableStream(obj) {

package/cjs/Request.js

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PonyfillRequest = void 0;
-const http_1 = require("http");
-const https_1 = require("https");
-const AbortController_js_1 = require("./AbortController.js");
+const node_http_1 = require("node:http");
+const node_https_1 = require("node:https");
 const Body_js_1 = require("./Body.js");
 const Headers_js_1 = require("./Headers.js");
 const URL_js_1 = require("./URL.js");
@@ -42,7 +41,7 @@ class PonyfillRequest extends Body_js_1.PonyfillBody {
             bodyInit = options.body || null;
             requestInit = options;
         }
-        super(bodyInit, options);
+        super(bodyInit, requestInit);
         this._url = _url;
         this._parsedUrl = _parsedUrl;
         this.cache = requestInit?.cache || 'default';
@@ -58,7 +57,6 @@ class PonyfillRequest extends Body_js_1.PonyfillBody {
         this.redirect = requestInit?.redirect || 'follow';
         this.referrer = requestInit?.referrer || 'about:client';
         this.referrerPolicy = requestInit?.referrerPolicy || 'no-referrer';
-        this._signal = requestInit?.signal;
         this.headersSerializer = requestInit?.headersSerializer;
         this.duplex = requestInit?.duplex || 'half';
         this.destination = 'document';
@@ -71,10 +69,10 @@ class PonyfillRequest extends Body_js_1.PonyfillBody {
             if (requestInit.agent === false) {
                 this.agent = false;
             }
-            else if (protocol.startsWith('http:') && requestInit.agent instanceof http_1.Agent) {
+            else if (protocol.startsWith('http:') && requestInit.agent instanceof node_http_1.Agent) {
                 this.agent = requestInit.agent;
             }
-            else if (protocol.startsWith('https:') && requestInit.agent instanceof https_1.Agent) {
+            else if (protocol.startsWith('https:') && requestInit.agent instanceof node_https_1.Agent) {
                 this.agent = requestInit.agent;
             }
         }
@@ -93,6 +91,10 @@ class PonyfillRequest extends Body_js_1.PonyfillBody {
     referrer;
     referrerPolicy;
     _url;
+    get signal() {
+        this._signal ||= new AbortController().signal;
+        return this._signal;
+    }
     get url() {
         if (this._url == null) {
             if (this._parsedUrl) {
@@ -118,15 +120,6 @@ class PonyfillRequest extends Body_js_1.PonyfillBody {
     }
     duplex;
     agent;
-    _signal;
-    get signal() {
-        // Create a new signal only if needed
-        // Because the creation of signal is expensive
-        if (!this._signal) {
-            this._signal = new AbortController_js_1.PonyfillAbortController().signal;
-        }
-        return this._signal;
-    }
     clone() {
         return this;
     }

package/cjs/Response.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PonyfillResponse = void 0;
-const http_1 = require("http");
+const node_http_1 = require("node:http");
 const Body_js_1 = require("./Body.js");
 const Headers_js_1 = require("./Headers.js");
 const JSON_CONTENT_TYPE = 'application/json; charset=utf-8';
@@ -14,7 +14,7 @@ class PonyfillResponse extends Body_js_1.PonyfillBody {
                 ? init.headers
                 : new Headers_js_1.PonyfillHeaders(init?.headers);
         this.status = init?.status || 200;
-        this.statusText = init?.statusText || http_1.STATUS_CODES[this.status] || 'OK';
+        this.statusText = init?.statusText || node_http_1.STATUS_CODES[this.status] || 'OK';
         this.url = init?.url || '';
         this.redirected = init?.redirected || false;
         this.type = init?.type || 'default';
@@ -48,15 +48,61 @@ class PonyfillResponse extends Body_js_1.PonyfillBody {
             status,
         });
     }
-    static json(data, init = {}) {
-        init.headers =
-            init?.headers && (0, Headers_js_1.isHeadersLike)(init.headers)
-                ? init.headers
-                : new Headers_js_1.PonyfillHeaders(init?.headers);
-        if (!init.headers.has('content-type')) {
-            init.headers.set('content-type', JSON_CONTENT_TYPE);
+    static json(data, init) {
+        const bodyInit = JSON.stringify(data);
+        if (!init) {
+            init = {
+                headers: {
+                    'content-type': JSON_CONTENT_TYPE,
+                    'content-length': Buffer.byteLength(bodyInit).toString(),
+                },
+            };
+        }
+        else if (!init.headers) {
+            init.headers = {
+                'content-type': JSON_CONTENT_TYPE,
+                'content-length': Buffer.byteLength(bodyInit).toString(),
+            };
+        }
+        else if ((0, Headers_js_1.isHeadersLike)(init.headers)) {
+            if (!init.headers.has('content-type')) {
+                init.headers.set('content-type', JSON_CONTENT_TYPE);
+            }
+            if (!init.headers.has('content-length')) {
+                init.headers.set('content-length', Buffer.byteLength(bodyInit).toString());
+            }
+        }
+        else if (Array.isArray(init.headers)) {
+            let contentTypeExists = false;
+            let contentLengthExists = false;
+            for (const [key] of init.headers) {
+                if (contentLengthExists && contentTypeExists) {
+                    break;
+                }
+                if (!contentTypeExists && key.toLowerCase() === 'content-type') {
+                    contentTypeExists = true;
+                }
+                else if (!contentLengthExists && key.toLowerCase() === 'content-length') {
+                    contentLengthExists = true;
+                }
+            }
+            if (!contentTypeExists) {
+                init.headers.push(['content-type', JSON_CONTENT_TYPE]);
+            }
+            if (!contentLengthExists) {
+                init.headers.push(['content-length', Buffer.byteLength(bodyInit).toString()]);
+            }
+        }
+        else if (typeof init.headers === 'object') {
+            if (init.headers?.['content-type'] == null) {
+                init.headers['content-type'] = JSON_CONTENT_TYPE;
+            }
+            if (init.headers?.['content-length'] == null) {
+                init.headers['content-length'] = Buffer.byteLength(bodyInit).toString();
+            }
         }
-        return new PonyfillResponse(JSON.stringify(data), init);
+        return new PonyfillResponse(bodyInit, init);
     }
+    [Symbol.toStringTag] = 'Response';
 }
 exports.PonyfillResponse = PonyfillResponse;

package/cjs/TextEncoderDecoder.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PonyfillTextDecoder = exports.PonyfillTextEncoder = void 0;
 exports.PonyfillBtoa = PonyfillBtoa;
+const node_buffer_1 = require("node:buffer");
 const utils_js_1 = require("./utils.js");
 class PonyfillTextEncoder {
     encoding;
@@ -9,7 +10,7 @@ class PonyfillTextEncoder {
         this.encoding = encoding;
     }
     encode(input) {
-        return Buffer.from(input, this.encoding);
+        return node_buffer_1.Buffer.from(input, this.encoding);
     }
     encodeInto(source, destination) {
         const buffer = this.encode(source);
@@ -33,16 +34,16 @@ class PonyfillTextDecoder {
         }
     }
     decode(input) {
-        if (Buffer.isBuffer(input)) {
+        if (node_buffer_1.Buffer.isBuffer(input)) {
             return input.toString(this.encoding);
         }
         if ((0, utils_js_1.isArrayBufferView)(input)) {
-            return Buffer.from(input.buffer, input.byteOffset, input.byteLength).toString(this.encoding);
+            return node_buffer_1.Buffer.from(input.buffer, input.byteOffset, input.byteLength).toString(this.encoding);
         }
-        return Buffer.from(input).toString(this.encoding);
+        return node_buffer_1.Buffer.from(input).toString(this.encoding);
     }
 }
 exports.PonyfillTextDecoder = PonyfillTextDecoder;
 function PonyfillBtoa(input) {
-    return Buffer.from(input, 'binary').toString('base64');
+    return node_buffer_1.Buffer.from(input, 'binary').toString('base64');
 }

package/cjs/TextEncoderDecoderStream.js

@@ -7,9 +7,7 @@ class PonyfillTextDecoderStream extends TransformStream_js_1.PonyfillTransformSt
     textDecoder;
     constructor(encoding, options) {
         super({
-            transform: (chunk, controller) => {
-                controller.enqueue(this.textDecoder.decode(chunk, { stream: true }));
-            },
+            transform: (chunk, controller) => controller.enqueue(this.textDecoder.decode(chunk, { stream: true })),
         });
         this.textDecoder = new TextEncoderDecoder_js_1.PonyfillTextDecoder(encoding, options);
     }
@@ -28,9 +26,7 @@ class PonyfillTextEncoderStream extends TransformStream_js_1.PonyfillTransformSt
     textEncoder;
     constructor(encoding) {
         super({
-            transform: (chunk, controller) => {
-                controller.enqueue(this.textEncoder.encode(chunk));
-            },
+            transform: (chunk, controller) => controller.enqueue(this.textEncoder.encode(chunk)),
         });
         this.textEncoder = new TextEncoderDecoder_js_1.PonyfillTextEncoder(encoding);
     }