@cj-tech-master/excelts 4.2.1-canary.20260111102127.f808a37 → 4.2.1

package/dist/browser/modules/stream/streams.js

@@ -16,34 +16,20 @@ export class Writable extends NodeWritable {
     constructor(options) {
         // If wrapping an existing stream, proxy to it
         if (options?.stream) {
-            const underlying = options.stream;
             // Create a pass-through wrapper that proxies to the underlying stream
             super({
                 highWaterMark: options?.highWaterMark,
                 objectMode: options?.objectMode,
                 write(chunk, encoding, callback) {
-                    underlying.write(chunk, encoding, callback);
+                    options.stream.write(chunk, encoding, callback);
                 },
                 final(callback) {
-                    underlying.end(callback);
+                    options.stream.end(callback);
                 }
             });
-            // Proxy events from underlying stream, but ensure we clean up listeners so
-            // the underlying stream cannot retain this wrapper longer than necessary.
-            const onUnderlyingError = (err) => {
-                this.emit("error", err);
-            };
-            const onUnderlyingClose = () => {
-                this.emit("close");
-            };
-            const cleanup = () => {
-                underlying.off("error", onUnderlyingError);
-                underlying.off("close", onUnderlyingClose);
-            };
-            underlying.on("error", onUnderlyingError);
-            underlying.on("close", onUnderlyingClose);
-            this.once("close", cleanup);
-            this.once("finish", cleanup);
+            // Proxy events from underlying stream
+            options.stream.on("error", err => this.emit("error", err));
+            options.stream.on("close", () => this.emit("close"));
         }
         else {
             super({
@@ -71,16 +57,17 @@ export function normalizeWritable(stream) {
     if (stream instanceof Writable) {
         return stream;
     }
-    // Node.js Writable: already compatible, avoid extra wrapper allocation.
+    // Node.js Writable: accept structurally even if typed as unknown.
     if (stream instanceof NodeWritable) {
-        return stream;
+        return new Writable({ stream: stream });
     }
     // Web WritableStream: detect by getWriter() (avoid relying on global WritableStream).
     if (stream?.getWriter) {
-        return NodeWritable.fromWeb(stream);
+        const nodeWritable = NodeWritable.fromWeb(stream);
+        return new Writable({ stream: nodeWritable });
     }
-    // Assume it structurally matches Node's Writable.
-    return stream;
+    // Assume it structurally matches Node's Writable; wrap for consistent API.
+    return new Writable({ stream: stream });
 }
 // Import for internal use
 import { textDecoder } from "./shared.js";
@@ -193,13 +180,12 @@ export function finished(stream, optionsOrCallback, callback) {
     const promise = new Promise((resolve, reject) => {
         const normalizedStream = toNodePipelineStream(stream);
         nodeFinished(normalizedStream, options, (err) => {
-            // Node.js semantics: options.error defaults to true (report errors).
-            // If options.error === false, ignore errors and resolve.
-            if (err && options?.error !== false) {
+            if (err && !(options && options.error)) {
                 reject(err);
-                return;
             }
-            resolve();
+            else {
+                resolve();
+            }
         });
     });
     if (cb) {
@@ -547,28 +533,13 @@ export function addAbortSignal(signal, stream) {
         stream.destroy(new Error("Aborted"));
         return stream;
     }
-    const cleanup = () => {
-        signal.removeEventListener("abort", onAbort);
-        stream.off?.("close", onDone);
-        stream.off?.("end", onDone);
-        stream.off?.("finish", onDone);
-        stream.off?.("error", onError);
-    };
     const onAbort = () => {
-        cleanup();
         stream.destroy(new Error("Aborted"));
     };
-    const onDone = () => {
-        cleanup();
-    };
-    const onError = () => {
-        cleanup();
-    };
     signal.addEventListener("abort", onAbort, { once: true });
-    stream.once?.("close", onDone);
-    stream.once?.("end", onDone);
-    stream.once?.("finish", onDone);
-    stream.once?.("error", onError);
+    stream.on("close", () => {
+        signal.removeEventListener("abort", onAbort);
+    });
     return stream;
 }
 /**
@@ -611,109 +582,56 @@ export function compose(...transforms) {
     if (len === 1 && isNativeTransform(transforms[0])) {
         return transforms[0];
     }
-    // Chain all transforms together once.
+    // Chain all transforms together
     for (let i = 0; i < len - 1; i++) {
         transforms[i].pipe(transforms[i + 1]);
     }
+    // Create a Duplex that writes to first and reads from last
     const first = transforms[0];
     const last = transforms[len - 1];
-    // Use a private output stream so we don't have to monkey-patch `write()` on the
-    // public composed stream (which would break piping into it).
-    const output = new PassThrough({ objectMode: last.readableObjectMode ?? true });
-    last.pipe(output);
-    let outputEnded = false;
-    const pumpOutput = (target) => {
-        if (outputEnded) {
-            return;
-        }
-        while (true) {
-            const chunk = output.read();
-            if (chunk === null) {
-                break;
-            }
-            if (!target.push(chunk)) {
-                break;
-            }
+    // Create a PassThrough as the composed stream
+    const composed = new PassThrough({ objectMode: first.readableObjectMode });
+    // Store original methods for forwarding
+    const passthroughWrite = composed.write.bind(composed);
+    const passthroughEnd = composed.end.bind(composed);
+    // Override write to write to first transform
+    composed.write = function (chunk, encodingOrCallback, callback) {
+        if (typeof encodingOrCallback === "function") {
+            return first.write(chunk, encodingOrCallback);
         }
+        return first.write(chunk, encodingOrCallback, callback);
     };
-    const composed = new Transform({
-        readableObjectMode: last.readableObjectMode,
-        writableObjectMode: first.writableObjectMode,
-        transform(chunk, encoding, callback) {
-            try {
-                // Forward writes into the head of the chain.
-                first.write(chunk, encoding, callback);
-            }
-            catch (err) {
-                callback(err);
-            }
-        },
-        flush(callback) {
-            // End the head of the chain; readable completion is driven by `output` ending.
-            const onFinish = () => {
-                cleanupFlush();
-                callback();
-            };
-            const onError = (err) => {
-                cleanupFlush();
-                callback(err);
-            };
-            const cleanupFlush = () => {
-                first.off?.("finish", onFinish);
-                first.off?.("error", onError);
-            };
-            first.once?.("finish", onFinish);
-            first.once?.("error", onError);
-            first.end();
-        },
-        read() {
-            pumpOutput(this);
-        },
-        destroy(err, callback) {
-            try {
-                output.destroy(err ?? undefined);
-                for (const t of transforms) {
-                    t.destroy?.(err ?? undefined);
-                }
-            }
-            finally {
-                callback(err);
-            }
+    // Override end to end first transform
+    composed.end = function (chunkOrCallback, encodingOrCallback, callback) {
+        if (typeof chunkOrCallback === "function") {
+            first.end(chunkOrCallback);
         }
-    });
-    const onOutputReadable = () => {
-        pumpOutput(composed);
-    };
-    const onOutputEnd = () => {
-        cleanupListeners();
-        outputEnded = true;
-        composed.push(null);
-    };
-    const onAnyError = (err) => {
-        cleanupListeners();
-        composed.destroy(err);
-    };
-    const transformErrorListeners = [];
-    const cleanupListeners = () => {
-        output.off("readable", onOutputReadable);
-        output.off("end", onOutputEnd);
-        output.off("error", onAnyError);
-        for (const { t, fn } of transformErrorListeners) {
-            t.off?.("error", fn);
+        else if (typeof encodingOrCallback === "function") {
+            first.end(chunkOrCallback, encodingOrCallback);
+        }
+        else {
+            first.end(chunkOrCallback, encodingOrCallback, callback);
         }
-        transformErrorListeners.length = 0;
+        return composed;
+    };
+    // Override pipe to pipe from last transform
+    composed.pipe = function (dest) {
+        return last.pipe(dest);
     };
-    output.on("readable", onOutputReadable);
-    output.once("end", onOutputEnd);
-    output.once("error", onAnyError);
-    for (const t of transforms) {
-        const tt = t;
-        tt.once?.("error", onAnyError);
-        transformErrorListeners.push({ t: tt, fn: onAnyError });
-    }
-    composed.once("close", () => {
-        cleanupListeners();
+    // Forward data from last to composed
+    last.on("data", (chunk) => {
+        passthroughWrite(chunk);
+    });
+    // Forward end from last
+    last.on("end", () => {
+        passthroughEnd();
     });
+    // Forward errors from any transform
+    for (const transform of transforms) {
+        transform.on("error", (err) => {
+            composed.emit("error", err);
+        });
+    }
     return composed;
 }
 /**
@@ -794,7 +712,7 @@ export function once(emitter, event, options) {
                 onAbort();
                 return;
             }
-            options.signal.addEventListener("abort", onAbort, { once: true });
+            options.signal.addEventListener("abort", onAbort);
         }
     });
 }

package/dist/cjs/modules/archive/byte-queue.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ByteQueue = void 0;
+class ByteQueue {
+    constructor(initial) {
+        this._start = 0;
+        this._end = 0;
+        this._cachedView = null;
+        this._cachedBuf = null;
+        this._cachedStart = 0;
+        this._cachedEnd = 0;
+        this._buf = new Uint8Array(0);
+        if (initial && initial.length > 0) {
+            this.reset(initial);
+        }
+    }
+    get length() {
+        return this._end - this._start;
+    }
+    isEmpty() {
+        return this.length === 0;
+    }
+    view() {
+        if (this._start === this._end) {
+            return ByteQueue.EMPTY;
+        }
+        if (this._cachedView &&
+            this._cachedBuf === this._buf &&
+            this._cachedStart === this._start &&
+            this._cachedEnd === this._end) {
+            return this._cachedView;
+        }
+        const view = this._buf.subarray(this._start, this._end);
+        this._cachedView = view;
+        this._cachedBuf = this._buf;
+        this._cachedStart = this._start;
+        this._cachedEnd = this._end;
+        return view;
+    }
+    reset(data) {
+        this._cachedView = null;
+        this._cachedBuf = null;
+        if (!data || data.length === 0) {
+            this._buf = ByteQueue.EMPTY;
+            this._start = 0;
+            this._end = 0;
+            return;
+        }
+        // Keep a private copy to ensure future writes cannot mutate the source.
+        const copy = new Uint8Array(data.length);
+        copy.set(data);
+        this._buf = copy;
+        this._start = 0;
+        this._end = copy.length;
+    }
+    append(chunk) {
+        if (chunk.length === 0) {
+            return;
+        }
+        this._cachedView = null;
+        this._cachedBuf = null;
+        const unread = this.length;
+        // Fast path: enough tail room.
+        if (this._end + chunk.length <= this._buf.length) {
+            this._buf.set(chunk, this._end);
+            this._end += chunk.length;
+            return;
+        }
+        // Allocate a new buffer and copy unread bytes (never compacts in-place).
+        const required = unread + chunk.length;
+        const nextSize = this._buf.length === 0 ? required : Math.max(this._buf.length * 2, required);
+        const next = new Uint8Array(nextSize);
+        if (unread > 0) {
+            next.set(this._buf.subarray(this._start, this._end), 0);
+        }
+        next.set(chunk, unread);
+        this._buf = next;
+        this._start = 0;
+        this._end = required;
+    }
+    read(length) {
+        if (length <= 0) {
+            return new Uint8Array(0);
+        }
+        if (length > this.length) {
+            throw new RangeError("ByteQueue: read beyond available data");
+        }
+        // Return a view for performance.
+        // To keep this safe for async consumers, we must ensure we never write into
+        // the same backing buffer again after it becomes fully consumed.
+        const out = this._buf.subarray(this._start, this._start + length);
+        this._start += length;
+        this._cachedView = null;
+        this._cachedBuf = null;
+        if (this._start === this._end) {
+            // Release backing storage to avoid reusing memory that might still be
+            // referenced by previously returned views.
+            this._buf = ByteQueue.EMPTY;
+            this._start = 0;
+            this._end = 0;
+        }
+        return out;
+    }
+    discard(length) {
+        if (length <= 0) {
+            return;
+        }
+        if (length >= this.length) {
+            // Release backing storage for the same reason as read(): previously
+            // returned views may still be referenced by consumers.
+            this._buf = ByteQueue.EMPTY;
+            this._start = 0;
+            this._end = 0;
+            this._cachedView = null;
+            this._cachedBuf = null;
+            return;
+        }
+        this._start += length;
+        this._cachedView = null;
+        this._cachedBuf = null;
+        if (this._start === this._end) {
+            this._buf = ByteQueue.EMPTY;
+            this._start = 0;
+            this._end = 0;
+        }
+    }
+}
+exports.ByteQueue = ByteQueue;
+ByteQueue.EMPTY = new Uint8Array(0);

package/dist/cjs/modules/archive/{compression/compress.base.js → compress.base.js}

@@ -21,7 +21,7 @@ exports.hasDeflateRawDecompressionStream = hasDeflateRawDecompressionStream;
 exports.hasDeflateRawWebStreams = hasDeflateRawWebStreams;
 exports.compressWithStream = compressWithStream;
 exports.decompressWithStream = decompressWithStream;
-const byte_queue_1 = require("../internal/byte-queue.js");
+const byte_queue_1 = require("./byte-queue.js");
 /**
  * Default threshold (in bytes) to choose the lower-overhead path.
  *

package/dist/cjs/modules/archive/{compression/compress.browser.js → compress.browser.js}

@@ -12,15 +12,23 @@
  * - Edge >= 89
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasCompressionStream = void 0;
+exports.hasCompressionStream = hasCompressionStream;
 exports.compress = compress;
 exports.compressSync = compressSync;
 exports.decompress = decompress;
 exports.decompressSync = decompressSync;
 const compress_base_1 = require("./compress.base.js");
-Object.defineProperty(exports, "hasCompressionStream", { enumerable: true, get: function () { return compress_base_1.hasCompressionStream; } });
 const deflate_fallback_1 = require("./deflate-fallback.js");
-const defaults_1 = require("../defaults.js");
+const defaults_1 = require("./defaults.js");
+/**
+ * Check if CompressionStream is available in this environment.
+ *
+ * Note: Some environments may expose CompressionStream but not support
+ * the "deflate-raw" format that ZIP requires.
+ */
+function hasCompressionStream() {
+    return typeof CompressionStream !== "undefined";
+}
 /**
  * Compress data using browser's native CompressionStream or JS fallback
  *

package/dist/cjs/modules/archive/{compression/compress.js → compress.js}

@@ -46,7 +46,7 @@ exports.decompress = decompress;
 exports.decompressSync = decompressSync;
 const util_1 = require("util");
 const zlib = __importStar(require("zlib"));
-const defaults_1 = require("../defaults.js");
+const defaults_1 = require("./defaults.js");
 // Re-export shared types and utilities
 var compress_base_1 = require("./compress.base.js");
 Object.defineProperty(exports, "hasCompressionStream", { enumerable: true, get: function () { return compress_base_1.hasCompressionStream; } });

package/dist/cjs/modules/archive/{compression/crc32.js → crc32.js}

@@ -47,7 +47,7 @@ exports.crc32Finalize = void 0;
 exports.crc32 = crc32;
 exports.ensureCrc32 = ensureCrc32;
 exports.crc32Update = crc32Update;
-const env_1 = require("../../../utils/env.js");
+const env_1 = require("../../utils/env.js");
 const crc32_base_1 = require("./crc32.base.js");
 Object.defineProperty(exports, "crc32Finalize", { enumerable: true, get: function () { return crc32_base_1.crc32Finalize; } });
 // Lazy-loaded zlib module for Node.js

package/dist/cjs/modules/archive/defaults.js

@@ -1,9 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_ZIP_TIMESTAMPS = exports.DEFAULT_ZIP_LEVEL = exports.DEFAULT_COMPRESS_LEVEL = exports.DEFAULT_DEFLATE_LEVEL = void 0;
-exports.DEFAULT_DEFLATE_LEVEL = 6;
-// Backward-compatible aliases (avoid default drift across modules).
-exports.DEFAULT_COMPRESS_LEVEL = exports.DEFAULT_DEFLATE_LEVEL;
-exports.DEFAULT_ZIP_LEVEL = exports.DEFAULT_DEFLATE_LEVEL;
-// Prefer reproducible output by default: omit the Info-ZIP UTC mtime extra field.
-exports.DEFAULT_ZIP_TIMESTAMPS = "dos";
+exports.DEFAULT_ZIP_TIMESTAMPS = exports.DEFAULT_ZIP_LEVEL = exports.DEFAULT_COMPRESS_LEVEL = void 0;
+exports.DEFAULT_COMPRESS_LEVEL = 6;
+exports.DEFAULT_ZIP_LEVEL = 6;
+exports.DEFAULT_ZIP_TIMESTAMPS = "dos+utc";

package/dist/cjs/modules/archive/{compression/deflate-fallback.js → deflate-fallback.js}

@@ -15,7 +15,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.inflateRaw = inflateRaw;
 exports.deflateRawStore = deflateRawStore;
 exports.deflateRawCompressed = deflateRawCompressed;
-const bytes_1 = require("../utils/bytes.js");
+const bytes_1 = require("./utils/bytes.js");
 // ============================================================================
 // DEFLATE Decompression (Full implementation)
 // ============================================================================

package/dist/cjs/modules/archive/index.base.js

@@ -7,12 +7,22 @@
  * from this file and then layer their platform-specific bindings.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnzipEntry = exports.ZipReader = exports.unzip = exports.ZipArchive = exports.zip = void 0;
-// High-level APIs
-var zip_1 = require("./zip/index.js");
-Object.defineProperty(exports, "zip", { enumerable: true, get: function () { return zip_1.zip; } });
-Object.defineProperty(exports, "ZipArchive", { enumerable: true, get: function () { return zip_1.ZipArchive; } });
-var unzip_1 = require("./unzip/index.js");
-Object.defineProperty(exports, "unzip", { enumerable: true, get: function () { return unzip_1.unzip; } });
-Object.defineProperty(exports, "ZipReader", { enumerable: true, get: function () { return unzip_1.ZipReader; } });
-Object.defineProperty(exports, "UnzipEntry", { enumerable: true, get: function () { return unzip_1.UnzipEntry; } });
+exports.ZipParser = exports.forEachEntry = exports.listFiles = exports.extractFile = exports.extractAll = exports.ZipDeflate = exports.Zip = exports.ZipDeflateFile = exports.StreamingZip = exports.ZipBuilder = exports.createZipSync = exports.createZip = void 0;
+// ZIP builders
+var zip_builder_1 = require("./zip-builder.js");
+Object.defineProperty(exports, "createZip", { enumerable: true, get: function () { return zip_builder_1.createZip; } });
+Object.defineProperty(exports, "createZipSync", { enumerable: true, get: function () { return zip_builder_1.createZipSync; } });
+Object.defineProperty(exports, "ZipBuilder", { enumerable: true, get: function () { return zip_builder_1.ZipBuilder; } });
+// Streaming ZIP (fflate-like API)
+var streaming_zip_1 = require("./streaming-zip.js");
+Object.defineProperty(exports, "StreamingZip", { enumerable: true, get: function () { return streaming_zip_1.StreamingZip; } });
+Object.defineProperty(exports, "ZipDeflateFile", { enumerable: true, get: function () { return streaming_zip_1.ZipDeflateFile; } });
+Object.defineProperty(exports, "Zip", { enumerable: true, get: function () { return streaming_zip_1.Zip; } });
+Object.defineProperty(exports, "ZipDeflate", { enumerable: true, get: function () { return streaming_zip_1.ZipDeflate; } });
+// Buffer-based unzip API (cross-platform)
+var extract_1 = require("./extract.js");
+Object.defineProperty(exports, "extractAll", { enumerable: true, get: function () { return extract_1.extractAll; } });
+Object.defineProperty(exports, "extractFile", { enumerable: true, get: function () { return extract_1.extractFile; } });
+Object.defineProperty(exports, "listFiles", { enumerable: true, get: function () { return extract_1.listFiles; } });
+Object.defineProperty(exports, "forEachEntry", { enumerable: true, get: function () { return extract_1.forEachEntry; } });
+Object.defineProperty(exports, "ZipParser", { enumerable: true, get: function () { return extract_1.ZipParser; } });

package/dist/cjs/modules/archive/index.browser.js

@@ -20,22 +20,28 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasDeflateRaw = exports.createInflateStream = exports.createDeflateStream = exports.hasCompressionStream = exports.decompressSync = exports.decompress = exports.compressSync = exports.compress = exports.crc32Finalize = exports.crc32Update = exports.crc32 = void 0;
+exports.createParse = exports.Parse = exports.hasDeflateRaw = exports.createInflateStream = exports.createDeflateStream = exports.hasCompressionStream = exports.decompressSync = exports.decompress = exports.compressSync = exports.compress = exports.crc32Finalize = exports.crc32Update = exports.crc32 = void 0;
 __exportStar(require("./index.base.js"), exports);
 // CRC32
-var crc32_browser_1 = require("./compression/crc32.browser.js");
+var crc32_browser_1 = require("./crc32.browser.js");
 Object.defineProperty(exports, "crc32", { enumerable: true, get: function () { return crc32_browser_1.crc32; } });
 Object.defineProperty(exports, "crc32Update", { enumerable: true, get: function () { return crc32_browser_1.crc32Update; } });
 Object.defineProperty(exports, "crc32Finalize", { enumerable: true, get: function () { return crc32_browser_1.crc32Finalize; } });
 // Compression
-var compress_browser_1 = require("./compression/compress.browser.js");
+var compress_browser_1 = require("./compress.browser.js");
 Object.defineProperty(exports, "compress", { enumerable: true, get: function () { return compress_browser_1.compress; } });
 Object.defineProperty(exports, "compressSync", { enumerable: true, get: function () { return compress_browser_1.compressSync; } });
 Object.defineProperty(exports, "decompress", { enumerable: true, get: function () { return compress_browser_1.decompress; } });
 Object.defineProperty(exports, "decompressSync", { enumerable: true, get: function () { return compress_browser_1.decompressSync; } });
 Object.defineProperty(exports, "hasCompressionStream", { enumerable: true, get: function () { return compress_browser_1.hasCompressionStream; } });
 // Streaming compression
-var streaming_compress_browser_1 = require("./compression/streaming-compress.browser.js");
+var streaming_compress_browser_1 = require("./streaming-compress.browser.js");
 Object.defineProperty(exports, "createDeflateStream", { enumerable: true, get: function () { return streaming_compress_browser_1.createDeflateStream; } });
 Object.defineProperty(exports, "createInflateStream", { enumerable: true, get: function () { return streaming_compress_browser_1.createInflateStream; } });
 Object.defineProperty(exports, "hasDeflateRaw", { enumerable: true, get: function () { return streaming_compress_browser_1.hasDeflateRaw; } });
+// Stream-based unzip API (browser implementation)
+var parse_browser_1 = require("./parse.browser.js");
+Object.defineProperty(exports, "Parse", { enumerable: true, get: function () { return parse_browser_1.Parse; } });
+Object.defineProperty(exports, "createParse", { enumerable: true, get: function () { return parse_browser_1.createParse; } });
+// Buffer-based unzip API (cross-platform)
+// (re-exported from ./index.base)

package/dist/cjs/modules/archive/index.js

@@ -20,22 +20,26 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasDeflateRaw = exports.createInflateStream = exports.createDeflateStream = exports.hasCompressionStream = exports.decompressSync = exports.decompress = exports.compressSync = exports.compress = exports.crc32Finalize = exports.crc32Update = exports.crc32 = void 0;
+exports.createParse = exports.Parse = exports.hasDeflateRaw = exports.createInflateStream = exports.createDeflateStream = exports.hasCompressionStream = exports.decompressSync = exports.decompress = exports.compressSync = exports.compress = exports.crc32Finalize = exports.crc32Update = exports.crc32 = void 0;
 __exportStar(require("./index.base.js"), exports);
 // CRC32
-var crc32_1 = require("./compression/crc32.js");
+var crc32_1 = require("./crc32.js");
 Object.defineProperty(exports, "crc32", { enumerable: true, get: function () { return crc32_1.crc32; } });
 Object.defineProperty(exports, "crc32Update", { enumerable: true, get: function () { return crc32_1.crc32Update; } });
 Object.defineProperty(exports, "crc32Finalize", { enumerable: true, get: function () { return crc32_1.crc32Finalize; } });
 // Compression
-var compress_1 = require("./compression/compress.js");
+var compress_1 = require("./compress.js");
 Object.defineProperty(exports, "compress", { enumerable: true, get: function () { return compress_1.compress; } });
 Object.defineProperty(exports, "compressSync", { enumerable: true, get: function () { return compress_1.compressSync; } });
 Object.defineProperty(exports, "decompress", { enumerable: true, get: function () { return compress_1.decompress; } });
 Object.defineProperty(exports, "decompressSync", { enumerable: true, get: function () { return compress_1.decompressSync; } });
 Object.defineProperty(exports, "hasCompressionStream", { enumerable: true, get: function () { return compress_1.hasCompressionStream; } });
 // Streaming compression
-var streaming_compress_1 = require("./compression/streaming-compress.js");
+var streaming_compress_1 = require("./streaming-compress.js");
 Object.defineProperty(exports, "createDeflateStream", { enumerable: true, get: function () { return streaming_compress_1.createDeflateStream; } });
 Object.defineProperty(exports, "createInflateStream", { enumerable: true, get: function () { return streaming_compress_1.createInflateStream; } });
 Object.defineProperty(exports, "hasDeflateRaw", { enumerable: true, get: function () { return streaming_compress_1.hasDeflateRaw; } });
+// Stream-based unzip API (Node.js; browser build aliases to ./parse.browser.ts)
+var parse_1 = require("./parse.js");
+Object.defineProperty(exports, "Parse", { enumerable: true, get: function () { return parse_1.Parse; } });
+Object.defineProperty(exports, "createParse", { enumerable: true, get: function () { return parse_1.createParse; } });