@cj-tech-master/excelts 1.4.3 → 1.4.5

package/dist/cjs/doc/column.js

@@ -143,7 +143,7 @@ class Column {
         const colNumber = this.number;
         if (!iteratee) {
             iteratee = options;
-            options = null;
+            options = {};
         }
         this._worksheet.eachRow(options, (row, rowNumber) => {
             iteratee(row.getCell(colNumber), rowNumber);

package/dist/cjs/doc/row.js

@@ -115,10 +115,15 @@ class Row {
             cDst._comment = undefined;
         }
     }
-    eachCell(options, iteratee) {
-        if (!iteratee) {
-            iteratee = options;
-            options = null;
+    eachCell(optionsOrIteratee, maybeIteratee) {
+        let options = null;
+        let iteratee;
+        if (typeof optionsOrIteratee === "function") {
+            iteratee = optionsOrIteratee;
+        }
+        else {
+            options = optionsOrIteratee;
+            iteratee = maybeIteratee;
         }
         if (options && options.includeEmpty) {
             const n = this._cells.length;

package/dist/cjs/doc/worksheet.js

@@ -473,10 +473,15 @@ class Worksheet {
         // account for defined names
         this.workbook.definedNames.spliceRows(this.name, start, count, nInserts);
     }
-    eachRow(options, iteratee) {
-        if (!iteratee) {
-            iteratee = options;
-            options = undefined;
+    eachRow(optionsOrIteratee, maybeIteratee) {
+        let options;
+        let iteratee;
+        if (typeof optionsOrIteratee === "function") {
+            iteratee = optionsOrIteratee;
+        }
+        else {
+            options = optionsOrIteratee;
+            iteratee = maybeIteratee;
         }
         if (options && options.includeEmpty) {
             const n = this._rows.length;

package/dist/cjs/stream/xlsx/workbook-writer.js

@@ -37,8 +37,9 @@ class WorkbookWriter {
         this.views = [];
         this.zipOptions = options.zip;
         // Extract compression level from zip options (supports both zlib.level and compressionOptions.level)
-        // Default compression level is 6 (good balance of speed and size)
-        const level = options.zip?.zlib?.level ?? options.zip?.compressionOptions?.level ?? 6;
+        // Default compression level is 1 (fast compression with good ratio)
+        // Level 1 is ~2x faster than level 6 with only ~7% larger files
+        const level = options.zip?.zlib?.level ?? options.zip?.compressionOptions?.level ?? 1;
         this.compressionLevel = Math.max(0, Math.min(9, level));
         this.media = [];
         this.commentRefs = [];

package/dist/cjs/utils/unzip/extract.js

@@ -0,0 +1,166 @@
+"use strict";
+/**
+ * Simple ZIP extraction utilities
+ * Provides easy-to-use Promise-based API for extracting ZIP files
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractAll = extractAll;
+exports.extractFile = extractFile;
+exports.listFiles = listFiles;
+exports.forEachEntry = forEachEntry;
+const stream_1 = require("stream");
+const parse_js_1 = require("./parse");
+/**
+ * Extract all files from a ZIP buffer
+ *
+ * @param zipData - ZIP file data as Buffer or Uint8Array
+ * @returns Map of file paths to their content
+ *
+ * @example
+ * ```ts
+ * import { extractAll } from "./utils/unzip/extract.js";
+ *
+ * const zipData = fs.readFileSync("archive.zip");
+ * const files = await extractAll(zipData);
+ *
+ * for (const [path, file] of files) {
+ *   console.log(`${path}: ${file.data.length} bytes`);
+ * }
+ * ```
+ */
+async function extractAll(zipData) {
+    const files = new Map();
+    const buffer = Buffer.isBuffer(zipData) ? zipData : Buffer.from(zipData);
+    const parse = (0, parse_js_1.createParse)({ forceStream: true });
+    const stream = stream_1.Readable.from([buffer]);
+    stream.pipe(parse);
+    for await (const entry of parse) {
+        const zipEntry = entry;
+        const isDirectory = zipEntry.type === "Directory";
+        if (isDirectory) {
+            files.set(zipEntry.path, {
+                path: zipEntry.path,
+                data: Buffer.alloc(0),
+                isDirectory: true,
+                size: 0
+            });
+            zipEntry.autodrain();
+        }
+        else {
+            const data = await zipEntry.buffer();
+            files.set(zipEntry.path, {
+                path: zipEntry.path,
+                data,
+                isDirectory: false,
+                size: data.length
+            });
+        }
+    }
+    return files;
+}
+/**
+ * Extract a single file from a ZIP buffer
+ *
+ * @param zipData - ZIP file data as Buffer or Uint8Array
+ * @param filePath - Path of the file to extract
+ * @returns File content as Buffer, or null if not found
+ *
+ * @example
+ * ```ts
+ * import { extractFile } from "./utils/unzip/extract.js";
+ *
+ * const zipData = fs.readFileSync("archive.zip");
+ * const content = await extractFile(zipData, "readme.txt");
+ * if (content) {
+ *   console.log(content.toString("utf-8"));
+ * }
+ * ```
+ */
+async function extractFile(zipData, filePath) {
+    const buffer = Buffer.isBuffer(zipData) ? zipData : Buffer.from(zipData);
+    const parse = (0, parse_js_1.createParse)({ forceStream: true });
+    const stream = stream_1.Readable.from([buffer]);
+    stream.pipe(parse);
+    for await (const entry of parse) {
+        const zipEntry = entry;
+        if (zipEntry.path === filePath) {
+            if (zipEntry.type === "Directory") {
+                return Buffer.alloc(0);
+            }
+            return zipEntry.buffer();
+        }
+        zipEntry.autodrain();
+    }
+    return null;
+}
+/**
+ * List all file paths in a ZIP buffer (without extracting content)
+ *
+ * @param zipData - ZIP file data as Buffer or Uint8Array
+ * @returns Array of file paths
+ *
+ * @example
+ * ```ts
+ * import { listFiles } from "./utils/unzip/extract.js";
+ *
+ * const zipData = fs.readFileSync("archive.zip");
+ * const paths = await listFiles(zipData);
+ * console.log(paths); // ["file1.txt", "folder/file2.txt", ...]
+ * ```
+ */
+async function listFiles(zipData) {
+    const paths = [];
+    const buffer = Buffer.isBuffer(zipData) ? zipData : Buffer.from(zipData);
+    const parse = (0, parse_js_1.createParse)({ forceStream: true });
+    const stream = stream_1.Readable.from([buffer]);
+    stream.pipe(parse);
+    for await (const entry of parse) {
+        const zipEntry = entry;
+        paths.push(zipEntry.path);
+        zipEntry.autodrain();
+    }
+    return paths;
+}
+/**
+ * Iterate over ZIP entries with a callback (memory efficient for large ZIPs)
+ *
+ * @param zipData - ZIP file data as Buffer or Uint8Array
+ * @param callback - Async callback for each entry, return false to stop iteration
+ *
+ * @example
+ * ```ts
+ * import { forEachEntry } from "./utils/unzip/extract.js";
+ *
+ * await forEachEntry(zipData, async (path, getData) => {
+ *   if (path.endsWith(".xml")) {
+ *     const content = await getData();
+ *     console.log(content.toString("utf-8"));
+ *   }
+ *   return true; // continue iteration
+ * });
+ * ```
+ */
+async function forEachEntry(zipData, callback) {
+    const buffer = Buffer.isBuffer(zipData) ? zipData : Buffer.from(zipData);
+    const parse = (0, parse_js_1.createParse)({ forceStream: true });
+    const stream = stream_1.Readable.from([buffer]);
+    stream.pipe(parse);
+    for await (const entry of parse) {
+        const zipEntry = entry;
+        let dataPromise = null;
+        const getData = () => {
+            if (!dataPromise) {
+                dataPromise = zipEntry.buffer();
+            }
+            return dataPromise;
+        };
+        const shouldContinue = await callback(zipEntry.path, getData, zipEntry);
+        // If callback didn't read data, drain it
+        if (!dataPromise) {
+            zipEntry.autodrain();
+        }
+        if (shouldContinue === false) {
+            break;
+        }
+    }
+}

package/dist/cjs/utils/unzip/index.js

@@ -5,7 +5,7 @@
  * License: MIT
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseExtraField = exports.parseDateTime = exports.parseBuffer = exports.bufferStream = exports.NoopStream = exports.PullStream = exports.createParse = exports.Parse = void 0;
+exports.forEachEntry = exports.listFiles = exports.extractFile = exports.extractAll = exports.parseExtraField = exports.parseDateTime = exports.parseBuffer = exports.bufferStream = exports.NoopStream = exports.PullStream = exports.createParse = exports.Parse = void 0;
 var parse_js_1 = require("./parse");
 Object.defineProperty(exports, "Parse", { enumerable: true, get: function () { return parse_js_1.Parse; } });
 Object.defineProperty(exports, "createParse", { enumerable: true, get: function () { return parse_js_1.createParse; } });
@@ -21,3 +21,9 @@ var parse_datetime_js_1 = require("./parse-datetime");
 Object.defineProperty(exports, "parseDateTime", { enumerable: true, get: function () { return parse_datetime_js_1.parseDateTime; } });
 var parse_extra_field_js_1 = require("./parse-extra-field");
 Object.defineProperty(exports, "parseExtraField", { enumerable: true, get: function () { return parse_extra_field_js_1.parseExtraField; } });
+// Simple extraction API
+var extract_js_1 = require("./extract");
+Object.defineProperty(exports, "extractAll", { enumerable: true, get: function () { return extract_js_1.extractAll; } });
+Object.defineProperty(exports, "extractFile", { enumerable: true, get: function () { return extract_js_1.extractFile; } });
+Object.defineProperty(exports, "listFiles", { enumerable: true, get: function () { return extract_js_1.listFiles; } });
+Object.defineProperty(exports, "forEachEntry", { enumerable: true, get: function () { return extract_js_1.forEachEntry; } });

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

@@ -7,6 +7,8 @@ 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}="${(0, utils_js_1.xmlEncode)(value.toString())}"`);
 }
@@ -24,15 +26,23 @@ function pushAttributes(xml, attributes) {
 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._xml.length;
+        return this._chunks.length * CHUNK_SIZE + this._xml.length;
     }
     openXml(docAttributes) {
         const xml = this._xml;
@@ -99,6 +109,7 @@ class XmlStream {
         }
         this.open = false;
         this.leaf = false;
+        this._consolidate();
     }
     leafNode(name, attributes, text) {
         this.openNode(name, attributes);
@@ -118,7 +129,8 @@ class XmlStream {
             xml: this._xml.length,
             stack: this._stack.length,
             leaf: this.leaf,
-            open: this.open
+            open: this.open,
+            chunksLength: this._chunks.length
         });
         return this.cursor;
     }
@@ -133,12 +145,22 @@ class XmlStream {
         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();
-        return this._xml.join("");
+        // 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("");
     }
 }
 exports.XmlStream = XmlStream;

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

@@ -0,0 +1,261 @@
+"use strict";
+/**
+ * Native compression utilities using platform APIs
+ *
+ * - 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)
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureZlib = ensureZlib;
+exports.hasNativeZlib = hasNativeZlib;
+exports.hasCompressionStream = hasCompressionStream;
+exports.compress = compress;
+exports.compressSync = compressSync;
+exports.decompress = decompress;
+exports.decompressSync = decompressSync;
+// 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 = Promise.resolve().then(() => __importStar(require("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
+ */
+async function ensureZlib() {
+    if (_zlibLoading) {
+        return _zlibLoading;
+    }
+    return _zlib;
+}
+/**
+ * Check if native zlib is available (Node.js)
+ */
+function hasNativeZlib() {
+    const zlib = getZlib();
+    return zlib !== null && typeof zlib.deflateRawSync === "function";
+}
+/**
+ * Check if CompressionStream is available (Browser/Node.js 17+)
+ */
+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)
+ *
+ * @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 });
+ * ```
+ */
+async function compress(data, options = {}) {
+    const level = options.level ?? 6;
+    // Level 0 means no compression
+    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;
+}
+/**
+ * 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
+ */
+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 });
+    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
+ *
+ * @param data - Compressed data (deflate-raw format)
+ * @returns Decompressed data
+ */
+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");
+}
+/**
+ * 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
+ */
+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));
+    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;
+}