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

package/dist/esm/utils/utils.js

@@ -4,16 +4,95 @@
  */
 import fs from "fs";
 // Re-export all shared utilities
-export { delay, nop, inherits, dateToExcel, excelToDate, toIsoDateString, parsePath, getRelsPath, xmlDecode, xmlEncode, validInt, isDateFmt, parseBoolean, range, toSortedArray, objectFromProps, bufferToString, base64ToUint8Array, uint8ArrayToBase64, stringToUtf16Le } from "@utils/utils.base";
+export { delay, nop, inherits, dateToExcel, excelToDate, toIsoDateString, parsePath, getRelsPath, xmlDecode, validInt, isDateFmt, parseBoolean, range, toSortedArray, objectFromProps, bufferToString } from "./utils.base.js";
 // =============================================================================
-// File system utilities (Node.js only)
+// XML encoding (Node.js optimized version)
 // =============================================================================
-export async function fileExists(path) {
-    try {
-        await fs.promises.access(path, fs.constants.F_OK);
-        return true;
+// oxlint-disable-next-line no-control-regex -- Control characters are intentionally matched for XML encoding
+const xmlDecodeRegex = /[<>&'"\x7F\x00-\x08\x0B-\x0C\x0E-\x1F]/;
+export function xmlEncode(text) {
+    const regexResult = xmlDecodeRegex.exec(text);
+    if (!regexResult) {
+        return text;
+    }
+    let result = "";
+    let escape = "";
+    let lastIndex = 0;
+    let i = regexResult.index;
+    for (; i < text.length; i++) {
+        const charCode = text.charCodeAt(i);
+        switch (charCode) {
+            case 34: // "
+                escape = "&quot;";
+                break;
+            case 38: // &
+                escape = "&amp;";
+                break;
+            case 39: // '
+                escape = "&apos;";
+                break;
+            case 60: // <
+                escape = "&lt;";
+                break;
+            case 62: // >
+                escape = "&gt;";
+                break;
+            case 127:
+                escape = "";
+                break;
+            default: {
+                if (charCode <= 31 && (charCode <= 8 || (charCode >= 11 && charCode !== 13))) {
+                    escape = "";
+                    break;
+                }
+                continue;
+            }
+        }
+        if (lastIndex !== i) {
+            result += text.substring(lastIndex, i);
+        }
+        lastIndex = i + 1;
+        if (escape) {
+            result += escape;
+        }
     }
-    catch {
-        return false;
+    if (lastIndex !== i) {
+        return result + text.substring(lastIndex, i);
     }
+    return result;
+}
+// =============================================================================
+// File system utilities (Node.js only)
+// =============================================================================
+export function fileExists(path) {
+    return new Promise(resolve => {
+        fs.access(path, fs.constants.F_OK, err => {
+            resolve(!err);
+        });
+    });
 }
+// =============================================================================
+// Legacy export for backward compatibility
+// =============================================================================
+import { nop, inherits, dateToExcel, excelToDate, parsePath, getRelsPath, xmlDecode, validInt, isDateFmt, toIsoDateString, parseBoolean, range, toSortedArray, objectFromProps } from "./utils.base.js";
+/** @deprecated Import functions directly instead of using the utils object */
+export const utils = {
+    nop,
+    inherits,
+    dateToExcel,
+    excelToDate,
+    parsePath,
+    getRelsPath,
+    xmlEncode,
+    xmlDecode,
+    validInt,
+    isDateFmt,
+    fs: {
+        exists: fileExists
+    },
+    toIsoDateString,
+    parseBoolean,
+    range,
+    toSortedArray,
+    objectFromProps
+};

package/dist/esm/utils/xml-stream.js

@@ -0,0 +1,168 @@
+import { xmlEncode } from "./utils.js";
+// constants
+const OPEN_ANGLE = "<";
+const CLOSE_ANGLE = ">";
+const OPEN_ANGLE_SLASH = "</";
+const CLOSE_SLASH_ANGLE = "/>";
+// Chunk size for periodic consolidation (reduces final join overhead)
+const CHUNK_SIZE = 10000;
+function pushAttribute(xml, name, value) {
+    xml.push(` ${name}="${xmlEncode(value.toString())}"`);
+}
+function pushAttributes(xml, attributes) {
+    if (attributes) {
+        const tmp = [];
+        Object.entries(attributes).forEach(([name, value]) => {
+            if (value !== undefined) {
+                pushAttribute(tmp, name, value);
+            }
+        });
+        xml.push(tmp.join(""));
+    }
+}
+class XmlStream {
+    constructor() {
+        this._xml = [];
+        this._chunks = [];
+        this._stack = [];
+        this._rollbacks = [];
+    }
+    _consolidate() {
+        // Periodically join small strings into larger chunks to reduce final join overhead
+        if (this._xml.length >= CHUNK_SIZE) {
+            this._chunks.push(this._xml.join(""));
+            this._xml = [];
+        }
+    }
+    get tos() {
+        return this._stack.length ? this._stack[this._stack.length - 1] : undefined;
+    }
+    get cursor() {
+        // handy way to track whether anything has been added
+        return this._chunks.length * CHUNK_SIZE + this._xml.length;
+    }
+    openXml(docAttributes) {
+        const xml = this._xml;
+        // <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+        xml.push("<?xml");
+        pushAttributes(xml, docAttributes);
+        xml.push("?>\n");
+    }
+    openNode(name, attributes) {
+        const parent = this.tos;
+        const xml = this._xml;
+        if (parent && this.open) {
+            xml.push(CLOSE_ANGLE);
+        }
+        this._stack.push(name);
+        // start streaming node
+        xml.push(OPEN_ANGLE);
+        xml.push(name);
+        pushAttributes(xml, attributes);
+        this.leaf = true;
+        this.open = true;
+    }
+    addAttribute(name, value) {
+        if (!this.open) {
+            throw new Error("Cannot write attributes to node if it is not open");
+        }
+        if (value !== undefined) {
+            pushAttribute(this._xml, name, value);
+        }
+    }
+    addAttributes(attrs) {
+        if (!this.open) {
+            throw new Error("Cannot write attributes to node if it is not open");
+        }
+        pushAttributes(this._xml, attrs);
+    }
+    writeText(text) {
+        const xml = this._xml;
+        if (this.open) {
+            xml.push(CLOSE_ANGLE);
+            this.open = false;
+        }
+        this.leaf = false;
+        xml.push(xmlEncode(text.toString()));
+    }
+    writeXml(xml) {
+        if (this.open) {
+            this._xml.push(CLOSE_ANGLE);
+            this.open = false;
+        }
+        this.leaf = false;
+        this._xml.push(xml);
+    }
+    closeNode() {
+        const node = this._stack.pop();
+        const xml = this._xml;
+        if (this.leaf) {
+            xml.push(CLOSE_SLASH_ANGLE);
+        }
+        else {
+            xml.push(OPEN_ANGLE_SLASH);
+            xml.push(node);
+            xml.push(CLOSE_ANGLE);
+        }
+        this.open = false;
+        this.leaf = false;
+        this._consolidate();
+    }
+    leafNode(name, attributes, text) {
+        this.openNode(name, attributes);
+        if (text !== undefined) {
+            // zeros need to be written
+            this.writeText(text);
+        }
+        this.closeNode();
+    }
+    closeAll() {
+        while (this._stack.length) {
+            this.closeNode();
+        }
+    }
+    addRollback() {
+        this._rollbacks.push({
+            xml: this._xml.length,
+            stack: this._stack.length,
+            leaf: this.leaf,
+            open: this.open,
+            chunksLength: this._chunks.length
+        });
+        return this.cursor;
+    }
+    commit() {
+        this._rollbacks.pop();
+    }
+    rollback() {
+        const r = this._rollbacks.pop();
+        if (this._xml.length > r.xml) {
+            this._xml.splice(r.xml, this._xml.length - r.xml);
+        }
+        if (this._stack.length > r.stack) {
+            this._stack.splice(r.stack, this._stack.length - r.stack);
+        }
+        if (this._chunks.length > r.chunksLength) {
+            this._chunks.splice(r.chunksLength, this._chunks.length - r.chunksLength);
+        }
+        this.leaf = r.leaf;
+        this.open = r.open;
+    }
+    get xml() {
+        this.closeAll();
+        // Join chunks first, then remaining xml array
+        if (this._chunks.length === 0) {
+            return this._xml.join("");
+        }
+        if (this._xml.length > 0) {
+            this._chunks.push(this._xml.join(""));
+        }
+        return this._chunks.join("");
+    }
+}
+XmlStream.StdDocAttributes = {
+    version: "1.0",
+    encoding: "UTF-8",
+    standalone: "yes"
+};
+export { XmlStream };

package/dist/esm/utils/zip/compress.base.js

@@ -0,0 +1,83 @@
+/**
+ * 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
+ */
+/**
+ * Check if CompressionStream is available
+ */
+export function hasCompressionStream() {
+    return typeof CompressionStream !== "undefined";
+}
+/**
+ * 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");
+    const writer = cs.writable.getWriter();
+    const reader = cs.readable.getReader();
+    // Write data and close
+    writer.write(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
+    writer.close();
+    // Read all compressed chunks
+    const chunks = [];
+    let totalLength = 0;
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+            break;
+        }
+        chunks.push(value);
+        totalLength += value.length;
+    }
+    // Combine chunks into single array
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+        result.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return result;
+}
+/**
+ * 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");
+    const writer = ds.writable.getWriter();
+    const reader = ds.readable.getReader();
+    // Write data and close
+    writer.write(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
+    writer.close();
+    // Read all decompressed chunks
+    const chunks = [];
+    let totalLength = 0;
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+            break;
+        }
+        chunks.push(value);
+        totalLength += value.length;
+    }
+    // Combine chunks into single array
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+        result.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return result;
+}

package/dist/esm/utils/zip/compress.browser.js

@@ -0,0 +1,121 @@
+/**
+ * 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 >= 85
+ * - Firefox >= 79
+ * - Safari >= 14
+ * - Edge >= 85
+ */
+import { compressWithStream, decompressWithStream } from "./compress.base.js";
+import { inflateRaw, deflateRawCompressed, deflateRawStore } from "./deflate-fallback.js";
+// Re-export shared types
+export {};
+/**
+ * Check if CompressionStream with "deflate-raw" is available
+ * Note: Chrome 80-102 has CompressionStream but not deflate-raw support
+ */
+export function hasCompressionStream() {
+    if (typeof CompressionStream === "undefined") {
+        return false;
+    }
+    // Test if deflate-raw is supported (not just CompressionStream existence)
+    try {
+        new CompressionStream("deflate-raw");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// Cache the detection result for performance
+let _hasDeflateRaw = null;
+/**
+ * Check if deflate-raw is supported, with caching for performance.
+ * The cache is bypassed if CompressionStream is undefined (for testing).
+ */
+function hasDeflateRawSupport() {
+    // If API doesn't exist, return false immediately (bypass cache for tests)
+    if (typeof CompressionStream === "undefined") {
+        return false;
+    }
+    // Use cached result for performance
+    if (_hasDeflateRaw === null) {
+        _hasDeflateRaw = hasCompressionStream();
+    }
+    return _hasDeflateRaw;
+}
+/**
+ * Check if native zlib is available (always false in browser)
+ */
+export function hasNativeZlib() {
+    return false;
+}
+/**
+ * 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 ?? 6;
+    // Level 0 means no compression (STORE mode)
+    if (level === 0) {
+        return deflateRawStore(data);
+    }
+    // Use native CompressionStream if available
+    if (hasDeflateRawSupport()) {
+        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 ?? 6;
+    // Level 0 means no compression (STORE mode)
+    if (level === 0) {
+        return deflateRawStore(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) {
+    // Use native DecompressionStream if available
+    if (hasDeflateRawSupport()) {
+        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);
+}

package/dist/esm/utils/zip/compress.js

@@ -0,0 +1,72 @@
+/**
+ * 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)
+ */
+import { deflateRawSync, inflateRawSync } from "zlib";
+// Re-export shared types and utilities
+export { hasCompressionStream } from "./compress.base.js";
+/**
+ * Check if native zlib is available (always true in Node.js)
+ */
+export function hasNativeZlib() {
+    return true;
+}
+/**
+ * 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 async function compress(data, options = {}) {
+    const level = options.level ?? 6;
+    // Level 0 means no compression
+    if (level === 0) {
+        return data;
+    }
+    const result = deflateRawSync(Buffer.from(data), { level });
+    return new Uint8Array(result.buffer, result.byteOffset, result.byteLength);
+}
+/**
+ * Compress data synchronously using Node.js zlib
+ *
+ * @param data - Data to compress
+ * @param options - Compression options
+ * @returns Compressed data
+ */
+export function compressSync(data, options = {}) {
+    const level = options.level ?? 6;
+    if (level === 0) {
+        return data;
+    }
+    const result = deflateRawSync(Buffer.from(data), { level });
+    return new Uint8Array(result.buffer, result.byteOffset, result.byteLength);
+}
+/**
+ * Decompress data using Node.js native zlib
+ *
+ * @param data - Compressed data (deflate-raw format)
+ * @returns Decompressed data
+ */
+export async function decompress(data) {
+    const result = inflateRawSync(Buffer.from(data));
+    return new Uint8Array(result.buffer, result.byteOffset, result.byteLength);
+}
+/**
+ * Decompress data synchronously using Node.js zlib
+ *
+ * @param data - Compressed data (deflate-raw format)
+ * @returns Decompressed data
+ */
+export function decompressSync(data) {
+    const result = inflateRawSync(Buffer.from(data));
+    return new Uint8Array(result.buffer, result.byteOffset, result.byteLength);
+}

package/dist/esm/utils/zip/crc32.browser.js

@@ -0,0 +1,82 @@
+/**
+ * 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
+ */
+/**
+ * Pre-computed CRC32 lookup table (256 entries)
+ * Generated using the standard polynomial 0xEDB88320
+ */
+const CRC32_TABLE = /* @__PURE__ */ (() => {
+    const table = new Uint32Array(256);
+    for (let i = 0; i < 256; i++) {
+        let crc = i;
+        for (let j = 0; j < 8; j++) {
+            crc = crc & 1 ? 0xedb88320 ^ (crc >>> 1) : crc >>> 1;
+        }
+        table[i] = crc;
+    }
+    return table;
+})();
+/**
+ * Calculate CRC32 checksum for the given data
+ *
+ * @param data - Input data as Uint8Array
+ * @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 function crc32(data) {
+    let crc = 0xffffffff;
+    for (let i = 0; i < data.length; i++) {
+        crc = CRC32_TABLE[(crc ^ data[i]) & 0xff] ^ (crc >>> 8);
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+}
+/**
+ * Ensure CRC32 is ready (no-op in browser, for API compatibility)
+ */
+export async function ensureCrc32() {
+    // No-op in browser
+}
+/**
+ * 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);
+ * ```
+ */
+export function crc32Update(crc, data) {
+    for (let i = 0; i < data.length; i++) {
+        crc = CRC32_TABLE[(crc ^ data[i]) & 0xff] ^ (crc >>> 8);
+    }
+    return crc;
+}
+/**
+ * Finalize CRC32 calculation
+ * XOR with 0xffffffff and convert to unsigned 32-bit
+ *
+ * @param crc - CRC value from crc32Update
+ * @returns Final CRC32 checksum
+ */
+export function crc32Finalize(crc) {
+    return (crc ^ 0xffffffff) >>> 0;
+}