@cj-tech-master/excelts 1.1.0 → 1.4.1

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

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseSax = parseSax;
 const saxes_1 = require("saxes");
-const browser_buffer_decode_js_1 = require("./browser-buffer-decode");
+const utils_js_1 = require("./utils");
 async function* parseSax(iterable) {
     const saxesParser = new saxes_1.SaxesParser({
         xmlns: false,
@@ -17,7 +17,7 @@ async function* parseSax(iterable) {
     saxesParser.on("text", (value) => events.push({ eventType: "text", value }));
     saxesParser.on("closetag", (value) => events.push({ eventType: "closetag", value }));
     for await (const chunk of iterable) {
-        saxesParser.write((0, browser_buffer_decode_js_1.bufferToString)(chunk));
+        saxesParser.write((0, utils_js_1.bufferToString)(chunk));
         // saxesParser.write and saxesParser.on() are synchronous,
         // so we can only reach the below line once all events have been emitted
         if (error) {

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

@@ -2,106 +2,131 @@
 /**
  * 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
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.utils = void 0;
-exports.decode_col = decode_col;
-exports.encode_col = encode_col;
-exports.decode_row = decode_row;
-exports.encode_row = encode_row;
-exports.decode_cell = decode_cell;
-exports.encode_cell = encode_cell;
-exports.decode_range = decode_range;
-exports.encode_range = encode_range;
-exports.json_to_sheet = json_to_sheet;
-exports.sheet_add_json = sheet_add_json;
-exports.sheet_to_json = sheet_to_json;
-exports.sheet_to_csv = sheet_to_csv;
-exports.book_new = book_new;
-exports.book_append_sheet = book_append_sheet;
-exports.aoa_to_sheet = aoa_to_sheet;
-exports.sheet_add_aoa = sheet_add_aoa;
-exports.sheet_to_aoa = sheet_to_aoa;
+exports.decodeCol = decodeCol;
+exports.encodeCol = encodeCol;
+exports.decodeRow = decodeRow;
+exports.encodeRow = encodeRow;
+exports.decodeCell = decodeCell;
+exports.encodeCell = encodeCell;
+exports.decodeRange = decodeRange;
+exports.encodeRange = encodeRange;
+exports.jsonToSheet = jsonToSheet;
+exports.sheetAddJson = sheetAddJson;
+exports.sheetToJson = sheetToJson;
+exports.sheetToCsv = sheetToCsv;
+exports.bookNew = bookNew;
+exports.bookAppendSheet = bookAppendSheet;
+exports.aoaToSheet = aoaToSheet;
+exports.sheetAddAoa = sheetAddAoa;
+exports.sheetToAoa = sheetToAoa;
 const workbook_js_1 = require("../doc/workbook");
 const col_cache_js_1 = require("./col-cache");
+const utils_js_1 = require("./utils");
+const cell_format_js_1 = require("./cell-format");
+/**
+ * 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 = (0, utils_js_1.dateToExcel)(value, false);
+        return (0, cell_format_js_1.format)(fmt, serial);
+    }
+    // Number/Boolean/String - let cellFormat handle it
+    if (typeof value === "number" || typeof value === "boolean" || typeof value === "string") {
+        return (0, cell_format_js_1.format)(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
  */
-function decode_col(colstr) {
+function decodeCol(colstr) {
     return col_cache_js_1.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"
  */
-function encode_col(col) {
+function encodeCol(col) {
     return col_cache_js_1.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
  */
-function decode_row(rowstr) {
+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"
  */
-function encode_row(row) {
+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}
  */
-function decode_cell(cstr) {
+function decodeCell(cstr) {
     const addr = col_cache_js_1.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"
  */
-function encode_cell(cell) {
+function encodeCell(cell) {
     return col_cache_js_1.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}}
  */
-function decode_range(range) {
+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))
     };
 }
-function encode_range(startOrRange, end) {
+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}])
  */
-function json_to_sheet(data, opts) {
+function jsonToSheet(data, opts) {
     const o = opts || {};
     // Create a temporary workbook to get a worksheet
     const tempWb = new workbook_js_1.Workbook();
@@ -147,7 +172,7 @@ function json_to_sheet(data, opts) {
 /**
  * Add data from an array of objects to an existing worksheet (xlsx compatible)
  */
-function sheet_add_json(worksheet, data, opts) {
+function sheetAddJson(worksheet, data, opts) {
     const o = opts || {};
     if (data.length === 0) {
         return worksheet;
@@ -157,7 +182,7 @@ 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;
         }
@@ -213,18 +238,18 @@ 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}]
  */
-function sheet_to_json(worksheet, opts) {
+function sheetToJson(worksheet, opts) {
     const o = opts || {};
     // Determine range
     let startRow = 1;
@@ -236,7 +261,7 @@ 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;
@@ -258,8 +283,8 @@ 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;
                 }
@@ -286,9 +311,9 @@ 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;
                 }
@@ -313,8 +338,8 @@ 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;
                 }
@@ -355,9 +380,9 @@ 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;
             }
@@ -374,7 +399,7 @@ function sheet_to_json(worksheet, opts) {
 /**
  * Convert worksheet to CSV string
  */
-function sheet_to_csv(worksheet, opts) {
+function sheetToCsv(worksheet, opts) {
     const o = opts || {};
     const FS = o.FS ?? ",";
     const RS = o.RS ?? "\n";
@@ -435,17 +460,17 @@ function sheet_to_csv(worksheet, opts) {
 /**
  * Create a new workbook
  */
-function book_new() {
+function bookNew() {
     return new workbook_js_1.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");
  */
-function book_append_sheet(workbook, worksheet, name) {
+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
@@ -470,9 +495,9 @@ 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]])
  */
-function aoa_to_sheet(data, opts) {
+function aoaToSheet(data, opts) {
     const tempWb = new workbook_js_1.Workbook();
     const worksheet = tempWb.addWorksheet("Sheet1");
     if (data.length === 0) {
@@ -483,7 +508,7 @@ 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;
         }
@@ -510,7 +535,7 @@ function aoa_to_sheet(data, opts) {
 /**
  * Add data from an array of arrays to an existing worksheet (xlsx compatible)
  */
-function sheet_add_aoa(worksheet, data, opts) {
+function sheetAddAoa(worksheet, data, opts) {
     if (data.length === 0) {
         return worksheet;
     }
@@ -519,7 +544,7 @@ 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;
         }
@@ -552,7 +577,7 @@ function sheet_add_aoa(worksheet, data, opts) {
 /**
  * Convert worksheet to array of arrays
  */
-function sheet_to_aoa(worksheet) {
+function sheetToAoa(worksheet) {
     const result = [];
     worksheet.eachRow({ includeEmpty: true }, (row, rowNumber) => {
         const rowData = [];
@@ -567,24 +592,24 @@ function sheet_to_aoa(worksheet) {
 // Export utils object
 // =============================================================================
 exports.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/cjs/utils/stream-buf.js

@@ -202,14 +202,24 @@ exports.StreamBuf = StreamBuf;
         if (data instanceof string_buf_js_1.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) {
@@ -225,7 +235,8 @@ exports.StreamBuf = StreamBuf;
             }
             else {
                 this._writeToBuffers(chunk);
-                process.nextTick(callback);
+                // Use queueMicrotask for cross-platform compatibility (ES2020+)
+                queueMicrotask(() => callback());
             }
         }
         else {

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

@@ -20,6 +20,87 @@ const buffer_stream_js_1 = require("./buffer-stream");
 const parse_extra_field_js_1 = require("./parse-extra-field");
 const parse_datetime_js_1 = require("./parse-datetime");
 const parse_buffer_js_1 = require("./parse-buffer");
+// 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_1.default?.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 stream_1.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_1.default.createInflateRaw();
+    }
+    return new BrowserInflateRawStream();
+}
 const endDirectorySignature = Buffer.alloc(4);
 endDirectorySignature.writeUInt32LE(0x06054b50, 0);
 class Parse extends pull_stream_js_1.PullStream {
@@ -175,7 +256,7 @@ class Parse extends pull_stream_js_1.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_1.default.createInflateRaw() : new stream_1.PassThrough();
+        const inflater = vars.compressionMethod && !__autodraining ? createInflateRaw() : new stream_1.PassThrough();
         if (fileSizeKnown) {
             entry.size = vars.uncompressedSize;
             eof = vars.compressedSize;

package/dist/cjs/utils/utils.js

@@ -6,7 +6,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.utils = exports.inherits = void 0;
 exports.delay = delay;
 exports.nop = nop;
-exports.promiseImmediate = promiseImmediate;
 exports.dateToExcel = dateToExcel;
 exports.excelToDate = excelToDate;
 exports.parsePath = parsePath;
@@ -21,26 +20,12 @@ exports.parseBoolean = parseBoolean;
 exports.range = range;
 exports.toSortedArray = toSortedArray;
 exports.objectFromProps = objectFromProps;
+exports.bufferToString = bufferToString;
 const fs_1 = __importDefault(require("fs"));
 function delay(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
 function nop() { }
-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
 const inherits = function (cls, superCtor, statics, prototype) {
     cls.super_ = superCtor;
@@ -213,7 +198,6 @@ function objectFromProps(props, value = null) {
 /** @deprecated Import functions directly instead of using the utils object */
 exports.utils = {
     nop,
-    promiseImmediate,
     inherits: exports.inherits,
     dateToExcel,
     excelToDate,
@@ -232,3 +216,15 @@ exports.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
+ */
+function bufferToString(chunk) {
+    if (typeof chunk === "string") {
+        return chunk;
+    }
+    return textDecoder.decode(chunk);
+}

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

@@ -7,8 +7,6 @@ exports.ZipWriter = void 0;
 const events_1 = __importDefault(require("events"));
 const fflate_1 = require("fflate");
 const stream_buf_js_1 = require("./stream-buf");
-const browser_buffer_encode_js_1 = require("./browser-buffer-encode");
-const browser_js_1 = require("./browser");
 // =============================================================================
 // The ZipWriter class
 // Packs streamed data into an output zip stream
@@ -42,39 +40,29 @@ class ZipWriter extends events_1.default.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 (browser_js_1.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 (browser_js_1.isBrowser) {
-                    buffer = (0, browser_buffer_encode_js_1.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