@cj-tech-master/excelts 7.6.0 → 8.0.0

package/dist/cjs/modules/archive/compression/streaming-compress.browser.js

@@ -19,6 +19,7 @@ exports.createGzipStream = createGzipStream;
 exports.createGunzipStream = createGunzipStream;
 exports.createZlibStream = createZlibStream;
 exports.createUnzlibStream = createUnzlibStream;
+exports.hasNativeAsyncDeflate = hasNativeAsyncDeflate;
 const event_emitter_1 = require("../../../utils/event-emitter.js");
 const deflate_fallback_1 = require("./deflate-fallback.js");
 Object.defineProperty(exports, "SyncDeflater", { enumerable: true, get: function () { return deflate_fallback_1.SyncDeflater; } });
@@ -264,10 +265,13 @@ function createStreamCodec(type, options) {
     if (options.useWorker && (0, index_browser_1.hasWorkerSupport)()) {
         return createWorkerStreamCodec(type, options.workerPool, level, options.allowTransfer);
     }
-    if ((0, compress_base_1.hasDeflateRawWebStreams)()) {
+    // Use native CompressionStream/DecompressionStream when the required
+    // direction is available. Compression only needs CompressionStream;
+    // decompression only needs DecompressionStream.
+    if (type === "deflate" ? (0, compress_base_1.hasDeflateRawCompressionStream)() : (0, compress_base_1.hasDeflateRawWebStreams)()) {
         return createNativeWebStreamCodec("deflate-raw", type === "deflate");
     }
-    return new BufferedCodec(type === "deflate" ? deflate_fallback_1.deflateRawCompressed : deflate_fallback_1.inflateRaw);
+    return new BufferedCodec(type === "deflate" ? data => (0, deflate_fallback_1.deflateRawCompressed)(data, level) : deflate_fallback_1.inflateRaw);
 }
 // =============================================================================
 // Public API
@@ -319,3 +323,12 @@ function createZlibStream(options = {}) {
 function createUnzlibStream(options = {}) {
     return createWrappedStream(ZLIB_CONFIG, false, options);
 }
+/**
+ * Returns true when the browser supports native `CompressionStream("deflate-raw")`,
+ * signalling that `push()` should prefer the async path over `SyncDeflater`.
+ *
+ * Only checks for compression support — decompression is not needed for writing.
+ */
+function hasNativeAsyncDeflate() {
+    return (0, compress_base_1.hasDeflateRawCompressionStream)();
+}

package/dist/cjs/modules/archive/compression/streaming-compress.js

@@ -14,6 +14,7 @@ exports.createGzipStream = createGzipStream;
 exports.createGunzipStream = createGunzipStream;
 exports.createZlibStream = createZlibStream;
 exports.createUnzlibStream = createUnzlibStream;
+exports.hasNativeAsyncDeflate = hasNativeAsyncDeflate;
 const zlib_1 = require("zlib");
 const _stream_1 = require("../../stream/index.js");
 const defaults_1 = require("../shared/defaults.js");
@@ -177,3 +178,10 @@ class SyncDeflater {
     }
 }
 exports.SyncDeflater = SyncDeflater;
+/**
+ * On Node.js, `zlib.deflateRawSync` is native and fast — no need to detour
+ * through the async streaming path. Always returns false.
+ */
+function hasNativeAsyncDeflate() {
+    return false;
+}

package/dist/cjs/modules/archive/zip/stream.js

@@ -574,6 +574,12 @@ class ZipDeflateFile {
             this._tapCallback(promise, callback);
             return promise;
         }
+        // If a previous async operation already failed, don't do more work.
+        if (this._completeError) {
+            const promise = Promise.reject(this._completeError);
+            this._tapCallback(promise, callback);
+            return promise;
+        }
         if (this._deflateWanted === null) {
             this._accumulateSampleLen(data);
             if (!this._shouldDecide(final)) {
@@ -616,7 +622,16 @@ class ZipDeflateFile {
      * memory growth when callers push data in a tight synchronous loop.
      */
     push(data, final = false, callback) {
-        if (!this._deflate && this._encryptionMethod === "none") {
+        // Use the synchronous path only when:
+        //  1. No async deflate stream is already active
+        //  2. No encryption (which requires async crypto)
+        //  3. No native async deflate available (browser CompressionStream)
+        //
+        // When a native async CompressionStream("deflate-raw") is available
+        // (modern browsers), prefer the async path — it produces better
+        // compression (Dynamic Huffman via the browser's native engine) and
+        // doesn't block the main thread.
+        if (!this._deflate && this._encryptionMethod === "none" && !(0, streaming_compress_1.hasNativeAsyncDeflate)()) {
             try {
                 this._pushSyncPath(data, final);
                 callback?.();
@@ -627,7 +642,10 @@ class ZipDeflateFile {
             }
             return Promise.resolve();
         }
-        const promise = (this._pushChain = this._pushChain.then(() => this._pushUnchained(data, final, callback)));
+        // Chain the async push so calls are serialized. Use a recovery wrapper
+        // so that a single failed push does not break the chain for subsequent
+        // pushes — errors are surfaced via onerror/rejectComplete instead.
+        const promise = (this._pushChain = this._pushChain.then(() => this._pushUnchained(data, final, callback), () => this._pushUnchained(data, final, callback)));
         // Prevent unhandled rejection when callers intentionally ignore the Promise.
         promise.catch(() => { });
         return promise;
@@ -698,6 +716,12 @@ class ZipDeflateFile {
             this._syncDeflater = null;
         }
         this._emitDataDescriptor();
+        // _emitDataDescriptor may call _rejectComplete instead of throwing
+        // (e.g. ZIP64 required but zip64=false). In the sync path, surface
+        // this as a throw so push() can reject properly.
+        if (this._completeError) {
+            throw this._completeError;
+        }
     }
     /**
      * Emit local file header with Data Descriptor flag

package/dist/cjs/modules/excel/workbook.browser.js

@@ -22,6 +22,8 @@ const parse_1 = require("../csv/parse/index.js");
 const format_1 = require("../csv/format/index.js");
 const stream_1 = require("../csv/stream/index.js");
 const number_1 = require("../csv/utils/number.js");
+const index_1 = require("../markdown/parse/index.js");
+const index_2 = require("../markdown/format/index.js");
 const errors_1 = require("./errors.js");
 const _stream_1 = require("../stream/index.js");
 const utils_base_1 = require("../stream/utils.base.js");
@@ -116,6 +118,57 @@ function createDefaultWriteMapper(dateFormat, dateUTC) {
     };
 }
 // =============================================================================
+// Markdown Value Mapper (Internal)
+// =============================================================================
+/**
+ * Create a stringify function for Markdown output.
+ * Handles hyperlinks, formulas, rich text, dates, errors, and objects.
+ */
+function createMarkdownStringify(dateFormat, dateUTC) {
+    const formatter = dateFormat
+        ? datetime_1.DateFormatter.create(dateFormat, { utc: dateUTC })
+        : datetime_1.DateFormatter.iso(dateUTC);
+    return function stringify(value) {
+        if (value === null || value === undefined) {
+            return "";
+        }
+        if (typeof value === "string") {
+            return value;
+        }
+        if (typeof value === "number" || typeof value === "bigint") {
+            return String(value);
+        }
+        if (typeof value === "boolean") {
+            return value ? "true" : "false";
+        }
+        if (value instanceof Date) {
+            return formatter.format(value);
+        }
+        if (typeof value === "object") {
+            const v = value;
+            if (v.text || v.hyperlink) {
+                return v.hyperlink || v.text || "";
+            }
+            if (v.formula || v.result) {
+                return v.result != null ? String(v.result) : "";
+            }
+            if (v.richText && Array.isArray(v.richText)) {
+                return v.richText.map((r) => r.text).join("");
+            }
+            if (v.error) {
+                return v.error;
+            }
+            try {
+                return JSON.stringify(value);
+            }
+            catch {
+                return "[object Object]";
+            }
+        }
+        return String(value);
+    };
+}
+// =============================================================================
 // CSV Input Type Detection (Internal)
 // =============================================================================
 function isUrl(input) {
@@ -563,6 +616,179 @@ class Workbook {
         formatter.end();
         await pipelinePromise;
     }
+    /**
+     * Populate a worksheet from a parsed Markdown table result.
+     * Shared by readMarkdown and readMarkdownAll.
+     */
+    _populateMarkdownWorksheet(worksheet, result, map) {
+        worksheet.addRow(result.headers);
+        worksheet._markdownAlignments = result.alignments;
+        for (const row of result.rows) {
+            if (map) {
+                worksheet.addRow(row.map((v, i) => map(v, i)));
+            }
+            else {
+                worksheet.addRow(row);
+            }
+        }
+    }
+    /**
+     * Read a Markdown table and add as worksheet.
+     *
+     * @example
+     * ```ts
+     * // From a Markdown string
+     * workbook.readMarkdown("| Name | Age |\n| --- | --- |\n| Alice | 30 |");
+     *
+     * // With options
+     * workbook.readMarkdown(markdownString, { sheetName: "Data", map: (v, col) => Number(v) || v });
+     * ```
+     */
+    readMarkdown(input, options) {
+        const parseResult = (0, index_1.parseMarkdown)(input, {
+            trim: options?.trim,
+            unescape: options?.unescape,
+            skipEmptyRows: options?.skipEmptyRows,
+            maxRows: options?.maxRows,
+            convertBr: options?.convertBr
+        });
+        const worksheet = this.addWorksheet(options?.sheetName);
+        this._populateMarkdownWorksheet(worksheet, parseResult, options?.map);
+        return worksheet;
+    }
+    /**
+     * Read all Markdown tables from a document, each becoming a separate worksheet.
+     *
+     * @param input - Markdown string containing one or more tables
+     * @param options - Parse options (sheetName is used as prefix: "sheetName", "sheetName_2", ...)
+     * @returns Array of created worksheets (empty if no tables found)
+     *
+     * @example
+     * ```ts
+     * // Parse a document with multiple tables
+     * const sheets = workbook.readMarkdownAll(markdownDoc);
+     * console.log(`Created ${sheets.length} worksheets`);
+     *
+     * // With a naming prefix
+     * const sheets = workbook.readMarkdownAll(markdownDoc, { sheetName: "Table" });
+     * // Creates "Table", "Table_2", "Table_3", ...
+     * ```
+     */
+    readMarkdownAll(input, options) {
+        const parseResults = (0, index_1.parseMarkdownAll)(input, {
+            trim: options?.trim,
+            unescape: options?.unescape,
+            skipEmptyRows: options?.skipEmptyRows,
+            maxRows: options?.maxRows,
+            convertBr: options?.convertBr
+        });
+        const baseName = options?.sheetName;
+        const map = options?.map;
+        const worksheets = [];
+        for (let t = 0; t < parseResults.length; t++) {
+            const name = baseName ? (t === 0 ? baseName : `${baseName}_${t + 1}`) : undefined;
+            const worksheet = this.addWorksheet(name);
+            this._populateMarkdownWorksheet(worksheet, parseResults[t], map);
+            worksheets.push(worksheet);
+        }
+        return worksheets;
+    }
+    /**
+     * Write worksheet as a Markdown table string.
+     *
+     * @example
+     * ```ts
+     * // Write first worksheet
+     * const markdownText = workbook.writeMarkdown();
+     *
+     * // Write specific worksheet with options
+     * const markdownText = workbook.writeMarkdown({ sheetName: "Data", padding: true });
+     * ```
+     */
+    writeMarkdown(options) {
+        const worksheet = this.getWorksheet(options?.sheetName || options?.sheetId);
+        if (!worksheet) {
+            return "";
+        }
+        const dateFormat = options?.dateFormat;
+        const dateUTC = options?.dateUTC;
+        const includeEmptyRows = options?.includeEmptyRows !== false;
+        // Build stringify function
+        const stringify = options?.stringify ?? createMarkdownStringify(dateFormat, dateUTC);
+        // Collect all rows from worksheet
+        const allRows = [];
+        let lastRow = 1;
+        worksheet.eachRow((row, rowNumber) => {
+            if (includeEmptyRows) {
+                while (lastRow++ < rowNumber - 1) {
+                    allRows.push([]);
+                }
+            }
+            // row.values is a 1-indexed sparse array — use Array.from to fill holes
+            // with undefined, then slice(1) to remove the leading 1-indexed slot
+            const values = Array.from(row.values).slice(1);
+            allRows.push(values);
+            lastRow = rowNumber;
+        });
+        if (allRows.length === 0) {
+            return "";
+        }
+        // First row is the header
+        const headerRow = allRows[0];
+        const headers = headerRow.map(v => stringify(v));
+        const dataRows = allRows.slice(1);
+        // Check for stored alignments from a previous readMarkdown
+        const storedAlignments = worksheet
+            ._markdownAlignments;
+        // Build column configs
+        const columns = options?.columns;
+        let resolvedColumns;
+        if (!columns && storedAlignments) {
+            // Use stored alignments from parsed Markdown
+            resolvedColumns = headers.map((h, i) => ({
+                header: h,
+                alignment: i < storedAlignments.length ? storedAlignments[i] : undefined
+            }));
+        }
+        return (0, index_2.formatMarkdown)(headers, dataRows, {
+            columns: resolvedColumns ?? columns,
+            alignment: options?.alignment,
+            padding: options?.padding,
+            trailingNewline: options?.trailingNewline,
+            escapeContent: options?.escapeContent,
+            stringify
+        });
+    }
+    /**
+     * Write worksheet to Markdown buffer (Uint8Array).
+     *
+     * @example
+     * ```ts
+     * const buffer = workbook.writeMarkdownBuffer();
+     * ```
+     */
+    writeMarkdownBuffer(options) {
+        const markdownString = this.writeMarkdown(options);
+        return new TextEncoder().encode(markdownString);
+    }
+    /**
+     * Read Markdown from file (Node.js only - throws in browser)
+     */
+    async readMarkdownFile(_filename, _options) {
+        throw new errors_1.ExcelNotSupportedError("readMarkdownFile()", "not available in browser. Use readMarkdown(string) instead.");
+    }
+    /**
+     * Read all Markdown tables from file (Node.js only - throws in browser)
+     */
+    async readMarkdownAllFile(_filename, _options) {
+        throw new errors_1.ExcelNotSupportedError("readMarkdownAllFile()", "not available in browser. Use readMarkdownAll(string) instead.");
+    }
+    /**
+     * Write Markdown to file (Node.js only - throws in browser)
+     */
+    async writeMarkdownFile(_filename, _options) {
+        throw new errors_1.ExcelNotSupportedError("writeMarkdownFile()", "not available in browser. Use writeMarkdown() and trigger a download instead.");
+    }
     // ===========================================================================
     // Static Factory Methods for Streaming
     // ===========================================================================

package/dist/cjs/modules/excel/workbook.js

@@ -2,7 +2,7 @@
 /**
  * Workbook - Node.js Version
  *
- * Extends browser Workbook with Node.js file system support for CSV operations.
+ * Extends browser Workbook with Node.js file system support for CSV and Markdown operations.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Workbook = void 0;
@@ -60,5 +60,50 @@ class Workbook extends workbook_browser_1.Workbook {
         }
         return this._writeCsvStream(writeStream, options);
     }
+    /**
+     * Read Markdown table from file (Node.js only)
+     *
+     * @example
+     * ```ts
+     * await workbook.readMarkdownFile("table.md");
+     * await workbook.readMarkdownFile("table.md", { sheetName: "Data" });
+     * ```
+     */
+    async readMarkdownFile(filename, options) {
+        if (!(await (0, fs_1.fileExists)(filename))) {
+            throw new errors_1.ExcelFileError(filename, "read", "file not found");
+        }
+        const content = await (0, fs_1.readFileText)(filename);
+        return this.readMarkdown(content, options);
+    }
+    /**
+     * Read all Markdown tables from file, each as a separate worksheet (Node.js only)
+     *
+     * @example
+     * ```ts
+     * await workbook.readMarkdownAllFile("doc.md");
+     * await workbook.readMarkdownAllFile("doc.md", { sheetName: "Table" });
+     * ```
+     */
+    async readMarkdownAllFile(filename, options) {
+        if (!(await (0, fs_1.fileExists)(filename))) {
+            throw new errors_1.ExcelFileError(filename, "read", "file not found");
+        }
+        const content = await (0, fs_1.readFileText)(filename);
+        return this.readMarkdownAll(content, options);
+    }
+    /**
+     * Write Markdown table to file (Node.js only)
+     *
+     * @example
+     * ```ts
+     * await workbook.writeMarkdownFile("output.md");
+     * await workbook.writeMarkdownFile("output.md", { sheetName: "Data", padding: true });
+     * ```
+     */
+    async writeMarkdownFile(filename, options) {
+        const markdownString = this.writeMarkdown(options);
+        await (0, fs_1.writeFileText)(filename, markdownString);
+    }
 }
 exports.Workbook = Workbook;

package/dist/cjs/modules/excel/xlsx/xlsx.browser.js

@@ -49,6 +49,13 @@ class StreamingZipWriterAdapter {
         // Backpressure tracking
         this._needsDrain = false;
         this._drainResolvers = [];
+        // Count of in-flight async write() calls whose backpressure result is unknown.
+        // waitForDrain() must wait for this to reach 0 before checking _needsDrain.
+        this._pendingWrites = 0;
+        this._pendingWriteResolvers = [];
+        // Buffer errors that occur before _finalize registers its error listener,
+        // so async compression errors during writeToZip() are never silently lost.
+        this._earlyError = null;
         this.level = options?.level ?? 6;
         this.modTime = options?.modTime;
         this.timestamps = options?.timestamps;
@@ -72,6 +79,15 @@ class StreamingZipWriterAdapter {
         });
     }
     _emit(event, ...args) {
+        // Buffer error events that fire before any listener is registered,
+        // so _finalize() can surface them even if it registers late.
+        if (event === "error") {
+            const callbacks = this.events.get(event);
+            if (!callbacks || callbacks.size === 0) {
+                this._earlyError = args[0] instanceof Error ? args[0] : new Error(String(args[0]));
+                return;
+            }
+        }
         const callbacks = this.events.get(event);
         if (!callbacks) {
             return;
@@ -86,12 +102,21 @@ class StreamingZipWriterAdapter {
      */
     _checkBackpressure(ok) {
         if (ok instanceof Promise) {
+            this._pendingWrites++;
             ok.then(result => {
                 if (result === false) {
                     this._needsDrain = true;
                 }
             }, () => { } // write errors surface via the stream's error event
-            );
+            ).finally(() => {
+                this._pendingWrites--;
+                if (this._pendingWrites === 0) {
+                    const resolvers = this._pendingWriteResolvers.splice(0);
+                    for (const resolve of resolvers) {
+                        resolve();
+                    }
+                }
+            });
             return;
         }
         if (ok === false) {
@@ -102,6 +127,12 @@ class StreamingZipWriterAdapter {
         const callbacks = this.events.get(event) || new Set();
         callbacks.add(callback);
         this.events.set(event, callbacks);
+        // If an error was buffered before any listener was registered, deliver it now.
+        if (event === "error" && this._earlyError) {
+            const err = this._earlyError;
+            this._earlyError = null;
+            callback(err);
+        }
         return this;
     }
     once(event, callback) {
@@ -137,11 +168,18 @@ class StreamingZipWriterAdapter {
     }
     /**
      * Wait for the downstream writable to drain if it signaled backpressure.
-     * Resolves immediately if no backpressure is active.
+     * If any write() calls are still in-flight (returned a Promise that hasn't
+     * settled), waits for all of them first so the backpressure signal isn't missed.
      */
-    waitForDrain() {
+    async waitForDrain() {
+        // Wait for all in-flight async writes to settle so _needsDrain is up to date.
+        if (this._pendingWrites > 0) {
+            await new Promise(resolve => {
+                this._pendingWriteResolvers.push(resolve);
+            });
+        }
         if (!this._needsDrain || !this.pipedStream) {
-            return Promise.resolve();
+            return;
         }
         return new Promise(resolve => {
             this._drainResolvers.push(resolve);

package/dist/cjs/modules/markdown/constants.js

@@ -0,0 +1,33 @@
+"use strict";
+/**
+ * Markdown Module Constants
+ *
+ * Shared constants used across the Markdown module.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NEWLINE_IN_CELL = exports.BR_TAG_REGEX = exports.UNESCAPE_REGEX = exports.ESCAPE_AND_NEWLINE = exports.LINEBREAK_REGEX = void 0;
+/**
+ * Pre-compiled regex for line splitting (matches CR, LF, or CRLF)
+ */
+exports.LINEBREAK_REGEX = /\r\n|\r|\n/;
+/**
+ * Characters that need escaping in Markdown table cells.
+ * Also matches CRLF/CR/LF so that escaping + newline conversion
+ * can be done in a single `replace()` call.
+ * Note: `\r\n` must come before `\r` to match CRLF as a single unit.
+ */
+exports.ESCAPE_AND_NEWLINE = /\r\n|[|\\\r\n]/g;
+/**
+ * Regex to unescape Markdown table cell content (`\|` → `|`, `\\` → `\`)
+ */
+exports.UNESCAPE_REGEX = /\\([|\\])/g;
+/**
+ * Regex to match `<br>`, `<br/>`, or `<br />` tags (case-insensitive).
+ * Used to convert multiline cell representations back to newlines during parsing.
+ */
+exports.BR_TAG_REGEX = /<br\s*\/?>/gi;
+/**
+ * Regex to match literal newlines (CR, LF, or CRLF) in cell content.
+ * Used when escaping is disabled but newline conversion is still needed.
+ */
+exports.NEWLINE_IN_CELL = /\r\n|\r|\n/g;

package/dist/cjs/modules/markdown/errors.js

@@ -0,0 +1,28 @@
+"use strict";
+/**
+ * Markdown module error types.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MarkdownParseError = exports.MarkdownError = void 0;
+const errors_1 = require("../../utils/errors.js");
+/**
+ * Base class for all Markdown-related errors.
+ */
+class MarkdownError extends errors_1.BaseError {
+    constructor() {
+        super(...arguments);
+        this.name = "MarkdownError";
+    }
+}
+exports.MarkdownError = MarkdownError;
+/**
+ * Error thrown when Markdown parsing fails.
+ */
+class MarkdownParseError extends MarkdownError {
+    constructor(message, line, options) {
+        super(`Line ${line}: ${message}`, options);
+        this.name = "MarkdownParseError";
+        this.line = line;
+    }
+}
+exports.MarkdownParseError = MarkdownParseError;