@cj-tech-master/excelts 1.1.0 → 1.4.1

package/dist/esm/utils/parse-sax.js

@@ -1,5 +1,5 @@
 import { SaxesParser } from "saxes";
-import { bufferToString } from "./browser-buffer-decode.js";
+import { bufferToString } from "./utils.js";
 async function* parseSax(iterable) {
     const saxesParser = new SaxesParser({
         xmlns: false,

package/dist/esm/utils/{extra-utils.js → sheet-utils.js}

@@ -1,87 +1,112 @@
 /**
  * Utility functions for ExcelTS
  * Provides convenient helper functions for common spreadsheet operations
- * compatible with xlsx library's utils API but built on excelts native types
  */
 import { Workbook } from "../doc/workbook.js";
 import { colCache } from "./col-cache.js";
+import { dateToExcel } from "./utils.js";
+import { format as cellFormat } from "./cell-format.js";
+/**
+ * Get formatted display text for a cell value
+ * Returns the value formatted according to the cell's numFmt
+ * This matches Excel's display exactly
+ */
+function getCellDisplayText(cell) {
+    const value = cell.value;
+    const fmt = cell.numFmt || "General";
+    // Null/undefined
+    if (value == null) {
+        return "";
+    }
+    // Date object - convert to Excel serial number
+    if (value instanceof Date) {
+        const serial = dateToExcel(value, false);
+        return cellFormat(fmt, serial);
+    }
+    // Number/Boolean/String - let cellFormat handle it
+    if (typeof value === "number" || typeof value === "boolean" || typeof value === "string") {
+        return cellFormat(fmt, value);
+    }
+    // Fallback to cell.text for other types (rich text, hyperlink, error, formula, etc.)
+    return cell.text;
+}
 // =============================================================================
 // Cell Address Encoding/Decoding
 // =============================================================================
 /**
  * Decode column string to 0-indexed number
- * @example decode_col("A") => 0, decode_col("Z") => 25, decode_col("AA") => 26
+ * @example decodeCol("A") => 0, decodeCol("Z") => 25, decodeCol("AA") => 26
  */
-export function decode_col(colstr) {
+export function decodeCol(colstr) {
     return colCache.l2n(colstr.toUpperCase()) - 1;
 }
 /**
  * Encode 0-indexed column number to string
- * @example encode_col(0) => "A", encode_col(25) => "Z", encode_col(26) => "AA"
+ * @example encodeCol(0) => "A", encodeCol(25) => "Z", encodeCol(26) => "AA"
  */
-export function encode_col(col) {
+export function encodeCol(col) {
     return colCache.n2l(col + 1);
 }
 /**
  * Decode row string to 0-indexed number
- * @example decode_row("1") => 0, decode_row("10") => 9
+ * @example decodeRow("1") => 0, decodeRow("10") => 9
  */
-export function decode_row(rowstr) {
+export function decodeRow(rowstr) {
     return parseInt(rowstr, 10) - 1;
 }
 /**
  * Encode 0-indexed row number to string
- * @example encode_row(0) => "1", encode_row(9) => "10"
+ * @example encodeRow(0) => "1", encodeRow(9) => "10"
  */
-export function encode_row(row) {
+export function encodeRow(row) {
     return String(row + 1);
 }
 /**
  * Decode cell address string to CellAddress object
- * @example decode_cell("A1") => {c: 0, r: 0}, decode_cell("B2") => {c: 1, r: 1}
+ * @example decodeCell("A1") => {c: 0, r: 0}, decodeCell("B2") => {c: 1, r: 1}
  */
-export function decode_cell(cstr) {
+export function decodeCell(cstr) {
     const addr = colCache.decodeAddress(cstr.toUpperCase());
     return { c: addr.col - 1, r: addr.row - 1 };
 }
 /**
  * Encode CellAddress object to cell address string
- * @example encode_cell({c: 0, r: 0}) => "A1", encode_cell({c: 1, r: 1}) => "B2"
+ * @example encodeCell({c: 0, r: 0}) => "A1", encodeCell({c: 1, r: 1}) => "B2"
  */
-export function encode_cell(cell) {
+export function encodeCell(cell) {
     return colCache.encodeAddress(cell.r + 1, cell.c + 1);
 }
 /**
  * Decode range string to Range object
- * @example decode_range("A1:B2") => {s: {c: 0, r: 0}, e: {c: 1, r: 1}}
+ * @example decodeRange("A1:B2") => {s: {c: 0, r: 0}, e: {c: 1, r: 1}}
  */
-export function decode_range(range) {
+export function decodeRange(range) {
     const idx = range.indexOf(":");
     if (idx === -1) {
-        const cell = decode_cell(range);
+        const cell = decodeCell(range);
         return { s: cell, e: { ...cell } };
     }
     return {
-        s: decode_cell(range.slice(0, idx)),
-        e: decode_cell(range.slice(idx + 1))
+        s: decodeCell(range.slice(0, idx)),
+        e: decodeCell(range.slice(idx + 1))
     };
 }
-export function encode_range(startOrRange, end) {
+export function encodeRange(startOrRange, end) {
     if (end === undefined) {
         const range = startOrRange;
-        return encode_range(range.s, range.e);
+        return encodeRange(range.s, range.e);
     }
     const start = startOrRange;
-    const startStr = encode_cell(start);
-    const endStr = encode_cell(end);
+    const startStr = encodeCell(start);
+    const endStr = encodeCell(end);
     return startStr === endStr ? startStr : `${startStr}:${endStr}`;
 }
 /**
  * Create a worksheet from an array of objects (xlsx compatible)
  * @example
- * const ws = json_to_sheet([{name: "Alice", age: 30}, {name: "Bob", age: 25}])
+ * const ws = jsonToSheet([{name: "Alice", age: 30}, {name: "Bob", age: 25}])
  */
-export function json_to_sheet(data, opts) {
+export function jsonToSheet(data, opts) {
     const o = opts || {};
     // Create a temporary workbook to get a worksheet
     const tempWb = new Workbook();
@@ -127,7 +152,7 @@ export function json_to_sheet(data, opts) {
 /**
  * Add data from an array of objects to an existing worksheet (xlsx compatible)
  */
-export function sheet_add_json(worksheet, data, opts) {
+export function sheetAddJson(worksheet, data, opts) {
     const o = opts || {};
     if (data.length === 0) {
         return worksheet;
@@ -137,7 +162,7 @@ export function sheet_add_json(worksheet, data, opts) {
     let startCol = 1;
     if (o.origin !== undefined) {
         if (typeof o.origin === "string") {
-            const addr = decode_cell(o.origin);
+            const addr = decodeCell(o.origin);
             startRow = addr.r + 1;
             startCol = addr.c + 1;
         }
@@ -193,18 +218,18 @@ export function sheet_add_json(worksheet, data, opts) {
  * Convert worksheet to JSON array (xlsx compatible)
  * @example
  * // Default: array of objects with first row as headers
- * const data = sheet_to_json(worksheet)
+ * const data = sheetToJson(worksheet)
  * // => [{name: "Alice", age: 30}, {name: "Bob", age: 25}]
  *
  * // Array of arrays
- * const aoa = sheet_to_json(worksheet, { header: 1 })
+ * const aoa = sheetToJson(worksheet, { header: 1 })
  * // => [["name", "age"], ["Alice", 30], ["Bob", 25]]
  *
  * // Column letters as keys
- * const cols = sheet_to_json(worksheet, { header: "A" })
+ * const cols = sheetToJson(worksheet, { header: "A" })
  * // => [{A: "name", B: "age"}, {A: "Alice", B: 30}]
  */
-export function sheet_to_json(worksheet, opts) {
+export function sheetToJson(worksheet, opts) {
     const o = opts || {};
     // Determine range
     let startRow = 1;
@@ -216,7 +241,7 @@ export function sheet_to_json(worksheet, opts) {
             startRow = o.range + 1; // 0-indexed to 1-indexed
         }
         else if (typeof o.range === "string") {
-            const r = decode_range(o.range);
+            const r = decodeRange(o.range);
             startRow = r.s.r + 1;
             endRow = r.e.r + 1;
             startCol = r.s.c + 1;
@@ -238,8 +263,8 @@ export function sheet_to_json(worksheet, opts) {
             let isEmpty = true;
             for (let col = startCol; col <= endCol; col++) {
                 const cell = worksheet.getCell(row, col);
-                const val = cell.value;
-                if (val != null) {
+                const val = o.raw === false ? getCellDisplayText(cell).trim() : cell.value;
+                if (val != null && val !== "") {
                     rowData[col - startCol] = val;
                     isEmpty = false;
                 }
@@ -266,9 +291,9 @@ export function sheet_to_json(worksheet, opts) {
             let isEmpty = true;
             for (let col = startCol; col <= endCol; col++) {
                 const cell = worksheet.getCell(row, col);
-                const val = cell.value;
-                const key = encode_col(col - 1); // 0-indexed for encode_col
-                if (val != null) {
+                const val = o.raw === false ? getCellDisplayText(cell).trim() : cell.value;
+                const key = encodeCol(col - 1); // 0-indexed for encodeCol
+                if (val != null && val !== "") {
                     rowData[key] = val;
                     isEmpty = false;
                 }
@@ -293,8 +318,8 @@ export function sheet_to_json(worksheet, opts) {
                 const colIdx = col - startCol;
                 const key = headerOpt[colIdx] ?? `__EMPTY_${colIdx}`;
                 const cell = worksheet.getCell(row, col);
-                const val = cell.value;
-                if (val != null) {
+                const val = o.raw === false ? getCellDisplayText(cell).trim() : cell.value;
+                if (val != null && val !== "") {
                     rowData[key] = val;
                     isEmpty = false;
                 }
@@ -335,9 +360,9 @@ export function sheet_to_json(worksheet, opts) {
         let isEmpty = true;
         for (let col = startCol; col <= endCol; col++) {
             const cell = worksheet.getCell(row, col);
-            const val = cell.value;
+            const val = o.raw === false ? getCellDisplayText(cell).trim() : cell.value;
             const key = headers[col - startCol];
-            if (val != null) {
+            if (val != null && val !== "") {
                 rowData[key] = val;
                 isEmpty = false;
             }
@@ -354,7 +379,7 @@ export function sheet_to_json(worksheet, opts) {
 /**
  * Convert worksheet to CSV string
  */
-export function sheet_to_csv(worksheet, opts) {
+export function sheetToCsv(worksheet, opts) {
     const o = opts || {};
     const FS = o.FS ?? ",";
     const RS = o.RS ?? "\n";
@@ -415,17 +440,17 @@ export function sheet_to_csv(worksheet, opts) {
 /**
  * Create a new workbook
  */
-export function book_new() {
+export function bookNew() {
     return new Workbook();
 }
 /**
  * Append worksheet to workbook (xlsx compatible)
  * @example
- * const wb = book_new();
- * const ws = json_to_sheet([{a: 1, b: 2}]);
- * book_append_sheet(wb, ws, "Sheet1");
+ * const wb = bookNew();
+ * const ws = jsonToSheet([{a: 1, b: 2}]);
+ * bookAppendSheet(wb, ws, "Sheet1");
  */
-export function book_append_sheet(workbook, worksheet, name) {
+export function bookAppendSheet(workbook, worksheet, name) {
     // Copy the worksheet data to a new sheet in the workbook
     const newWs = workbook.addWorksheet(name);
     // Copy all cells from source worksheet
@@ -450,9 +475,9 @@ export function book_append_sheet(workbook, worksheet, name) {
 /**
  * Create a worksheet from an array of arrays (xlsx compatible)
  * @example
- * const ws = aoa_to_sheet([["Name", "Age"], ["Alice", 30], ["Bob", 25]])
+ * const ws = aoaToSheet([["Name", "Age"], ["Alice", 30], ["Bob", 25]])
  */
-export function aoa_to_sheet(data, opts) {
+export function aoaToSheet(data, opts) {
     const tempWb = new Workbook();
     const worksheet = tempWb.addWorksheet("Sheet1");
     if (data.length === 0) {
@@ -463,7 +488,7 @@ export function aoa_to_sheet(data, opts) {
     let startCol = 1;
     if (opts?.origin !== undefined) {
         if (typeof opts.origin === "string") {
-            const addr = decode_cell(opts.origin);
+            const addr = decodeCell(opts.origin);
             startRow = addr.r + 1;
             startCol = addr.c + 1;
         }
@@ -490,7 +515,7 @@ export function aoa_to_sheet(data, opts) {
 /**
  * Add data from an array of arrays to an existing worksheet (xlsx compatible)
  */
-export function sheet_add_aoa(worksheet, data, opts) {
+export function sheetAddAoa(worksheet, data, opts) {
     if (data.length === 0) {
         return worksheet;
     }
@@ -499,7 +524,7 @@ export function sheet_add_aoa(worksheet, data, opts) {
     let startCol = 1;
     if (opts?.origin !== undefined) {
         if (typeof opts.origin === "string") {
-            const addr = decode_cell(opts.origin);
+            const addr = decodeCell(opts.origin);
             startRow = addr.r + 1;
             startCol = addr.c + 1;
         }
@@ -532,7 +557,7 @@ export function sheet_add_aoa(worksheet, data, opts) {
 /**
  * Convert worksheet to array of arrays
  */
-export function sheet_to_aoa(worksheet) {
+export function sheetToAoa(worksheet) {
     const result = [];
     worksheet.eachRow({ includeEmpty: true }, (row, rowNumber) => {
         const rowData = [];
@@ -547,24 +572,24 @@ export function sheet_to_aoa(worksheet) {
 // Export utils object
 // =============================================================================
 export const utils = {
-    // Cell encoding/decoding
-    decode_col,
-    encode_col,
-    decode_row,
-    encode_row,
-    decode_cell,
-    encode_cell,
-    decode_range,
-    encode_range,
-    // Sheet/JSON conversion
-    json_to_sheet,
-    sheet_add_json,
-    sheet_to_json,
-    sheet_to_csv,
-    aoa_to_sheet,
-    sheet_add_aoa,
-    sheet_to_aoa,
-    // Workbook functions
-    book_new,
-    book_append_sheet
+    // Cell encoding/decoding (camelCase)
+    decodeCol,
+    encodeCol,
+    decodeRow,
+    encodeRow,
+    decodeCell,
+    encodeCell,
+    decodeRange,
+    encodeRange,
+    // Sheet/JSON conversion (camelCase)
+    jsonToSheet,
+    sheetAddJson,
+    sheetToJson,
+    sheetToCsv,
+    aoaToSheet,
+    sheetAddAoa,
+    sheetToAoa,
+    // Workbook functions (camelCase)
+    bookNew,
+    bookAppendSheet
 };

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

@@ -198,14 +198,24 @@ inherits(StreamBuf, Duplex, {
         if (data instanceof StringBuf || (data && data.constructor?.name === "StringBuf")) {
             chunk = new StringBufChunk(data);
         }
-        else if (data instanceof Buffer) {
+        else if (Buffer.isBuffer(data)) {
+            // Use Buffer.isBuffer() instead of instanceof for cross-realm compatibility
+            // (e.g., Web Workers where Buffer polyfill instances may differ)
             chunk = new BufferChunk(data);
         }
-        else if (typeof data === "string" || data instanceof String || data instanceof ArrayBuffer) {
+        else if (ArrayBuffer.isView(data)) {
+            // Handle typed arrays (Uint8Array, Int8Array, etc.) - cross-realm safe
+            chunk = new BufferChunk(Buffer.from(data.buffer, data.byteOffset, data.byteLength));
+        }
+        else if (data instanceof ArrayBuffer) {
+            // Handle ArrayBuffer - convert to Buffer
+            chunk = new BufferChunk(Buffer.from(data));
+        }
+        else if (typeof data === "string" || data instanceof String) {
             chunk = new StringChunk(String(data), encoding);
         }
         else {
-            throw new Error("Chunk must be one of type String, Buffer or StringBuf.");
+            throw new Error("Chunk must be one of type String, Buffer, Uint8Array, ArrayBuffer or StringBuf.");
         }
         // now, do something with the chunk
         if (this.pipes.length) {
@@ -221,7 +231,8 @@ inherits(StreamBuf, Duplex, {
             }
             else {
                 this._writeToBuffers(chunk);
-                process.nextTick(callback);
+                // Use queueMicrotask for cross-platform compatibility (ES2020+)
+                queueMicrotask(() => callback());
             }
         }
         else {

package/dist/esm/utils/unzip/parse.js

@@ -6,13 +6,94 @@
  * Commits in this fork are (c) Ziggy Jonsson (ziggy.jonsson.nyc@gmail.com)
  */
 import zlib from "zlib";
-import { PassThrough, pipeline } from "stream";
+import { PassThrough, Transform, pipeline } from "stream";
 import { PullStream } from "./pull-stream.js";
 import { NoopStream } from "./noop-stream.js";
 import { bufferStream } from "./buffer-stream.js";
 import { parseExtraField } from "./parse-extra-field.js";
 import { parseDateTime } from "./parse-datetime.js";
 import { parse as parseBuffer } from "./parse-buffer.js";
+// Check if native zlib is available (Node.js environment)
+// In browser with polyfill, createInflateRaw may not exist or may not work properly
+const hasNativeZlib = typeof zlib?.createInflateRaw === "function" &&
+    typeof process !== "undefined" &&
+    process.versions?.node;
+/**
+ * A Transform stream that wraps browser's native DecompressionStream.
+ * Used when native zlib is not available (browser environment).
+ */
+class BrowserInflateRawStream extends Transform {
+    constructor() {
+        super();
+        this.chunks = [];
+        this.totalLength = 0;
+    }
+    _transform(chunk, _encoding, callback) {
+        // Avoid unnecessary copy - Buffer extends Uint8Array
+        this.chunks.push(chunk);
+        this.totalLength += chunk.length;
+        callback();
+    }
+    _flush(callback) {
+        try {
+            // Use pre-calculated totalLength for better performance
+            const combined = new Uint8Array(this.totalLength);
+            let offset = 0;
+            for (const chunk of this.chunks) {
+                combined.set(chunk, offset);
+                offset += chunk.length;
+            }
+            // Clear chunks to free memory
+            this.chunks = [];
+            // Use native DecompressionStream
+            const ds = new DecompressionStream("deflate-raw");
+            const writer = ds.writable.getWriter();
+            const reader = ds.readable.getReader();
+            // Optimized read loop - collect chunks and concatenate at the end
+            const readAll = async () => {
+                const results = [];
+                let total = 0;
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done) {
+                        break;
+                    }
+                    results.push(value);
+                    total += value.length;
+                }
+                // Single allocation for final result
+                const result = Buffer.allocUnsafe(total);
+                let off = 0;
+                for (const r of results) {
+                    result.set(r, off);
+                    off += r.length;
+                }
+                return result;
+            };
+            writer.write(combined);
+            writer.close();
+            readAll()
+                .then(decompressed => {
+                this.push(decompressed);
+                callback();
+            })
+                .catch(callback);
+        }
+        catch (err) {
+            callback(err);
+        }
+    }
+}
+/**
+ * Creates an InflateRaw stream.
+ * Uses native zlib in Node.js for best performance, falls back to DecompressionStream in browser.
+ */
+function createInflateRaw() {
+    if (hasNativeZlib) {
+        return zlib.createInflateRaw();
+    }
+    return new BrowserInflateRawStream();
+}
 const endDirectorySignature = Buffer.alloc(4);
 endDirectorySignature.writeUInt32LE(0x06054b50, 0);
 export class Parse extends PullStream {
@@ -168,7 +249,7 @@ export class Parse extends PullStream {
         const fileSizeKnown = !((vars.flags || 0) & 0x08) || vars.compressedSize > 0;
         let eof;
         entry.__autodraining = __autodraining; // expose __autodraining for test purposes
-        const inflater = vars.compressionMethod && !__autodraining ? zlib.createInflateRaw() : new PassThrough();
+        const inflater = vars.compressionMethod && !__autodraining ? createInflateRaw() : new PassThrough();
         if (fileSizeKnown) {
             entry.size = vars.uncompressedSize;
             eof = vars.compressedSize;

package/dist/esm/utils/utils.js

@@ -3,21 +3,6 @@ export function delay(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
 export function nop() { }
-export function promiseImmediate(value) {
-    return new Promise(resolve => {
-        if (global.setImmediate) {
-            setImmediate(() => {
-                resolve(value);
-            });
-        }
-        else {
-            // poorman's setImmediate - must wait at least 1ms
-            setTimeout(() => {
-                resolve(value);
-            }, 1);
-        }
-    });
-}
 // useful stuff
 export const inherits = function (cls, superCtor, statics, prototype) {
     cls.super_ = superCtor;
@@ -189,7 +174,6 @@ export function objectFromProps(props, value = null) {
 /** @deprecated Import functions directly instead of using the utils object */
 export const utils = {
     nop,
-    promiseImmediate,
     inherits,
     dateToExcel,
     excelToDate,
@@ -208,3 +192,15 @@ 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-stream.js

@@ -1,8 +1,6 @@
 import events from "events";
 import { Zip, ZipPassThrough, ZipDeflate } from "fflate";
 import { StreamBuf } from "./stream-buf.js";
-import { stringToBuffer } from "./browser-buffer-encode.js";
-import { isBrowser } from "./browser.js";
 // =============================================================================
 // The ZipWriter class
 // Packs streamed data into an output zip stream
@@ -36,39 +34,29 @@ class ZipWriter extends events.EventEmitter {
     append(data, options) {
         let buffer;
         if (Object.prototype.hasOwnProperty.call(options, "base64") && options.base64) {
-            // Use Buffer.from for efficient base64 decoding
+            // Decode base64 data - Buffer.from works in both Node.js and browser (via polyfill)
             const base64Data = typeof data === "string" ? data : data.toString();
-            if (isBrowser) {
-                // Browser: use atob with optimized Uint8Array conversion
-                const binaryString = atob(base64Data);
-                const len = binaryString.length;
-                buffer = new Uint8Array(len);
-                // Use a single loop with cached length for better performance
-                for (let i = 0; i < len; i++) {
-                    buffer[i] = binaryString.charCodeAt(i);
-                }
-            }
-            else {
-                // Node.js: use efficient Buffer.from
-                buffer = Buffer.from(base64Data, "base64");
-            }
+            buffer = Buffer.from(base64Data, "base64");
+        }
+        else if (typeof data === "string") {
+            // Convert string to Buffer - works in both environments
+            buffer = Buffer.from(data, "utf8");
+        }
+        else if (Buffer.isBuffer(data)) {
+            // Buffer extends Uint8Array, fflate can use it directly - no copy needed
+            buffer = data;
+        }
+        else if (ArrayBuffer.isView(data)) {
+            // Handle typed arrays - create view without copy
+            buffer = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+        }
+        else if (data instanceof ArrayBuffer) {
+            // Handle ArrayBuffer directly
+            buffer = new Uint8Array(data);
         }
         else {
-            if (typeof data === "string") {
-                // Convert string to Uint8Array
-                if (isBrowser) {
-                    buffer = stringToBuffer(data);
-                }
-                else {
-                    buffer = Buffer.from(data, "utf8");
-                }
-            }
-            else if (Buffer.isBuffer(data)) {
-                buffer = new Uint8Array(data);
-            }
-            else {
-                buffer = data;
-            }
+            // 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