neozipkit 0.8.0 → 1.0.5

package/src/node/ZipkitNode.ts

@@ -19,9 +19,20 @@ import {
   ENCRYPT_HDR_SIZE
 } from '../core/constants/Headers';
 import { NEO_CRYPTO_ALGORITHM_AES256_V1 } from '../core/encryption/NeoCrypto';
+import { AesCrypto } from '../core/encryption/AesCrypto';
+import {
+  detectLegacyWasmZstd,
+  type LegacyZstdDetectResult,
+} from './LegacyZstd';
 import * as fs from 'fs';
 import * as path from 'path';
 import { minimatch } from 'minimatch';
+import {
+  computeMerkleRootV0FromDigests,
+  computeMerkleRootV1FromLeaves,
+  type MerkleAlgorithm,
+} from '../core/merkle/MerkleRoot';
+import { isMetaInfPath } from '../core/constants/MetaPaths';
 
 // Re-export everything from core Zipkit
 export * from '../core';
@@ -106,6 +117,79 @@ export default class ZipkitNode extends Zipkit {
     return this._zipkitDeCmpNode;
   }
 
+  /**
+   * Streaming Merkle root for file-based archives.
+   * V1 leaves come from the same decompress→hash pass as integrity (testEntry / extract),
+   * chunked — never re-reads uncompressed sources or materializes whole entries for the root alone.
+   */
+  async getMerkleRootAsync(options?: { algorithm?: MerkleAlgorithm }): Promise<string | null> {
+    const algorithm: MerkleAlgorithm = options?.algorithm ?? 'v1';
+    let zipEntries: ZipEntry[];
+    try {
+      zipEntries = this.getDirectory();
+    } catch {
+      return null;
+    }
+    if (!zipEntries?.length) {
+      return null;
+    }
+
+    const contentEntries = zipEntries.filter((e) => !isMetaInfPath(e.filename || ''));
+    if (contentEntries.length === 0) {
+      return null;
+    }
+
+    if (algorithm === 'v0') {
+      const digests = contentEntries
+        .filter((e) => e.sha256)
+        .map((e) => ({ path: e.filename || '', sha256: e.sha256 as string }));
+      return computeMerkleRootV0FromDigests(digests);
+    }
+
+    if (contentEntries.every((e) => !!e.merkleLeafV1)) {
+      return computeMerkleRootV1FromLeaves(
+        contentEntries.map((e) => ({
+          path: e.filename || '',
+          merkleLeafV1: e.merkleLeafV1 as string,
+        }))
+      );
+    }
+
+    // Buffer-loaded: base class extract path
+    if ((this as any).inBuffer) {
+      return super.getMerkleRootAsync(options);
+    }
+
+    // File-based: stream hash each content entry once via testEntry (no write, dual hash)
+    if (!this.fileHandle && !this.filePath) {
+      // Create-session only: may only have live ZipEntry[] with leaves from write
+      return super.getMerkleRootAsync(options);
+    }
+
+    try {
+      for (const entry of contentEntries) {
+        if (entry.merkleLeafV1) {
+          continue;
+        }
+        await this.getZipDecompressNode().testEntry(entry, { skipHashCheck: false });
+      }
+    } catch (err) {
+      console.error('[ZipkitNode.getMerkleRootAsync] stream hash failed:', err);
+      return null;
+    }
+
+    if (!contentEntries.every((e) => !!e.merkleLeafV1)) {
+      return null;
+    }
+
+    return computeMerkleRootV1FromLeaves(
+      contentEntries.map((e) => ({
+        path: e.filename || '',
+        merkleLeafV1: e.merkleLeafV1 as string,
+      }))
+    );
+  }
+
   // ============================================================================
   // File Loading Methods
   // ============================================================================
@@ -345,6 +429,75 @@ export default class ZipkitNode extends Zipkit {
     };
   }
 
+  /**
+   * Scan the loaded archive (or `archivePath`) for entries compressed with the
+   * legacy NeoZipKit WASM zstd codec (`@oneidentity/zstd-js`).
+   *
+   * Encrypted entries are skipped unless you only need a header check after
+   * decrypting externally — this API inspects raw stored payloads.
+   */
+  async detectLegacyZstdEntries(
+    archivePath?: string,
+    options?: { verify?: boolean }
+  ): Promise<Array<{ entry: ZipEntry; detection: LegacyZstdDetectResult }>> {
+    if (archivePath && !this.filePath) {
+      await this.loadZipFile(archivePath);
+    }
+    if (!this.filePath) {
+      throw new Error('Archive not loaded. Call loadZipFile() first or provide archivePath parameter.');
+    }
+
+    const verify = options?.verify !== false;
+    const results: Array<{ entry: ZipEntry; detection: LegacyZstdDetectResult }> = [];
+    const entries = this.getDirectory();
+
+    for (const entry of entries) {
+      if (entry.isDirectory) {
+        continue;
+      }
+      const method =
+        entry.cmpMethod === CMP_METHOD.AES_ENCRYPT && entry.realCmpMethod >= 0
+          ? entry.realCmpMethod
+          : entry.cmpMethod;
+      if (method !== CMP_METHOD.ZSTD) {
+        continue;
+      }
+      if (entry.isEncrypted || (entry.bitFlags & GP_FLAG.ENCRYPTED)) {
+        results.push({
+          entry,
+          detection: {
+            isLegacyWasm: false,
+            confidence: 'none',
+            frameContentSize: null,
+            expectedUncompressedSize: entry.uncompressedSize,
+            paddingBytes: 18,
+            reason: 'Encrypted zstd entry — decrypt before detecting legacy WASM frames',
+          },
+        });
+        continue;
+      }
+
+      const compressed = await this.getZipDecompressNode().readCompressedPayload(entry);
+
+      if (!verify) {
+        const detection = await detectLegacyWasmZstd(compressed, entry.uncompressedSize, {
+          verify: false,
+          crc: entry.crc,
+        });
+        results.push({ entry, detection });
+        continue;
+      }
+
+      const detection = await detectLegacyWasmZstd(compressed, entry.uncompressedSize, {
+        verify: true,
+        crc: entry.crc,
+      });
+      results.push({ entry, detection });
+    }
+
+    return results;
+  }
+
   /**
    * Test entry integrity without extracting to disk
    * Validates CRC-32 or SHA-256 hash without writing decompressed data
@@ -576,10 +729,13 @@ export default class ZipkitNode extends Zipkit {
     }
 
     // For AES encryption, pre-configure the entry so the initial local header
-    // includes the 0x9901 extra field and method 99. The actual compression
-    // method is preserved in realCmpMethod for the AES extra field.
-    const isAesRequested = options?.password && options?.encryptionMethod === 'aes256';
-    const isNeoRequested = options?.password && options?.encryptionMethod === 'neo-aes256';
+    // matches the chosen scheme (WinZip method 99 + 0x9901, or NeoEncrypt + 0x024E).
+    // Default password encryption is NeoEncrypt (matches NeoZip product AES-256).
+    const encMethod = options?.password
+      ? (options.encryptionMethod || 'neo-aes256')
+      : undefined;
+    const isAesRequested = encMethod === 'aes256';
+    const isNeoRequested = encMethod === 'neo-aes256';
     if (isAesRequested) {
       entry.cmpMethod = CMP_METHOD.AES_ENCRYPT;
       entry.aesVersion = 1;
@@ -615,55 +771,87 @@ export default class ZipkitNode extends Zipkit {
       });
     });
 
-    // Step 3: Compress file and write data
+    // Step 3: Compress file and write data (chunked when large).
+    // ZipCrypto still uses the buffer path (legacy header needs CRC up front).
+    // AES / NeoEncrypt use AesEncryptor so ciphertext is written in chunks.
     const bufferSize = options?.bufferSize || this.getBufferSize();
-    const useZstd = options?.useZstd !== false;
-    // Never use the chunked/streaming path when encrypting: the streaming path writes
-    // compressed data to the writer via onOutputBuffer BEFORE encryption can be applied.
-    // Encryption requires the full compressed buffer to create the 12-byte header and
-    // encrypt all data in one pass, so we must use the buffer path (compressFile).
-    const shouldUseChunked = !useZstd && !options?.password && entry.uncompressedSize && entry.uncompressedSize > bufferSize;
-
-    if (shouldUseChunked) {
-      // Use streaming compression for large files
-      // Data is written directly via onOutputBuffer callback
-      const onOutputBuffer = async (data: Buffer) => {
-        await new Promise<void>((resolve, reject) => {
-          writer.outputStream.write(data, (error) => {
-            if (error) {
-              reject(error);
-            } else {
-              writer.currentPosition += data.length;
-              if (callbacks?.onProgress) {
-                callbacks.onProgress(entry, data.length);
-              }
-              resolve();
-            }
-          });
-        });
-      };
-
-      // compressFileStream will set entry.compressedSize and entry.crc
-      await this.compressFileStream(filePath, entry, options, onOutputBuffer);
-    } else {
-      // Use regular buffer compression for small files
-      // compressFile will set entry.compressedSize and entry.crc
-      const compressedData = await this.compressFile(filePath, entry, options);
-      
-      // Write compressed data to file
+    const useZipCrypto = encMethod === 'zipcrypto';
+    const shouldUseChunked =
+      !!entry.uncompressedSize &&
+      entry.uncompressedSize > bufferSize &&
+      !useZipCrypto;
+
+    const writeChunk = async (data: Buffer): Promise<void> => {
+      if (data.length === 0) {
+        return;
+      }
       await new Promise<void>((resolve, reject) => {
-        writer.outputStream.write(compressedData, (error) => {
+        writer.outputStream.write(data, (error) => {
           if (error) {
             reject(error);
           } else {
-            writer.currentPosition += compressedData.length;
+            writer.currentPosition += data.length;
             if (callbacks?.onProgress) {
-              callbacks.onProgress(entry, compressedData.length);
+              callbacks.onProgress(entry, data.length);
             }
             resolve();
           }
         });
       });
+    };
+
+    if (shouldUseChunked) {
+      const useAesStream = isAesRequested || isNeoRequested;
+      const encryptor = useAesStream
+        ? AesCrypto.createEncryptor(options!.password!)
+        : null;
+      let streamedBytes = 0;
+
+      if (encryptor) {
+        const hdr = encryptor.header();
+        await writeChunk(hdr);
+        streamedBytes += hdr.length;
+        entry.isEncrypted = true;
+        entry.bitFlags |= GP_FLAG.ENCRYPTED;
+      }
+
+      // Compress without applying buffer encrypt — we stream-encrypt below.
+      const streamOptions: CompressOptions = encryptor
+        ? { ...options, password: undefined, encryptionMethod: undefined }
+        : { ...options };
+
+      const onOutputBuffer = async (data: Buffer) => {
+        const out = encryptor ? encryptor.update(data) : data;
+        await writeChunk(out);
+        streamedBytes += out.length;
+      };
+
+      await this.compressFileStream(filePath, entry, streamOptions, onOutputBuffer);
+
+      if (encryptor) {
+        const auth = encryptor.finish();
+        await writeChunk(auth);
+        streamedBytes += auth.length;
+        entry.compressedSize = streamedBytes;
+        entry.isEncrypted = true;
+        entry.bitFlags |= GP_FLAG.ENCRYPTED;
+        // compressFileStream overwrites cmpMethod with the real codec — restore AES/Neo metadata
+        if (isAesRequested) {
+          entry.realCmpMethod = realCmpMethod;
+          entry.cmpMethod = CMP_METHOD.AES_ENCRYPT;
+          entry.aesVersion = 1;
+          entry.aesStrength = 3;
+        } else if (isNeoRequested) {
+          entry.cmpMethod = realCmpMethod;
+          entry.neoCryptoPayloadVersion = 1;
+          entry.neoCryptoAlgorithm = NEO_CRYPTO_ALGORITHM_AES256_V1;
+          entry.neoCryptoFlags = 0;
+        }
+      }
+    } else {
+      // Small files / ZipCrypto: buffer compression (may encrypt inside compressFile)
+      const compressedData = await this.compressFile(filePath, entry, options);
+      await writeChunk(compressedData);
     }
 
     // Step 4: Patch local header in-place with final compressed size, CRC, and flags

package/src/node/ZstdNode.ts

@@ -0,0 +1,155 @@
+/**
+ * ZstdNode - Native Node.js Zstandard via zlib (streaming / chunked)
+ *
+ * This is the only zstd backend in NeoZipKit. There is no WASM codec.
+ * Requires Node.js with `zlib.createZstdCompress` (Node >= 22.15 or >= 23.8).
+ * Browser builds alias this module to a stub that throws.
+ */
+
+import * as zlib from 'zlib';
+import { Readable } from 'stream';
+import { promisify } from 'util';
+
+const zstdCompressAsync = promisify(zlib.zstdCompress);
+const zstdDecompressAsync = promisify(zlib.zstdDecompress);
+
+export function isNativeZstdAvailable(): boolean {
+  return (
+    typeof zlib.createZstdCompress === 'function' &&
+    typeof zlib.createZstdDecompress === 'function' &&
+    typeof zlib.zstdCompress === 'function' &&
+    typeof zlib.zstdDecompress === 'function'
+  );
+}
+
+function assertNativeZstd(): void {
+  if (!isNativeZstdAvailable()) {
+    throw new Error(
+      'Native zstd requires Node.js with zlib ZSTD support ' +
+        '(Node.js >= 22.15 or >= 23.8).'
+    );
+  }
+}
+
+/** Map NeoZipKit level 1–9 to a zstd compression level (1–19). */
+export function mapCompressionLevel(level: number): number {
+  return Math.min(Math.max(1, Math.floor(level * 2.1)), 19);
+}
+
+function compressOptions(level: number): zlib.ZstdOptions {
+  return {
+    params: {
+      [zlib.constants.ZSTD_c_compressionLevel]: mapCompressionLevel(level),
+    },
+  };
+}
+
+export function createCompressTransform(level: number = 6): zlib.ZstdCompress {
+  assertNativeZstd();
+  return zlib.createZstdCompress(compressOptions(level));
+}
+
+export function createDecompressTransform(): zlib.ZstdDecompress {
+  assertNativeZstd();
+  return zlib.createZstdDecompress();
+}
+
+export async function compress(data: Buffer, level: number = 6): Promise<Buffer> {
+  assertNativeZstd();
+  const result = await zstdCompressAsync(data, compressOptions(level));
+  return Buffer.from(result);
+}
+
+export async function decompress(data: Buffer): Promise<Buffer> {
+  assertNativeZstd();
+  const result = await zstdDecompressAsync(data);
+  return Buffer.from(result);
+}
+
+export function compressSync(data: Buffer, level: number = 6): Buffer {
+  assertNativeZstd();
+  return zlib.zstdCompressSync(data, compressOptions(level));
+}
+
+export function decompressSync(data: Buffer): Buffer {
+  assertNativeZstd();
+  return zlib.zstdDecompressSync(data);
+}
+
+/**
+ * Stream-compress plaintext from a chunked reader (primary path for all sizes).
+ */
+export async function compressChunks(
+  readChunk: (position: number, size: number) => Buffer,
+  totalSize: number,
+  chunkSize: number,
+  level: number,
+  onPlainChunk?: (chunk: Buffer) => void,
+  onCompressedChunk?: (chunk: Buffer) => void | Promise<void>
+): Promise<number> {
+  async function* plainChunks(): AsyncGenerator<Buffer> {
+    let position = 0;
+    while (position < totalSize) {
+      const size = Math.min(chunkSize, totalSize - position);
+      const chunk = readChunk(position, size);
+      onPlainChunk?.(chunk);
+      position += chunk.length;
+      yield chunk;
+    }
+  }
+
+  const transform = createCompressTransform(level);
+  const readable = Readable.from(plainChunks());
+  readable.pipe(transform);
+
+  let compressedSize = 0;
+  try {
+    for await (const out of transform) {
+      const buf = Buffer.isBuffer(out) ? out : Buffer.from(out as Uint8Array);
+      compressedSize += buf.length;
+      if (onCompressedChunk) {
+        await onCompressedChunk(buf);
+      }
+    }
+  } finally {
+    readable.destroy();
+    transform.destroy();
+  }
+
+  return compressedSize;
+}
+
+/**
+ * Decompress an async iterable of compressed chunks, yielding plaintext buffers.
+ */
+export async function* decompressStream(
+  compressedStream: AsyncIterable<Buffer>
+): AsyncGenerator<Buffer> {
+  const transform = createDecompressTransform();
+  const readable = Readable.from(compressedStream);
+  readable.pipe(transform);
+
+  try {
+    for await (const chunk of transform) {
+      yield Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk as Uint8Array);
+    }
+  } finally {
+    readable.destroy();
+    transform.destroy();
+  }
+}
+
+export const ZstdNode = {
+  isNativeZstdAvailable,
+  mapCompressionLevel,
+  createCompressTransform,
+  createDecompressTransform,
+  compress,
+  decompress,
+  compressSync,
+  decompressSync,
+  compressChunks,
+  decompressStream,
+};
+
+export default ZstdNode;

package/src/node/index.ts

@@ -21,6 +21,16 @@ export default ZipkitNodeDefault;
 export type { ZipFileWriter } from './ZipkitNode';
 export { ZipCompressNode } from './ZipCompressNode';
 export { ZipDecompressNode } from './ZipDecompressNode';
+export { ZstdNode, isNativeZstdAvailable } from './ZstdNode';
+export {
+  LegacyZstd,
+  LEGACY_WASM_ZSTD_PADDING,
+  parseZstdFrameContentSize,
+  looksLikeLegacyWasmZstd,
+  detectLegacyWasmZstd,
+  repairLegacyWasmZstdPlaintext,
+} from './LegacyZstd';
+export type { LegacyZstdDetectResult, LegacyZstdConfidence, DetectLegacyZstdOptions } from './LegacyZstd';
 
 // Efficient ZIP copying using ZipEntry directly
 export { ZipCopyNode } from './ZipCopyNode';

package/dist/core/ZstdManager.d.ts

@@ -1,56 +0,0 @@
-/**
- * ZstdManager - Global Zstd Codec Manager
- *
- * This manager ensures safe usage of the Zstd WASM module across multiple instances.
- *
- * ## Why This Is Necessary
- *
- * The `@oneidentity/zstd-js` library uses a shared WASM module internally.
- * While `ZstdInit()` returns different object references, they all share the same
- * `ZstdSimple` implementation and WASM memory/heap.
- *
- * This means concurrent or improperly managed sequential operations can cause
- * memory corruption because they're all operating on the same underlying WASM state.
- *
- * ## How It Works
- *
- * 1. Single initialization: WASM module is initialized once globally
- * 2. Operation queuing: All compress/decompress operations are queued
- * 3. Sequential execution: JavaScript's single-threaded nature ensures safe execution
- * 4. Automatic initialization: Lazy initialization on first use
- *
- * ## Usage
- *
- * ```typescript
- * import { ZstdManager } from './ZstdManager';
- *
- * // Compress
- * const compressed = await ZstdManager.compress(data, level);
- *
- * // Decompress
- * const decompressed = await ZstdManager.decompress(compressedData);
- * ```
- */
-/**
- * Global Zstd Manager
- * Use this for all Zstd compression/decompression operations
- */
-export declare const ZstdManager: {
-    /**
-     * Compress data using Zstd
-     * Operations are automatically queued to prevent interference
-     */
-    compress: (data: Uint8Array, level?: number) => Promise<Uint8Array<ArrayBufferLike>>;
-    /**
-     * Decompress data using Zstd
-     * Operations are automatically queued to prevent interference
-     */
-    decompress: (data: Uint8Array | Buffer) => Promise<Uint8Array<ArrayBufferLike>>;
-    /**
-     * Reset the manager (for testing)
-     * @internal
-     */
-    reset: () => void;
-};
-export default ZstdManager;
-//# sourceMappingURL=ZstdManager.d.ts.map

package/dist/core/ZstdManager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ZstdManager.d.ts","sourceRoot":"","sources":["../../src/core/ZstdManager.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAyGH;;;GAGG;AACH,eAAO,MAAM,WAAW;IACtB;;;OAGG;qBACc,UAAU,UAAU,MAAM;IAG3C;;;OAGG;uBACgB,UAAU,GAAG,MAAM;IAGtC;;;OAGG;;CAEJ,CAAC;AAEF,eAAe,WAAW,CAAC"}

package/dist/core/ZstdManager.js

@@ -1,144 +0,0 @@
-"use strict";
-/**
- * ZstdManager - Global Zstd Codec Manager
- *
- * This manager ensures safe usage of the Zstd WASM module across multiple instances.
- *
- * ## Why This Is Necessary
- *
- * The `@oneidentity/zstd-js` library uses a shared WASM module internally.
- * While `ZstdInit()` returns different object references, they all share the same
- * `ZstdSimple` implementation and WASM memory/heap.
- *
- * This means concurrent or improperly managed sequential operations can cause
- * memory corruption because they're all operating on the same underlying WASM state.
- *
- * ## How It Works
- *
- * 1. Single initialization: WASM module is initialized once globally
- * 2. Operation queuing: All compress/decompress operations are queued
- * 3. Sequential execution: JavaScript's single-threaded nature ensures safe execution
- * 4. Automatic initialization: Lazy initialization on first use
- *
- * ## Usage
- *
- * ```typescript
- * import { ZstdManager } from './ZstdManager';
- *
- * // Compress
- * const compressed = await ZstdManager.compress(data, level);
- *
- * // Decompress
- * const decompressed = await ZstdManager.decompress(compressedData);
- * ```
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ZstdManager = void 0;
-const zstd_js_1 = require("@oneidentity/zstd-js");
-class ZstdCodecManager {
-    constructor() {
-        this.codec = null;
-        this.initPromise = null;
-        this.operationQueue = Promise.resolve();
-    }
-    /**
-     * Get the singleton instance of ZstdCodecManager
-     */
-    static getInstance() {
-        if (!ZstdCodecManager.instance) {
-            ZstdCodecManager.instance = new ZstdCodecManager();
-        }
-        return ZstdCodecManager.instance;
-    }
-    /**
-     * Ensure the Zstd codec is initialized
-     * This is called automatically before any compress/decompress operation
-     */
-    async ensureInitialized() {
-        if (this.codec) {
-            return;
-        }
-        if (this.initPromise) {
-            return this.initPromise;
-        }
-        this.initPromise = (async () => {
-            this.codec = await (0, zstd_js_1.ZstdInit)();
-        })();
-        return this.initPromise;
-    }
-    /**
-     * Queue an operation to ensure sequential execution
-     * This prevents concurrent operations from interfering with each other
-     */
-    async queueOperation(operation) {
-        // Chain this operation after the previous one
-        const promise = this.operationQueue.then(operation, operation);
-        // Update the queue to point to this operation
-        this.operationQueue = promise.catch(() => { }); // Catch to prevent unhandled rejections in queue
-        return promise;
-    }
-    /**
-     * Compress data using Zstd
-     * @param data - Data to compress (Uint8Array)
-     * @param level - Compression level (1-22, default 6)
-     * @returns Compressed data as Uint8Array
-     */
-    async compress(data, level = 6) {
-        return this.queueOperation(async () => {
-            await this.ensureInitialized();
-            if (!this.codec) {
-                throw new Error('Zstd codec not initialized');
-            }
-            return this.codec.ZstdSimple.compress(data, level);
-        });
-    }
-    /**
-     * Decompress data using Zstd
-     * @param data - Compressed data (Uint8Array or Buffer)
-     * @returns Decompressed data as Uint8Array
-     */
-    async decompress(data) {
-        return this.queueOperation(async () => {
-            await this.ensureInitialized();
-            if (!this.codec) {
-                throw new Error('Zstd codec not initialized');
-            }
-            // Convert Buffer to Uint8Array if needed
-            const inputData = data instanceof Buffer
-                ? new Uint8Array(data.buffer, data.byteOffset, data.byteLength)
-                : data;
-            return this.codec.ZstdSimple.decompress(inputData);
-        });
-    }
-    /**
-     * Reset the manager (for testing purposes)
-     * @internal
-     */
-    static reset() {
-        ZstdCodecManager.instance = null;
-    }
-}
-ZstdCodecManager.instance = null;
-/**
- * Global Zstd Manager
- * Use this for all Zstd compression/decompression operations
- */
-exports.ZstdManager = {
-    /**
-     * Compress data using Zstd
-     * Operations are automatically queued to prevent interference
-     */
-    compress: (data, level) => ZstdCodecManager.getInstance().compress(data, level),
-    /**
-     * Decompress data using Zstd
-     * Operations are automatically queued to prevent interference
-     */
-    decompress: (data) => ZstdCodecManager.getInstance().decompress(data),
-    /**
-     * Reset the manager (for testing)
-     * @internal
-     */
-    reset: () => ZstdCodecManager.reset(),
-};
-exports.default = exports.ZstdManager;
-//# sourceMappingURL=ZstdManager.js.map