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

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

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

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

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

package/dist/cjs/utils/browser.js

@@ -1,55 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.preferBrowserFilesPlugin = preferBrowserFilesPlugin;
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("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
- */
-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 (!node_path_1.default.isAbsolute(cleanId)) {
-                return resolved;
-            }
-            if (cleanId.includes(".browser.")) {
-                return resolved;
-            }
-            const ext = node_path_1.default.extname(cleanId);
-            if (!ext || cleanId.endsWith(".d.ts")) {
-                return resolved;
-            }
-            const candidate = cleanId.slice(0, -ext.length) + ".browser" + ext;
-            if (node_fs_1.default.existsSync(candidate)) {
-                return candidate;
-            }
-            return resolved;
-        }
-    };
-}

package/dist/cjs/utils/env.js

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

package/dist/cjs/utils/uuid.js

@@ -1,58 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.uuidV4 = uuidV4;
-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).
- */
-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/esm/modules/archive/byte-queue.js

@@ -1,125 +0,0 @@
-export class ByteQueue {
-    constructor(initial) {
-        this._start = 0;
-        this._end = 0;
-        this._cachedView = null;
-        this._cachedBuf = null;
-        this._cachedStart = 0;
-        this._cachedEnd = 0;
-        this._buf = new Uint8Array(0);
-        if (initial && initial.length > 0) {
-            this.reset(initial);
-        }
-    }
-    get length() {
-        return this._end - this._start;
-    }
-    isEmpty() {
-        return this.length === 0;
-    }
-    view() {
-        if (this._start === this._end) {
-            return ByteQueue.EMPTY;
-        }
-        if (this._cachedView &&
-            this._cachedBuf === this._buf &&
-            this._cachedStart === this._start &&
-            this._cachedEnd === this._end) {
-            return this._cachedView;
-        }
-        const view = this._buf.subarray(this._start, this._end);
-        this._cachedView = view;
-        this._cachedBuf = this._buf;
-        this._cachedStart = this._start;
-        this._cachedEnd = this._end;
-        return view;
-    }
-    reset(data) {
-        this._cachedView = null;
-        this._cachedBuf = null;
-        if (!data || data.length === 0) {
-            this._buf = ByteQueue.EMPTY;
-            this._start = 0;
-            this._end = 0;
-            return;
-        }
-        // Keep a private copy to ensure future writes cannot mutate the source.
-        const copy = new Uint8Array(data.length);
-        copy.set(data);
-        this._buf = copy;
-        this._start = 0;
-        this._end = copy.length;
-    }
-    append(chunk) {
-        if (chunk.length === 0) {
-            return;
-        }
-        this._cachedView = null;
-        this._cachedBuf = null;
-        const unread = this.length;
-        // Fast path: enough tail room.
-        if (this._end + chunk.length <= this._buf.length) {
-            this._buf.set(chunk, this._end);
-            this._end += chunk.length;
-            return;
-        }
-        // Allocate a new buffer and copy unread bytes (never compacts in-place).
-        const required = unread + chunk.length;
-        const nextSize = this._buf.length === 0 ? required : Math.max(this._buf.length * 2, required);
-        const next = new Uint8Array(nextSize);
-        if (unread > 0) {
-            next.set(this._buf.subarray(this._start, this._end), 0);
-        }
-        next.set(chunk, unread);
-        this._buf = next;
-        this._start = 0;
-        this._end = required;
-    }
-    read(length) {
-        if (length <= 0) {
-            return new Uint8Array(0);
-        }
-        if (length > this.length) {
-            throw new RangeError("ByteQueue: read beyond available data");
-        }
-        // Return a view for performance.
-        // To keep this safe for async consumers, we must ensure we never write into
-        // the same backing buffer again after it becomes fully consumed.
-        const out = this._buf.subarray(this._start, this._start + length);
-        this._start += length;
-        this._cachedView = null;
-        this._cachedBuf = null;
-        if (this._start === this._end) {
-            // Release backing storage to avoid reusing memory that might still be
-            // referenced by previously returned views.
-            this._buf = ByteQueue.EMPTY;
-            this._start = 0;
-            this._end = 0;
-        }
-        return out;
-    }
-    discard(length) {
-        if (length <= 0) {
-            return;
-        }
-        if (length >= this.length) {
-            // Release backing storage for the same reason as read(): previously
-            // returned views may still be referenced by consumers.
-            this._buf = ByteQueue.EMPTY;
-            this._start = 0;
-            this._end = 0;
-            this._cachedView = null;
-            this._cachedBuf = null;
-            return;
-        }
-        this._start += length;
-        this._cachedView = null;
-        this._cachedBuf = null;
-        if (this._start === this._end) {
-            this._buf = ByteQueue.EMPTY;
-            this._start = 0;
-            this._end = 0;
-        }
-    }
-}
-ByteQueue.EMPTY = new Uint8Array(0);

package/dist/esm/modules/archive/compress.base.js

@@ -1,173 +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
- */
-import { ByteQueue } from "@archive/byte-queue";
-/**
- * Default threshold (in bytes) to choose the lower-overhead path.
- *
- * This is a performance knob, not a correctness requirement.
- */
-export const DEFAULT_COMPRESS_THRESHOLD_BYTES = 8 * 1024 * 1024;
-/**
- * Resolve the effective threshold bytes.
- */
-export function resolveCompressThresholdBytes(options) {
-    const value = options.thresholdBytes;
-    if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
-        return DEFAULT_COMPRESS_THRESHOLD_BYTES;
-    }
-    return value;
-}
-/**
- * Check if CompressionStream is available
- */
-export function hasCompressionStream() {
-    return typeof CompressionStream !== "undefined";
-}
-/**
- * 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 function probeDeflateRawCompressionStream() {
-    try {
-        if (typeof CompressionStream === "undefined") {
-            return false;
-        }
-        new CompressionStream("deflate-raw");
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Non-cached probe for DecompressionStream("deflate-raw") support.
- */
-export function probeDeflateRawDecompressionStream() {
-    try {
-        if (typeof DecompressionStream === "undefined") {
-            return false;
-        }
-        new DecompressionStream("deflate-raw");
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * 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 function probeDeflateRawWebStreams() {
-    return probeDeflateRawCompressionStream() && probeDeflateRawDecompressionStream();
-}
-let _hasDeflateRawCompressionStream = null;
-let _hasDeflateRawDecompressionStream = null;
-/**
- * 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 function hasDeflateRawCompressionStream() {
-    if (typeof CompressionStream === "undefined") {
-        return false;
-    }
-    if (_hasDeflateRawCompressionStream !== null) {
-        return _hasDeflateRawCompressionStream;
-    }
-    _hasDeflateRawCompressionStream = probeDeflateRawCompressionStream();
-    return _hasDeflateRawCompressionStream;
-}
-/**
- * Check if DecompressionStream supports the "deflate-raw" format.
- */
-export function hasDeflateRawDecompressionStream() {
-    if (typeof DecompressionStream === "undefined") {
-        return false;
-    }
-    if (_hasDeflateRawDecompressionStream !== null) {
-        return _hasDeflateRawDecompressionStream;
-    }
-    _hasDeflateRawDecompressionStream = probeDeflateRawDecompressionStream();
-    return _hasDeflateRawDecompressionStream;
-}
-/**
- * Cached check for full deflate-raw Web Streams support.
- *
- * Returns true only if BOTH CompressionStream("deflate-raw") and
- * DecompressionStream("deflate-raw") are supported.
- */
-export function hasDeflateRawWebStreams() {
-    return hasDeflateRawCompressionStream() && hasDeflateRawDecompressionStream();
-}
-async function streamToUint8Array(reader) {
-    const out = new ByteQueue();
-    while (true) {
-        const { done, value } = await reader.read();
-        if (done) {
-            break;
-        }
-        out.append(value);
-    }
-    return out.read(out.length);
-}
-async function transformWithStream(data, stream) {
-    const writer = stream.writable.getWriter();
-    const reader = stream.readable.getReader();
-    try {
-        // Start reading immediately to avoid potential backpressure deadlocks
-        // (writer.write/close may wait for the readable side to be consumed).
-        const readPromise = streamToUint8Array(reader);
-        await writer.write(data);
-        await writer.close();
-        return await readPromise;
-    }
-    finally {
-        try {
-            writer.releaseLock();
-        }
-        catch {
-            // ignore
-        }
-        try {
-            reader.releaseLock();
-        }
-        catch {
-            // ignore
-        }
-    }
-}
-/**
- * Compress using CompressionStream API
- * Uses "deflate-raw" format (required for ZIP files)
- *
- * @param data - Data to compress
- * @returns Compressed data
- */
-export async function compressWithStream(data) {
-    const cs = new CompressionStream("deflate-raw");
-    return transformWithStream(data, cs);
-}
-/**
- * Decompress using DecompressionStream API
- *
- * @param data - Compressed data (deflate-raw format)
- * @returns Decompressed data
- */
-export async function decompressWithStream(data) {
-    const ds = new DecompressionStream("deflate-raw");
-    return transformWithStream(data, ds);
-}

package/dist/esm/modules/archive/compress.browser.js

@@ -1,93 +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 { compressWithStream, decompressWithStream, hasDeflateRawCompressionStream, hasDeflateRawDecompressionStream, resolveCompressThresholdBytes } from "@archive/compress.base";
-import { inflateRaw, deflateRawCompressed } from "@archive/deflate-fallback";
-import { DEFAULT_COMPRESS_LEVEL } from "@archive/defaults";
-// Re-export shared types
-export {};
-/**
- * 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 function hasCompressionStream() {
-    return typeof CompressionStream !== "undefined";
-}
-/**
- * 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 async function compress(data, options = {}) {
-    const level = options.level ?? DEFAULT_COMPRESS_LEVEL;
-    const thresholdBytes = resolveCompressThresholdBytes(options);
-    // Level 0 means no compression
-    if (level === 0) {
-        return data;
-    }
-    // Use native CompressionStream only for larger inputs.
-    if (hasDeflateRawCompressionStream() && data.byteLength > thresholdBytes) {
-        return compressWithStream(data);
-    }
-    // Fallback to pure JS implementation
-    return deflateRawCompressed(data);
-}
-/**
- * Compress data synchronously using pure JS implementation
- *
- * @param data - Data to compress
- * @param options - Compression options
- * @returns Compressed data
- */
-export function compressSync(data, options = {}) {
-    const level = options.level ?? DEFAULT_COMPRESS_LEVEL;
-    // Level 0 means no compression
-    if (level === 0) {
-        return data;
-    }
-    // Pure JS implementation
-    return deflateRawCompressed(data);
-}
-/**
- * Decompress data using browser's native DecompressionStream or JS fallback
- *
- * @param data - Compressed data (deflate-raw format)
- * @returns Decompressed data
- */
-export async function decompress(data, options = {}) {
-    const thresholdBytes = resolveCompressThresholdBytes(options);
-    // Use native DecompressionStream only for larger inputs.
-    if (hasDeflateRawDecompressionStream() && data.byteLength > thresholdBytes) {
-        return decompressWithStream(data);
-    }
-    // Fallback to pure JS implementation
-    return inflateRaw(data);
-}
-/**
- * Decompress data synchronously using pure JS implementation
- *
- * @param data - Compressed data (deflate-raw format)
- * @returns Decompressed data
- */
-export function decompressSync(data) {
-    return inflateRaw(data);
-}