@cj-tech-master/excelts 1.6.2-canary.20251224015244.0b06ae9 → 1.6.3-canary.20251224124621.73c5d94

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;
+}

package/dist/esm/utils/zip-stream.browser.js

@@ -0,0 +1,132 @@
+import { ZipBuilder } from "./zip/zip-builder.js";
+import { StreamBuf } from "./stream-buf.browser.js";
+// Helper function for base64 decoding in browser
+function base64ToUint8Array(base64) {
+    const binaryString = atob(base64);
+    const bytes = new Uint8Array(binaryString.length);
+    for (let i = 0; i < binaryString.length; i++) {
+        bytes[i] = binaryString.charCodeAt(i);
+    }
+    return bytes;
+}
+// =============================================================================
+// The ZipWriter class - Browser version without Node.js events dependency
+// Packs streamed data into an output zip stream
+class ZipWriter {
+    constructor(options) {
+        this.finalized = false;
+        this.pendingWrites = [];
+        this.events = new Map();
+        const level = options?.compression === "STORE"
+            ? 0
+            : Math.max(0, Math.min(9, options?.compressionOptions?.level ?? 1));
+        this.stream = new StreamBuf();
+        this.zipBuilder = new ZipBuilder({ level });
+    }
+    // Event emitter methods
+    on(event, callback) {
+        const callbacks = this.events.get(event) || [];
+        callbacks.push(callback);
+        this.events.set(event, callbacks);
+        return this;
+    }
+    once(event, callback) {
+        const onceCallback = (...args) => {
+            this.off(event, onceCallback);
+            callback(...args);
+        };
+        return this.on(event, onceCallback);
+    }
+    off(event, callback) {
+        const callbacks = this.events.get(event) || [];
+        const index = callbacks.indexOf(callback);
+        if (index !== -1) {
+            callbacks.splice(index, 1);
+        }
+        return this;
+    }
+    emit(event, ...args) {
+        const callbacks = this.events.get(event) || [];
+        callbacks.forEach(cb => cb(...args));
+        return callbacks.length > 0;
+    }
+    removeListener(event, callback) {
+        return this.off(event, callback);
+    }
+    append(data, options) {
+        let buffer;
+        if (Object.prototype.hasOwnProperty.call(options, "base64") && options.base64) {
+            const base64Data = typeof data === "string" ? data : String(data);
+            buffer = base64ToUint8Array(base64Data);
+        }
+        else if (typeof data === "string") {
+            buffer = new TextEncoder().encode(data);
+        }
+        else if (data instanceof Uint8Array) {
+            buffer = data;
+        }
+        else if (ArrayBuffer.isView(data)) {
+            buffer = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+        }
+        else if (data instanceof ArrayBuffer) {
+            buffer = new Uint8Array(data);
+        }
+        else {
+            buffer = data;
+        }
+        const writePromise = this.zipBuilder
+            .addFile({ name: options.name, data: buffer })
+            .then(chunks => {
+            for (const chunk of chunks) {
+                this.stream.write(new Uint8Array(chunk));
+            }
+        });
+        this.pendingWrites.push(writePromise);
+    }
+    push(chunk) {
+        return this.stream.push(chunk);
+    }
+    async finalize() {
+        if (this.finalized) {
+            return;
+        }
+        this.finalized = true;
+        await Promise.all(this.pendingWrites);
+        const finalChunks = this.zipBuilder.finalize();
+        for (const chunk of finalChunks) {
+            this.stream.write(new Uint8Array(chunk));
+        }
+        this.stream.end();
+        this.emit("finish");
+    }
+    // ==========================================================================
+    // Stream.Readable interface
+    read(size) {
+        return this.stream.read(size);
+    }
+    setEncoding(encoding) {
+        return this.stream.setEncoding(encoding);
+    }
+    pause() {
+        return this.stream.pause();
+    }
+    resume() {
+        return this.stream.resume();
+    }
+    isPaused() {
+        return this.stream.isPaused();
+    }
+    pipe(destination) {
+        return this.stream.pipe(destination);
+    }
+    unpipe(destination) {
+        return this.stream.unpipe(destination);
+    }
+    unshift() {
+        return this.stream.unshift();
+    }
+    wrap() {
+        return this.stream.wrap();
+    }
+}
+export { ZipWriter };

package/dist/esm/xlsx/xform/pivot-table/pivot-table-xform.js

@@ -1,4 +1,3 @@
-import { v4 as uuidv4 } from "uuid";
 import { XmlStream } from "../../../utils/xml-stream.js";
 import { xmlEncode, xmlDecode } from "../../../utils/utils.js";
 import { BaseXform } from "../base-xform.js";
@@ -57,7 +56,7 @@ class PivotTableXform extends BaseXform {
     renderNew(xmlStream, model) {
         const { rows, columns, values, cacheFields, cacheId, applyWidthHeightFormats } = model;
         // Generate unique UID for each pivot table to prevent Excel treating them as identical
-        const uniqueUid = `{${uuidv4().toUpperCase()}}`;
+        const uniqueUid = `{${crypto.randomUUID().toUpperCase()}}`;
         xmlStream.openXml(XmlStream.StdDocAttributes);
         xmlStream.openNode(this.tag, {
             ...PivotTableXform.PIVOT_TABLE_ATTRIBUTES,
@@ -138,7 +137,7 @@ class PivotTableXform extends BaseXform {
      * Render loaded pivot table (preserving original structure)
      */
     renderLoaded(xmlStream, model) {
-        const uniqueUid = model.uid || `{${uuidv4().toUpperCase()}}`;
+        const uniqueUid = model.uid || `{${crypto.randomUUID().toUpperCase()}}`;
         xmlStream.openXml(XmlStream.StdDocAttributes);
         xmlStream.openNode(this.tag, {
             ...PivotTableXform.PIVOT_TABLE_ATTRIBUTES,

package/dist/esm/xlsx/xform/sheet/cf-ext/cf-rule-ext-xform.js

@@ -1,4 +1,3 @@
-import { v4 } from "uuid";
 import { BaseXform } from "../../base-xform.js";
 import { CompositeXform } from "../../composite-xform.js";
 import { DatabarExtXform } from "./databar-ext-xform.js";
@@ -33,7 +32,7 @@ class CfRuleExtXform extends CompositeXform {
     }
     prepare(model) {
         if (CfRuleExtXform.isExt(model)) {
-            model.x14Id = `{${v4()}}`.toUpperCase();
+            model.x14Id = `{${crypto.randomUUID()}}`.toUpperCase();
         }
     }
     render(xmlStream, model) {
@@ -61,7 +60,7 @@ class CfRuleExtXform extends CompositeXform {
         xmlStream.openNode(this.tag, {
             type: "iconSet",
             priority: model.priority,
-            id: model.x14Id || `{${v4()}}`
+            id: model.x14Id || `{${crypto.randomUUID()}}`
         });
         this.iconSetXform.render(xmlStream, model);
         xmlStream.closeNode();