@whatwg-node/node-fetch 0.5.15 → 0.5.16-alpha-20240726002236-105dd434a11d1e455ea8f23481530c2ec4ca0aae

package/cjs/CompressionStream.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PonyfillCompressionStream = void 0;
+const node_zlib_1 = require("node:zlib");
+const TransformStream_1 = require("./TransformStream");
+class PonyfillCompressionStream extends TransformStream_1.PonyfillTransformStream {
+    constructor(compressionFormat) {
+        switch (compressionFormat) {
+            case 'x-gzip':
+            case 'gzip':
+                super((0, node_zlib_1.createGzip)());
+                break;
+            case 'x-deflate':
+            case 'deflate':
+                super((0, node_zlib_1.createDeflate)());
+                break;
+            case 'deflate-raw':
+                super((0, node_zlib_1.createDeflateRaw)());
+                break;
+            case 'br':
+                super((0, node_zlib_1.createBrotliCompress)());
+                break;
+            default:
+                throw new Error(`Unsupported compression format: ${compressionFormat}`);
+        }
+    }
+}
+exports.PonyfillCompressionStream = PonyfillCompressionStream;

package/cjs/DecompressionStream.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PonyfillDecompressionStream = void 0;
+const node_zlib_1 = require("node:zlib");
+const TransformStream_js_1 = require("./TransformStream.js");
+class PonyfillDecompressionStream extends TransformStream_js_1.PonyfillTransformStream {
+    constructor(compressionFormat) {
+        switch (compressionFormat) {
+            case 'x-gzip':
+            case 'gzip':
+                super((0, node_zlib_1.createGunzip)());
+                break;
+            case 'x-deflate':
+            case 'deflate':
+                super((0, node_zlib_1.createInflate)());
+                break;
+            case 'deflate-raw':
+                super((0, node_zlib_1.createInflateRaw)());
+                break;
+            case 'br':
+                super((0, node_zlib_1.createBrotliDecompress)());
+                break;
+            default:
+                throw new Error(`Unsupported compression format: ${compressionFormat}`);
+        }
+    }
+}
+exports.PonyfillDecompressionStream = PonyfillDecompressionStream;

package/cjs/ReadableStream.js

@@ -155,13 +155,25 @@ class PonyfillReadableStream {
         throw new Error('Not implemented');
     }
     async pipeTo(destination) {
-        const writer = destination.getWriter();
-        await writer.ready;
-        for await (const chunk of this.readable) {
-            await writer.write(chunk);
+        if (isPonyfillWritableStream(destination)) {
+            return new Promise((resolve, reject) => {
+                this.readable.pipe(destination.writable);
+                destination.writable.once('finish', resolve);
+                destination.writable.once('error', reject);
+            });
+        }
+        else {
+            const writer = destination.getWriter();
+            try {
+                for await (const chunk of this) {
+                    await writer.write(chunk);
+                }
+                await writer.close();
+            }
+            catch (err) {
+                await writer.abort(err);
+            }
         }
-        await writer.ready;
-        return writer.close();
     }
     pipeThrough({ writable, readable, }) {
         this.pipeTo(writable);
@@ -172,3 +184,6 @@ class PonyfillReadableStream {
     }
 }
 exports.PonyfillReadableStream = PonyfillReadableStream;
+function isPonyfillWritableStream(obj) {
+    return obj?.writable != null;
+}

package/cjs/TransformStream.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PonyfillTransformStream = void 0;
+const node_stream_1 = require("node:stream");
+const ReadableStream_js_1 = require("./ReadableStream.js");
+const WritableStream_js_1 = require("./WritableStream.js");
+class PonyfillTransformStream {
+    constructor(transformer) {
+        if (transformer instanceof node_stream_1.Transform) {
+            this.transform = transformer;
+        }
+        else if (transformer) {
+            const controller = {
+                enqueue(chunk) {
+                    transform.push(chunk);
+                },
+                error(reason) {
+                    transform.destroy(reason);
+                },
+                terminate() {
+                    transform.end();
+                },
+                get desiredSize() {
+                    return transform.writableLength;
+                },
+            };
+            const transform = new node_stream_1.Transform({
+                read() { },
+                write(chunk, _encoding, callback) {
+                    try {
+                        const result = transformer.transform?.(chunk, controller);
+                        if (result instanceof Promise) {
+                            result.then(() => {
+                                callback();
+                            }, err => {
+                                callback(err);
+                            });
+                        }
+                        else {
+                            callback();
+                        }
+                    }
+                    catch (err) {
+                        callback(err);
+                    }
+                },
+                final(callback) {
+                    try {
+                        const result = transformer.flush?.(controller);
+                        if (result instanceof Promise) {
+                            result.then(() => {
+                                callback();
+                            }, err => {
+                                callback(err);
+                            });
+                        }
+                        else {
+                            callback();
+                        }
+                    }
+                    catch (err) {
+                        callback(err);
+                    }
+                },
+            });
+            this.transform = transform;
+        }
+        else {
+            this.transform = new node_stream_1.Transform();
+        }
+        this.writable = new WritableStream_js_1.PonyfillWritableStream(this.transform);
+        this.readable = new ReadableStream_js_1.PonyfillReadableStream(this.transform);
+    }
+}
+exports.PonyfillTransformStream = PonyfillTransformStream;

package/cjs/WritableStream.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PonyfillWritableStream = void 0;
+const stream_1 = require("stream");
+class PonyfillWritableStream {
+    constructor(underlyingSink) {
+        this.locked = false;
+        if (underlyingSink instanceof stream_1.Writable) {
+            this.writable = underlyingSink;
+        }
+        else if (underlyingSink) {
+            const writable = new stream_1.Writable({
+                write(chunk, _encoding, callback) {
+                    try {
+                        const result = underlyingSink.write?.(chunk, controller);
+                        if (result instanceof Promise) {
+                            result.then(() => {
+                                callback();
+                            }, err => {
+                                callback(err);
+                            });
+                        }
+                        else {
+                            callback();
+                        }
+                    }
+                    catch (err) {
+                        callback(err);
+                    }
+                },
+                final(callback) {
+                    const result = underlyingSink.close?.();
+                    if (result instanceof Promise) {
+                        result.then(() => {
+                            callback();
+                        }, err => {
+                            callback(err);
+                        });
+                    }
+                    else {
+                        callback();
+                    }
+                },
+            });
+            this.writable = writable;
+            let onabort;
+            let reason;
+            const controller = {
+                signal: {
+                    any(signals) {
+                        return AbortSignal.any([...signals]);
+                    },
+                    get reason() {
+                        return reason;
+                    },
+                    get aborted() {
+                        return writable.destroyed;
+                    },
+                    addEventListener: (_event, eventListener) => {
+                        writable.once('error', eventListener);
+                        writable.once('close', eventListener);
+                    },
+                    removeEventListener: (_event, eventListener) => {
+                        writable.off('error', eventListener);
+                        writable.off('close', eventListener);
+                    },
+                    dispatchEvent: (_event) => {
+                        return false;
+                    },
+                    get onabort() {
+                        return onabort;
+                    },
+                    set onabort(value) {
+                        if (onabort) {
+                            this.removeEventListener('abort', onabort);
+                        }
+                        onabort = value;
+                        if (onabort) {
+                            this.addEventListener('abort', onabort);
+                        }
+                    },
+                    throwIfAborted() {
+                        if (writable.destroyed) {
+                            throw reason;
+                        }
+                    },
+                },
+                error: e => {
+                    this.writable.destroy(e);
+                },
+            };
+            this.writable.once('error', err => {
+                reason = err;
+            });
+        }
+        else {
+            this.writable = new stream_1.Writable();
+        }
+    }
+    getWriter() {
+        const writable = this.writable;
+        return {
+            closed: new Promise(resolve => {
+                writable.once('close', () => {
+                    resolve(undefined);
+                });
+            }),
+            get desiredSize() {
+                return writable.writableLength;
+            },
+            ready: new Promise(resolve => {
+                writable.once('drain', () => {
+                    resolve(undefined);
+                });
+            }),
+            releaseLock() {
+                // no-op
+            },
+            write(chunk) {
+                return new Promise((resolve, reject) => {
+                    writable.write(chunk, (err) => {
+                        if (err) {
+                            reject(err);
+                        }
+                        else {
+                            resolve();
+                        }
+                    });
+                });
+            },
+            close() {
+                return new Promise((resolve, reject) => {
+                    writable.end((err) => {
+                        if (err) {
+                            reject(err);
+                        }
+                        else {
+                            resolve();
+                        }
+                    });
+                });
+            },
+            abort(reason) {
+                return new Promise(resolve => {
+                    writable.destroy(reason);
+                    resolve();
+                });
+            },
+        };
+    }
+    close() {
+        return new Promise((resolve, reject) => {
+            this.writable.end((err) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+    }
+    abort(reason) {
+        return new Promise(resolve => {
+            this.writable.destroy(reason);
+            resolve();
+        });
+    }
+}
+exports.PonyfillWritableStream = PonyfillWritableStream;

package/cjs/fetchNodeHttp.js

@@ -51,6 +51,10 @@ function fetchNodeHttp(fetchRequest) {
                     case 'deflate':
                         responseBody = nodeResponse.pipe((0, zlib_1.createInflate)());
                         break;
+                    case 'x-deflate-raw':
+                    case 'deflate-raw':
+                        responseBody = nodeResponse.pipe((0, zlib_1.createInflateRaw)());
+                        break;
                     case 'br':
                         responseBody = nodeResponse.pipe((0, zlib_1.createBrotliDecompress)());
                         break;

package/cjs/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.URLSearchParams = exports.URL = exports.btoa = exports.TextDecoder = exports.TextEncoder = exports.Blob = exports.FormData = exports.File = exports.ReadableStream = exports.Response = exports.Request = exports.Body = exports.Headers = exports.fetch = void 0;
+exports.DecompressionStream = exports.CompressionStream = exports.TransformStream = exports.WritableStream = exports.URLSearchParams = exports.URL = exports.btoa = exports.TextDecoder = exports.TextEncoder = exports.Blob = exports.FormData = exports.File = exports.ReadableStream = exports.Response = exports.Request = exports.Body = exports.Headers = exports.fetch = void 0;
 var fetch_js_1 = require("./fetch.js");
 Object.defineProperty(exports, "fetch", { enumerable: true, get: function () { return fetch_js_1.fetchPonyfill; } });
 var Headers_js_1 = require("./Headers.js");
@@ -27,3 +27,11 @@ var URL_js_1 = require("./URL.js");
 Object.defineProperty(exports, "URL", { enumerable: true, get: function () { return URL_js_1.PonyfillURL; } });
 var URLSearchParams_js_1 = require("./URLSearchParams.js");
 Object.defineProperty(exports, "URLSearchParams", { enumerable: true, get: function () { return URLSearchParams_js_1.PonyfillURLSearchParams; } });
+var WritableStream_js_1 = require("./WritableStream.js");
+Object.defineProperty(exports, "WritableStream", { enumerable: true, get: function () { return WritableStream_js_1.PonyfillWritableStream; } });
+var TransformStream_js_1 = require("./TransformStream.js");
+Object.defineProperty(exports, "TransformStream", { enumerable: true, get: function () { return TransformStream_js_1.PonyfillTransformStream; } });
+var CompressionStream_js_1 = require("./CompressionStream.js");
+Object.defineProperty(exports, "CompressionStream", { enumerable: true, get: function () { return CompressionStream_js_1.PonyfillCompressionStream; } });
+var DecompressionStream_js_1 = require("./DecompressionStream.js");
+Object.defineProperty(exports, "DecompressionStream", { enumerable: true, get: function () { return DecompressionStream_js_1.PonyfillDecompressionStream; } });

package/esm/CompressionStream.js

@@ -0,0 +1,24 @@
+import { createBrotliCompress, createDeflate, createDeflateRaw, createGzip } from 'node:zlib';
+import { PonyfillTransformStream } from './TransformStream';
+export class PonyfillCompressionStream extends PonyfillTransformStream {
+    constructor(compressionFormat) {
+        switch (compressionFormat) {
+            case 'x-gzip':
+            case 'gzip':
+                super(createGzip());
+                break;
+            case 'x-deflate':
+            case 'deflate':
+                super(createDeflate());
+                break;
+            case 'deflate-raw':
+                super(createDeflateRaw());
+                break;
+            case 'br':
+                super(createBrotliCompress());
+                break;
+            default:
+                throw new Error(`Unsupported compression format: ${compressionFormat}`);
+        }
+    }
+}

package/esm/DecompressionStream.js

@@ -0,0 +1,24 @@
+import { createBrotliDecompress, createGunzip, createInflate, createInflateRaw } from 'node:zlib';
+import { PonyfillTransformStream } from './TransformStream.js';
+export class PonyfillDecompressionStream extends PonyfillTransformStream {
+    constructor(compressionFormat) {
+        switch (compressionFormat) {
+            case 'x-gzip':
+            case 'gzip':
+                super(createGunzip());
+                break;
+            case 'x-deflate':
+            case 'deflate':
+                super(createInflate());
+                break;
+            case 'deflate-raw':
+                super(createInflateRaw());
+                break;
+            case 'br':
+                super(createBrotliDecompress());
+                break;
+            default:
+                throw new Error(`Unsupported compression format: ${compressionFormat}`);
+        }
+    }
+}

package/esm/ReadableStream.js

@@ -152,13 +152,25 @@ export class PonyfillReadableStream {
         throw new Error('Not implemented');
     }
     async pipeTo(destination) {
-        const writer = destination.getWriter();
-        await writer.ready;
-        for await (const chunk of this.readable) {
-            await writer.write(chunk);
+        if (isPonyfillWritableStream(destination)) {
+            return new Promise((resolve, reject) => {
+                this.readable.pipe(destination.writable);
+                destination.writable.once('finish', resolve);
+                destination.writable.once('error', reject);
+            });
+        }
+        else {
+            const writer = destination.getWriter();
+            try {
+                for await (const chunk of this) {
+                    await writer.write(chunk);
+                }
+                await writer.close();
+            }
+            catch (err) {
+                await writer.abort(err);
+            }
         }
-        await writer.ready;
-        return writer.close();
     }
     pipeThrough({ writable, readable, }) {
         this.pipeTo(writable);
@@ -168,3 +180,6 @@ export class PonyfillReadableStream {
         return isReadableStream(instance);
     }
 }
+function isPonyfillWritableStream(obj) {
+    return obj?.writable != null;
+}

package/esm/TransformStream.js

@@ -0,0 +1,71 @@
+import { Transform } from 'node:stream';
+import { PonyfillReadableStream } from './ReadableStream.js';
+import { PonyfillWritableStream } from './WritableStream.js';
+export class PonyfillTransformStream {
+    constructor(transformer) {
+        if (transformer instanceof Transform) {
+            this.transform = transformer;
+        }
+        else if (transformer) {
+            const controller = {
+                enqueue(chunk) {
+                    transform.push(chunk);
+                },
+                error(reason) {
+                    transform.destroy(reason);
+                },
+                terminate() {
+                    transform.end();
+                },
+                get desiredSize() {
+                    return transform.writableLength;
+                },
+            };
+            const transform = new Transform({
+                read() { },
+                write(chunk, _encoding, callback) {
+                    try {
+                        const result = transformer.transform?.(chunk, controller);
+                        if (result instanceof Promise) {
+                            result.then(() => {
+                                callback();
+                            }, err => {
+                                callback(err);
+                            });
+                        }
+                        else {
+                            callback();
+                        }
+                    }
+                    catch (err) {
+                        callback(err);
+                    }
+                },
+                final(callback) {
+                    try {
+                        const result = transformer.flush?.(controller);
+                        if (result instanceof Promise) {
+                            result.then(() => {
+                                callback();
+                            }, err => {
+                                callback(err);
+                            });
+                        }
+                        else {
+                            callback();
+                        }
+                    }
+                    catch (err) {
+                        callback(err);
+                    }
+                },
+            });
+            this.transform = transform;
+        }
+        else {
+            this.transform = new Transform();
+        }
+        this.writable = new PonyfillWritableStream(this.transform);
+        this.readable = new PonyfillReadableStream(this.transform);
+    }
+}

package/esm/WritableStream.js

@@ -0,0 +1,166 @@
+import { Writable } from 'stream';
+export class PonyfillWritableStream {
+    constructor(underlyingSink) {
+        this.locked = false;
+        if (underlyingSink instanceof Writable) {
+            this.writable = underlyingSink;
+        }
+        else if (underlyingSink) {
+            const writable = new Writable({
+                write(chunk, _encoding, callback) {
+                    try {
+                        const result = underlyingSink.write?.(chunk, controller);
+                        if (result instanceof Promise) {
+                            result.then(() => {
+                                callback();
+                            }, err => {
+                                callback(err);
+                            });
+                        }
+                        else {
+                            callback();
+                        }
+                    }
+                    catch (err) {
+                        callback(err);
+                    }
+                },
+                final(callback) {
+                    const result = underlyingSink.close?.();
+                    if (result instanceof Promise) {
+                        result.then(() => {
+                            callback();
+                        }, err => {
+                            callback(err);
+                        });
+                    }
+                    else {
+                        callback();
+                    }
+                },
+            });
+            this.writable = writable;
+            let onabort;
+            let reason;
+            const controller = {
+                signal: {
+                    any(signals) {
+                        return AbortSignal.any([...signals]);
+                    },
+                    get reason() {
+                        return reason;
+                    },
+                    get aborted() {
+                        return writable.destroyed;
+                    },
+                    addEventListener: (_event, eventListener) => {
+                        writable.once('error', eventListener);
+                        writable.once('close', eventListener);
+                    },
+                    removeEventListener: (_event, eventListener) => {
+                        writable.off('error', eventListener);
+                        writable.off('close', eventListener);
+                    },
+                    dispatchEvent: (_event) => {
+                        return false;
+                    },
+                    get onabort() {
+                        return onabort;
+                    },
+                    set onabort(value) {
+                        if (onabort) {
+                            this.removeEventListener('abort', onabort);
+                        }
+                        onabort = value;
+                        if (onabort) {
+                            this.addEventListener('abort', onabort);
+                        }
+                    },
+                    throwIfAborted() {
+                        if (writable.destroyed) {
+                            throw reason;
+                        }
+                    },
+                },
+                error: e => {
+                    this.writable.destroy(e);
+                },
+            };
+            this.writable.once('error', err => {
+                reason = err;
+            });
+        }
+        else {
+            this.writable = new Writable();
+        }
+    }
+    getWriter() {
+        const writable = this.writable;
+        return {
+            closed: new Promise(resolve => {
+                writable.once('close', () => {
+                    resolve(undefined);
+                });
+            }),
+            get desiredSize() {
+                return writable.writableLength;
+            },
+            ready: new Promise(resolve => {
+                writable.once('drain', () => {
+                    resolve(undefined);
+                });
+            }),
+            releaseLock() {
+                // no-op
+            },
+            write(chunk) {
+                return new Promise((resolve, reject) => {
+                    writable.write(chunk, (err) => {
+                        if (err) {
+                            reject(err);
+                        }
+                        else {
+                            resolve();
+                        }
+                    });
+                });
+            },
+            close() {
+                return new Promise((resolve, reject) => {
+                    writable.end((err) => {
+                        if (err) {
+                            reject(err);
+                        }
+                        else {
+                            resolve();
+                        }
+                    });
+                });
+            },
+            abort(reason) {
+                return new Promise(resolve => {
+                    writable.destroy(reason);
+                    resolve();
+                });
+            },
+        };
+    }
+    close() {
+        return new Promise((resolve, reject) => {
+            this.writable.end((err) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+    }
+    abort(reason) {
+        return new Promise(resolve => {
+            this.writable.destroy(reason);
+            resolve();
+        });
+    }
+}

package/esm/fetchNodeHttp.js

@@ -1,7 +1,7 @@
 import { request as httpRequest } from 'http';
 import { request as httpsRequest } from 'https';
 import { PassThrough, Readable } from 'stream';
-import { createBrotliDecompress, createGunzip, createInflate } from 'zlib';
+import { createBrotliDecompress, createGunzip, createInflate, createInflateRaw } from 'zlib';
 import { PonyfillAbortError } from './AbortError.js';
 import { PonyfillRequest } from './Request.js';
 import { PonyfillResponse } from './Response.js';
@@ -48,6 +48,10 @@ export function fetchNodeHttp(fetchRequest) {
                     case 'deflate':
                         responseBody = nodeResponse.pipe(createInflate());
                         break;
+                    case 'x-deflate-raw':
+                    case 'deflate-raw':
+                        responseBody = nodeResponse.pipe(createInflateRaw());
+                        break;
                     case 'br':
                         responseBody = nodeResponse.pipe(createBrotliDecompress());
                         break;

package/esm/index.js

@@ -10,3 +10,7 @@ export { PonyfillBlob as Blob } from './Blob.js';
 export { PonyfillTextEncoder as TextEncoder, PonyfillTextDecoder as TextDecoder, PonyfillBtoa as btoa, } from './TextEncoderDecoder.js';
 export { PonyfillURL as URL } from './URL.js';
 export { PonyfillURLSearchParams as URLSearchParams } from './URLSearchParams.js';
+export { PonyfillWritableStream as WritableStream } from './WritableStream.js';
+export { PonyfillTransformStream as TransformStream } from './TransformStream.js';
+export { PonyfillCompressionStream as CompressionStream } from './CompressionStream.js';
+export { PonyfillDecompressionStream as DecompressionStream } from './DecompressionStream.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@whatwg-node/node-fetch",
-  "version": "0.5.15",
+  "version": "0.5.16-alpha-20240726002236-105dd434a11d1e455ea8f23481530c2ec4ca0aae",
   "description": "Fetch API implementation for Node",
   "sideEffects": false,
   "dependencies": {

package/typings/CompressionStream.d.cts

@@ -0,0 +1,5 @@
+import { PonyfillTransformStream } from './TransformStream';
+export type PonyfillCompressionFormat = 'x-gzip' | 'gzip' | 'x-deflate' | 'deflate' | 'deflate-raw' | 'br';
+export declare class PonyfillCompressionStream extends PonyfillTransformStream implements CompressionStream {
+    constructor(compressionFormat: PonyfillCompressionFormat);
+}

package/typings/CompressionStream.d.ts

@@ -0,0 +1,5 @@
+import { PonyfillTransformStream } from './TransformStream';
+export type PonyfillCompressionFormat = 'x-gzip' | 'gzip' | 'x-deflate' | 'deflate' | 'deflate-raw' | 'br';
+export declare class PonyfillCompressionStream extends PonyfillTransformStream implements CompressionStream {
+    constructor(compressionFormat: PonyfillCompressionFormat);
+}

package/typings/DecompressionStream.d.cts

@@ -0,0 +1,5 @@
+import { PonyfillCompressionFormat } from './CompressionStream.cjs';
+import { PonyfillTransformStream } from './TransformStream.cjs';
+export declare class PonyfillDecompressionStream extends PonyfillTransformStream implements DecompressionStream {
+    constructor(compressionFormat: PonyfillCompressionFormat);
+}

package/typings/DecompressionStream.d.ts

@@ -0,0 +1,5 @@
+import { PonyfillCompressionFormat } from './CompressionStream.js';
+import { PonyfillTransformStream } from './TransformStream.js';
+export declare class PonyfillDecompressionStream extends PonyfillTransformStream implements DecompressionStream {
+    constructor(compressionFormat: PonyfillCompressionFormat);
+}

package/typings/TransformStream.d.cts

@@ -0,0 +1,9 @@
+import { Transform } from 'node:stream';
+import { PonyfillReadableStream } from './ReadableStream.cjs';
+import { PonyfillWritableStream } from './WritableStream.cjs';
+export declare class PonyfillTransformStream<I = any, O = any> implements TransformStream<I, O> {
+    transform: Transform;
+    writable: PonyfillWritableStream<I>;
+    readable: PonyfillReadableStream<O>;
+    constructor(transformer?: Transformer<I, O> | Transform);
+}

package/typings/TransformStream.d.ts

@@ -0,0 +1,9 @@
+import { Transform } from 'node:stream';
+import { PonyfillReadableStream } from './ReadableStream.js';
+import { PonyfillWritableStream } from './WritableStream.js';
+export declare class PonyfillTransformStream<I = any, O = any> implements TransformStream<I, O> {
+    transform: Transform;
+    writable: PonyfillWritableStream<I>;
+    readable: PonyfillReadableStream<O>;
+    constructor(transformer?: Transformer<I, O> | Transform);
+}

package/typings/WritableStream.d.cts

@@ -0,0 +1,9 @@
+import { Writable } from 'stream';
+export declare class PonyfillWritableStream<W = any> implements WritableStream<W> {
+    writable: Writable;
+    constructor(underlyingSink?: UnderlyingSink<W> | Writable);
+    getWriter(): WritableStreamDefaultWriter<W>;
+    close(): Promise<void>;
+    abort(reason: any): Promise<void>;
+    locked: boolean;
+}

package/typings/WritableStream.d.ts

@@ -0,0 +1,9 @@
+import { Writable } from 'stream';
+export declare class PonyfillWritableStream<W = any> implements WritableStream<W> {
+    writable: Writable;
+    constructor(underlyingSink?: UnderlyingSink<W> | Writable);
+    getWriter(): WritableStreamDefaultWriter<W>;
+    close(): Promise<void>;
+    abort(reason: any): Promise<void>;
+    locked: boolean;
+}

package/typings/index.d.cts

@@ -10,3 +10,7 @@ export { PonyfillBlob as Blob } from './Blob.cjs';
 export { PonyfillTextEncoder as TextEncoder, PonyfillTextDecoder as TextDecoder, PonyfillBtoa as btoa, } from './TextEncoderDecoder.cjs';
 export { PonyfillURL as URL } from './URL.cjs';
 export { PonyfillURLSearchParams as URLSearchParams } from './URLSearchParams.cjs';
+export { PonyfillWritableStream as WritableStream } from './WritableStream.cjs';
+export { PonyfillTransformStream as TransformStream } from './TransformStream.cjs';
+export { PonyfillCompressionStream as CompressionStream } from './CompressionStream.cjs';
+export { PonyfillDecompressionStream as DecompressionStream } from './DecompressionStream.cjs';

package/typings/index.d.ts

@@ -10,3 +10,7 @@ export { PonyfillBlob as Blob } from './Blob.js';
 export { PonyfillTextEncoder as TextEncoder, PonyfillTextDecoder as TextDecoder, PonyfillBtoa as btoa, } from './TextEncoderDecoder.js';
 export { PonyfillURL as URL } from './URL.js';
 export { PonyfillURLSearchParams as URLSearchParams } from './URLSearchParams.js';
+export { PonyfillWritableStream as WritableStream } from './WritableStream.js';
+export { PonyfillTransformStream as TransformStream } from './TransformStream.js';
+export { PonyfillCompressionStream as CompressionStream } from './CompressionStream.js';
+export { PonyfillDecompressionStream as DecompressionStream } from './DecompressionStream.js';