@cj-tech-master/excelts 5.1.18 → 6.0.0-beta.1

package/dist/browser/modules/archive/{utils → shared}/async-queue.d.ts

@@ -4,4 +4,6 @@ export type AsyncQueue<T> = {
     close: () => void;
     iterable: AsyncIterable<T>;
 };
-export declare function createAsyncQueue<T>(): AsyncQueue<T>;
+export declare function createAsyncQueue<T>(options?: {
+    onCancel?: () => void;
+}): AsyncQueue<T>;

package/dist/browser/modules/archive/{utils → shared}/async-queue.js

@@ -1,10 +1,34 @@
-export function createAsyncQueue() {
+export function createAsyncQueue(options = {}) {
+    const CLEARED = Symbol("async-queue.cleared");
     const values = [];
     let valuesHead = 0;
     const waiters = [];
     let waitersHead = 0;
     let done = false;
     let error = null;
+    let cancelled = false;
+    const cancel = () => {
+        if (cancelled) {
+            return;
+        }
+        cancelled = true;
+        // Mark as done and unblock all waiters before calling `onCancel()`.
+        // This avoids races where `onCancel()` triggers an abort that calls `fail()`.
+        done = true;
+        while (true) {
+            const waiter = shiftWaiter();
+            if (!waiter) {
+                break;
+            }
+            waiter.resolve({ value: undefined, done: true });
+        }
+        try {
+            options.onCancel?.();
+        }
+        catch {
+            // ignore
+        }
+    };
     const maybeCompact = () => {
         // Prevent unbounded growth of the underlying arrays.
         if (valuesHead > 1024 && valuesHead * 2 > values.length) {
@@ -32,15 +56,15 @@ export function createAsyncQueue() {
     const shiftValue = () => {
         while (valuesHead < values.length) {
             const v = values[valuesHead];
-            values[valuesHead] = undefined;
+            values[valuesHead] = CLEARED;
             valuesHead++;
-            if (v !== undefined) {
+            if (v !== CLEARED) {
                 maybeCompact();
-                return v;
+                return { found: true, value: v };
             }
         }
         maybeCompact();
-        return undefined;
+        return { found: false };
     };
     const push = (value) => {
         if (done || error) {
@@ -87,14 +111,22 @@ export function createAsyncQueue() {
                     if (error) {
                         return Promise.reject(error);
                     }
-                    const value = shiftValue();
-                    if (value !== undefined) {
-                        return Promise.resolve({ value, done: false });
+                    const r = shiftValue();
+                    if (r.found) {
+                        return Promise.resolve({ value: r.value, done: false });
                     }
                     if (done) {
                         return Promise.resolve({ value: undefined, done: true });
                     }
                     return new Promise((resolve, reject) => waiters.push({ resolve, reject }));
+                },
+                return() {
+                    cancel();
+                    return Promise.resolve({ value: undefined, done: true });
+                },
+                throw(err) {
+                    cancel();
+                    return Promise.reject(err);
                 }
             };
         }

package/dist/{types/modules/archive/internal → browser/modules/archive/shared}/byte-queue.d.ts

@@ -1,10 +1,14 @@
 export declare class ByteQueue {
-    private static readonly EMPTY;
     private _chunks;
+    private _chunkHead;
     private _headOffset;
     private _length;
     private _cachedView;
     private _cachedLength;
+    private _activeChunkCount;
+    private _headChunk;
+    private _compactConsumedChunks;
+    private _dropHeadChunk;
     constructor(initial?: Uint8Array);
     get length(): number;
     isEmpty(): boolean;

package/dist/{esm/modules/archive/internal → browser/modules/archive/shared}/byte-queue.js

@@ -1,8 +1,34 @@
-import { indexOfUint8ArrayPattern } from "../utils/bytes.js";
+import { EMPTY_UINT8ARRAY, indexOfUint8ArrayPattern } from "./bytes.js";
 export class ByteQueue {
+    _activeChunkCount() {
+        return this._chunks.length - this._chunkHead;
+    }
+    _headChunk() {
+        return this._chunks[this._chunkHead];
+    }
+    _compactConsumedChunks() {
+        if (this._chunkHead === 0) {
+            return;
+        }
+        if (this._chunkHead >= this._chunks.length) {
+            this._chunks = [];
+            this._chunkHead = 0;
+            return;
+        }
+        if (this._chunkHead > 32 && this._chunkHead * 2 >= this._chunks.length) {
+            this._chunks = this._chunks.slice(this._chunkHead);
+            this._chunkHead = 0;
+        }
+    }
+    _dropHeadChunk() {
+        this._chunkHead++;
+        this._headOffset = 0;
+        this._compactConsumedChunks();
+    }
     constructor(initial) {
         // Store data as immutable chunks to avoid copying on append.
         this._chunks = [];
+        this._chunkHead = 0;
         this._headOffset = 0;
         this._length = 0;
         // Lazily materialized contiguous view (used only by callers that require a single buffer).
@@ -20,11 +46,11 @@ export class ByteQueue {
     }
     view() {
         if (this._length === 0) {
-            return ByteQueue.EMPTY;
+            return EMPTY_UINT8ARRAY;
         }
         // Fast path: single chunk.
-        if (this._chunks.length === 1) {
-            const c = this._chunks[0];
+        if (this._activeChunkCount() === 1) {
+            const c = this._headChunk();
             return c.subarray(this._headOffset, this._headOffset + this._length);
         }
         if (this._cachedView && this._cachedLength === this._length) {
@@ -32,9 +58,9 @@ export class ByteQueue {
         }
         const out = new Uint8Array(this._length);
         let offset = 0;
-        for (let i = 0; i < this._chunks.length; i++) {
+        for (let i = this._chunkHead; i < this._chunks.length; i++) {
             const c = this._chunks[i];
-            const start = i === 0 ? this._headOffset : 0;
+            const start = i === this._chunkHead ? this._headOffset : 0;
             const end = i === this._chunks.length - 1 ? start + (this._length - offset) : c.length;
             out.set(c.subarray(start, end), offset);
             offset += end - start;
@@ -50,6 +76,7 @@ export class ByteQueue {
         this._cachedView = null;
         this._cachedLength = 0;
         this._chunks = [];
+        this._chunkHead = 0;
         this._headOffset = 0;
         this._length = 0;
         if (!data || data.length === 0) {
@@ -59,6 +86,7 @@ export class ByteQueue {
         const copy = new Uint8Array(data.length);
         copy.set(data);
         this._chunks = [copy];
+        this._chunkHead = 0;
         this._headOffset = 0;
         this._length = copy.length;
     }
@@ -73,15 +101,15 @@ export class ByteQueue {
     }
     read(length) {
         if (length <= 0) {
-            return new Uint8Array(0);
+            return EMPTY_UINT8ARRAY;
         }
         if (length > this._length) {
             throw new RangeError("ByteQueue: read beyond available data");
         }
         this._cachedView = null;
         this._cachedLength = 0;
-        if (this._chunks.length === 1) {
-            const c = this._chunks[0];
+        if (this._activeChunkCount() === 1) {
+            const c = this._headChunk();
             const start = this._headOffset;
             const end = start + length;
             const out = c.subarray(start, end);
@@ -89,11 +117,11 @@ export class ByteQueue {
             this._length -= length;
             if (this._length === 0) {
                 this._chunks = [];
+                this._chunkHead = 0;
                 this._headOffset = 0;
             }
             else if (this._headOffset >= c.length) {
-                this._chunks.shift();
-                this._headOffset = 0;
+                this._dropHeadChunk();
             }
             return out;
         }
@@ -102,7 +130,7 @@ export class ByteQueue {
         let outOffset = 0;
         let remaining = length;
         while (remaining > 0) {
-            const c = this._chunks[0];
+            const c = this._headChunk();
             const start = this._headOffset;
             const available = c.length - start;
             const toCopy = Math.min(available, remaining);
@@ -112,12 +140,12 @@ export class ByteQueue {
             this._headOffset += toCopy;
             this._length -= toCopy;
             if (this._headOffset >= c.length) {
-                this._chunks.shift();
-                this._headOffset = 0;
+                this._dropHeadChunk();
             }
         }
         if (this._length === 0) {
             this._chunks = [];
+            this._chunkHead = 0;
             this._headOffset = 0;
         }
         return out;
@@ -135,16 +163,16 @@ export class ByteQueue {
             throw new RangeError("ByteQueue: peek beyond available data");
         }
         // Fast path: single chunk.
-        if (this._chunks.length === 1) {
-            const c = this._chunks[0];
+        if (this._activeChunkCount() === 1) {
+            const c = this._headChunk();
             const start = this._headOffset;
             return [c.subarray(start, start + length)];
         }
         const parts = [];
         let remaining = length;
-        for (let i = 0; i < this._chunks.length && remaining > 0; i++) {
+        for (let i = this._chunkHead; i < this._chunks.length && remaining > 0; i++) {
             const c = this._chunks[i];
-            const start = i === 0 ? this._headOffset : 0;
+            const start = i === this._chunkHead ? this._headOffset : 0;
             const avail = c.length - start;
             if (avail <= 0) {
                 continue;
@@ -161,6 +189,7 @@ export class ByteQueue {
         }
         if (length >= this._length) {
             this._chunks = [];
+            this._chunkHead = 0;
             this._headOffset = 0;
             this._length = 0;
             this._cachedView = null;
@@ -171,7 +200,7 @@ export class ByteQueue {
         this._cachedLength = 0;
         let remaining = length;
         while (remaining > 0) {
-            const c = this._chunks[0];
+            const c = this._headChunk();
             const start = this._headOffset;
             const available = c.length - start;
             const toDrop = Math.min(available, remaining);
@@ -179,12 +208,12 @@ export class ByteQueue {
             this._length -= toDrop;
             remaining -= toDrop;
             if (this._headOffset >= c.length) {
-                this._chunks.shift();
-                this._headOffset = 0;
+                this._dropHeadChunk();
             }
         }
         if (this._length === 0) {
             this._chunks = [];
+            this._chunkHead = 0;
             this._headOffset = 0;
         }
     }
@@ -211,8 +240,8 @@ export class ByteQueue {
             return -1;
         }
         // Fast path: single chunk.
-        if (this._chunks.length === 1) {
-            const c = this._chunks[0];
+        if (this._activeChunkCount() === 1) {
+            const c = this._headChunk();
             const base = this._headOffset;
             const view = c.subarray(base, base + len);
             // Delegate to native indexOf checks for 1..4 bytes.
@@ -232,6 +261,7 @@ export class ByteQueue {
         const b2 = patLen >= 3 ? pattern[2] : 0;
         const b3 = patLen >= 4 ? pattern[3] : 0;
         const chunks = this._chunks;
+        const chunkHead = this._chunkHead;
         const peekByteAcrossChunks = (chunkIndex, absoluteIndex) => {
             let ci = chunkIndex;
             let idx = absoluteIndex;
@@ -246,9 +276,9 @@ export class ByteQueue {
             return null;
         };
         let globalBase = 0;
-        for (let ci = 0; ci < chunks.length; ci++) {
+        for (let ci = chunkHead; ci < chunks.length; ci++) {
             const c = chunks[ci];
-            const chunkOffset = ci === 0 ? this._headOffset : 0;
+            const chunkOffset = ci === chunkHead ? this._headOffset : 0;
             const chunkLen = c.length - chunkOffset;
             if (chunkLen <= 0) {
                 continue;
@@ -336,9 +366,9 @@ export class ByteQueue {
         // Try to read contiguously from a single chunk to avoid 4x chunk-walk.
         const chunks = this._chunks;
         let remaining = off;
-        for (let i = 0; i < chunks.length; i++) {
+        for (let i = this._chunkHead; i < chunks.length; i++) {
             const c = chunks[i];
-            const start = i === 0 ? this._headOffset : 0;
+            const start = i === this._chunkHead ? this._headOffset : 0;
             const avail = c.length - start;
             if (remaining < avail) {
                 const idx = start + remaining;
@@ -391,9 +421,9 @@ export class ByteQueue {
             throw new RangeError("ByteQueue: peek beyond available data");
         }
         let remaining = off;
-        for (let i = 0; i < this._chunks.length; i++) {
+        for (let i = this._chunkHead; i < this._chunks.length; i++) {
             const c = this._chunks[i];
-            const start = i === 0 ? this._headOffset : 0;
+            const start = i === this._chunkHead ? this._headOffset : 0;
             const avail = c.length - start;
             if (remaining < avail) {
                 return c[start + remaining] | 0;
@@ -404,4 +434,3 @@ export class ByteQueue {
         throw new RangeError("ByteQueue: peek beyond available data");
     }
 }
-ByteQueue.EMPTY = new Uint8Array(0);

package/dist/browser/modules/archive/shared/bytes.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Archive-specific binary utilities.
+ *
+ * For common utilities (concatUint8Arrays), import directly from @stream/shared.
+ */
+/**
+ * A reusable empty Uint8Array instance.
+ *
+ * Use this constant instead of creating `new Uint8Array(0)` to avoid
+ * allocating new objects for empty byte arrays.
+ */
+export declare const EMPTY_UINT8ARRAY: Uint8Array<ArrayBuffer>;
+/**
+ * Find the first index of `pattern` within `buffer`.
+ * Returns -1 when not found.
+ *
+ * This is optimized for small patterns (1-4 bytes) common in ZIP parsing.
+ */
+export declare function indexOfUint8ArrayPattern(buffer: Uint8Array, pattern: Uint8Array, startIndex?: number): number;

package/dist/{esm/modules/archive/utils → browser/modules/archive/shared}/bytes.js

@@ -1,31 +1,20 @@
-export function sumUint8ArrayLengths(arrays) {
-    let totalLength = 0;
-    for (let i = 0; i < arrays.length; i++) {
-        totalLength += arrays[i].length;
-    }
-    return totalLength;
-}
-export function concatUint8Arrays(arrays) {
-    const len = arrays.length;
-    if (len === 0) {
-        return new Uint8Array(0);
-    }
-    if (len === 1) {
-        return arrays[0];
-    }
-    const totalLength = sumUint8ArrayLengths(arrays);
-    const result = new Uint8Array(totalLength);
-    let offset = 0;
-    for (let i = 0; i < len; i++) {
-        const arr = arrays[i];
-        result.set(arr, offset);
-        offset += arr.length;
-    }
-    return result;
-}
+/**
+ * Archive-specific binary utilities.
+ *
+ * For common utilities (concatUint8Arrays), import directly from @stream/shared.
+ */
+/**
+ * A reusable empty Uint8Array instance.
+ *
+ * Use this constant instead of creating `new Uint8Array(0)` to avoid
+ * allocating new objects for empty byte arrays.
+ */
+export const EMPTY_UINT8ARRAY = new Uint8Array(0);
 /**
  * Find the first index of `pattern` within `buffer`.
  * Returns -1 when not found.
+ *
+ * This is optimized for small patterns (1-4 bytes) common in ZIP parsing.
  */
 export function indexOfUint8ArrayPattern(buffer, pattern, startIndex = 0) {
     const bufLen = buffer.length;

package/dist/browser/modules/archive/shared/defaults.d.ts

@@ -0,0 +1,12 @@
+import type { ZipTimestampMode } from "../zip-spec/timestamps.js";
+export declare const DEFAULT_DEFLATE_LEVEL = 6;
+export declare const DEFAULT_COMPRESS_LEVEL = 6;
+export declare const DEFAULT_ZIP_LEVEL = 6;
+export declare const DEFAULT_ZIP_TIMESTAMPS: ZipTimestampMode;
+/**
+ * Default modification time for reproducible ZIP archives.
+ *
+ * Uses 1980-01-01 00:00:00 (local time), the earliest valid DOS timestamp.
+ * Shared to ensure consistent reproducible output across all ZIP creation paths.
+ */
+export declare const REPRODUCIBLE_ZIP_MOD_TIME: Date;

package/dist/browser/modules/archive/{defaults.js → shared/defaults.js}

@@ -4,3 +4,10 @@ export const DEFAULT_COMPRESS_LEVEL = DEFAULT_DEFLATE_LEVEL;
 export const DEFAULT_ZIP_LEVEL = DEFAULT_DEFLATE_LEVEL;
 // Prefer reproducible output by default: omit the Info-ZIP UTC mtime extra field.
 export const DEFAULT_ZIP_TIMESTAMPS = "dos";
+/**
+ * Default modification time for reproducible ZIP archives.
+ *
+ * Uses 1980-01-01 00:00:00 (local time), the earliest valid DOS timestamp.
+ * Shared to ensure consistent reproducible output across all ZIP creation paths.
+ */
+export const REPRODUCIBLE_ZIP_MOD_TIME = new Date(1980, 0, 1, 0, 0, 0);

package/dist/browser/modules/archive/shared/errors.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Archive module error types.
+ *
+ * All archive-related errors extend ArchiveError.
+ */
+import { BaseError, type BaseErrorOptions } from "../../../utils/errors.js";
+export { AbortError, createAbortError, isAbortError, throwIfAborted, createLinkedAbortController, toError, suppressUnhandledRejection, errorToJSON, getErrorChain, getRootCause, type BaseErrorOptions } from "../../../utils/errors.js";
+/**
+ * Base class for all archive-related errors.
+ */
+export declare class ArchiveError extends BaseError {
+    constructor(message: string, options?: BaseErrorOptions);
+}
+/**
+ * Check if an error is an archive error.
+ */
+export declare function isArchiveError(err: unknown): err is ArchiveError;
+/**
+ * Error thrown when ZIP parsing fails.
+ */
+export declare class ZipParseError extends ArchiveError {
+    name: string;
+}
+/**
+ * Error thrown when an invalid ZIP signature is encountered.
+ */
+export declare class InvalidZipSignatureError extends ZipParseError {
+    name: string;
+    constructor(expected: string, actual: number, context?: string);
+}
+/**
+ * Error thrown when End of Central Directory is not found.
+ */
+export declare class EocdNotFoundError extends ZipParseError {
+    name: string;
+    constructor();
+}
+/**
+ * Error thrown when CRC32 validation fails.
+ */
+export declare class Crc32MismatchError extends ArchiveError {
+    readonly path: string;
+    readonly expected: number;
+    readonly actual: number;
+    name: string;
+    constructor(path: string, expected: number, actual: number);
+}
+/**
+ * Reason for entry size mismatch.
+ * - `too-many-bytes`: ZIP bomb detected - actual size exceeds declared size
+ * - `too-few-bytes`: Corruption detected - actual size is less than declared size
+ */
+export type EntrySizeMismatchReason = "too-many-bytes" | "too-few-bytes";
+/**
+ * Error thrown when the actual decompressed size doesn't match the declared size.
+ * This is a security feature to detect ZIP bombs and corrupted archives.
+ */
+export declare class EntrySizeMismatchError extends ArchiveError {
+    readonly path: string;
+    readonly expected: number;
+    readonly actual: number;
+    readonly reason: EntrySizeMismatchReason;
+    name: string;
+    constructor(path: string, expected: number, actual: number, reason: EntrySizeMismatchReason);
+    /**
+     * Check if this error indicates a potential ZIP bomb (too many bytes).
+     */
+    isZipBomb(): boolean;
+    /**
+     * Check if this error indicates data corruption (too few bytes).
+     */
+    isCorruption(): boolean;
+}
+/**
+ * Error thrown when decryption fails (wrong password or corrupted data).
+ */
+export declare class DecryptionError extends ArchiveError {
+    name: string;
+    constructor(path: string, details?: string);
+}
+/**
+ * Error thrown when a password is required but not provided.
+ */
+export declare class PasswordRequiredError extends ArchiveError {
+    name: string;
+    constructor(path: string);
+}
+/**
+ * Error thrown when the server doesn't support Range requests.
+ */
+export declare class RangeNotSupportedError extends ArchiveError {
+    name: string;
+    constructor(url: string);
+}
+/**
+ * Error thrown when an HTTP request fails.
+ */
+export declare class HttpRangeError extends ArchiveError {
+    readonly url: string;
+    readonly status: number;
+    readonly statusText: string;
+    name: string;
+    constructor(url: string, status: number, statusText: string);
+}
+/**
+ * Error thrown when a file is too large for in-memory extraction.
+ */
+export declare class FileTooLargeError extends ArchiveError {
+    name: string;
+    constructor(path: string, reason: string);
+}
+/**
+ * Error thrown when an unsupported compression method is encountered.
+ */
+export declare class UnsupportedCompressionError extends ArchiveError {
+    name: string;
+    constructor(method: number);
+}