@cj-tech-master/excelts 4.2.0 → 4.2.1-canary.20260112134913.a3cecdd

package/dist/browser/modules/stream/streams.d.ts

@@ -5,9 +5,9 @@
  * Provides Readable, Writable, Transform, Duplex, and PassThrough streams.
  */
 import { Readable, Writable as NodeWritable, Transform, Duplex, PassThrough } from "stream";
-import type { TransformStreamOptions, ReadableStreamOptions, WritableStreamOptions, DuplexStreamOptions, PullStreamOptions, BufferedStreamOptions, DataChunk, ICollector, IDuplex, IEventEmitter, IPassThrough, IReadable, ITransform, IWritable, PipelineStreamLike, ReadableLike, WritableLike } from "@stream/types";
-import { BufferedStream as StandaloneBufferedStream, StringChunk as StandaloneStringChunk, BufferChunk as StandaloneBufferChunk } from "@stream/buffered-stream";
-import { PullStream as StandalonePullStream } from "@stream/pull-stream";
+import type { TransformStreamOptions, ReadableStreamOptions, WritableStreamOptions, DuplexStreamOptions, PullStreamOptions, BufferedStreamOptions, ICollector, IDuplex, IEventEmitter, IPassThrough, IReadable, ITransform, IWritable, PipelineStreamLike, ReadableLike, WritableLike } from "@stream/types";
+import { BufferedStream, BufferChunk, StringChunk } from "@stream/buffered-stream";
+import { PullStream } from "@stream/pull-stream";
 /**
  * Extended Writable options that match browser API
  * Supports wrapping an existing Node.js stream
@@ -30,6 +30,7 @@ export declare class Writable<T = Uint8Array> extends NodeWritable {
     constructor(options?: WritableOptions<T>);
 }
 export { Readable, Transform, Duplex, PassThrough };
+export { PullStream, BufferedStream, StringChunk, BufferChunk };
 /**
  * Normalize a user-provided writable into a Node.js-compatible Writable.
  *
@@ -130,27 +131,10 @@ export declare class Collector<T = Uint8Array> extends Writable {
  * Create a collector stream
  */
 export declare function createCollector<T = Uint8Array>(options?: WritableStreamOptions): ICollector<T>;
-export declare class PullStream extends StandalonePullStream {
-}
 /**
  * Create a pull stream
  */
 export declare function createPullStream(options?: PullStreamOptions): PullStream;
-/**
- * String chunk implementation
- */
-export declare class StringChunk extends StandaloneStringChunk implements DataChunk {
-}
-/**
- * Buffer chunk implementation
- */
-export declare class BufferChunk extends StandaloneBufferChunk implements DataChunk {
-}
-/**
- * Buffered stream with efficient chunk management
- */
-export declare class BufferedStream extends StandaloneBufferedStream {
-}
 /**
  * Create a buffered stream
  */

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

@@ -5,8 +5,9 @@
  * Provides Readable, Writable, Transform, Duplex, and PassThrough streams.
  */
 import { Readable, Writable as NodeWritable, Transform, Duplex, PassThrough, pipeline as nodePipeline, finished as nodeFinished } from "stream";
-import { BufferedStream as StandaloneBufferedStream, StringChunk as StandaloneStringChunk, BufferChunk as StandaloneBufferChunk } from "./buffered-stream.js";
-import { PullStream as StandalonePullStream } from "./pull-stream.js";
+import { BufferedStream, BufferChunk, StringChunk } from "./buffered-stream.js";
+import { PullStream } from "./pull-stream.js";
+import { isAsyncIterable, isReadableStream, isTransformStream, isWritableStream } from "./internal/type-guards.js";
 /**
  * Unified Writable class - wraps Node.js Writable with browser-compatible API
  *
@@ -16,20 +17,34 @@ 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) {
-                    options.stream.write(chunk, encoding, callback);
+                    underlying.write(chunk, encoding, callback);
                 },
                 final(callback) {
-                    options.stream.end(callback);
+                    underlying.end(callback);
                 }
             });
-            // Proxy events from underlying stream
-            options.stream.on("error", err => this.emit("error", err));
-            options.stream.on("close", () => this.emit("close"));
+            // 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);
         }
         else {
             super({
@@ -45,6 +60,8 @@ export class Writable extends NodeWritable {
 // Re-export native classes with our interfaces
 // =============================================================================
 export { Readable, Transform, Duplex, PassThrough };
+// Standalone cross-platform helpers
+export { PullStream, BufferedStream, StringChunk, BufferChunk };
 // =============================================================================
 // Cross-environment stream normalization
 // =============================================================================
@@ -57,43 +74,25 @@ export function normalizeWritable(stream) {
     if (stream instanceof Writable) {
         return stream;
     }
-    // Node.js Writable: accept structurally even if typed as unknown.
+    // Node.js Writable: already compatible, avoid extra wrapper allocation.
     if (stream instanceof NodeWritable) {
-        return new Writable({ stream: stream });
+        return stream;
     }
     // Web WritableStream: detect by getWriter() (avoid relying on global WritableStream).
     if (stream?.getWriter) {
-        const nodeWritable = NodeWritable.fromWeb(stream);
-        return new Writable({ stream: nodeWritable });
+        return NodeWritable.fromWeb(stream);
     }
-    // Assume it structurally matches Node's Writable; wrap for consistent API.
-    return new Writable({ stream: stream });
+    // Assume it structurally matches Node's Writable.
+    return stream;
 }
 // Import for internal use
 import { textDecoder } from "./shared.js";
-const isReadableStream = (value) => !!value && typeof value === "object" && typeof value.getReader === "function";
-const isAsyncIterable = (value) => {
-    if (!value || (typeof value !== "object" && typeof value !== "function")) {
-        return false;
-    }
-    return typeof value[Symbol.asyncIterator] === "function";
-};
-const isWritableStream = (value) => !!value && typeof value === "object" && typeof value.getWriter === "function";
-const isTransformStream = (value) => !!value &&
-    typeof value === "object" &&
-    !!value.readable &&
-    !!value.writable &&
-    isReadableStream(value.readable) &&
-    isWritableStream(value.writable);
 const isPipelineOptions = (value) => {
     if (!value || typeof value !== "object") {
         return false;
     }
-    // IMPORTANT:
-    // Do NOT use `"end" in obj` here because streams have `.end()` and would be
-    // misclassified as options, breaking argument parsing and potentially hanging.
+    // Avoid treating streams as options objects.
     if (typeof value.pipe === "function" ||
-        typeof value.write === "function" ||
         typeof value.end === "function" ||
         typeof value.getReader === "function" ||
         typeof value.getWriter === "function") {
@@ -180,12 +179,13 @@ export function finished(stream, optionsOrCallback, callback) {
     const promise = new Promise((resolve, reject) => {
         const normalizedStream = toNodePipelineStream(stream);
         nodeFinished(normalizedStream, options, (err) => {
-            if (err && !(options && options.error)) {
+            // Node.js semantics: options.error defaults to true (report errors).
+            // If options.error === false, ignore errors and resolve.
+            if (err && options?.error !== false) {
                 reject(err);
+                return;
             }
-            else {
-                resolve();
-            }
+            resolve();
         });
     });
     if (cb) {
@@ -411,8 +411,6 @@ export function createCollector(options) {
 // =============================================================================
 // Pull Stream - Read data on demand with pattern matching
 // =============================================================================
-export class PullStream extends StandalonePullStream {
-}
 /**
  * Create a pull stream
  */
@@ -422,21 +420,6 @@ export function createPullStream(options) {
 // =============================================================================
 // Buffered Stream - Efficient chunk management
 // =============================================================================
-/**
- * String chunk implementation
- */
-export class StringChunk extends StandaloneStringChunk {
-}
-/**
- * Buffer chunk implementation
- */
-export class BufferChunk extends StandaloneBufferChunk {
-}
-/**
- * Buffered stream with efficient chunk management
- */
-export class BufferedStream extends StandaloneBufferedStream {
-}
 /**
  * Create a buffered stream
  */
@@ -533,13 +516,28 @@ 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.on("close", () => {
-        signal.removeEventListener("abort", onAbort);
-    });
+    stream.once?.("close", onDone);
+    stream.once?.("end", onDone);
+    stream.once?.("finish", onDone);
+    stream.once?.("error", onError);
     return stream;
 }
 /**
@@ -582,56 +580,109 @@ export function compose(...transforms) {
     if (len === 1 && isNativeTransform(transforms[0])) {
         return transforms[0];
     }
-    // Chain all transforms together
+    // Chain all transforms together once.
     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];
-    // 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);
-    };
-    // Override end to end first transform
-    composed.end = function (chunkOrCallback, encodingOrCallback, callback) {
-        if (typeof chunkOrCallback === "function") {
-            first.end(chunkOrCallback);
+    // 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;
         }
-        else if (typeof encodingOrCallback === "function") {
-            first.end(chunkOrCallback, encodingOrCallback);
+        while (true) {
+            const chunk = output.read();
+            if (chunk === null) {
+                break;
+            }
+            if (!target.push(chunk)) {
+                break;
+            }
         }
-        else {
-            first.end(chunkOrCallback, 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);
+            }
         }
-        return composed;
+    });
+    const onOutputReadable = () => {
+        pumpOutput(composed);
     };
-    // Override pipe to pipe from last transform
-    composed.pipe = function (dest) {
-        return last.pipe(dest);
+    const onOutputEnd = () => {
+        cleanupListeners();
+        outputEnded = true;
+        composed.push(null);
     };
-    // Forward data from last to composed
-    last.on("data", (chunk) => {
-        passthroughWrite(chunk);
-    });
-    // Forward end from last
-    last.on("end", () => {
-        passthroughEnd();
+    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);
+        }
+        transformErrorListeners.length = 0;
+    };
+    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 errors from any transform
-    for (const transform of transforms) {
-        transform.on("error", (err) => {
-            composed.emit("error", err);
-        });
-    }
     return composed;
 }
 /**
@@ -712,7 +763,7 @@ export function once(emitter, event, options) {
                 onAbort();
                 return;
             }
-            options.signal.addEventListener("abort", onAbort);
+            options.signal.addEventListener("abort", onAbort, { once: true });
         }
     });
 }

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

@@ -4,8 +4,8 @@
  * Small, cross-platform helpers built on top of the platform stream
  * implementation selected by `./streams` (Node.js or browser).
  */
-import { createReadableFromArray, createTransform } from "./streams.browser.js";
-import { stringToUint8Array as _stringToUint8Array, uint8ArrayToString as _uint8ArrayToString } from "./shared.js";
+import { consumers, createReadableFromArray, createTransform } from "./streams.browser.js";
+import { stringToUint8Array as _stringToUint8Array } from "./shared.js";
 // =============================================================================
 // High-Level Stream Consumers
 // =============================================================================
@@ -17,46 +17,13 @@ export async function collect(stream) {
     return result;
 }
 export async function text(stream) {
-    const chunks = [];
-    let totalLength = 0;
-    for await (const chunk of stream) {
-        chunks.push(chunk);
-        totalLength += chunk.length;
-    }
-    if (chunks.length === 1) {
-        return _uint8ArrayToString(chunks[0]);
-    }
-    const result = new Uint8Array(totalLength);
-    let offset = 0;
-    for (let i = 0, len = chunks.length; i < len; i++) {
-        const c = chunks[i];
-        result.set(c, offset);
-        offset += c.length;
-    }
-    return _uint8ArrayToString(result);
+    return consumers.text(stream);
 }
 export async function json(stream) {
-    const str = await text(stream);
-    return JSON.parse(str);
+    return consumers.json(stream);
 }
 export async function bytes(stream) {
-    const chunks = [];
-    let totalLength = 0;
-    for await (const chunk of stream) {
-        chunks.push(chunk);
-        totalLength += chunk.length;
-    }
-    if (chunks.length === 1) {
-        return chunks[0];
-    }
-    const result = new Uint8Array(totalLength);
-    let offset = 0;
-    for (let i = 0, len = chunks.length; i < len; i++) {
-        const c = chunks[i];
-        result.set(c, offset);
-        offset += c.length;
-    }
-    return result;
+    return consumers.buffer(stream);
 }
 // =============================================================================
 // Stream Factory Helpers

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

@@ -21,11 +21,12 @@ exports.hasDeflateRawDecompressionStream = hasDeflateRawDecompressionStream;
 exports.hasDeflateRawWebStreams = hasDeflateRawWebStreams;
 exports.compressWithStream = compressWithStream;
 exports.decompressWithStream = decompressWithStream;
-const byte_queue_1 = require("./byte-queue.js");
+const byte_queue_1 = require("../internal/byte-queue.js");
 /**
  * Default threshold (in bytes) to choose the lower-overhead path.
  *
  * This is a performance knob, not a correctness requirement.
+ * Default: 8MB.
  */
 exports.DEFAULT_COMPRESS_THRESHOLD_BYTES = 8 * 1024 * 1024;
 /**

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

@@ -12,26 +12,21 @@
  * - Edge >= 89
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasCompressionStream = hasCompressionStream;
+exports.hasCompressionStream = void 0;
 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");
-/**
- * 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";
-}
+const defaults_1 = require("../defaults.js");
 /**
  * Compress data using browser's native CompressionStream or JS fallback
  *
+ * Note: We always prefer native CompressionStream when available because
+ * it's significantly faster than pure JS implementation.
+ *
  * @param data - Data to compress
  * @param options - Compression options
  * @returns Compressed data
@@ -44,16 +39,15 @@ function hasCompressionStream() {
  */
 async function compress(data, options = {}) {
     const level = options.level ?? defaults_1.DEFAULT_COMPRESS_LEVEL;
-    const thresholdBytes = (0, compress_base_1.resolveCompressThresholdBytes)(options);
     // Level 0 means no compression
     if (level === 0) {
         return data;
     }
-    // Use native CompressionStream only for larger inputs.
-    if ((0, compress_base_1.hasDeflateRawCompressionStream)() && data.byteLength > thresholdBytes) {
+    // Always use native CompressionStream when available - it's much faster than JS
+    if ((0, compress_base_1.hasDeflateRawCompressionStream)()) {
         return (0, compress_base_1.compressWithStream)(data);
     }
-    // Fallback to pure JS implementation
+    // Fallback to pure JS implementation only when native is unavailable
     return (0, deflate_fallback_1.deflateRawCompressed)(data);
 }
 /**
@@ -75,16 +69,21 @@ function compressSync(data, options = {}) {
 /**
  * Decompress data using browser's native DecompressionStream or JS fallback
  *
+ * Note: We always prefer native DecompressionStream when available because
+ * it's significantly faster than pure JS implementation, regardless of data size.
+ * The threshold is only useful for compression where the overhead matters more.
+ *
  * @param data - Compressed data (deflate-raw format)
+ * @param options - Decompression options (kept for API parity; currently unused in browser)
  * @returns Decompressed data
  */
 async function decompress(data, options = {}) {
-    const thresholdBytes = (0, compress_base_1.resolveCompressThresholdBytes)(options);
-    // Use native DecompressionStream only for larger inputs.
-    if ((0, compress_base_1.hasDeflateRawDecompressionStream)() && data.byteLength > thresholdBytes) {
+    void options;
+    // Always use native DecompressionStream when available - it's much faster than JS
+    if ((0, compress_base_1.hasDeflateRawDecompressionStream)()) {
         return (0, compress_base_1.decompressWithStream)(data);
     }
-    // Fallback to pure JS implementation
+    // Fallback to pure JS implementation only when native is unavailable
     return (0, deflate_fallback_1.inflateRaw)(data);
 }
 /**

package/dist/cjs/modules/archive/{compress.js → compression/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/{crc32.js → compression/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/{deflate-fallback.js → compression/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/{streaming-compress.browser.js → compression/streaming-compress.browser.js}

@@ -11,11 +11,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.hasDeflateRaw = hasDeflateRaw;
 exports.createDeflateStream = createDeflateStream;
 exports.createInflateStream = createInflateStream;
-const _stream_1 = require("../stream/index.js");
+const _stream_1 = require("../../stream/index.js");
 const deflate_fallback_1 = require("./deflate-fallback.js");
 const compress_base_1 = require("./compress.base.js");
-const bytes_1 = require("./utils/bytes.js");
-const defaults_1 = require("./defaults.js");
+const bytes_1 = require("../utils/bytes.js");
+const defaults_1 = require("../defaults.js");
 const streaming_compress_base_1 = require("./streaming-compress.base.js");
 /**
  * Check if deflate-raw streaming compression is supported by this library.

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

@@ -10,8 +10,8 @@ exports.createDeflateStream = createDeflateStream;
 exports.createInflateStream = createInflateStream;
 exports.hasDeflateRaw = hasDeflateRaw;
 const zlib_1 = require("zlib");
-const _stream_1 = require("../stream/index.js");
-const defaults_1 = require("./defaults.js");
+const _stream_1 = require("../../stream/index.js");
+const defaults_1 = require("../defaults.js");
 /**
  * Wrapper around zlib DeflateRaw that flushes after every write
  * This ensures true streaming behavior - data is emitted immediately, not buffered

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

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-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";
+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";

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

@@ -7,22 +7,12 @@
  * from this file and then layer their platform-specific bindings.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-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; } });
+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; } });