simple-zstd 1.4.2 → 2.0.0

package/dist/src/buffer-writable.d.ts

@@ -0,0 +1,12 @@
+import { Writable, WritableOptions } from 'node:stream';
+export default class BufferWritable extends Writable {
+    #private;
+    constructor(options: WritableOptions);
+    _write(chunk: Buffer, encoding: string, callback?: () => void): void;
+    _writev(chunks: Array<{
+        chunk: Buffer;
+        encoding: string;
+    }>, callback?: () => void): void;
+    _final(callback?: () => void): void;
+    getBuffer(): Buffer;
+}

package/dist/src/buffer-writable.js

@@ -0,0 +1,41 @@
+"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 _BufferWritable_buf;
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_stream_1 = require("node:stream");
+class BufferWritable extends node_stream_1.Writable {
+    constructor(options) {
+        super(options);
+        _BufferWritable_buf.set(this, void 0);
+        __classPrivateFieldSet(this, _BufferWritable_buf, [], "f");
+    }
+    _write(chunk, encoding, callback = () => null) {
+        __classPrivateFieldGet(this, _BufferWritable_buf, "f").push(chunk);
+        callback();
+    }
+    _writev(chunks, callback = () => null) {
+        for (const { chunk } of chunks) {
+            __classPrivateFieldGet(this, _BufferWritable_buf, "f").push(chunk);
+        }
+        callback();
+    }
+    _final(callback = () => null) {
+        callback();
+    }
+    getBuffer() {
+        return Buffer.concat(__classPrivateFieldGet(this, _BufferWritable_buf, "f")) || Buffer.alloc(0);
+    }
+}
+_BufferWritable_buf = new WeakMap();
+exports.default = BufferWritable;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnVmZmVyLXdyaXRhYmxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2J1ZmZlci13cml0YWJsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7OztBQUFBLDZDQUF3RDtBQUV4RCxNQUFxQixjQUFlLFNBQVEsc0JBQVE7SUFHbEQsWUFBWSxPQUF3QjtRQUNsQyxLQUFLLENBQUMsT0FBTyxDQUFDLENBQUM7UUFIakIsc0NBQW9CO1FBSWxCLHVCQUFBLElBQUksdUJBQVEsRUFBRSxNQUFBLENBQUM7SUFDakIsQ0FBQztJQUVELE1BQU0sQ0FBQyxLQUFhLEVBQUUsUUFBZ0IsRUFBRSxXQUF1QixHQUFHLEVBQUUsQ0FBQyxJQUFJO1FBQ3ZFLHVCQUFBLElBQUksMkJBQUssQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUM7UUFDdEIsUUFBUSxFQUFFLENBQUM7SUFDYixDQUFDO0lBRUQsT0FBTyxDQUFDLE1BQWtELEVBQUUsV0FBdUIsR0FBRyxFQUFFLENBQUMsSUFBSTtRQUMzRixLQUFLLE1BQU0sRUFBRSxLQUFLLEVBQUUsSUFBSSxNQUFNLEVBQUUsQ0FBQztZQUMvQix1QkFBQSxJQUFJLDJCQUFLLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBQ3hCLENBQUM7UUFDRCxRQUFRLEVBQUUsQ0FBQztJQUNiLENBQUM7SUFFRCxNQUFNLENBQUMsV0FBdUIsR0FBRyxFQUFFLENBQUMsSUFBSTtRQUN0QyxRQUFRLEVBQUUsQ0FBQztJQUNiLENBQUM7SUFFRCxTQUFTO1FBQ1AsT0FBTyxNQUFNLENBQUMsTUFBTSxDQUFDLHVCQUFBLElBQUksMkJBQUssQ0FBQyxJQUFJLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFDckQsQ0FBQztDQUNGOztrQkEzQm9CLGNBQWMifQ==

package/dist/src/index.d.ts

@@ -0,0 +1,49 @@
+import { Duplex } from 'node:stream';
+import { ZSTDOpts, PoolOpts } from './types';
+export type { ZSTDOpts, PoolOpts, CompressOpts, DecompressOpts, DictionaryObject } from './types';
+/**
+ * Clear the dictionary cache and cleanup all temporary files
+ * This is useful for testing or manual cache management
+ * @returns Promise that resolves when all cleanups are complete
+ */
+export declare function clearDictionaryCache(): Promise<void>;
+export declare function compress(compLevel: number, opts?: ZSTDOpts): Promise<Duplex>;
+export declare function compressBuffer(buffer: Buffer, compLevel: number, opts?: ZSTDOpts): Promise<Buffer>;
+export declare function decompress(opts?: ZSTDOpts): Promise<Duplex>;
+export declare function decompressBuffer(buffer: Buffer, opts?: ZSTDOpts): Promise<Buffer>;
+export declare class SimpleZSTD {
+    #private;
+    private constructor();
+    /**
+     * Create a new SimpleZSTD instance with process pooling
+     * @param poolOptions - Configuration for compression and decompression process pools
+     * @returns Promise resolving to initialized SimpleZSTD instance
+     */
+    static create(poolOptions?: PoolOpts): Promise<SimpleZSTD>;
+    get queueStats(): {
+        compress: {
+            hits: number;
+            misses: number;
+        };
+        decompress: {
+            hits: number;
+            misses: number;
+        };
+    };
+    destroy(): Promise<void>;
+    /**
+     * Get a compression stream from the pool, or create a one-off stream with custom compression level
+     * @param compLevel - Optional compression level (1-22). If provided, creates a new stream instead of using the pool
+     * @returns Promise resolving to a Duplex compression stream
+     */
+    compress(compLevel?: number): Promise<Duplex>;
+    /**
+     * Compress a buffer using the pool, or with a custom compression level
+     * @param buffer - Buffer to compress
+     * @param compLevel - Optional compression level (1-22). If provided, uses this level instead of pool default
+     * @returns Promise resolving to compressed buffer
+     */
+    compressBuffer(buffer: Buffer, compLevel?: number): Promise<Buffer>;
+    decompress(): Promise<Duplex>;
+    decompressBuffer(buffer: Buffer): Promise<Buffer>;
+}

package/dist/src/index.js

@@ -0,0 +1,430 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _SimpleZSTD_compressQueue, _SimpleZSTD_decompressQueue, _SimpleZSTD_compressDictCleanup, _SimpleZSTD_decompressDictCleanup, _SimpleZSTD_ready, _SimpleZSTD_poolOptions;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleZSTD = void 0;
+exports.clearDictionaryCache = clearDictionaryCache;
+exports.compress = compress;
+exports.compressBuffer = compressBuffer;
+exports.decompress = decompress;
+exports.decompressBuffer = decompressBuffer;
+const node_fs_1 = __importDefault(require("node:fs"));
+const promises_1 = require("node:fs/promises");
+const node_crypto_1 = require("node:crypto");
+const node_stream_1 = require("node:stream");
+const promises_2 = require("node:stream/promises");
+const node_child_process_1 = require("node:child_process");
+const is_zst_1 = __importDefault(require("is-zst"));
+const tmp_promise_1 = require("tmp-promise");
+const debug_1 = __importDefault(require("debug"));
+const debug = (0, debug_1.default)('SimpleZSTD');
+const process_queue_1 = __importDefault(require("./process-queue"));
+const buffer_writable_1 = __importDefault(require("./buffer-writable"));
+const process_duplex_1 = __importDefault(require("./process-duplex"));
+const peek_transform_1 = __importDefault(require("./peek-transform"));
+// Dictionary cache to avoid recreating temp files for the same dictionary buffer
+// Map: hash -> { path: string, cleanup: () => void, refCount: number }
+const dictionaryCache = new Map();
+function hashBuffer(buffer) {
+    return (0, node_crypto_1.createHash)('sha256').update(buffer).digest('hex');
+}
+async function getCachedDictionaryPath(dictionary) {
+    const hash = hashBuffer(dictionary);
+    let cached = dictionaryCache.get(hash);
+    if (cached) {
+        cached.refCount++;
+        debug(`Dictionary cache hit: ${hash.slice(0, 8)}... (refCount: ${cached.refCount})`);
+        return {
+            path: cached.path,
+            cleanup: () => {
+                cached.refCount--;
+                debug(`Dictionary refCount decreased: ${hash.slice(0, 8)}... (refCount: ${cached.refCount})`);
+                // Don't call async cleanup here - it will be handled by clearDictionaryCache()
+                // or when all references are released
+            },
+        };
+    }
+    debug(`Dictionary cache miss: ${hash.slice(0, 8)}... - creating temp file`);
+    const { path, cleanup: tmpCleanup } = await (0, tmp_promise_1.file)({ prefix: 'zstd-dict-' });
+    await (0, promises_1.writeFile)(path, dictionary);
+    dictionaryCache.set(hash, {
+        path,
+        cleanup: tmpCleanup,
+        refCount: 1,
+    });
+    return {
+        path,
+        cleanup: () => {
+            const cached = dictionaryCache.get(hash);
+            if (cached) {
+                cached.refCount--;
+                debug(`Dictionary refCount decreased: ${hash.slice(0, 8)}... (refCount: ${cached.refCount})`);
+                // Don't call async cleanup here - it will be handled by clearDictionaryCache()
+                // or when all references are released
+            }
+        },
+    };
+}
+/**
+ * Clear the dictionary cache and cleanup all temporary files
+ * This is useful for testing or manual cache management
+ * @returns Promise that resolves when all cleanups are complete
+ */
+async function clearDictionaryCache() {
+    debug('Clearing dictionary cache');
+    const cleanupPromises = [];
+    for (const [hash, cached] of dictionaryCache.entries()) {
+        debug(`Cleaning up cached dictionary: ${hash.slice(0, 8)}...`);
+        // tmp-promise cleanup() returns a Promise
+        cleanupPromises.push(Promise.resolve(cached.cleanup()));
+    }
+    await Promise.all(cleanupPromises);
+    dictionaryCache.clear();
+}
+const find = process.platform === 'win32' ? 'where zstd.exe' : 'which zstd';
+let bin;
+try {
+    bin = (0, node_child_process_1.execSync)(find, { env: process.env }).toString().replace(/\n$/, '').replace(/\r$/, '');
+    debug(bin);
+}
+catch {
+    throw new Error('Can not access zstd! Is it installed?');
+}
+try {
+    node_fs_1.default.accessSync(bin, node_fs_1.default.constants.X_OK);
+}
+catch {
+    throw new Error('zstd is not executable');
+}
+async function CreateCompressStream(compLevel, opts) {
+    let lvl = compLevel;
+    let zo = opts.zstdOptions || [];
+    let path = null;
+    let cleanup = () => null;
+    if (!lvl)
+        lvl = 3;
+    if (lvl < 1 || lvl > 22)
+        lvl = 3;
+    // Dictionary
+    if (opts.dictionary && 'path' in opts.dictionary) {
+        zo = [...zo, '-D', `${opts.dictionary.path}`];
+    }
+    else if (Buffer.isBuffer(opts.dictionary)) {
+        // Use cached dictionary to avoid recreating temp files
+        ({ path, cleanup } = await getCachedDictionaryPath(opts.dictionary));
+        zo = [...zo, '-D', `${path}`];
+    }
+    let c;
+    try {
+        debug(bin, ['-zc', `-${lvl}`, ...zo], opts.spawnOptions, opts.streamOptions);
+        c = new process_duplex_1.default(bin, ['-zc', `-${lvl}`, ...zo], opts.spawnOptions, opts.streamOptions);
+    }
+    catch (err) {
+        // cleanup if error;
+        cleanup();
+        throw err;
+    }
+    c.on('exit', (code, signal) => {
+        debug('c exit', code, signal);
+        if (code !== 0) {
+            setImmediate(() => {
+                c.destroy(new Error(`zstd exited non zero. code: ${code} signal: ${signal}`));
+            });
+        }
+        cleanup();
+    });
+    return c;
+}
+function CompressBuffer(buffer, c) {
+    return new Promise((resolve, reject) => {
+        const w = new buffer_writable_1.default({});
+        c.once('close', () => {
+            setImmediate(() => {
+                const result = w.getBuffer();
+                if (result) {
+                    resolve(result);
+                }
+                else {
+                    reject(new Error('Compression failed'));
+                }
+            });
+        });
+        (0, promises_2.pipeline)(node_stream_1.Readable.from(buffer), c, w)
+            .then(() => {
+            c.destroy();
+        })
+            .catch((err) => {
+            reject(err);
+            c.destroy();
+        });
+    });
+}
+async function CreateDecompressStream(opts) {
+    // Dictionary
+    let zo = opts.zstdOptions || [];
+    let path = null;
+    let cleanup = () => null;
+    let terminate = false;
+    if (opts.dictionary && 'path' in opts.dictionary) {
+        zo = [...zo, '-D', `${opts.dictionary.path}`];
+    }
+    else if (Buffer.isBuffer(opts.dictionary)) {
+        // Use cached dictionary to avoid recreating temp files
+        ({ path, cleanup } = await getCachedDictionaryPath(opts.dictionary));
+        zo = [...zo, '-D', `${path}`];
+    }
+    let d;
+    try {
+        debug(bin, ['-dc', ...zo], opts.spawnOptions, opts.streamOptions);
+        d = new process_duplex_1.default(bin, ['-dc', ...zo], opts.spawnOptions, opts.streamOptions);
+    }
+    catch (err) {
+        // cleanup if error
+        cleanup();
+        throw err;
+    }
+    d.on('exit', (code, signal) => {
+        debug('d exit', code, signal);
+        if (code !== 0 && !terminate) {
+            setImmediate(() => {
+                d.destroy(new Error(`zstd exited non zero. code: ${code} signal: ${signal}`));
+            });
+        }
+        cleanup();
+    });
+    const wrapper = new peek_transform_1.default({ maxBuffer: 10 }, (data, swap) => {
+        if ((0, is_zst_1.default)(data)) {
+            swap(null, d);
+        }
+        else {
+            debug('not zstd');
+            terminate = true;
+            d.end();
+            swap(null, new node_stream_1.PassThrough());
+        }
+    });
+    // CRITICAL: Wrap _destroy to ensure ProcessDuplex is always destroyed
+    const originalDestroy = wrapper._destroy.bind(wrapper);
+    wrapper._destroy = function (error, callback) {
+        if (!d.destroyed) {
+            d.destroy();
+        }
+        originalDestroy(error, callback);
+    };
+    return wrapper;
+}
+function DecompressBuffer(buffer, d) {
+    return new Promise((resolve, reject) => {
+        const w = new buffer_writable_1.default({});
+        d.once('close', () => {
+            setImmediate(() => {
+                resolve(w.getBuffer() || Buffer.alloc(0));
+            });
+        });
+        (0, promises_2.pipeline)(node_stream_1.Readable.from(buffer), d, w)
+            .then(() => {
+            d.destroy();
+        })
+            .catch((err) => {
+            reject(err);
+            d.destroy();
+        });
+    });
+}
+// Standalone Functions
+function compress(compLevel, opts = {}) {
+    return CreateCompressStream(compLevel, opts);
+}
+async function compressBuffer(buffer, compLevel, opts = {}) {
+    const c = await CreateCompressStream(compLevel, opts);
+    return CompressBuffer(buffer, c);
+}
+function decompress(opts = {}) {
+    return CreateDecompressStream(opts);
+}
+async function decompressBuffer(buffer, opts = {}) {
+    const d = await CreateDecompressStream(opts);
+    return DecompressBuffer(buffer, d);
+}
+// SimpleZSTD Class
+class SimpleZSTD {
+    constructor(poolOptions) {
+        _SimpleZSTD_compressQueue.set(this, void 0);
+        _SimpleZSTD_decompressQueue.set(this, void 0);
+        _SimpleZSTD_compressDictCleanup.set(this, () => null);
+        _SimpleZSTD_decompressDictCleanup.set(this, () => null);
+        _SimpleZSTD_ready.set(this, void 0);
+        _SimpleZSTD_poolOptions.set(this, void 0);
+        debug('constructor', poolOptions);
+        __classPrivateFieldSet(this, _SimpleZSTD_poolOptions, poolOptions, "f");
+        __classPrivateFieldSet(this, _SimpleZSTD_compressDictCleanup, () => null, "f");
+        __classPrivateFieldSet(this, _SimpleZSTD_decompressDictCleanup, () => null, "f");
+        __classPrivateFieldSet(this, _SimpleZSTD_ready, new Promise((resolve, reject) => {
+            (async () => {
+                try {
+                    // Handle compress queue dictionary
+                    let compressDictPath = undefined;
+                    const compressDict = poolOptions?.compressQueue?.dictionary;
+                    if (compressDict && 'path' in compressDict) {
+                        compressDictPath = compressDict.path;
+                    }
+                    else if (compressDict && Buffer.isBuffer(compressDict)) {
+                        const { path, cleanup } = await (0, tmp_promise_1.file)({ prefix: 'zstd-dict-' });
+                        __classPrivateFieldSet(this, _SimpleZSTD_compressDictCleanup, cleanup, "f");
+                        await (0, promises_1.writeFile)(path, compressDict);
+                        compressDictPath = path;
+                    }
+                    // Handle decompress queue dictionary
+                    let decompressDictPath = undefined;
+                    const decompressDict = poolOptions?.decompressQueue?.dictionary;
+                    if (decompressDict && 'path' in decompressDict) {
+                        decompressDictPath = decompressDict.path;
+                    }
+                    else if (decompressDict && Buffer.isBuffer(decompressDict)) {
+                        const { path, cleanup } = await (0, tmp_promise_1.file)({ prefix: 'zstd-dict-' });
+                        __classPrivateFieldSet(this, _SimpleZSTD_decompressDictCleanup, cleanup, "f");
+                        await (0, promises_1.writeFile)(path, decompressDict);
+                        decompressDictPath = path;
+                    }
+                    __classPrivateFieldSet(this, _SimpleZSTD_compressQueue, new process_queue_1.default(poolOptions?.compressQueueSize || 0, () => {
+                        debug('compress factory');
+                        return CreateCompressStream(poolOptions?.compressQueue?.compLevel || 3, {
+                            ...poolOptions?.compressQueue,
+                            dictionary: compressDictPath ? { path: compressDictPath } : undefined,
+                        });
+                    }, async (p) => {
+                        debug('compress cleanup');
+                        const stream = await p;
+                        await new Promise((resolve) => {
+                            if (stream.destroyed) {
+                                resolve();
+                            }
+                            else {
+                                stream.once('close', () => resolve());
+                                stream.destroy();
+                            }
+                        });
+                    }), "f");
+                    __classPrivateFieldSet(this, _SimpleZSTD_decompressQueue, new process_queue_1.default(poolOptions?.decompressQueueSize || 0, () => {
+                        debug('decompress factory');
+                        return CreateDecompressStream({
+                            ...poolOptions?.decompressQueue,
+                            dictionary: decompressDictPath ? { path: decompressDictPath } : undefined,
+                        });
+                    }, async (p) => {
+                        debug('decompress cleanup');
+                        const stream = await p;
+                        await new Promise((resolve) => {
+                            if (stream.destroyed) {
+                                resolve();
+                            }
+                            else {
+                                stream.once('close', () => resolve());
+                                stream.destroy();
+                            }
+                        });
+                    }), "f");
+                    debug('READY');
+                    resolve(null);
+                }
+                catch (err) {
+                    reject(err);
+                }
+            })();
+        }).catch((err) => {
+            debug('ready error', err);
+            __classPrivateFieldGet(this, _SimpleZSTD_compressDictCleanup, "f").call(this);
+            __classPrivateFieldGet(this, _SimpleZSTD_decompressDictCleanup, "f").call(this);
+            __classPrivateFieldSet(this, _SimpleZSTD_compressDictCleanup, () => null, "f");
+            __classPrivateFieldSet(this, _SimpleZSTD_decompressDictCleanup, () => null, "f");
+        }), "f");
+    }
+    /**
+     * Create a new SimpleZSTD instance with process pooling
+     * @param poolOptions - Configuration for compression and decompression process pools
+     * @returns Promise resolving to initialized SimpleZSTD instance
+     */
+    static async create(poolOptions) {
+        const instance = new SimpleZSTD(poolOptions);
+        await __classPrivateFieldGet(instance, _SimpleZSTD_ready, "f");
+        return instance;
+    }
+    get queueStats() {
+        return {
+            compress: {
+                hits: __classPrivateFieldGet(this, _SimpleZSTD_compressQueue, "f").hits,
+                misses: __classPrivateFieldGet(this, _SimpleZSTD_compressQueue, "f").misses,
+            },
+            decompress: {
+                hits: __classPrivateFieldGet(this, _SimpleZSTD_decompressQueue, "f").hits,
+                misses: __classPrivateFieldGet(this, _SimpleZSTD_decompressQueue, "f").misses,
+            },
+        };
+    }
+    async destroy() {
+        await Promise.all([__classPrivateFieldGet(this, _SimpleZSTD_compressQueue, "f").destroy(), __classPrivateFieldGet(this, _SimpleZSTD_decompressQueue, "f").destroy()]);
+        __classPrivateFieldGet(this, _SimpleZSTD_compressDictCleanup, "f").call(this);
+        __classPrivateFieldGet(this, _SimpleZSTD_decompressDictCleanup, "f").call(this);
+        __classPrivateFieldSet(this, _SimpleZSTD_compressDictCleanup, () => null, "f");
+        __classPrivateFieldSet(this, _SimpleZSTD_decompressDictCleanup, () => null, "f");
+    }
+    /**
+     * Get a compression stream from the pool, or create a one-off stream with custom compression level
+     * @param compLevel - Optional compression level (1-22). If provided, creates a new stream instead of using the pool
+     * @returns Promise resolving to a Duplex compression stream
+     */
+    async compress(compLevel) {
+        await __classPrivateFieldGet(this, _SimpleZSTD_ready, "f");
+        // If custom compression level is provided, create a one-off stream
+        if (compLevel !== undefined) {
+            return CreateCompressStream(compLevel, {
+                ...__classPrivateFieldGet(this, _SimpleZSTD_poolOptions, "f")?.compressQueue,
+            });
+        }
+        // Otherwise, acquire from pool
+        return __classPrivateFieldGet(this, _SimpleZSTD_compressQueue, "f").acquire();
+    }
+    /**
+     * Compress a buffer using the pool, or with a custom compression level
+     * @param buffer - Buffer to compress
+     * @param compLevel - Optional compression level (1-22). If provided, uses this level instead of pool default
+     * @returns Promise resolving to compressed buffer
+     */
+    async compressBuffer(buffer, compLevel) {
+        await __classPrivateFieldGet(this, _SimpleZSTD_ready, "f");
+        const c = await this.compress(compLevel);
+        return CompressBuffer(buffer, c);
+    }
+    async decompress() {
+        await __classPrivateFieldGet(this, _SimpleZSTD_ready, "f");
+        return __classPrivateFieldGet(this, _SimpleZSTD_decompressQueue, "f").acquire();
+    }
+    async decompressBuffer(buffer) {
+        await __classPrivateFieldGet(this, _SimpleZSTD_ready, "f");
+        const d = await __classPrivateFieldGet(this, _SimpleZSTD_decompressQueue, "f").acquire();
+        return DecompressBuffer(buffer, d);
+    }
+}
+exports.SimpleZSTD = SimpleZSTD;
+_SimpleZSTD_compressQueue = new WeakMap(), _SimpleZSTD_decompressQueue = new WeakMap(), _SimpleZSTD_compressDictCleanup = new WeakMap(), _SimpleZSTD_decompressDictCleanup = new WeakMap(), _SimpleZSTD_ready = new WeakMap(), _SimpleZSTD_poolOptions = new WeakMap();
+// module.exports = {
+//   SimpleZSTD,
+//   compress,
+//   compressBuffer,
+//   decompress,
+//   decompressBuffer,
+// };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"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"}

package/dist/src/peek-transform.d.ts

@@ -0,0 +1,16 @@
+import { Duplex } from 'node:stream';
+import type { DuplexOptions } from 'node:stream';
+type SwapCallback = (err: Error | null, stream: Duplex | null) => void;
+type PeekCallback = (data: Buffer, swap: SwapCallback) => void;
+interface PeekOptions extends DuplexOptions {
+    maxBuffer?: number;
+}
+export default class PeekPassThrough extends Duplex {
+    #private;
+    constructor(options: PeekOptions, peekCallback: PeekCallback);
+    _write(chunk: Buffer, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
+    _final(callback: (error?: Error | null) => void): void;
+    _read(_size: number): void;
+    _destroy(error: Error | null, callback: (error: Error | null) => void): void;
+}
+export {};