@cj-tech-master/excelts 1.6.3 → 2.0.0-canary.20251228013952.4f2c3c6

package/dist/esm/utils/utils.js

@@ -1,53 +1,13 @@
+/**
+ * Node.js utility functions
+ * Re-exports shared utilities and adds Node.js-specific implementations
+ */
 import fs from "fs";
-export function delay(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
-}
-export function nop() { }
-// useful stuff
-export const inherits = function (cls, superCtor, statics, prototype) {
-    cls.super_ = superCtor;
-    if (!prototype) {
-        prototype = statics;
-        statics = null;
-    }
-    if (statics) {
-        Object.keys(statics).forEach(i => {
-            Object.defineProperty(cls, i, Object.getOwnPropertyDescriptor(statics, i));
-        });
-    }
-    const properties = {
-        constructor: {
-            value: cls,
-            enumerable: false,
-            writable: false,
-            configurable: true
-        }
-    };
-    if (prototype) {
-        Object.keys(prototype).forEach(i => {
-            properties[i] = Object.getOwnPropertyDescriptor(prototype, i);
-        });
-    }
-    cls.prototype = Object.create(superCtor.prototype, properties);
-};
-export function dateToExcel(d, date1904) {
-    return 25569 + d.getTime() / (24 * 3600 * 1000) - (date1904 ? 1462 : 0);
-}
-export function excelToDate(v, date1904) {
-    const millisecondSinceEpoch = Math.round((v - 25569 + (date1904 ? 1462 : 0)) * 24 * 3600 * 1000);
-    return new Date(millisecondSinceEpoch);
-}
-export function parsePath(filepath) {
-    const last = filepath.lastIndexOf("/");
-    return {
-        path: filepath.substring(0, last),
-        name: filepath.substring(last + 1)
-    };
-}
-export function getRelsPath(filepath) {
-    const path = parsePath(filepath);
-    return `${path.path}/_rels/${path.name}.rels`;
-}
+// Re-export all shared utilities
+export { delay, nop, inherits, dateToExcel, excelToDate, toIsoDateString, parsePath, getRelsPath, xmlDecode, validInt, isDateFmt, parseBoolean, range, toSortedArray, objectFromProps, bufferToString } from "./utils.base.js";
+// =============================================================================
+// XML encoding (Node.js optimized version)
+// =============================================================================
 // 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) {
@@ -101,39 +61,9 @@ export function xmlEncode(text) {
     }
     return result;
 }
-export function xmlDecode(text) {
-    return text.replace(/&([a-z]*);/g, c => {
-        switch (c) {
-            case "&lt;":
-                return "<";
-            case "&gt;":
-                return ">";
-            case "&amp;":
-                return "&";
-            case "&apos;":
-                return "'";
-            case "&quot;":
-                return '"';
-            default:
-                return c;
-        }
-    });
-}
-export function validInt(value) {
-    const i = parseInt(value, 10);
-    return !Number.isNaN(i) ? i : 0;
-}
-export function isDateFmt(fmt) {
-    if (!fmt) {
-        return false;
-    }
-    // must remove all chars inside quotes and []
-    fmt = fmt.replace(/\[[^\]]*]/g, "");
-    fmt = fmt.replace(/"[^"]*"/g, "");
-    // then check for date formatting chars
-    const result = fmt.match(/[ymdhMsb]+/) !== null;
-    return result;
-}
+// =============================================================================
+// File system utilities (Node.js only)
+// =============================================================================
 export function fileExists(path) {
     return new Promise(resolve => {
         fs.access(path, fs.constants.F_OK, err => {
@@ -141,36 +71,10 @@ export function fileExists(path) {
         });
     });
 }
-export function toIsoDateString(dt) {
-    return dt.toISOString().substr(0, 10);
-}
-export function parseBoolean(value) {
-    return value === true || value === "true" || value === 1 || value === "1";
-}
-export function* range(start, stop, step = 1) {
-    const compareOrder = step > 0 ? (a, b) => a < b : (a, b) => a > b;
-    for (let value = start; compareOrder(value, stop); value += step) {
-        yield value;
-    }
-}
-export function toSortedArray(values) {
-    const result = Array.from(values);
-    // Note: per default, `Array.prototype.sort()` converts values
-    // to strings when comparing. Here, if we have numbers, we use
-    // numeric sort.
-    if (result.every(item => Number.isFinite(item))) {
-        const compareNumbers = (a, b) => a - b;
-        return result.sort(compareNumbers);
-    }
-    return result.sort();
-}
-export function objectFromProps(props, value = null) {
-    return props.reduce((result, property) => {
-        result[property] = value;
-        return result;
-    }, {});
-}
+// =============================================================================
 // 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,
@@ -192,15 +96,3 @@ export const utils = {
     toSortedArray,
     objectFromProps
 };
-// TextDecoder is available in ES2020+ and all modern browsers/Node.js
-const textDecoder = new TextDecoder("utf-8");
-/**
- * Convert a Buffer or ArrayBuffer to a UTF-8 string
- * Works in both Node.js and browser environments
- */
-export function bufferToString(chunk) {
-    if (typeof chunk === "string") {
-        return chunk;
-    }
-    return textDecoder.decode(chunk);
-}

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

@@ -1,66 +1,20 @@
 /**
- * Native compression utilities using platform APIs
+ * Node.js compression utilities using native zlib
  *
- * - Node.js: Uses native zlib module (C++ implementation, fastest)
- * - Browser: Uses CompressionStream API (Chrome 80+, Firefox 113+, Safari 16.4+)
- *
- * Both use "deflate-raw" format which is required for ZIP files
- * (raw DEFLATE without zlib header/trailer)
- */
-// Detect environment
-const isNode = typeof process !== "undefined" && process.versions?.node;
-// Lazy-loaded zlib module for Node.js
-let _zlib = null;
-let _zlibLoading = null;
-// Auto-initialize zlib in Node.js environment
-if (isNode) {
-    _zlibLoading = import("zlib")
-        .then(module => {
-        _zlib = module.default ?? module;
-        return _zlib;
-    })
-        .catch(() => {
-        _zlib = null;
-        return null;
-    });
-}
-/**
- * Get zlib module (Node.js only)
- * Returns null if not yet loaded or not in Node.js
- */
-function getZlib() {
-    return _zlib;
-}
-/**
- * Ensure zlib is loaded (Node.js only)
- * Call this before using sync methods if you need to guarantee availability
+ * Uses zlib module (C++ implementation, fastest) with "deflate-raw" format
+ * (raw DEFLATE without zlib header/trailer, required for ZIP files)
  */
-export async function ensureZlib() {
-    if (_zlibLoading) {
-        return _zlibLoading;
-    }
-    return _zlib;
-}
+import { deflateRawSync, inflateRawSync } from "zlib";
+// Re-export shared types and utilities
+export { hasCompressionStream } from "./compress.base.js";
 /**
- * Check if native zlib is available (Node.js)
+ * Check if native zlib is available (always true in Node.js)
  */
 export function hasNativeZlib() {
-    const zlib = getZlib();
-    return zlib !== null && typeof zlib.deflateRawSync === "function";
+    return true;
 }
 /**
- * Check if CompressionStream is available (Browser/Node.js 17+)
- */
-export function hasCompressionStream() {
-    return typeof CompressionStream !== "undefined";
-}
-/**
- * Compress data using the best available native method
- *
- * Priority:
- * 1. Node.js zlib (if available) - fastest, supports compression levels
- * 2. CompressionStream (browser/Node.js 17+) - no level support
- * 3. Return uncompressed data (fallback)
+ * Compress data using Node.js native zlib
  *
  * @param data - Data to compress
  * @param options - Compression options
@@ -78,143 +32,41 @@ export async function compress(data, options = {}) {
     if (level === 0) {
         return data;
     }
-    // Ensure zlib is loaded first
-    const zlib = await ensureZlib();
-    // Try Node.js zlib first (fastest, supports levels)
-    if (zlib && typeof zlib.deflateRawSync === "function") {
-        const result = zlib.deflateRawSync(Buffer.from(data), { level });
-        return new Uint8Array(result.buffer, result.byteOffset, result.byteLength);
-    }
-    // Fall back to CompressionStream (browser/Node.js 17+)
-    if (typeof CompressionStream !== "undefined") {
-        return compressWithCompressionStream(data);
-    }
-    // No compression available - return original data
-    console.warn("No native compression available, returning uncompressed data");
-    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
- * Only available in Node.js environment
  *
  * @param data - Data to compress
  * @param options - Compression options
  * @returns Compressed data
- * @throws Error if not in Node.js environment
  */
 export function compressSync(data, options = {}) {
     const level = options.level ?? 6;
     if (level === 0) {
         return data;
     }
-    const zlib = getZlib();
-    if (!zlib || typeof zlib.deflateRawSync !== "function") {
-        throw new Error("Synchronous compression is only available in Node.js environment");
-    }
-    const result = zlib.deflateRawSync(Buffer.from(data), { level });
+    const result = deflateRawSync(Buffer.from(data), { level });
     return new Uint8Array(result.buffer, result.byteOffset, result.byteLength);
 }
 /**
- * Compress using browser's native CompressionStream
- * Uses "deflate-raw" format (required for ZIP files)
- *
- * Note: CompressionStream does not support compression level configuration
- *
- * @param data - Data to compress
- * @returns Compressed data
- */
-async function compressWithCompressionStream(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 data using the best available native method
+ * Decompress data using Node.js native zlib
  *
  * @param data - Compressed data (deflate-raw format)
  * @returns Decompressed data
  */
 export async function decompress(data) {
-    // Ensure zlib is loaded first
-    const zlib = await ensureZlib();
-    // Try Node.js zlib first
-    if (zlib && typeof zlib.inflateRawSync === "function") {
-        const result = zlib.inflateRawSync(Buffer.from(data));
-        return new Uint8Array(result.buffer, result.byteOffset, result.byteLength);
-    }
-    // Fall back to DecompressionStream
-    if (typeof DecompressionStream !== "undefined") {
-        return decompressWithDecompressionStream(data);
-    }
-    throw new Error("No native decompression available");
+    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
- * @throws Error if not in Node.js environment
  */
 export function decompressSync(data) {
-    const zlib = getZlib();
-    if (!zlib || typeof zlib.inflateRawSync !== "function") {
-        throw new Error("Synchronous decompression is only available in Node.js environment");
-    }
-    const result = zlib.inflateRawSync(Buffer.from(data));
+    const result = inflateRawSync(Buffer.from(data));
     return new Uint8Array(result.buffer, result.byteOffset, result.byteLength);
 }
-/**
- * Decompress using browser's native DecompressionStream
- *
- * @param data - Compressed data (deflate-raw format)
- * @returns Decompressed data
- */
-async function decompressWithDecompressionStream(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/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;
+}