@cj-tech-master/excelts 3.1.0-canary.20260102041828.82ed571 → 3.1.0

package/dist/esm/modules/stream/types.js

@@ -1,7 +0,0 @@
-/**
- * Stream Module - Shared Types
- *
- * Common type definitions for stream operations across Node.js and Browser.
- * These types provide a unified interface regardless of the underlying implementation.
- */
-export {};

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

@@ -1,85 +0,0 @@
-/**
- * Stream Utilities
- *
- * Small, cross-platform helpers built on top of the platform stream
- * implementation selected by `./streams` (Node.js or browser).
- */
-import { createReadableFromArray, createTransform } from "@stream/streams";
-import { stringToUint8Array as _stringToUint8Array, uint8ArrayToString as _uint8ArrayToString } from "@stream/shared";
-// =============================================================================
-// High-Level Stream Consumers
-// =============================================================================
-export async function collect(stream) {
-    const result = [];
-    for await (const chunk of stream) {
-        result.push(chunk);
-    }
-    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);
-}
-export async function json(stream) {
-    const str = await text(stream);
-    return JSON.parse(str);
-}
-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;
-}
-// =============================================================================
-// Stream Factory Helpers
-// =============================================================================
-export function fromString(str) {
-    return createReadableFromArray([_stringToUint8Array(str)], {
-        objectMode: false
-    });
-}
-export function fromJSON(data) {
-    return fromString(JSON.stringify(data));
-}
-export function fromBytes(data) {
-    return createReadableFromArray([data], { objectMode: false });
-}
-export function transform(fn) {
-    return createTransform(fn);
-}
-export function filter(predicate) {
-    return createTransform(async (chunk) => {
-        if (await predicate(chunk)) {
-            return chunk;
-        }
-        return undefined;
-    }, { objectMode: true });
-}

package/dist/esm/utils/browser.js

@@ -1,49 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-/**
- * Prefer sibling `.browser.*` implementation when it exists.
- *
- * Example:
- * - resolved: `/abs/path/to/streams.ts`
- * - if `/abs/path/to/streams.browser.ts` exists => use it
- */
-export function preferBrowserFilesPlugin() {
-    return {
-        name: "excelts-prefer-browser-files",
-        enforce: "pre",
-        async resolveId(source, importer) {
-            if (source.startsWith("\0") || source.startsWith("virtual:") || source.startsWith("node:")) {
-                return null;
-            }
-            const resolved = await this.resolve(source, importer, {
-                skipSelf: true
-            });
-            if (!resolved) {
-                return null;
-            }
-            if (typeof resolved === "object" && resolved.external) {
-                return resolved;
-            }
-            const resolvedId = typeof resolved === "string" ? resolved : resolved.id;
-            if (typeof resolvedId !== "string") {
-                return resolved;
-            }
-            const cleanId = resolvedId.split("?")[0].split("#")[0];
-            if (!path.isAbsolute(cleanId)) {
-                return resolved;
-            }
-            if (cleanId.includes(".browser.")) {
-                return resolved;
-            }
-            const ext = path.extname(cleanId);
-            if (!ext || cleanId.endsWith(".d.ts")) {
-                return resolved;
-            }
-            const candidate = cleanId.slice(0, -ext.length) + ".browser" + ext;
-            if (fs.existsSync(candidate)) {
-                return candidate;
-            }
-            return resolved;
-        }
-    };
-}

package/dist/esm/utils/env.js

@@ -1,18 +0,0 @@
-/**
- * Environment detection utilities
- * Common functions to detect runtime environment (Node.js vs Browser)
- */
-/**
- * Check if running in Node.js environment
- * Returns true if process.versions.node exists
- */
-export function isNode() {
-    return typeof process !== "undefined" && !!process.versions?.node;
-}
-/**
- * Check if running in browser environment
- * Returns true if window and document are defined
- */
-export function isBrowser() {
-    return typeof window !== "undefined" && typeof document !== "undefined";
-}

package/dist/esm/utils/uuid.js

@@ -1,55 +0,0 @@
-function toHex(byte) {
-    return byte.toString(16).padStart(2, "0");
-}
-function bytesToUuidV4(bytes) {
-    // RFC 4122, version 4 UUID
-    // Set version (4) and variant (10xx)
-    bytes[6] = (bytes[6] & 0x0f) | 0x40;
-    bytes[8] = (bytes[8] & 0x3f) | 0x80;
-    const b = bytes;
-    return (toHex(b[0]) +
-        toHex(b[1]) +
-        toHex(b[2]) +
-        toHex(b[3]) +
-        "-" +
-        toHex(b[4]) +
-        toHex(b[5]) +
-        "-" +
-        toHex(b[6]) +
-        toHex(b[7]) +
-        "-" +
-        toHex(b[8]) +
-        toHex(b[9]) +
-        "-" +
-        toHex(b[10]) +
-        toHex(b[11]) +
-        toHex(b[12]) +
-        toHex(b[13]) +
-        toHex(b[14]) +
-        toHex(b[15]));
-}
-/**
- * Generate a UUID v4.
- *
- * This exists to avoid a hard dependency on `crypto.randomUUID()` so that
- * older supported browsers can still generate UUIDs.
- *
- * - Prefers `crypto.randomUUID()` when available.
- * - Falls back to `crypto.getRandomValues()`.
- * - Last-resort fallback uses `Math.random()` (NOT cryptographically secure).
- */
-export function uuidV4() {
-    const cryptoObj = globalThis.crypto;
-    if (cryptoObj?.randomUUID) {
-        return cryptoObj.randomUUID();
-    }
-    const bytes = new Uint8Array(16);
-    if (cryptoObj?.getRandomValues) {
-        cryptoObj.getRandomValues(bytes);
-        return bytesToUuidV4(bytes);
-    }
-    for (let i = 0; i < bytes.length; i++) {
-        bytes[i] = Math.floor(Math.random() * 256);
-    }
-    return bytesToUuidV4(bytes);
-}

package/dist/types/modules/archive/byte-queue.d.ts

@@ -1,18 +0,0 @@
-export declare class ByteQueue {
-    private static readonly EMPTY;
-    private _buf;
-    private _start;
-    private _end;
-    private _cachedView;
-    private _cachedBuf;
-    private _cachedStart;
-    private _cachedEnd;
-    constructor(initial?: Uint8Array);
-    get length(): number;
-    isEmpty(): boolean;
-    view(): Uint8Array;
-    reset(data?: Uint8Array): void;
-    append(chunk: Uint8Array): void;
-    read(length: number): Uint8Array;
-    discard(length: number): void;
-}

package/dist/types/modules/archive/compress.base.d.ts

@@ -1,98 +0,0 @@
-/**
- * Base compression utilities using Web Streams API
- * Shared between Node.js and Browser implementations
- *
- * Uses CompressionStream/DecompressionStream API with "deflate-raw" format
- * (raw DEFLATE without zlib header/trailer, required for ZIP files)
- *
- * Browser fallback: For browsers without deflate-raw support (Firefox < 113, Safari < 16.4),
- * see deflate-fallback.ts for pure JS implementation
- */
-/**
- * Compression options
- */
-export interface CompressOptions {
-    /**
-     * Compression level (0-9)
-     * - 0: No compression (STORE)
-     * - 1: Fastest compression
-     * - 6: Default compression (good balance)
-     * - 9: Best compression (slowest)
-     *
-     * Note: CompressionStream does not support level configuration,
-     * it uses a fixed level (~6)
-     */
-    level?: number;
-    /**
-     * Threshold (in bytes) to choose the lower-overhead path.
-     *
-     * - Node.js: inputs <= threshold use sync zlib fast-path (avoid threadpool overhead)
-     * - Browser: inputs <= threshold use the pure-JS fallback (avoid stream scheduling overhead)
-     */
-    thresholdBytes?: number;
-}
-/**
- * Default threshold (in bytes) to choose the lower-overhead path.
- *
- * This is a performance knob, not a correctness requirement.
- */
-export declare const DEFAULT_COMPRESS_THRESHOLD_BYTES: number;
-/**
- * Resolve the effective threshold bytes.
- */
-export declare function resolveCompressThresholdBytes(options: CompressOptions): number;
-/**
- * Check if CompressionStream is available
- */
-export declare function hasCompressionStream(): boolean;
-/**
- * Non-cached probe for CompressionStream("deflate-raw") support.
- *
- * Prefer this in code paths that want up-to-date environment checks
- * (e.g. tests that stub globals).
- */
-export declare function probeDeflateRawCompressionStream(): boolean;
-/**
- * Non-cached probe for DecompressionStream("deflate-raw") support.
- */
-export declare function probeDeflateRawDecompressionStream(): boolean;
-/**
- * Non-cached probe for full deflate-raw Web Streams support.
- *
- * Returns true only if BOTH CompressionStream("deflate-raw") and
- * DecompressionStream("deflate-raw") are supported.
- */
-export declare function probeDeflateRawWebStreams(): boolean;
-/**
- * Check if CompressionStream supports the "deflate-raw" format.
- *
- * This is a stricter check than {@link hasCompressionStream} because some
- * environments expose CompressionStream but do not support "deflate-raw".
- */
-export declare function hasDeflateRawCompressionStream(): boolean;
-/**
- * Check if DecompressionStream supports the "deflate-raw" format.
- */
-export declare function hasDeflateRawDecompressionStream(): boolean;
-/**
- * Cached check for full deflate-raw Web Streams support.
- *
- * Returns true only if BOTH CompressionStream("deflate-raw") and
- * DecompressionStream("deflate-raw") are supported.
- */
-export declare function hasDeflateRawWebStreams(): boolean;
-/**
- * Compress using CompressionStream API
- * Uses "deflate-raw" format (required for ZIP files)
- *
- * @param data - Data to compress
- * @returns Compressed data
- */
-export declare function compressWithStream(data: Uint8Array): Promise<Uint8Array>;
-/**
- * Decompress using DecompressionStream API
- *
- * @param data - Compressed data (deflate-raw format)
- * @returns Decompressed data
- */
-export declare function decompressWithStream(data: Uint8Array): Promise<Uint8Array>;

package/dist/types/modules/archive/compress.browser.d.ts

@@ -1,57 +0,0 @@
-/**
- * Browser compression utilities
- *
- * Primary: CompressionStream API (Chrome 103+, Firefox 113+, Safari 16.4+)
- * Fallback: Pure JS DEFLATE implementation for older browsers
- *
- * Supported browsers with fallback:
- * - Chrome >= 89
- * - Firefox >= 102
- * - Safari >= 14.1
- * - Edge >= 89
- */
-import { type CompressOptions } from "@archive/compress.base";
-export { type CompressOptions };
-/**
- * Check if CompressionStream is available in this environment.
- *
- * Note: Some environments may expose CompressionStream but not support
- * the "deflate-raw" format that ZIP requires.
- */
-export declare function hasCompressionStream(): boolean;
-/**
- * Compress data using browser's native CompressionStream or JS fallback
- *
- * @param data - Data to compress
- * @param options - Compression options
- * @returns Compressed data
- *
- * @example
- * ```ts
- * const data = new TextEncoder().encode("Hello, World!");
- * const compressed = await compress(data, { level: 6 });
- * ```
- */
-export declare function compress(data: Uint8Array, options?: CompressOptions): Promise<Uint8Array>;
-/**
- * Compress data synchronously using pure JS implementation
- *
- * @param data - Data to compress
- * @param options - Compression options
- * @returns Compressed data
- */
-export declare function compressSync(data: Uint8Array, options?: CompressOptions): Uint8Array;
-/**
- * Decompress data using browser's native DecompressionStream or JS fallback
- *
- * @param data - Compressed data (deflate-raw format)
- * @returns Decompressed data
- */
-export declare function decompress(data: Uint8Array, options?: CompressOptions): Promise<Uint8Array>;
-/**
- * Decompress data synchronously using pure JS implementation
- *
- * @param data - Compressed data (deflate-raw format)
- * @returns Decompressed data
- */
-export declare function decompressSync(data: Uint8Array): Uint8Array;

package/dist/types/modules/archive/compress.d.ts

@@ -1,44 +0,0 @@
-/**
- * Node.js compression utilities using native zlib
- *
- * Uses zlib module (C++ implementation, fastest) with "deflate-raw" format
- * (raw DEFLATE without zlib header/trailer, required for ZIP files)
- */
-export { type CompressOptions, hasCompressionStream } from "@archive/compress.base";
-import type { CompressOptions } from "@archive/compress.base";
-/**
- * Compress data using Node.js native zlib
- *
- * @param data - Data to compress
- * @param options - Compression options
- * @returns Compressed data
- *
- * @example
- * ```ts
- * const data = new TextEncoder().encode("Hello, World!");
- * const compressed = await compress(data, { level: 6 });
- * ```
- */
-export declare function compress(data: Uint8Array, options?: CompressOptions): Promise<Uint8Array>;
-/**
- * Compress data synchronously using Node.js zlib
- *
- * @param data - Data to compress
- * @param options - Compression options
- * @returns Compressed data
- */
-export declare function compressSync(data: Uint8Array, options?: CompressOptions): Uint8Array;
-/**
- * Decompress data using Node.js native zlib
- *
- * @param data - Compressed data (deflate-raw format)
- * @returns Decompressed data
- */
-export declare function decompress(data: Uint8Array, options?: CompressOptions): Promise<Uint8Array>;
-/**
- * Decompress data synchronously using Node.js zlib
- *
- * @param data - Compressed data (deflate-raw format)
- * @returns Decompressed data
- */
-export declare function decompressSync(data: Uint8Array): Uint8Array;

package/dist/types/modules/archive/crc32.base.d.ts

@@ -1,25 +0,0 @@
-/**
- * CRC32 calculation core (shared between Node.js and browser).
- *
- * Implements CRC-32 IEEE 802.3 using the reversed polynomial 0xEDB88320.
- *
- * Notes:
- * - Uses a lazily-initialized 256-entry lookup table.
- * - Exposes an incremental update API for streaming use cases.
- */
-/**
- * Update a CRC32 value with a new data chunk.
- *
- * The CRC state here is the non-finalized (inverted) form:
- * - initial state: 0xffffffff
- * - finalize: xor with 0xffffffff
- */
-export declare function crc32UpdateJS(crc: number, data: Uint8Array): number;
-/**
- * Finalize CRC32 calculation.
- */
-export declare function crc32Finalize(crc: number): number;
-/**
- * Compute CRC32 for the full input using the JS table implementation.
- */
-export declare function crc32JS(data: Uint8Array): number;

package/dist/types/modules/archive/crc32.browser.d.ts

@@ -1,30 +0,0 @@
-/**
- * CRC32 calculation utility for ZIP files (Browser version)
- *
- * Uses lookup table optimization - no Node.js dependencies
- *
- * The polynomial used is the standard CRC-32 IEEE 802.3:
- * x^32 + x^26 + x^23 + x^22 + x^16 + x^12 + x^11 + x^10 + x^8 + x^7 + x^5 + x^4 + x^2 + x + 1
- * Represented as 0xEDB88320 in reversed (LSB-first) form
- */
-export { crc32JS as crc32, crc32UpdateJS as crc32Update, crc32Finalize } from "@archive/crc32.base";
-/**
- * Ensure CRC32 is ready (no-op in browser, for API compatibility)
- */
-export declare function ensureCrc32(): Promise<void>;
-/**
- * Calculate CRC32 incrementally (useful for streaming)
- * Call with initial crc of 0xffffffff, then finalize with crc32Finalize
- *
- * @param crc - Current CRC value (start with 0xffffffff)
- * @param data - Input data chunk
- * @returns Updated CRC value (not finalized)
- *
- * @example
- * ```ts
- * let crc = 0xffffffff;
- * crc = crc32Update(crc, chunk1);
- * crc = crc32Update(crc, chunk2);
- * const checksum = crc32Finalize(crc);
- * ```
- */

package/dist/types/modules/archive/crc32.d.ts

@@ -1,59 +0,0 @@
-/**
- * CRC32 calculation utility for ZIP files
- *
- * - Node.js: Uses native zlib.crc32 (C++ implementation, ~100x faster)
- * - Browser: Uses lookup table optimization
- *
- * The polynomial used is the standard CRC-32 IEEE 802.3:
- * x^32 + x^26 + x^23 + x^22 + x^16 + x^12 + x^11 + x^10 + x^8 + x^7 + x^5 + x^4 + x^2 + x + 1
- * Represented as 0xEDB88320 in reversed (LSB-first) form
- */
-import { crc32Finalize } from "@archive/crc32.base";
-/**
- * Calculate CRC32 checksum for the given data
- * Uses native zlib.crc32 in Node.js for ~100x better performance
- *
- * @param data - Input data as Uint8Array or Buffer
- * @returns CRC32 checksum as unsigned 32-bit integer
- *
- * @example
- * ```ts
- * const data = new TextEncoder().encode("Hello, World!");
- * const checksum = crc32(data);
- * console.log(checksum.toString(16)); // "ec4ac3d0"
- * ```
- */
-export declare function crc32(data: Uint8Array): number;
-/**
- * Ensure zlib is loaded (for use before calling crc32)
- */
-export declare function ensureCrc32(): Promise<void>;
-/**
- * Calculate CRC32 incrementally (useful for streaming)
- * Call with initial crc of 0xffffffff, then finalize with crc32Finalize
- * In Node.js, this uses native zlib.crc32 when available for performance.
- * The internal CRC state remains the same as the JS table implementation:
- * - initial state: 0xffffffff
- * - finalize: xor with 0xffffffff
- *
- * @param crc - Current CRC value (start with 0xffffffff)
- * @param data - Input data chunk
- * @returns Updated CRC value (not finalized)
- *
- * @example
- * ```ts
- * let crc = 0xffffffff;
- * crc = crc32Update(crc, chunk1);
- * crc = crc32Update(crc, chunk2);
- * const checksum = crc32Finalize(crc);
- * ```
- */
-export declare function crc32Update(crc: number, data: Uint8Array): number;
-/**
- * Finalize CRC32 calculation
- * XOR with 0xffffffff and convert to unsigned 32-bit
- *
- * @param crc - CRC value from crc32Update
- * @returns Final CRC32 checksum
- */
-export { crc32Finalize };

package/dist/types/modules/archive/defaults.d.ts

@@ -1,4 +0,0 @@
-import type { ZipTimestampMode } from "@archive/utils/timestamps";
-export declare const DEFAULT_COMPRESS_LEVEL = 6;
-export declare const DEFAULT_ZIP_LEVEL = 6;
-export declare const DEFAULT_ZIP_TIMESTAMPS: ZipTimestampMode;

package/dist/types/modules/archive/extract.d.ts

@@ -1,94 +0,0 @@
-/**
- * Simple ZIP extraction utilities
- * Provides easy-to-use Promise-based API for extracting ZIP files
- * Works in both Node.js and browser environments
- */
-import { type ZipEntryInfo } from "@archive/zip-parser";
-/**
- * Extracted file entry
- */
-export interface ExtractedFile {
-    /** File path within the ZIP */
-    path: string;
-    /** File content as Uint8Array */
-    data: Uint8Array;
-    /** Whether this is a directory */
-    isDirectory: boolean;
-    /** Uncompressed size */
-    size: number;
-}
-/**
- * Extract all files from a ZIP buffer
- *
- * @param zipData - ZIP file data as Buffer, Uint8Array, or ArrayBuffer
- * @returns Map of file paths to their content
- *
- * @example
- * ```ts
- * import { extractAll } from "./utils/unzip/extract";
- *
- * const zipData = fs.readFileSync("archive.zip");
- * const files = await extractAll(zipData);
- *
- * for (const [path, file] of files) {
- *   console.log(`${path}: ${file.data.length} bytes`);
- * }
- * ```
- */
-export declare function extractAll(zipData: Uint8Array | ArrayBuffer): Promise<Map<string, ExtractedFile>>;
-/**
- * Extract a single file from a ZIP buffer
- *
- * @param zipData - ZIP file data as Buffer, Uint8Array, or ArrayBuffer
- * @param filePath - Path of the file to extract
- * @returns File content as Uint8Array, or null if not found
- *
- * @example
- * ```ts
- * import { extractFile } from "./utils/unzip/extract";
- *
- * const zipData = fs.readFileSync("archive.zip");
- * const content = await extractFile(zipData, "readme.txt");
- * if (content) {
- *   console.log(new TextDecoder().decode(content));
- * }
- * ```
- */
-export declare function extractFile(zipData: Uint8Array | ArrayBuffer, filePath: string): Promise<Uint8Array | null>;
-/**
- * List all file paths in a ZIP buffer (without extracting content)
- *
- * @param zipData - ZIP file data as Buffer, Uint8Array, or ArrayBuffer
- * @returns Array of file paths
- *
- * @example
- * ```ts
- * import { listFiles } from "./utils/unzip/extract";
- *
- * const zipData = fs.readFileSync("archive.zip");
- * const paths = await listFiles(zipData);
- * console.log(paths); // ["file1.txt", "folder/file2.txt", ...]
- * ```
- */
-export declare function listFiles(zipData: Uint8Array | ArrayBuffer): Promise<string[]>;
-/**
- * Iterate over ZIP entries with a callback (memory efficient for large ZIPs)
- *
- * @param zipData - ZIP file data as Buffer, Uint8Array, or ArrayBuffer
- * @param callback - Async callback for each entry, return false to stop iteration
- *
- * @example
- * ```ts
- * import { forEachEntry } from "./utils/unzip/extract";
- *
- * await forEachEntry(zipData, async (path, getData) => {
- *   if (path.endsWith(".xml")) {
- *     const content = await getData();
- *     console.log(new TextDecoder().decode(content));
- *   }
- *   return true; // continue iteration
- * });
- * ```
- */
-export declare function forEachEntry(zipData: Uint8Array | ArrayBuffer, callback: (path: string, getData: () => Promise<Uint8Array>, entry: ZipEntryInfo) => Promise<boolean | void>): Promise<void>;
-export { ZipParser, type ZipEntryInfo, type ZipParseOptions } from "@archive/zip-parser";

package/dist/types/modules/archive/index.base.d.ts

@@ -1,11 +0,0 @@
-/**
- * Archive (ZIP) module - shared exports.
- *
- * This module contains exports that are identical across Node.js and browser.
- * Platform-specific entrypoints (index.ts / index.browser.ts) should re-export
- * from this file and then layer their platform-specific bindings.
- */
-export { createZip, createZipSync, ZipBuilder, type ZipEntry, type ZipOptions } from "@archive/zip-builder";
-export { StreamingZip, ZipDeflateFile, Zip, ZipDeflate } from "@archive/streaming-zip";
-export { extractAll, extractFile, listFiles, forEachEntry, ZipParser, type ExtractedFile, type ZipParseOptions } from "@archive/extract";
-export type { ZipEntryInfo } from "@archive/zip-entry-info";

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

@@ -1,11 +0,0 @@
-/**
- * Archive (ZIP) module - unified ZIP + Unzip implementation (browser type surface).
- *
- * This file mirrors [src/modules/archive/index.ts] but explicitly re-exports
- * browser-specific implementations so we can enforce export-surface parity.
- */
-export * from "@archive/index.base";
-export { crc32, crc32Update, crc32Finalize } from "@archive/crc32.browser";
-export { compress, compressSync, decompress, decompressSync, hasCompressionStream, type CompressOptions } from "@archive/compress.browser";
-export { createDeflateStream, createInflateStream, hasDeflateRaw, type StreamCompressOptions } from "@archive/streaming-compress.browser";
-export { Parse, createParse, type ParseOptions, type ZipEntry as StreamZipEntry } from "@archive/parse.browser";