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

package/dist/browser/modules/archive/utils/async-queue.d.ts

@@ -1,7 +0,0 @@
-export type AsyncQueue<T> = {
-    push: (value: T) => void;
-    fail: (err: Error) => void;
-    close: () => void;
-    iterable: AsyncIterable<T>;
-};
-export declare function createAsyncQueue<T>(): AsyncQueue<T>;

package/dist/browser/modules/archive/utils/async-queue.js

@@ -1,103 +0,0 @@
-export function createAsyncQueue() {
-    const values = [];
-    let valuesHead = 0;
-    const waiters = [];
-    let waitersHead = 0;
-    let done = false;
-    let error = null;
-    const maybeCompact = () => {
-        // Prevent unbounded growth of the underlying arrays.
-        if (valuesHead > 1024 && valuesHead * 2 > values.length) {
-            values.splice(0, valuesHead);
-            valuesHead = 0;
-        }
-        if (waitersHead > 1024 && waitersHead * 2 > waiters.length) {
-            waiters.splice(0, waitersHead);
-            waitersHead = 0;
-        }
-    };
-    const shiftWaiter = () => {
-        while (waitersHead < waiters.length) {
-            const w = waiters[waitersHead];
-            waiters[waitersHead] = undefined;
-            waitersHead++;
-            if (w) {
-                maybeCompact();
-                return w;
-            }
-        }
-        maybeCompact();
-        return undefined;
-    };
-    const shiftValue = () => {
-        while (valuesHead < values.length) {
-            const v = values[valuesHead];
-            values[valuesHead] = undefined;
-            valuesHead++;
-            if (v !== undefined) {
-                maybeCompact();
-                return v;
-            }
-        }
-        maybeCompact();
-        return undefined;
-    };
-    const push = (value) => {
-        if (done || error) {
-            return;
-        }
-        const waiter = shiftWaiter();
-        if (waiter) {
-            waiter.resolve({ value, done: false });
-        }
-        else {
-            values.push(value);
-        }
-    };
-    const fail = (err) => {
-        if (done || error) {
-            return;
-        }
-        error = err;
-        while (true) {
-            const waiter = shiftWaiter();
-            if (!waiter) {
-                break;
-            }
-            waiter.reject(err);
-        }
-    };
-    const close = () => {
-        if (done || error) {
-            return;
-        }
-        done = true;
-        while (true) {
-            const waiter = shiftWaiter();
-            if (!waiter) {
-                break;
-            }
-            waiter.resolve({ value: undefined, done: true });
-        }
-    };
-    const iterable = {
-        [Symbol.asyncIterator]() {
-            return {
-                next() {
-                    if (error) {
-                        return Promise.reject(error);
-                    }
-                    const value = shiftValue();
-                    if (value !== undefined) {
-                        return Promise.resolve({ value, done: false });
-                    }
-                    if (done) {
-                        return Promise.resolve({ value: undefined, done: true });
-                    }
-                    return new Promise((resolve, reject) => waiters.push({ resolve, reject }));
-                }
-            };
-        }
-    };
-    return { push, fail, close, iterable };
-}

package/dist/browser/modules/archive/utils/compressibility.d.ts

@@ -1,10 +0,0 @@
-/**
- * Heuristic: detect incompressible (high-entropy) data.
- *
- * This is a performance optimization: if data looks random, DEFLATE usually
- * wastes CPU and may even produce slightly larger output.
- */
-export declare function isProbablyIncompressible(data: Uint8Array, options?: {
-    sampleBytes?: number;
-    minDecisionBytes?: number;
-}): boolean;

package/dist/browser/modules/archive/utils/compressibility.js

@@ -1,57 +0,0 @@
-const DEFAULT_SAMPLE_BYTES = 64 * 1024;
-const MIN_DECISION_BYTES = 16 * 1024;
-function log2(x) {
-    return Math.log(x) / Math.LN2;
-}
-function shannonEntropy(bytes) {
-    const counts = new Uint32Array(256);
-    for (let i = 0; i < bytes.length; i++) {
-        counts[bytes[i]] += 1;
-    }
-    let entropy = 0;
-    const total = bytes.length;
-    for (let i = 0; i < 256; i++) {
-        const count = counts[i];
-        if (count === 0) {
-            continue;
-        }
-        const p = count / total;
-        entropy -= p * log2(p);
-    }
-    return entropy;
-}
-/**
- * Heuristic: detect incompressible (high-entropy) data.
- *
- * This is a performance optimization: if data looks random, DEFLATE usually
- * wastes CPU and may even produce slightly larger output.
- */
-export function isProbablyIncompressible(data, options = {}) {
-    const sampleBytes = options.sampleBytes ?? DEFAULT_SAMPLE_BYTES;
-    const minDecisionBytes = options.minDecisionBytes ?? MIN_DECISION_BYTES;
-    const len = Math.min(data.length, sampleBytes);
-    if (len < minDecisionBytes) {
-        return false;
-    }
-    const sample = data.subarray(0, len);
-    // Fast-ish early filter: if there are too few unique bytes, it's probably compressible.
-    // (e.g. text, repeated patterns)
-    const seen = new Uint8Array(256);
-    let unique = 0;
-    for (let i = 0; i < sample.length; i++) {
-        const b = sample[i];
-        if (seen[b] === 0) {
-            seen[b] = 1;
-            unique += 1;
-            if (unique >= 200) {
-                break;
-            }
-        }
-    }
-    if (unique < 200) {
-        return false;
-    }
-    // Shannon entropy in bits/byte; random tends to ~8.
-    // Threshold picked to be conservative.
-    return shannonEntropy(sample) >= 7.95;
-}

package/dist/browser/modules/archive/utils/pattern-scanner.d.ts

@@ -1,21 +0,0 @@
-export interface PatternSearchTarget {
-    indexOfPattern(pattern: Uint8Array, startIndex: number): number;
-}
-/**
- * Stateful helper for incremental pattern scanning in growing buffers.
- *
- * The scanner tracks a `searchFrom` cursor and an `overlap` region so callers
- * can avoid rescanning bytes that cannot start a match.
- */
-export declare class PatternScanner {
-    readonly pattern: Uint8Array;
-    readonly overlap: number;
-    searchFrom: number;
-    constructor(pattern: Uint8Array);
-    /** Find the next match index starting at the current `searchFrom`. */
-    find(target: PatternSearchTarget): number;
-    /** Update `searchFrom` after consuming `consumed` bytes from the front. */
-    onConsume(consumed: number): void;
-    /** Update `searchFrom` after a no-match scan on a buffer of length `bufferLength`. */
-    onNoMatch(bufferLength: number): void;
-}

package/dist/browser/modules/archive/utils/pattern-scanner.js

@@ -1,27 +0,0 @@
-/**
- * Stateful helper for incremental pattern scanning in growing buffers.
- *
- * The scanner tracks a `searchFrom` cursor and an `overlap` region so callers
- * can avoid rescanning bytes that cannot start a match.
- */
-export class PatternScanner {
-    constructor(pattern) {
-        this.searchFrom = 0;
-        this.pattern = pattern;
-        this.overlap = Math.max(0, pattern.length - 1);
-    }
-    /** Find the next match index starting at the current `searchFrom`. */
-    find(target) {
-        return target.indexOfPattern(this.pattern, this.searchFrom);
-    }
-    /** Update `searchFrom` after consuming `consumed` bytes from the front. */
-    onConsume(consumed) {
-        if (consumed > 0) {
-            this.searchFrom = Math.max(0, this.searchFrom - consumed);
-        }
-    }
-    /** Update `searchFrom` after a no-match scan on a buffer of length `bufferLength`. */
-    onNoMatch(bufferLength) {
-        this.searchFrom = Math.max(this.searchFrom, Math.max(0, bufferLength - this.overlap));
-    }
-}

package/dist/browser/modules/archive/zip/index.d.ts

@@ -1,42 +0,0 @@
-import type { ZipTimestampMode } from "@archive/utils/timestamps";
-import { type ArchiveSink } from "@archive/io/archive-sink";
-import { type ArchiveSource } from "@archive/io/archive-source";
-export interface ZipOptions {
-    level?: number;
-    timestamps?: ZipTimestampMode;
-    comment?: string;
-    /**
-     * Default modification time for entries that don't specify `modTime`.
-     *
-     * If you need stable output across runs, either pass this explicitly or use `reproducible: true`.
-     */
-    modTime?: Date;
-    /**
-     * If true, bias defaults toward reproducible output:
-     * - default `modTime` becomes 1980-01-01 00:00:00 (local time)
-     * - default `timestamps` becomes "dos" (no UTC extra field)
-     */
-    reproducible?: boolean;
-    /**
-     * If true (default), automatically STORE incompressible data.
-     * If false, always follow `level` (DEFLATE when level > 0).
-     */
-    smartStore?: boolean;
-}
-export interface ZipEntryOptions {
-    level?: number;
-    modTime?: Date;
-    comment?: string;
-}
-export declare class ZipArchive {
-    private readonly _options;
-    private readonly _entries;
-    private _sealed;
-    constructor(options?: ZipOptions);
-    add(name: string, source: ArchiveSource, options?: ZipEntryOptions): this;
-    stream(): AsyncIterable<Uint8Array>;
-    bytes(): Promise<Uint8Array>;
-    bytesSync(): Uint8Array;
-    pipeTo(sink: ArchiveSink): Promise<void>;
-}
-export declare function zip(options?: ZipOptions): ZipArchive;

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

@@ -1,157 +0,0 @@
-import { DEFAULT_ZIP_LEVEL, DEFAULT_ZIP_TIMESTAMPS } from "../defaults.js";
-import { ZipDeflateFile, StreamingZip } from "./stream.js";
-import { createZip, createZipSync } from "./zip-bytes.js";
-import { collect, pipeIterableToSink } from "../io/archive-sink.js";
-import { toAsyncIterable, toUint8Array, toUint8ArraySync } from "../io/archive-source.js";
-import { createAsyncQueue } from "../utils/async-queue.js";
-const REPRODUCIBLE_ZIP_MOD_TIME = new Date(1980, 0, 1, 0, 0, 0);
-export class ZipArchive {
-    constructor(options = {}) {
-        this._entries = [];
-        this._sealed = false;
-        const reproducible = options.reproducible ?? false;
-        this._options = {
-            level: options.level ?? DEFAULT_ZIP_LEVEL,
-            timestamps: options.timestamps ?? (reproducible ? "dos" : DEFAULT_ZIP_TIMESTAMPS),
-            comment: options.comment,
-            modTime: options.modTime ?? (reproducible ? REPRODUCIBLE_ZIP_MOD_TIME : new Date()),
-            smartStore: options.smartStore ?? true
-        };
-    }
-    add(name, source, options) {
-        if (this._sealed) {
-            throw new Error("Cannot add entries after output has started");
-        }
-        if (!name) {
-            throw new Error("Entry name is required");
-        }
-        this._entries.push({ name, source, options });
-        return this;
-    }
-    stream() {
-        this._sealed = true;
-        const queue = createAsyncQueue();
-        const zip = new StreamingZip((err, data, final) => {
-            if (err) {
-                queue.fail(err);
-                return;
-            }
-            if (data.length) {
-                queue.push(data);
-            }
-            if (final) {
-                queue.close();
-            }
-        }, { comment: this._options.comment });
-        (async () => {
-            try {
-                for (const entry of this._entries) {
-                    const level = entry.options?.level ?? this._options.level;
-                    const file = new ZipDeflateFile(entry.name, {
-                        level,
-                        modTime: entry.options?.modTime ?? this._options.modTime,
-                        timestamps: this._options.timestamps,
-                        comment: entry.options?.comment,
-                        smartStore: this._options.smartStore
-                    });
-                    zip.add(file);
-                    // Feed data
-                    if (entry.source instanceof Uint8Array ||
-                        entry.source instanceof ArrayBuffer ||
-                        typeof entry.source === "string" ||
-                        (typeof Blob !== "undefined" && entry.source instanceof Blob)) {
-                        const bytes = await toUint8Array(entry.source);
-                        await file.push(bytes, true);
-                    }
-                    else {
-                        for await (const chunk of toAsyncIterable(entry.source)) {
-                            await file.push(chunk, false);
-                        }
-                        await file.push(new Uint8Array(0), true);
-                    }
-                    await file.complete();
-                }
-                zip.end();
-            }
-            catch (e) {
-                queue.fail(e instanceof Error ? e : new Error(String(e)));
-            }
-        })();
-        return queue.iterable;
-    }
-    async bytes() {
-        this._sealed = true;
-        const allSourcesInMemory = this._entries.every(e => e.source instanceof Uint8Array ||
-            e.source instanceof ArrayBuffer ||
-            typeof e.source === "string" ||
-            (typeof Blob !== "undefined" && e.source instanceof Blob));
-        const hasBlobSource = this._entries.some(e => typeof Blob !== "undefined" && e.source instanceof Blob);
-        // Fast-path: when all sources are already in memory and there are no
-        // per-entry compression overrides, use the single-buffer ZIP builder.
-        // This avoids the overhead of chunking + collecting from the streaming writer.
-        if (allSourcesInMemory) {
-            // Prefer the sync builder when possible (Node.js hot path): it avoids
-            // async/Promise overhead and uses zlib sync fast paths.
-            if (!hasBlobSource) {
-                const entries = this._entries.map(e => ({
-                    name: e.name,
-                    data: toUint8ArraySync(e.source),
-                    level: e.options?.level,
-                    modTime: e.options?.modTime,
-                    comment: e.options?.comment
-                }));
-                return createZipSync(entries, {
-                    level: this._options.level,
-                    timestamps: this._options.timestamps,
-                    modTime: this._options.modTime,
-                    comment: this._options.comment,
-                    smartStore: this._options.smartStore
-                });
-            }
-            const entries = await Promise.all(this._entries.map(async (e) => ({
-                name: e.name,
-                data: await toUint8Array(e.source),
-                level: e.options?.level,
-                modTime: e.options?.modTime,
-                comment: e.options?.comment
-            })));
-            return createZip(entries, {
-                level: this._options.level,
-                timestamps: this._options.timestamps,
-                modTime: this._options.modTime,
-                comment: this._options.comment,
-                smartStore: this._options.smartStore
-            });
-        }
-        return collect(this.stream());
-    }
-    bytesSync() {
-        this._sealed = true;
-        const entries = this._entries.map(e => {
-            if (!(e.source instanceof Uint8Array) &&
-                !(e.source instanceof ArrayBuffer) &&
-                typeof e.source !== "string") {
-                throw new Error("bytesSync() only supports Uint8Array/ArrayBuffer/string sources");
-            }
-            return {
-                name: e.name,
-                data: toUint8ArraySync(e.source),
-                modTime: e.options?.modTime,
-                comment: e.options?.comment
-            };
-        });
-        return createZipSync(entries, {
-            level: this._options.level,
-            timestamps: this._options.timestamps,
-            modTime: this._options.modTime,
-            comment: this._options.comment,
-            smartStore: this._options.smartStore
-        });
-    }
-    async pipeTo(sink) {
-        await pipeIterableToSink(this.stream(), sink);
-    }
-}
-export function zip(options) {
-    return new ZipArchive(options);
-}

package/dist/browser/modules/archive/zip/zip-bytes.d.ts

@@ -1,73 +0,0 @@
-/**
- * ZIP file format encoder (single-buffer output)
- *
- * Implements ZIP file structure according to PKWARE's APPNOTE.TXT specification
- * https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT
- *
- * This module focuses on producing a complete ZIP as a single Uint8Array.
- * For true streaming (push chunks while reading sources), use `zip()` / `ZipArchive.stream()`.
- */
-import { type CompressOptions } from "@archive/compression/compress";
-import { type ZipTimestampMode } from "@archive/utils/timestamps";
-/**
- * ZIP file entry
- */
-export interface ZipEntry {
-    /** File name (can include directory path, use forward slashes) */
-    name: string;
-    /** File data (will be compressed unless level=0) */
-    data: Uint8Array;
-    /** Optional per-entry compression level override */
-    level?: number;
-    /** File modification time (optional, defaults to current time) */
-    modTime?: Date;
-    /** File comment (optional) */
-    comment?: string;
-}
-/**
- * ZIP encoder options
- */
-export interface ZipOptions extends CompressOptions {
-    /** ZIP file comment (optional) */
-    comment?: string;
-    /**
-     * Default modification time for entries that don't specify `modTime`.
-     *
-     * If you need stable output across runs, either pass this explicitly or use `reproducible: true`.
-     */
-    modTime?: Date;
-    /**
-     * If true, bias defaults toward reproducible output:
-     * - default `modTime` becomes 1980-01-01 00:00:00 (local time)
-     * - default `timestamps` becomes "dos" (no UTC extra field)
-     */
-    reproducible?: boolean;
-    /**
-     * Max number of entries to compress concurrently in `createZip()`.
-     * This helps avoid zlib threadpool saturation / memory spikes with many files.
-     *
-     * Defaults to 4.
-     */
-    concurrency?: number;
-    /**
-     * If true (default), automatically STORE incompressible data.
-     * If false, always follow `level` (DEFLATE when level > 0).
-     */
-    smartStore?: boolean;
-    /**
-     * Timestamp writing strategy.
-     * - "dos": only write DOS date/time fields (smallest output)
-     * - "dos+utc": also write UTC mtime in 0x5455 extra field
-     */
-    timestamps?: ZipTimestampMode;
-}
-/**
- * Create a ZIP file from entries (async)
- */
-export declare function createZip(entries: ZipEntry[], options?: ZipOptions): Promise<Uint8Array>;
-/**
- * Create a ZIP file from entries (sync)
- *
- * This is supported in both Node.js and browser builds.
- */
-export declare function createZipSync(entries: ZipEntry[], options?: ZipOptions): Uint8Array;