@cj-tech-master/excelts 1.4.3 → 1.4.5

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

@@ -5,37 +5,25 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZipWriter = void 0;
 const events_1 = __importDefault(require("events"));
-const fflate_1 = require("fflate");
+const index_js_1 = require("./zip/index");
 const stream_buf_js_1 = require("./stream-buf");
 // =============================================================================
 // The ZipWriter class
 // Packs streamed data into an output zip stream
+// Uses native zlib (Node.js) or CompressionStream (browser) for best performance
 class ZipWriter extends events_1.default.EventEmitter {
     constructor(options) {
         super();
-        this.options = Object.assign({
-            type: "nodebuffer",
-            compression: "DEFLATE"
-        }, options);
-        // Default compression level is 6 (good balance of speed and size)
-        // 0 = no compression, 9 = best compression
-        const level = this.options.compressionOptions?.level ?? 6;
-        this.compressionLevel = Math.max(0, Math.min(9, level));
-        this.files = {};
-        this.stream = new stream_buf_js_1.StreamBuf();
         this.finalized = false;
-        // Create fflate Zip instance for streaming compression
-        this.zip = new fflate_1.Zip((err, data, final) => {
-            if (err) {
-                this.stream.emit("error", err);
-            }
-            else {
-                this.stream.write(Buffer.from(data));
-                if (final) {
-                    this.stream.end();
-                }
-            }
-        });
+        this.pendingWrites = [];
+        // Determine compression level:
+        // - STORE mode = 0 (no compression)
+        // - DEFLATE mode = user level or default 1 (fast compression)
+        const level = options?.compression === "STORE"
+            ? 0
+            : Math.max(0, Math.min(9, options?.compressionOptions?.level ?? 1));
+        this.stream = new stream_buf_js_1.StreamBuf();
+        this.zipBuilder = new index_js_1.ZipBuilder({ level });
     }
     append(data, options) {
         let buffer;
@@ -49,7 +37,7 @@ class ZipWriter extends events_1.default.EventEmitter {
             buffer = Buffer.from(data, "utf8");
         }
         else if (Buffer.isBuffer(data)) {
-            // Buffer extends Uint8Array, fflate can use it directly - no copy needed
+            // Buffer extends Uint8Array, can use it directly - no copy needed
             buffer = data;
         }
         else if (ArrayBuffer.isView(data)) {
@@ -64,14 +52,16 @@ class ZipWriter extends events_1.default.EventEmitter {
             // Assume it's already a Uint8Array or compatible type
             buffer = data;
         }
-        // Add file to zip using streaming API
-        // Use ZipDeflate for compression or ZipPassThrough for no compression
-        const useCompression = this.options.compression !== "STORE";
-        const zipFile = useCompression
-            ? new fflate_1.ZipDeflate(options.name, { level: this.compressionLevel })
-            : new fflate_1.ZipPassThrough(options.name);
-        this.zip.add(zipFile);
-        zipFile.push(buffer, true); // true = final chunk
+        // Add file to zip using native compression
+        // addFile returns chunks that we write to stream immediately
+        const writePromise = this.zipBuilder
+            .addFile({ name: options.name, data: buffer })
+            .then(chunks => {
+            for (const chunk of chunks) {
+                this.stream.write(Buffer.from(chunk));
+            }
+        });
+        this.pendingWrites.push(writePromise);
     }
     push(chunk) {
         return this.stream.push(chunk);
@@ -81,8 +71,14 @@ class ZipWriter extends events_1.default.EventEmitter {
             return;
         }
         this.finalized = true;
-        // End the zip stream
-        this.zip.end();
+        // Wait for all pending writes to complete
+        await Promise.all(this.pendingWrites);
+        // Finalize the zip and write central directory
+        const finalChunks = this.zipBuilder.finalize();
+        for (const chunk of finalChunks) {
+            this.stream.write(Buffer.from(chunk));
+        }
+        this.stream.end();
         this.emit("finish");
     }
     // ==========================================================================

package/dist/cjs/xlsx/xform/book/defined-name-xform.js

@@ -46,16 +46,50 @@ class DefinedNamesXform extends base_xform_js_1.BaseXform {
     }
 }
 exports.DefinedNamesXform = DefinedNamesXform;
+// Regex to validate cell range format:
+// - Cell: $A$1 or A1
+// - Range: $A$1:$B$10 or A1:B10
+// - Row range: $1:$2 (for print titles)
+// - Column range: $A:$B (for print titles)
+const cellRangeRegexp = /^[$]?[A-Za-z]{1,3}[$]?\d+(:[$]?[A-Za-z]{1,3}[$]?\d+)?$/;
+const rowRangeRegexp = /^[$]?\d+:[$]?\d+$/;
+const colRangeRegexp = /^[$]?[A-Za-z]{1,3}:[$]?[A-Za-z]{1,3}$/;
 function isValidRange(range) {
+    // Skip array constants wrapped in {} - these are not valid cell ranges
+    // e.g., {"'Sheet1'!$A$1:$B$10"} or {#N/A,#N/A,FALSE,"text"}
+    if (range.startsWith("{") || range.endsWith("}")) {
+        return false;
+    }
+    // Extract the cell reference part (after the sheet name if present)
+    const cellRef = range.split("!").pop() || "";
+    // Must match one of the valid patterns
+    if (!cellRangeRegexp.test(cellRef) &&
+        !rowRangeRegexp.test(cellRef) &&
+        !colRangeRegexp.test(cellRef)) {
+        return false;
+    }
     try {
-        col_cache_js_1.colCache.decodeEx(range);
-        return true;
+        const decoded = col_cache_js_1.colCache.decodeEx(range);
+        // For cell ranges: row/col or top/bottom/left/right should be valid numbers
+        // For row ranges ($1:$2): top/bottom are numbers, left/right are null
+        // For column ranges ($A:$B): left/right are numbers, top/bottom are null
+        if (("row" in decoded && typeof decoded.row === "number") ||
+            ("top" in decoded && typeof decoded.top === "number") ||
+            ("left" in decoded && typeof decoded.left === "number")) {
+            return true;
+        }
+        return false;
     }
     catch {
         return false;
     }
 }
 function extractRanges(parsedText) {
+    // Skip if the entire text is wrapped in {} (array constant)
+    const trimmed = parsedText.trim();
+    if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+        return [];
+    }
     const ranges = [];
     let quotesOpened = false;
     let last = "";

package/dist/cjs/xlsx/xform/list-xform.js

@@ -82,5 +82,11 @@ class ListXform extends base_xform_js_1.BaseXform {
             });
         }
     }
+    reset() {
+        super.reset();
+        if (this.childXform) {
+            this.childXform.reset();
+        }
+    }
 }
 exports.ListXform = ListXform;

package/dist/cjs/xlsx/xform/sheet/cell-xform.js

@@ -410,7 +410,12 @@ class CellXform extends base_xform_js_1.BaseXform {
                 }
                 break;
             case enums_js_1.Enums.ValueType.Formula:
-                if (model.result !== undefined && style && (0, utils_js_1.isDateFmt)(style.numFmt)) {
+                // Only convert formula result to date if the result is a number
+                // String results (t="str") should not be converted even if the cell has a date format
+                if (model.result !== undefined &&
+                    typeof model.result === "number" &&
+                    style &&
+                    (0, utils_js_1.isDateFmt)(style.numFmt)) {
                     model.result = (0, utils_js_1.excelToDate)(model.result, options.date1904);
                 }
                 if (model.shareType === "shared") {

package/dist/cjs/xlsx/xform/sheet/row-xform.js

@@ -4,6 +4,7 @@ exports.RowXform = void 0;
 const base_xform_js_1 = require("../base-xform");
 const cell_xform_js_1 = require("./cell-xform");
 const utils_js_1 = require("../../../utils/utils");
+const col_cache_js_1 = require("../../../utils/col-cache");
 class RowXform extends base_xform_js_1.BaseXform {
     constructor(options) {
         super();
@@ -15,6 +16,11 @@ class RowXform extends base_xform_js_1.BaseXform {
     get tag() {
         return "row";
     }
+    reset() {
+        super.reset();
+        this.numRowsSeen = 0;
+        this.lastCellCol = 0;
+    }
     prepare(model, options) {
         const styleId = options.styles.addStyleModel(model.style);
         if (styleId) {
@@ -65,11 +71,15 @@ class RowXform extends base_xform_js_1.BaseXform {
         }
         if (node.name === "row") {
             this.numRowsSeen += 1;
+            // Reset lastCellCol for each new row
+            this.lastCellCol = 0;
             const spans = node.attributes.spans
                 ? node.attributes.spans.split(":").map((span) => parseInt(span, 10))
                 : [undefined, undefined];
+            // If r attribute is missing, use numRowsSeen as the row number
+            const rowNumber = node.attributes.r ? parseInt(node.attributes.r, 10) : this.numRowsSeen;
             const model = (this.model = {
-                number: parseInt(node.attributes.r, 10),
+                number: rowNumber,
                 min: spans[0],
                 max: spans[1],
                 cells: []
@@ -109,7 +119,19 @@ class RowXform extends base_xform_js_1.BaseXform {
     parseClose(name) {
         if (this.parser) {
             if (!this.parser.parseClose(name)) {
-                this.model.cells.push(this.parser.model);
+                const cellModel = this.parser.model;
+                // If cell has address, extract column number from it
+                // Otherwise, calculate address based on position
+                if (cellModel.address) {
+                    const decoded = col_cache_js_1.colCache.decodeAddress(cellModel.address);
+                    this.lastCellCol = decoded.col;
+                }
+                else {
+                    // No r attribute, calculate address from position
+                    this.lastCellCol += 1;
+                    cellModel.address = col_cache_js_1.colCache.encodeAddress(this.model.number, this.lastCellCol);
+                }
+                this.model.cells.push(cellModel);
                 if (this.maxItems && this.model.cells.length > this.maxItems) {
                     throw new Error(`Max column count (${this.maxItems}) exceeded`);
                 }

package/dist/cjs/xlsx/xform/table/filter-column-xform.js

@@ -57,6 +57,10 @@ class FilterColumnXform extends base_xform_js_1.BaseXform {
                     filterButton: attributes.hiddenButton === "0"
                 };
                 return true;
+            case "dynamicFilter":
+                // Ignore dynamicFilter nodes - we don't need to preserve them for reading
+                // See: https://github.com/exceljs/exceljs/issues/2972
+                return true;
             default:
                 this.parser = this.map[node.name];
                 if (this.parser) {

package/dist/esm/doc/column.js

@@ -140,7 +140,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/esm/doc/row.js

@@ -112,10 +112,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/esm/doc/worksheet.js

@@ -470,10 +470,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/esm/stream/xlsx/workbook-writer.js

@@ -31,8 +31,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/esm/utils/unzip/extract.js

@@ -0,0 +1,160 @@
+/**
+ * Simple ZIP extraction utilities
+ * Provides easy-to-use Promise-based API for extracting ZIP files
+ */
+import { Readable } from "stream";
+import { createParse } from "./parse.js";
+/**
+ * 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`);
+ * }
+ * ```
+ */
+export async function extractAll(zipData) {
+    const files = new Map();
+    const buffer = Buffer.isBuffer(zipData) ? zipData : Buffer.from(zipData);
+    const parse = createParse({ forceStream: true });
+    const stream = 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"));
+ * }
+ * ```
+ */
+export async function extractFile(zipData, filePath) {
+    const buffer = Buffer.isBuffer(zipData) ? zipData : Buffer.from(zipData);
+    const parse = createParse({ forceStream: true });
+    const stream = 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", ...]
+ * ```
+ */
+export async function listFiles(zipData) {
+    const paths = [];
+    const buffer = Buffer.isBuffer(zipData) ? zipData : Buffer.from(zipData);
+    const parse = createParse({ forceStream: true });
+    const stream = 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
+ * });
+ * ```
+ */
+export async function forEachEntry(zipData, callback) {
+    const buffer = Buffer.isBuffer(zipData) ? zipData : Buffer.from(zipData);
+    const parse = createParse({ forceStream: true });
+    const stream = 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/esm/utils/unzip/index.js

@@ -10,3 +10,5 @@ export { bufferStream } from "./buffer-stream.js";
 export { parse as parseBuffer } from "./parse-buffer.js";
 export { parseDateTime } from "./parse-datetime.js";
 export { parseExtraField } from "./parse-extra-field.js";
+// Simple extraction API
+export { extractAll, extractFile, listFiles, forEachEntry } from "./extract.js";

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

@@ -4,6 +4,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}="${xmlEncode(value.toString())}"`);
 }
@@ -21,15 +23,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;
@@ -96,6 +106,7 @@ class XmlStream {
         }
         this.open = false;
         this.leaf = false;
+        this._consolidate();
     }
     leafNode(name, attributes, text) {
         this.openNode(name, attributes);
@@ -115,7 +126,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;
     }
@@ -130,12 +142,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("");
     }
 }
 XmlStream.StdDocAttributes = {