simple-zstd 1.4.2 → 2.0.0

package/dist/src/peek-transform.js

@@ -0,0 +1,145 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _PeekPassThrough_instances, _PeekPassThrough_maxBuffer, _PeekPassThrough_buffer, _PeekPassThrough_bufferedLength, _PeekPassThrough_peeked, _PeekPassThrough_peekCallback, _PeekPassThrough_swappedStream, _PeekPassThrough_ended, _PeekPassThrough_performPeek;
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_stream_1 = require("node:stream");
+class PeekPassThrough extends node_stream_1.Duplex {
+    constructor(options, peekCallback) {
+        super(options);
+        _PeekPassThrough_instances.add(this);
+        _PeekPassThrough_maxBuffer.set(this, void 0);
+        _PeekPassThrough_buffer.set(this, void 0);
+        _PeekPassThrough_bufferedLength.set(this, void 0);
+        _PeekPassThrough_peeked.set(this, void 0);
+        _PeekPassThrough_peekCallback.set(this, void 0);
+        _PeekPassThrough_swappedStream.set(this, void 0);
+        _PeekPassThrough_ended.set(this, void 0);
+        __classPrivateFieldSet(this, _PeekPassThrough_maxBuffer, options.maxBuffer || 65536, "f");
+        __classPrivateFieldSet(this, _PeekPassThrough_buffer, [], "f");
+        __classPrivateFieldSet(this, _PeekPassThrough_bufferedLength, 0, "f");
+        __classPrivateFieldSet(this, _PeekPassThrough_peeked, false, "f");
+        __classPrivateFieldSet(this, _PeekPassThrough_peekCallback, peekCallback, "f");
+        __classPrivateFieldSet(this, _PeekPassThrough_swappedStream, null, "f");
+        __classPrivateFieldSet(this, _PeekPassThrough_ended, false, "f");
+    }
+    _write(chunk, encoding, callback) {
+        // If we already peeked and have a swapped stream, write to it
+        if (__classPrivateFieldGet(this, _PeekPassThrough_peeked, "f") && __classPrivateFieldGet(this, _PeekPassThrough_swappedStream, "f")) {
+            __classPrivateFieldGet(this, _PeekPassThrough_swappedStream, "f").write(chunk, encoding, callback);
+            return;
+        }
+        // If we already peeked but no swap, just pass through
+        if (__classPrivateFieldGet(this, _PeekPassThrough_peeked, "f")) {
+            this.push(chunk);
+            callback();
+            return;
+        }
+        // Buffer chunks until we have enough to peek
+        __classPrivateFieldGet(this, _PeekPassThrough_buffer, "f").push(chunk);
+        __classPrivateFieldSet(this, _PeekPassThrough_bufferedLength, __classPrivateFieldGet(this, _PeekPassThrough_bufferedLength, "f") + chunk.length, "f");
+        if (__classPrivateFieldGet(this, _PeekPassThrough_bufferedLength, "f") >= __classPrivateFieldGet(this, _PeekPassThrough_maxBuffer, "f")) {
+            __classPrivateFieldGet(this, _PeekPassThrough_instances, "m", _PeekPassThrough_performPeek).call(this, callback);
+        }
+        else {
+            callback();
+        }
+    }
+    _final(callback) {
+        // If we haven't peeked yet and stream is ending, peek now
+        if (!__classPrivateFieldGet(this, _PeekPassThrough_peeked, "f")) {
+            __classPrivateFieldGet(this, _PeekPassThrough_instances, "m", _PeekPassThrough_performPeek).call(this, callback);
+        }
+        else if (__classPrivateFieldGet(this, _PeekPassThrough_swappedStream, "f")) {
+            // End the swapped stream
+            __classPrivateFieldGet(this, _PeekPassThrough_swappedStream, "f").end(callback);
+        }
+        else {
+            // No swap - signal EOF for passthrough case
+            if (!__classPrivateFieldGet(this, _PeekPassThrough_ended, "f")) {
+                __classPrivateFieldSet(this, _PeekPassThrough_ended, true, "f");
+                this.push(null);
+            }
+            callback();
+        }
+    }
+    _read(_size) {
+        // If we have a swapped stream, resume it if paused
+        if (__classPrivateFieldGet(this, _PeekPassThrough_swappedStream, "f")) {
+            if (__classPrivateFieldGet(this, _PeekPassThrough_swappedStream, "f").isPaused && __classPrivateFieldGet(this, _PeekPassThrough_swappedStream, "f").isPaused()) {
+                __classPrivateFieldGet(this, _PeekPassThrough_swappedStream, "f").resume();
+            }
+        }
+    }
+    _destroy(error, callback) {
+        if (__classPrivateFieldGet(this, _PeekPassThrough_swappedStream, "f") && !__classPrivateFieldGet(this, _PeekPassThrough_swappedStream, "f").destroyed) {
+            __classPrivateFieldGet(this, _PeekPassThrough_swappedStream, "f").destroy();
+        }
+        callback(error);
+    }
+}
+_PeekPassThrough_maxBuffer = new WeakMap(), _PeekPassThrough_buffer = new WeakMap(), _PeekPassThrough_bufferedLength = new WeakMap(), _PeekPassThrough_peeked = new WeakMap(), _PeekPassThrough_peekCallback = new WeakMap(), _PeekPassThrough_swappedStream = new WeakMap(), _PeekPassThrough_ended = new WeakMap(), _PeekPassThrough_instances = new WeakSet(), _PeekPassThrough_performPeek = function _PeekPassThrough_performPeek(callback) {
+    __classPrivateFieldSet(this, _PeekPassThrough_peeked, true, "f");
+    const peekData = Buffer.concat(__classPrivateFieldGet(this, _PeekPassThrough_buffer, "f"));
+    // Call the peek callback to determine which stream to use
+    __classPrivateFieldGet(this, _PeekPassThrough_peekCallback, "f").call(this, peekData, (err, swappedStream) => {
+        if (err) {
+            callback(err);
+            return;
+        }
+        if (swappedStream) {
+            // We have a swapped stream
+            __classPrivateFieldSet(this, _PeekPassThrough_swappedStream, swappedStream, "f");
+            // Pipe swapped stream's output to our output
+            swappedStream.on('data', (chunk) => {
+                if (!this.push(chunk)) {
+                    swappedStream.pause();
+                }
+            });
+            swappedStream.on('end', () => {
+                if (!__classPrivateFieldGet(this, _PeekPassThrough_ended, "f")) {
+                    __classPrivateFieldSet(this, _PeekPassThrough_ended, true, "f");
+                    this.push(null);
+                }
+            });
+            swappedStream.on('error', (streamErr) => {
+                this.destroy(streamErr);
+            });
+            // Resume reading when downstream is ready
+            this.on('drain', () => {
+                if (swappedStream.isPaused && swappedStream.isPaused()) {
+                    swappedStream.resume();
+                }
+            });
+            // Write all buffered data to the swapped stream
+            for (const bufferedChunk of __classPrivateFieldGet(this, _PeekPassThrough_buffer, "f")) {
+                swappedStream.write(bufferedChunk);
+            }
+            // Ensure the swapped stream is in flowing mode
+            if (swappedStream.isPaused && swappedStream.isPaused()) {
+                swappedStream.resume();
+            }
+        }
+        else {
+            // No swap - just push buffered data through
+            for (const bufferedChunk of __classPrivateFieldGet(this, _PeekPassThrough_buffer, "f")) {
+                this.push(bufferedChunk);
+            }
+        }
+        // Clear the buffer
+        __classPrivateFieldSet(this, _PeekPassThrough_buffer, [], "f");
+        __classPrivateFieldSet(this, _PeekPassThrough_bufferedLength, 0, "f");
+        callback();
+    });
+};
+exports.default = PeekPassThrough;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/process-duplex.d.ts

@@ -0,0 +1,11 @@
+import { Duplex } from 'node:stream';
+import { SpawnOptions } from 'node:child_process';
+import type { DuplexOptions } from 'node:stream';
+export default class ProcessDuplex extends Duplex {
+    #private;
+    constructor(command: string, args: string[], spawnOptions?: SpawnOptions, streamOptions?: DuplexOptions);
+    _read(_size: number): void;
+    _write(chunk: Buffer, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
+    _final(callback: (error?: Error | null) => void): void;
+    _destroy(error: Error | null, callback: (error: Error | null) => void): void;
+}

package/dist/src/process-duplex.js

@@ -0,0 +1,157 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _ProcessDuplex_process, _ProcessDuplex_stdoutDataHandler, _ProcessDuplex_stdoutEndHandler, _ProcessDuplex_stdoutErrorHandler, _ProcessDuplex_stdoutCloseHandler, _ProcessDuplex_stderrDataHandler, _ProcessDuplex_processExitHandler, _ProcessDuplex_processErrorHandler;
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_stream_1 = require("node:stream");
+const node_child_process_1 = require("node:child_process");
+class ProcessDuplex extends node_stream_1.Duplex {
+    constructor(command, args, spawnOptions, streamOptions) {
+        super(streamOptions);
+        _ProcessDuplex_process.set(this, void 0);
+        _ProcessDuplex_stdoutDataHandler.set(this, void 0);
+        _ProcessDuplex_stdoutEndHandler.set(this, void 0);
+        _ProcessDuplex_stdoutErrorHandler.set(this, void 0);
+        _ProcessDuplex_stdoutCloseHandler.set(this, void 0);
+        _ProcessDuplex_stderrDataHandler.set(this, void 0);
+        _ProcessDuplex_processExitHandler.set(this, void 0);
+        _ProcessDuplex_processErrorHandler.set(this, void 0);
+        // Spawn the child process
+        __classPrivateFieldSet(this, _ProcessDuplex_process, (0, node_child_process_1.spawn)(command, args, spawnOptions || {}), "f");
+        // Forward stdout to the readable side of this duplex
+        if (__classPrivateFieldGet(this, _ProcessDuplex_process, "f").stdout) {
+            __classPrivateFieldSet(this, _ProcessDuplex_stdoutDataHandler, (chunk) => {
+                const canPushMore = this.push(chunk);
+                if (!canPushMore) {
+                    __classPrivateFieldGet(this, _ProcessDuplex_process, "f").stdout?.pause();
+                }
+            }, "f");
+            __classPrivateFieldGet(this, _ProcessDuplex_process, "f").stdout.on('data', __classPrivateFieldGet(this, _ProcessDuplex_stdoutDataHandler, "f"));
+            __classPrivateFieldSet(this, _ProcessDuplex_stdoutEndHandler, () => {
+                // Signal end of readable side
+                this.push(null);
+            }, "f");
+            __classPrivateFieldGet(this, _ProcessDuplex_process, "f").stdout.on('end', __classPrivateFieldGet(this, _ProcessDuplex_stdoutEndHandler, "f"));
+            __classPrivateFieldSet(this, _ProcessDuplex_stdoutErrorHandler, (err) => {
+                this.destroy(err);
+            }, "f");
+            __classPrivateFieldGet(this, _ProcessDuplex_process, "f").stdout.on('error', __classPrivateFieldGet(this, _ProcessDuplex_stdoutErrorHandler, "f"));
+            __classPrivateFieldSet(this, _ProcessDuplex_stdoutCloseHandler, () => {
+                // Ensure we signal end if not already done
+                this.push(null);
+            }, "f");
+            __classPrivateFieldGet(this, _ProcessDuplex_process, "f").stdout.on('close', __classPrivateFieldGet(this, _ProcessDuplex_stdoutCloseHandler, "f"));
+        }
+        // Forward stderr errors
+        if (__classPrivateFieldGet(this, _ProcessDuplex_process, "f").stderr) {
+            __classPrivateFieldSet(this, _ProcessDuplex_stderrDataHandler, (chunk) => {
+                // Emit stderr as a warning or error event
+                this.emit('stderr', chunk.toString());
+            }, "f");
+            __classPrivateFieldGet(this, _ProcessDuplex_process, "f").stderr.on('data', __classPrivateFieldGet(this, _ProcessDuplex_stderrDataHandler, "f"));
+        }
+        // Handle process exit
+        __classPrivateFieldSet(this, _ProcessDuplex_processExitHandler, (code, signal) => {
+            this.emit('exit', code, signal);
+        }, "f");
+        __classPrivateFieldGet(this, _ProcessDuplex_process, "f").on('exit', __classPrivateFieldGet(this, _ProcessDuplex_processExitHandler, "f"));
+        // Handle process errors
+        __classPrivateFieldSet(this, _ProcessDuplex_processErrorHandler, (err) => {
+            this.destroy(err);
+        }, "f");
+        __classPrivateFieldGet(this, _ProcessDuplex_process, "f").on('error', __classPrivateFieldGet(this, _ProcessDuplex_processErrorHandler, "f"));
+    }
+    _read(_size) {
+        // Resume stdout if it was paused
+        if (__classPrivateFieldGet(this, _ProcessDuplex_process, "f").stdout && __classPrivateFieldGet(this, _ProcessDuplex_process, "f").stdout.isPaused()) {
+            __classPrivateFieldGet(this, _ProcessDuplex_process, "f").stdout.resume();
+        }
+    }
+    _write(chunk, encoding, callback) {
+        // Write to the process stdin
+        if (__classPrivateFieldGet(this, _ProcessDuplex_process, "f").stdin) {
+            if (!__classPrivateFieldGet(this, _ProcessDuplex_process, "f").stdin.write(chunk, encoding)) {
+                // If the write buffer is full, wait for drain
+                __classPrivateFieldGet(this, _ProcessDuplex_process, "f").stdin.once('drain', callback);
+            }
+            else {
+                callback();
+            }
+        }
+        else {
+            callback(new Error('Process stdin is not available'));
+        }
+    }
+    _final(callback) {
+        // Close stdin when the writable side is finished
+        if (__classPrivateFieldGet(this, _ProcessDuplex_process, "f").stdin) {
+            __classPrivateFieldGet(this, _ProcessDuplex_process, "f").stdin.end(callback);
+        }
+        else {
+            callback();
+        }
+    }
+    _destroy(error, callback) {
+        // Remove all event listeners to prevent memory leaks
+        if (__classPrivateFieldGet(this, _ProcessDuplex_process, "f").stdout) {
+            if (__classPrivateFieldGet(this, _ProcessDuplex_stdoutDataHandler, "f"))
+                __classPrivateFieldGet(this, _ProcessDuplex_process, "f").stdout.removeListener('data', __classPrivateFieldGet(this, _ProcessDuplex_stdoutDataHandler, "f"));
+            if (__classPrivateFieldGet(this, _ProcessDuplex_stdoutEndHandler, "f"))
+                __classPrivateFieldGet(this, _ProcessDuplex_process, "f").stdout.removeListener('end', __classPrivateFieldGet(this, _ProcessDuplex_stdoutEndHandler, "f"));
+            if (__classPrivateFieldGet(this, _ProcessDuplex_stdoutErrorHandler, "f"))
+                __classPrivateFieldGet(this, _ProcessDuplex_process, "f").stdout.removeListener('error', __classPrivateFieldGet(this, _ProcessDuplex_stdoutErrorHandler, "f"));
+            if (__classPrivateFieldGet(this, _ProcessDuplex_stdoutCloseHandler, "f"))
+                __classPrivateFieldGet(this, _ProcessDuplex_process, "f").stdout.removeListener('close', __classPrivateFieldGet(this, _ProcessDuplex_stdoutCloseHandler, "f"));
+        }
+        if (__classPrivateFieldGet(this, _ProcessDuplex_process, "f").stderr && __classPrivateFieldGet(this, _ProcessDuplex_stderrDataHandler, "f")) {
+            __classPrivateFieldGet(this, _ProcessDuplex_process, "f").stderr.removeListener('data', __classPrivateFieldGet(this, _ProcessDuplex_stderrDataHandler, "f"));
+        }
+        if (__classPrivateFieldGet(this, _ProcessDuplex_processExitHandler, "f")) {
+            __classPrivateFieldGet(this, _ProcessDuplex_process, "f").removeListener('exit', __classPrivateFieldGet(this, _ProcessDuplex_processExitHandler, "f"));
+        }
+        if (__classPrivateFieldGet(this, _ProcessDuplex_processErrorHandler, "f")) {
+            __classPrivateFieldGet(this, _ProcessDuplex_process, "f").removeListener('error', __classPrivateFieldGet(this, _ProcessDuplex_processErrorHandler, "f"));
+        }
+        // Kill the child process and wait for it to exit
+        if (__classPrivateFieldGet(this, _ProcessDuplex_process, "f") && !__classPrivateFieldGet(this, _ProcessDuplex_process, "f").killed) {
+            // Close stdin first so the process receives EOF and can exit cleanly
+            if (__classPrivateFieldGet(this, _ProcessDuplex_process, "f").stdin && !__classPrivateFieldGet(this, _ProcessDuplex_process, "f").stdin.destroyed) {
+                __classPrivateFieldGet(this, _ProcessDuplex_process, "f").stdin.end();
+            }
+            // Wait for the process to fully exit before calling callback
+            const onClose = () => {
+                clearTimeout(forceKillTimeout);
+                callback(error);
+            };
+            // Set up close listener
+            __classPrivateFieldGet(this, _ProcessDuplex_process, "f").once('close', onClose);
+            // Kill the process (should exit quickly now that stdin is closed)
+            __classPrivateFieldGet(this, _ProcessDuplex_process, "f").kill();
+            // Force kill if process doesn't exit within 1 second
+            const forceKillTimeout = setTimeout(() => {
+                if (!__classPrivateFieldGet(this, _ProcessDuplex_process, "f").killed) {
+                    __classPrivateFieldGet(this, _ProcessDuplex_process, "f").kill('SIGKILL');
+                }
+                // Remove the close listener and call callback
+                __classPrivateFieldGet(this, _ProcessDuplex_process, "f").removeListener('close', onClose);
+                callback(error);
+            }, 1000);
+        }
+        else {
+            // Process already killed or doesn't exist
+            callback(error);
+        }
+    }
+}
+_ProcessDuplex_process = new WeakMap(), _ProcessDuplex_stdoutDataHandler = new WeakMap(), _ProcessDuplex_stdoutEndHandler = new WeakMap(), _ProcessDuplex_stdoutErrorHandler = new WeakMap(), _ProcessDuplex_stdoutCloseHandler = new WeakMap(), _ProcessDuplex_stderrDataHandler = new WeakMap(), _ProcessDuplex_processExitHandler = new WeakMap(), _ProcessDuplex_processErrorHandler = new WeakMap();
+exports.default = ProcessDuplex;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvY2Vzcy1kdXBsZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcHJvY2Vzcy1kdXBsZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7QUFBQSw2Q0FBcUM7QUFDckMsMkRBQXVFO0FBR3ZFLE1BQXFCLGFBQWMsU0FBUSxvQkFBTTtJQVUvQyxZQUNFLE9BQWUsRUFDZixJQUFjLEVBQ2QsWUFBMkIsRUFDM0IsYUFBNkI7UUFFN0IsS0FBSyxDQUFDLGFBQWEsQ0FBQyxDQUFDO1FBZnZCLHlDQUF1QjtRQUN2QixtREFBNkM7UUFDN0Msa0RBQStCO1FBQy9CLG9EQUEyQztRQUMzQyxvREFBaUM7UUFDakMsbURBQTZDO1FBQzdDLG9EQUFtRjtRQUNuRixxREFBNEM7UUFVMUMsMEJBQTBCO1FBQzFCLHVCQUFBLElBQUksMEJBQVksSUFBQSwwQkFBSyxFQUFDLE9BQU8sRUFBRSxJQUFJLEVBQUUsWUFBWSxJQUFJLEVBQUUsQ0FBQyxNQUFBLENBQUM7UUFFekQscURBQXFEO1FBQ3JELElBQUksdUJBQUEsSUFBSSw4QkFBUyxDQUFDLE1BQU0sRUFBRSxDQUFDO1lBQ3pCLHVCQUFBLElBQUksb0NBQXNCLENBQUMsS0FBYSxFQUFFLEVBQUU7Z0JBQzFDLE1BQU0sV0FBVyxHQUFHLElBQUksQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUM7Z0JBQ3JDLElBQUksQ0FBQyxXQUFXLEVBQUUsQ0FBQztvQkFDakIsdUJBQUEsSUFBSSw4QkFBUyxDQUFDLE1BQU0sRUFBRSxLQUFLLEVBQUUsQ0FBQztnQkFDaEMsQ0FBQztZQUNILENBQUMsTUFBQSxDQUFDO1lBQ0YsdUJBQUEsSUFBSSw4QkFBUyxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUMsTUFBTSxFQUFFLHVCQUFBLElBQUksd0NBQW1CLENBQUMsQ0FBQztZQUV6RCx1QkFBQSxJQUFJLG1DQUFxQixHQUFHLEVBQUU7Z0JBQzVCLDhCQUE4QjtnQkFDOUIsSUFBSSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQztZQUNsQixDQUFDLE1BQUEsQ0FBQztZQUNGLHVCQUFBLElBQUksOEJBQVMsQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDLEtBQUssRUFBRSx1QkFBQSxJQUFJLHVDQUFrQixDQUFDLENBQUM7WUFFdkQsdUJBQUEsSUFBSSxxQ0FBdUIsQ0FBQyxHQUFVLEVBQUUsRUFBRTtnQkFDeEMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQztZQUNwQixDQUFDLE1BQUEsQ0FBQztZQUNGLHVCQUFBLElBQUksOEJBQVMsQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDLE9BQU8sRUFBRSx1QkFBQSxJQUFJLHlDQUFvQixDQUFDLENBQUM7WUFFM0QsdUJBQUEsSUFBSSxxQ0FBdUIsR0FBRyxFQUFFO2dCQUM5QiwyQ0FBMkM7Z0JBQzNDLElBQUksQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7WUFDbEIsQ0FBQyxNQUFBLENBQUM7WUFDRix1QkFBQSxJQUFJLDhCQUFTLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQyxPQUFPLEVBQUUsdUJBQUEsSUFBSSx5Q0FBb0IsQ0FBQyxDQUFDO1FBQzdELENBQUM7UUFFRCx3QkFBd0I7UUFDeEIsSUFBSSx1QkFBQSxJQUFJLDhCQUFTLENBQUMsTUFBTSxFQUFFLENBQUM7WUFDekIsdUJBQUEsSUFBSSxvQ0FBc0IsQ0FBQyxLQUFhLEVBQUUsRUFBRTtnQkFDMUMsMENBQTBDO2dCQUMxQyxJQUFJLENBQUMsSUFBSSxDQUFDLFFBQVEsRUFBRSxLQUFLLENBQUMsUUFBUSxFQUFFLENBQUMsQ0FBQztZQUN4QyxDQUFDLE1BQUEsQ0FBQztZQUNGLHVCQUFBLElBQUksOEJBQVMsQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDLE1BQU0sRUFBRSx1QkFBQSxJQUFJLHdDQUFtQixDQUFDLENBQUM7UUFDM0QsQ0FBQztRQUVELHNCQUFzQjtRQUN0Qix1QkFBQSxJQUFJLHFDQUF1QixDQUFDLElBQW1CLEVBQUUsTUFBNkIsRUFBRSxFQUFFO1lBQ2hGLElBQUksQ0FBQyxJQUFJLENBQUMsTUFBTSxFQUFFLElBQUksRUFBRSxNQUFNLENBQUMsQ0FBQztRQUNsQyxDQUFDLE1BQUEsQ0FBQztRQUNGLHVCQUFBLElBQUksOEJBQVMsQ0FBQyxFQUFFLENBQUMsTUFBTSxFQUFFLHVCQUFBLElBQUkseUNBQW9CLENBQUMsQ0FBQztRQUVuRCx3QkFBd0I7UUFDeEIsdUJBQUEsSUFBSSxzQ0FBd0IsQ0FBQyxHQUFVLEVBQUUsRUFBRTtZQUN6QyxJQUFJLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFDO1FBQ3BCLENBQUMsTUFBQSxDQUFDO1FBQ0YsdUJBQUEsSUFBSSw4QkFBUyxDQUFDLEVBQUUsQ0FBQyxPQUFPLEVBQUUsdUJBQUEsSUFBSSwwQ0FBcUIsQ0FBQyxDQUFDO0lBQ3ZELENBQUM7SUFFRCxLQUFLLENBQUMsS0FBYTtRQUNqQixpQ0FBaUM7UUFDakMsSUFBSSx1QkFBQSxJQUFJLDhCQUFTLENBQUMsTUFBTSxJQUFJLHVCQUFBLElBQUksOEJBQVMsQ0FBQyxNQUFNLENBQUMsUUFBUSxFQUFFLEVBQUUsQ0FBQztZQUM1RCx1QkFBQSxJQUFJLDhCQUFTLENBQUMsTUFBTSxDQUFDLE1BQU0sRUFBRSxDQUFDO1FBQ2hDLENBQUM7SUFDSCxDQUFDO0lBRUQsTUFBTSxDQUFDLEtBQWEsRUFBRSxRQUF3QixFQUFFLFFBQXdDO1FBQ3RGLDZCQUE2QjtRQUM3QixJQUFJLHVCQUFBLElBQUksOEJBQVMsQ0FBQyxLQUFLLEVBQUUsQ0FBQztZQUN4QixJQUFJLENBQUMsdUJBQUEsSUFBSSw4QkFBUyxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUMsS0FBSyxFQUFFLFFBQVEsQ0FBQyxFQUFFLENBQUM7Z0JBQ2hELDhDQUE4QztnQkFDOUMsdUJBQUEsSUFBSSw4QkFBUyxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsT0FBTyxFQUFFLFFBQVEsQ0FBQyxDQUFDO1lBQzlDLENBQUM7aUJBQU0sQ0FBQztnQkFDTixRQUFRLEVBQUUsQ0FBQztZQUNiLENBQUM7UUFDSCxDQUFDO2FBQU0sQ0FBQztZQUNOLFFBQVEsQ0FBQyxJQUFJLEtBQUssQ0FBQyxnQ0FBZ0MsQ0FBQyxDQUFDLENBQUM7UUFDeEQsQ0FBQztJQUNILENBQUM7SUFFRCxNQUFNLENBQUMsUUFBd0M7UUFDN0MsaURBQWlEO1FBQ2pELElBQUksdUJBQUEsSUFBSSw4QkFBUyxDQUFDLEtBQUssRUFBRSxDQUFDO1lBQ3hCLHVCQUFBLElBQUksOEJBQVMsQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxDQUFDO1FBQ3BDLENBQUM7YUFBTSxDQUFDO1lBQ04sUUFBUSxFQUFFLENBQUM7UUFDYixDQUFDO0lBQ0gsQ0FBQztJQUVELFFBQVEsQ0FBQyxLQUFtQixFQUFFLFFBQXVDO1FBQ25FLHFEQUFxRDtRQUNyRCxJQUFJLHVCQUFBLElBQUksOEJBQVMsQ0FBQyxNQUFNLEVBQUUsQ0FBQztZQUN6QixJQUFJLHVCQUFBLElBQUksd0NBQW1CO2dCQUN6Qix1QkFBQSxJQUFJLDhCQUFTLENBQUMsTUFBTSxDQUFDLGNBQWMsQ0FBQyxNQUFNLEVBQUUsdUJBQUEsSUFBSSx3Q0FBbUIsQ0FBQyxDQUFDO1lBQ3ZFLElBQUksdUJBQUEsSUFBSSx1Q0FBa0I7Z0JBQ3hCLHVCQUFBLElBQUksOEJBQVMsQ0FBQyxNQUFNLENBQUMsY0FBYyxDQUFDLEtBQUssRUFBRSx1QkFBQSxJQUFJLHVDQUFrQixDQUFDLENBQUM7WUFDckUsSUFBSSx1QkFBQSxJQUFJLHlDQUFvQjtnQkFDMUIsdUJBQUEsSUFBSSw4QkFBUyxDQUFDLE1BQU0sQ0FBQyxjQUFjLENBQUMsT0FBTyxFQUFFLHVCQUFBLElBQUkseUNBQW9CLENBQUMsQ0FBQztZQUN6RSxJQUFJLHVCQUFBLElBQUkseUNBQW9CO2dCQUMxQix1QkFBQSxJQUFJLDhCQUFTLENBQUMsTUFBTSxDQUFDLGNBQWMsQ0FBQyxPQUFPLEVBQUUsdUJBQUEsSUFBSSx5Q0FBb0IsQ0FBQyxDQUFDO1FBQzNFLENBQUM7UUFFRCxJQUFJLHVCQUFBLElBQUksOEJBQVMsQ0FBQyxNQUFNLElBQUksdUJBQUEsSUFBSSx3Q0FBbUIsRUFBRSxDQUFDO1lBQ3BELHVCQUFBLElBQUksOEJBQVMsQ0FBQyxNQUFNLENBQUMsY0FBYyxDQUFDLE1BQU0sRUFBRSx1QkFBQSxJQUFJLHdDQUFtQixDQUFDLENBQUM7UUFDdkUsQ0FBQztRQUVELElBQUksdUJBQUEsSUFBSSx5Q0FBb0IsRUFBRSxDQUFDO1lBQzdCLHVCQUFBLElBQUksOEJBQVMsQ0FBQyxjQUFjLENBQUMsTUFBTSxFQUFFLHVCQUFBLElBQUkseUNBQW9CLENBQUMsQ0FBQztRQUNqRSxDQUFDO1FBRUQsSUFBSSx1QkFBQSxJQUFJLDBDQUFxQixFQUFFLENBQUM7WUFDOUIsdUJBQUEsSUFBSSw4QkFBUyxDQUFDLGNBQWMsQ0FBQyxPQUFPLEVBQUUsdUJBQUEsSUFBSSwwQ0FBcUIsQ0FBQyxDQUFDO1FBQ25FLENBQUM7UUFFRCxpREFBaUQ7UUFDakQsSUFBSSx1QkFBQSxJQUFJLDhCQUFTLElBQUksQ0FBQyx1QkFBQSxJQUFJLDhCQUFTLENBQUMsTUFBTSxFQUFFLENBQUM7WUFDM0MscUVBQXFFO1lBQ3JFLElBQUksdUJBQUEsSUFBSSw4QkFBUyxDQUFDLEtBQUssSUFBSSxDQUFDLHVCQUFBLElBQUksOEJBQVMsQ0FBQyxLQUFLLENBQUMsU0FBUyxFQUFFLENBQUM7Z0JBQzFELHVCQUFBLElBQUksOEJBQVMsQ0FBQyxLQUFLLENBQUMsR0FBRyxFQUFFLENBQUM7WUFDNUIsQ0FBQztZQUVELDZEQUE2RDtZQUM3RCxNQUFNLE9BQU8sR0FBRyxHQUFHLEVBQUU7Z0JBQ25CLFlBQVksQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDO2dCQUMvQixRQUFRLENBQUMsS0FBSyxDQUFDLENBQUM7WUFDbEIsQ0FBQyxDQUFDO1lBRUYsd0JBQXdCO1lBQ3hCLHVCQUFBLElBQUksOEJBQVMsQ0FBQyxJQUFJLENBQUMsT0FBTyxFQUFFLE9BQU8sQ0FBQyxDQUFDO1lBRXJDLGtFQUFrRTtZQUNsRSx1QkFBQSxJQUFJLDhCQUFTLENBQUMsSUFBSSxFQUFFLENBQUM7WUFFckIscURBQXFEO1lBQ3JELE1BQU0sZ0JBQWdCLEdBQUcsVUFBVSxDQUFDLEdBQUcsRUFBRTtnQkFDdkMsSUFBSSxDQUFDLHVCQUFBLElBQUksOEJBQVMsQ0FBQyxNQUFNLEVBQUUsQ0FBQztvQkFDMUIsdUJBQUEsSUFBSSw4QkFBUyxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsQ0FBQztnQkFDaEMsQ0FBQztnQkFDRCw4Q0FBOEM7Z0JBQzlDLHVCQUFBLElBQUksOEJBQVMsQ0FBQyxjQUFjLENBQUMsT0FBTyxFQUFFLE9BQU8sQ0FBQyxDQUFDO2dCQUMvQyxRQUFRLENBQUMsS0FBSyxDQUFDLENBQUM7WUFDbEIsQ0FBQyxFQUFFLElBQUksQ0FBQyxDQUFDO1FBQ1gsQ0FBQzthQUFNLENBQUM7WUFDTiwwQ0FBMEM7WUFDMUMsUUFBUSxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBQ2xCLENBQUM7SUFDSCxDQUFDO0NBQ0Y7O2tCQS9Kb0IsYUFBYSJ9

package/dist/src/process-queue.d.ts

@@ -0,0 +1,8 @@
+export default class ProcessQueue<QueueItem> {
+    #private;
+    constructor(targetSize: number, factory: () => Promise<QueueItem>, destroy: (process: Promise<QueueItem>) => void);
+    get hits(): number;
+    get misses(): number;
+    acquire(): Promise<QueueItem>;
+    destroy(): Promise<void>;
+}

package/dist/src/process-queue.js

@@ -0,0 +1,94 @@
+"use strict";
+// This is a generic class for creating a queue of worker processes.
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _ProcessQueue_instances, _ProcessQueue_targetSize, _ProcessQueue_queue, _ProcessQueue_factory, _ProcessQueue_destroy, _ProcessQueue_hitCount, _ProcessQueue_missCount, _ProcessQueue_destroyed, _ProcessQueue_createResource;
+Object.defineProperty(exports, "__esModule", { value: true });
+const debug_1 = __importDefault(require("debug"));
+const debug = (0, debug_1.default)('SimpleZSTDQueue');
+class ProcessQueue {
+    constructor(targetSize, factory, destroy) {
+        _ProcessQueue_instances.add(this);
+        _ProcessQueue_targetSize.set(this, void 0);
+        _ProcessQueue_queue.set(this, void 0);
+        _ProcessQueue_factory.set(this, void 0);
+        _ProcessQueue_destroy.set(this, void 0);
+        _ProcessQueue_hitCount.set(this, void 0);
+        _ProcessQueue_missCount.set(this, void 0);
+        _ProcessQueue_destroyed.set(this, void 0);
+        debug('constructor', targetSize);
+        __classPrivateFieldSet(this, _ProcessQueue_targetSize, targetSize, "f");
+        __classPrivateFieldSet(this, _ProcessQueue_queue, [], "f");
+        __classPrivateFieldSet(this, _ProcessQueue_factory, factory, "f");
+        __classPrivateFieldSet(this, _ProcessQueue_destroy, destroy, "f");
+        __classPrivateFieldSet(this, _ProcessQueue_hitCount, 0, "f");
+        __classPrivateFieldSet(this, _ProcessQueue_missCount, 0, "f");
+        __classPrivateFieldSet(this, _ProcessQueue_destroyed, false, "f");
+        for (let i = 0; i < targetSize || 0; i += 1) {
+            __classPrivateFieldGet(this, _ProcessQueue_instances, "m", _ProcessQueue_createResource).call(this);
+        }
+    }
+    get hits() {
+        return __classPrivateFieldGet(this, _ProcessQueue_hitCount, "f");
+    }
+    get misses() {
+        return __classPrivateFieldGet(this, _ProcessQueue_missCount, "f");
+    }
+    async acquire() {
+        debug('acquire');
+        const attempt = __classPrivateFieldGet(this, _ProcessQueue_queue, "f").pop();
+        if (attempt) {
+            debug('acquire hit');
+            if (!__classPrivateFieldGet(this, _ProcessQueue_destroyed, "f")) {
+                setImmediate(() => {
+                    // Double-check destroyed flag in case it changed
+                    if (!__classPrivateFieldGet(this, _ProcessQueue_destroyed, "f")) {
+                        __classPrivateFieldGet(this, _ProcessQueue_instances, "m", _ProcessQueue_createResource).call(this);
+                    }
+                });
+            }
+            __classPrivateFieldSet(this, _ProcessQueue_hitCount, __classPrivateFieldGet(this, _ProcessQueue_hitCount, "f") + 1, "f");
+            return attempt;
+        }
+        debug('acquire miss');
+        __classPrivateFieldSet(this, _ProcessQueue_missCount, __classPrivateFieldGet(this, _ProcessQueue_missCount, "f") + 1, "f");
+        return __classPrivateFieldGet(this, _ProcessQueue_factory, "f").call(this);
+    }
+    async destroy() {
+        debug('destroy', __classPrivateFieldGet(this, _ProcessQueue_queue, "f").length);
+        __classPrivateFieldSet(this, _ProcessQueue_destroyed, true, "f");
+        const destroyPromises = [];
+        while (__classPrivateFieldGet(this, _ProcessQueue_queue, "f").length > 0) {
+            const p = __classPrivateFieldGet(this, _ProcessQueue_queue, "f").pop();
+            if (p) {
+                destroyPromises.push(Promise.resolve(__classPrivateFieldGet(this, _ProcessQueue_destroy, "f").call(this, p)));
+            }
+        }
+        await Promise.all(destroyPromises);
+    }
+}
+_ProcessQueue_targetSize = new WeakMap(), _ProcessQueue_queue = new WeakMap(), _ProcessQueue_factory = new WeakMap(), _ProcessQueue_destroy = new WeakMap(), _ProcessQueue_hitCount = new WeakMap(), _ProcessQueue_missCount = new WeakMap(), _ProcessQueue_destroyed = new WeakMap(), _ProcessQueue_instances = new WeakSet(), _ProcessQueue_createResource = async function _ProcessQueue_createResource() {
+    debug('createResource?', __classPrivateFieldGet(this, _ProcessQueue_queue, "f").length);
+    if (__classPrivateFieldGet(this, _ProcessQueue_destroyed, "f")) {
+        debug('createResource skipped - queue destroyed');
+        return;
+    }
+    if (__classPrivateFieldGet(this, _ProcessQueue_queue, "f").length < __classPrivateFieldGet(this, _ProcessQueue_targetSize, "f")) {
+        debug('createResource call factory');
+        __classPrivateFieldGet(this, _ProcessQueue_queue, "f").push(__classPrivateFieldGet(this, _ProcessQueue_factory, "f").call(this));
+    }
+};
+exports.default = ProcessQueue;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/types.d.ts

@@ -0,0 +1,34 @@
+import { SpawnOptions } from 'child_process';
+import { DuplexOptions } from 'stream';
+export interface CompressOpts {
+    compLevel?: number;
+    dictionary?: Buffer | {
+        path: string;
+    };
+    zstdOptions?: Array<string>;
+    spawnOptions?: SpawnOptions;
+    streamOptions?: DuplexOptions;
+}
+export interface DecompressOpts {
+    dictionary?: Buffer | {
+        path: string;
+    };
+    zstdOptions?: Array<string>;
+    spawnOptions?: SpawnOptions;
+    streamOptions?: DuplexOptions;
+}
+export interface PoolOpts {
+    compressQueueSize?: number;
+    decompressQueueSize?: number;
+    compressQueue?: CompressOpts;
+    decompressQueue?: DecompressOpts;
+}
+export interface DictionaryObject {
+    path: string;
+}
+export interface ZSTDOpts {
+    spawnOptions?: object;
+    streamOptions?: DuplexOptions;
+    zstdOptions?: string[];
+    dictionary?: DictionaryObject | Buffer;
+}

package/dist/src/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/eslint.config.js

@@ -0,0 +1,49 @@
+import js from '@eslint/js';
+import tsPlugin from '@typescript-eslint/eslint-plugin';
+import tsParser from '@typescript-eslint/parser';
+import globals from 'globals';
+import prettierConfig from 'eslint-config-prettier';
+
+export default [
+  js.configs.recommended,
+  {
+    files: ['**/*.ts'],
+    languageOptions: {
+      parser: tsParser,
+      parserOptions: {
+        ecmaVersion: 'latest',
+        sourceType: 'module',
+      },
+      globals: {
+        ...globals.node,
+        ...globals.es2020,
+        BufferEncoding: 'readonly',
+        NodeJS: 'readonly',
+      },
+    },
+    plugins: {
+      '@typescript-eslint': tsPlugin,
+    },
+    rules: {
+      ...tsPlugin.configs.recommended.rules,
+      'max-len': 'off',
+      'no-underscore-dangle': 'off',
+      '@typescript-eslint/no-unused-vars': ['error', {
+        argsIgnorePattern: '^_',
+        varsIgnorePattern: '^_',
+      }],
+    },
+  },
+  {
+    files: ['**/*.js'],
+    languageOptions: {
+      globals: {
+        ...globals.node,
+      },
+    },
+  },
+  {
+    ignores: ['node_modules', 'dist'],
+  },
+  prettierConfig,
+];

package/package.json

@@ -1,10 +1,22 @@
 {
   "name": "simple-zstd",
-  "version": "1.4.2",
+  "version": "2.0.0",
   "description": "Node.js interface to the system installed zstd.",
-  "main": "index.js",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "engines": {
+    "node": ">=20.0.0"
+  },
   "scripts": {
-    "test": "mocha"
+    "build": "tsc",
+    "prepublish": "tsc",
+    "lint": "eslint . --ext .ts",
+    "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
+    "format:check": "prettier --check \"src/**/*.ts\" \"test/**/*.ts\"",
+    "test": "timeout --signal=TERM --kill-after=5s 120s node --test --require ts-node/register test/test.ts || true",
+    "test-debug": "DEBUG=SimpleZSTD,SimpleZSTDQueue timeout --signal=TERM --kill-after=5s 120s node --test --require ts-node/register test/test.ts || true",
+    "test-ci": "timeout --signal=TERM --kill-after=5s 120s node --test --require ts-node/register test/test.ts && exit 0 || exit 1",
+    "coverage": "timeout --signal=TERM --kill-after=5s 120s node --test --experimental-test-coverage --require ts-node/register test/test.ts || true"
   },
   "repository": {
     "type": "git",
@@ -42,20 +54,24 @@
   },
   "homepage": "https://github.com/Stieneee/simple-zstd#readme",
   "devDependencies": {
-    "brake": "^1.0.1",
-    "chai": "^4.3.6",
-    "chai-as-promised": "^7.1.1",
-    "chai-fs": "^2.0.0",
-    "eslint": "^8.25.0",
-    "eslint-config-airbnb-base": "^15.0.0",
-    "eslint-plugin-import": "^2.26.0",
-    "mocha": "^10.1.0",
-    "release-it": "^15.5.0"
+    "@release-it/conventional-changelog": "^10.0.1",
+    "@types/debug": "^4.1.12",
+    "@types/node": "^24.10.0",
+    "@typescript-eslint/eslint-plugin": "^8.46.3",
+    "@typescript-eslint/parser": "^8.46.3",
+    "eslint": "^9.39.1",
+    "eslint-config-prettier": "^10.1.8",
+    "globals": "^16.5.0",
+    "prettier": "^3.6.2",
+    "release-it": "^19.0.6",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.9.3"
   },
   "dependencies": {
+    "debug": "^4.3.4",
     "is-zst": "^1.0.0",
-    "peek-stream": "^1.1.3",
-    "process-streams": "^1.0.1",
-    "through2": "^4.0.2"
-  }
+    "tmp": "^0.2.1",
+    "tmp-promise": "^3.0.3"
+  },
+  "packageManager": "npm@11.6.2"
 }

package/src/buffer-writable.ts

@@ -0,0 +1,30 @@
+import { Writable, WritableOptions } from 'node:stream';
+
+export default class BufferWritable extends Writable {
+  #buf: Array<Buffer>;
+
+  constructor(options: WritableOptions) {
+    super(options);
+    this.#buf = [];
+  }
+
+  _write(chunk: Buffer, encoding: string, callback: () => void = () => null) {
+    this.#buf.push(chunk);
+    callback();
+  }
+
+  _writev(chunks: Array<{ chunk: Buffer; encoding: string }>, callback: () => void = () => null) {
+    for (const { chunk } of chunks) {
+      this.#buf.push(chunk);
+    }
+    callback();
+  }
+
+  _final(callback: () => void = () => null) {
+    callback();
+  }
+
+  getBuffer(): Buffer {
+    return Buffer.concat(this.#buf) || Buffer.alloc(0);
+  }
+}