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

package/dist/esm/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/esm/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/esm/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/esm/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/esm/modules/archive/zip/zip-bytes.js

@@ -1,239 +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 { compress, compressSync } from "../compression/compress.js";
-import { crc32 } from "../compression/crc32.js";
-import { DEFAULT_ZIP_LEVEL, DEFAULT_ZIP_TIMESTAMPS } from "../defaults.js";
-import { isProbablyIncompressible } from "../utils/compressibility.js";
-import { encodeUtf8 } from "../utils/text.js";
-import {} from "../utils/timestamps.js";
-import { buildZipEntryMetadata, resolveZipCompressionMethod } from "./zip-entry-metadata.js";
-import { FLAG_UTF8, ZIP_CENTRAL_DIR_HEADER_FIXED_SIZE, ZIP_END_OF_CENTRAL_DIR_FIXED_SIZE, ZIP_LOCAL_FILE_HEADER_FIXED_SIZE, writeCentralDirectoryHeaderInto, writeEndOfCentralDirectoryInto, writeLocalFileHeaderInto } from "../zip-spec/zip-records.js";
-const REPRODUCIBLE_ZIP_MOD_TIME = new Date(1980, 0, 1, 0, 0, 0);
-function encodeZipComment(comment) {
-    // Keep empty comment as empty bytes (no encoding surprises).
-    return comment ? encodeUtf8(comment) : new Uint8Array(0);
-}
-function shouldDeflate(level, data) {
-    return level > 0 && data.length > 0;
-}
-async function compressEntryMaybe(entry, level, compressOptions, smartStore) {
-    if (!shouldDeflate(level, entry.data)) {
-        return { compressedData: entry.data, deflate: false };
-    }
-    if (!smartStore) {
-        const compressed = await compress(entry.data, compressOptions);
-        return { compressedData: compressed, deflate: true };
-    }
-    // Heuristic: skip deflate for high-entropy inputs.
-    if (isProbablyIncompressible(entry.data)) {
-        return { compressedData: entry.data, deflate: false };
-    }
-    const compressed = await compress(entry.data, compressOptions);
-    if (compressed.length >= entry.data.length) {
-        return { compressedData: entry.data, deflate: false };
-    }
-    return { compressedData: compressed, deflate: true };
-}
-function compressEntryMaybeSync(entry, level, compressOptions, smartStore) {
-    if (!shouldDeflate(level, entry.data)) {
-        return { compressedData: entry.data, deflate: false };
-    }
-    if (!smartStore) {
-        const compressed = compressSync(entry.data, compressOptions);
-        return { compressedData: compressed, deflate: true };
-    }
-    if (isProbablyIncompressible(entry.data)) {
-        return { compressedData: entry.data, deflate: false };
-    }
-    const compressed = compressSync(entry.data, compressOptions);
-    if (compressed.length >= entry.data.length) {
-        return { compressedData: entry.data, deflate: false };
-    }
-    return { compressedData: compressed, deflate: true };
-}
-function computeLocalRecordSize(entry) {
-    return (ZIP_LOCAL_FILE_HEADER_FIXED_SIZE +
-        entry.name.length +
-        entry.extraField.length +
-        entry.compressedData.length);
-}
-function computeCentralDirHeaderSize(entry) {
-    return (ZIP_CENTRAL_DIR_HEADER_FIXED_SIZE +
-        entry.name.length +
-        entry.extraField.length +
-        entry.comment.length);
-}
-function buildProcessedEntry(entry, offset, settings, compressedData, deflate) {
-    const modDate = entry.modTime ?? settings.defaultModTime;
-    const metadata = buildZipEntryMetadata({
-        name: entry.name,
-        comment: entry.comment,
-        modTime: modDate,
-        timestamps: settings.timestamps,
-        useDataDescriptor: false,
-        deflate
-    });
-    return {
-        name: metadata.nameBytes,
-        uncompressedSize: entry.data.length,
-        compressedData,
-        crc: crc32(entry.data),
-        compressionMethod: resolveZipCompressionMethod(deflate),
-        modTime: metadata.dosTime,
-        modDate: metadata.dosDate,
-        extraField: metadata.extraField,
-        comment: metadata.commentBytes,
-        offset
-    };
-}
-function appendProcessedEntry(processedEntries, entry, compressedData, deflate, currentOffset, settings) {
-    const processedEntry = buildProcessedEntry(entry, currentOffset, settings, compressedData, deflate);
-    processedEntries.push(processedEntry);
-    return {
-        processedEntry,
-        nextOffset: currentOffset + computeLocalRecordSize(processedEntry)
-    };
-}
-function finalizeZip(processedEntries, zipComment) {
-    // Assemble ZIP into a single buffer to reduce allocations and copying.
-    let localSectionSize = 0;
-    let centralDirSize = 0;
-    for (const entry of processedEntries) {
-        localSectionSize += computeLocalRecordSize(entry);
-        centralDirSize += computeCentralDirHeaderSize(entry);
-    }
-    // The central directory should start immediately after local section.
-    const centralDirOffset = localSectionSize;
-    const totalSize = localSectionSize + centralDirSize + ZIP_END_OF_CENTRAL_DIR_FIXED_SIZE + zipComment.length;
-    const out = new Uint8Array(totalSize);
-    const view = new DataView(out.buffer, out.byteOffset, out.byteLength);
-    let offset = 0;
-    // Local file headers and data
-    for (const entry of processedEntries) {
-        offset += writeLocalFileHeaderInto(out, view, offset, {
-            fileName: entry.name,
-            extraField: entry.extraField,
-            flags: FLAG_UTF8,
-            compressionMethod: entry.compressionMethod,
-            dosTime: entry.modTime,
-            dosDate: entry.modDate,
-            crc32: entry.crc,
-            compressedSize: entry.compressedData.length,
-            uncompressedSize: entry.uncompressedSize
-        });
-        out.set(entry.compressedData, offset);
-        offset += entry.compressedData.length;
-    }
-    // Central directory headers
-    for (const entry of processedEntries) {
-        offset += writeCentralDirectoryHeaderInto(out, view, offset, {
-            fileName: entry.name,
-            extraField: entry.extraField,
-            comment: entry.comment,
-            flags: FLAG_UTF8,
-            compressionMethod: entry.compressionMethod,
-            dosTime: entry.modTime,
-            dosDate: entry.modDate,
-            crc32: entry.crc,
-            compressedSize: entry.compressedData.length,
-            uncompressedSize: entry.uncompressedSize,
-            localHeaderOffset: entry.offset
-        });
-    }
-    // End of central directory
-    writeEndOfCentralDirectoryInto(out, view, offset, {
-        entryCount: processedEntries.length,
-        centralDirSize,
-        centralDirOffset,
-        comment: zipComment
-    });
-    return out;
-}
-/**
- * Create a ZIP file from entries (async)
- */
-export async function createZip(entries, options = {}) {
-    const reproducible = options.reproducible ?? false;
-    const level = options.level ?? DEFAULT_ZIP_LEVEL;
-    const smartStore = options.smartStore ?? true;
-    const concurrency = options.concurrency ?? 4;
-    const timestamps = options.timestamps ?? (reproducible ? "dos" : DEFAULT_ZIP_TIMESTAMPS);
-    const zipComment = encodeZipComment(options.comment);
-    const defaultModTime = options.modTime ?? (reproducible ? REPRODUCIBLE_ZIP_MOD_TIME : new Date());
-    const settings = {
-        level,
-        timestamps,
-        defaultModTime
-    };
-    const thresholdBytes = options.thresholdBytes;
-    const limit = Math.max(1, Math.floor(concurrency));
-    const processedEntries = new Array(entries.length);
-    if (entries.length > 0) {
-        let nextIndex = 0;
-        const workerCount = Math.min(limit, entries.length);
-        const workers = Array.from({ length: workerCount }, async () => {
-            while (true) {
-                const idx = nextIndex++;
-                if (idx >= entries.length) {
-                    return;
-                }
-                const entry = entries[idx];
-                const entryLevel = entry.level ?? level;
-                const compressOptions = {
-                    level: entryLevel,
-                    thresholdBytes
-                };
-                const { compressedData, deflate } = await compressEntryMaybe(entry, entryLevel, compressOptions, smartStore);
-                processedEntries[idx] = buildProcessedEntry(entry, 0, settings, compressedData, deflate);
-            }
-        });
-        await Promise.all(workers);
-    }
-    // Compute offsets in original order.
-    let currentOffset = 0;
-    for (let i = 0; i < processedEntries.length; i++) {
-        const processedEntry = processedEntries[i];
-        processedEntry.offset = currentOffset;
-        currentOffset += computeLocalRecordSize(processedEntry);
-    }
-    return finalizeZip(processedEntries, zipComment);
-}
-/**
- * Create a ZIP file from entries (sync)
- *
- * This is supported in both Node.js and browser builds.
- */
-export function createZipSync(entries, options = {}) {
-    const reproducible = options.reproducible ?? false;
-    const level = options.level ?? DEFAULT_ZIP_LEVEL;
-    const smartStore = options.smartStore ?? true;
-    const timestamps = options.timestamps ?? (reproducible ? "dos" : DEFAULT_ZIP_TIMESTAMPS);
-    const zipComment = encodeZipComment(options.comment);
-    const defaultModTime = options.modTime ?? (reproducible ? REPRODUCIBLE_ZIP_MOD_TIME : new Date());
-    const settings = {
-        level,
-        timestamps,
-        defaultModTime
-    };
-    const thresholdBytes = options.thresholdBytes;
-    const processedEntries = [];
-    let currentOffset = 0;
-    for (const entry of entries) {
-        const entryLevel = entry.level ?? level;
-        const compressOptions = {
-            level: entryLevel,
-            thresholdBytes
-        };
-        const { compressedData, deflate } = compressEntryMaybeSync(entry, entryLevel, compressOptions, smartStore);
-        const result = appendProcessedEntry(processedEntries, entry, compressedData, deflate, currentOffset, settings);
-        currentOffset = result.nextOffset;
-    }
-    return finalizeZip(processedEntries, zipComment);
-}