@cj-tech-master/excelts 3.0.1 → 3.1.0-canary.20260102041828.82ed571

package/dist/esm/utils/zip-stream.browser.js

@@ -1,132 +0,0 @@
-import { ZipBuilder } from "./zip/zip-builder.js";
-import { StreamBuf } from "./stream-buf.browser.js";
-// Helper function for base64 decoding in browser
-function base64ToUint8Array(base64) {
-    const binaryString = atob(base64);
-    const bytes = new Uint8Array(binaryString.length);
-    for (let i = 0; i < binaryString.length; i++) {
-        bytes[i] = binaryString.charCodeAt(i);
-    }
-    return bytes;
-}
-// =============================================================================
-// The ZipWriter class - Browser version without Node.js events dependency
-// Packs streamed data into an output zip stream
-class ZipWriter {
-    constructor(options) {
-        this.finalized = false;
-        this.pendingWrites = [];
-        this.events = new Map();
-        const level = options?.compression === "STORE"
-            ? 0
-            : Math.max(0, Math.min(9, options?.compressionOptions?.level ?? 1));
-        this.stream = new StreamBuf();
-        this.zipBuilder = new ZipBuilder({ level });
-    }
-    // Event emitter methods
-    on(event, callback) {
-        const callbacks = this.events.get(event) || [];
-        callbacks.push(callback);
-        this.events.set(event, callbacks);
-        return this;
-    }
-    once(event, callback) {
-        const onceCallback = (...args) => {
-            this.off(event, onceCallback);
-            callback(...args);
-        };
-        return this.on(event, onceCallback);
-    }
-    off(event, callback) {
-        const callbacks = this.events.get(event) || [];
-        const index = callbacks.indexOf(callback);
-        if (index !== -1) {
-            callbacks.splice(index, 1);
-        }
-        return this;
-    }
-    emit(event, ...args) {
-        const callbacks = this.events.get(event) || [];
-        callbacks.forEach(cb => cb(...args));
-        return callbacks.length > 0;
-    }
-    removeListener(event, callback) {
-        return this.off(event, callback);
-    }
-    append(data, options) {
-        let buffer;
-        if (Object.prototype.hasOwnProperty.call(options, "base64") && options.base64) {
-            const base64Data = typeof data === "string" ? data : String(data);
-            buffer = base64ToUint8Array(base64Data);
-        }
-        else if (typeof data === "string") {
-            buffer = new TextEncoder().encode(data);
-        }
-        else if (data instanceof Uint8Array) {
-            buffer = data;
-        }
-        else if (ArrayBuffer.isView(data)) {
-            buffer = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-        }
-        else if (data instanceof ArrayBuffer) {
-            buffer = new Uint8Array(data);
-        }
-        else {
-            buffer = data;
-        }
-        const writePromise = this.zipBuilder
-            .addFile({ name: options.name, data: buffer })
-            .then(chunks => {
-            for (const chunk of chunks) {
-                this.stream.write(new Uint8Array(chunk));
-            }
-        });
-        this.pendingWrites.push(writePromise);
-    }
-    push(chunk) {
-        return this.stream.push(chunk);
-    }
-    async finalize() {
-        if (this.finalized) {
-            return;
-        }
-        this.finalized = true;
-        await Promise.all(this.pendingWrites);
-        const finalChunks = this.zipBuilder.finalize();
-        for (const chunk of finalChunks) {
-            this.stream.write(new Uint8Array(chunk));
-        }
-        this.stream.end();
-        this.emit("finish");
-    }
-    // ==========================================================================
-    // Stream.Readable interface
-    read(size) {
-        return this.stream.read(size);
-    }
-    setEncoding(encoding) {
-        return this.stream.setEncoding(encoding);
-    }
-    pause() {
-        return this.stream.pause();
-    }
-    resume() {
-        return this.stream.resume();
-    }
-    isPaused() {
-        return this.stream.isPaused();
-    }
-    pipe(destination) {
-        return this.stream.pipe(destination);
-    }
-    unpipe(destination) {
-        return this.stream.unpipe(destination);
-    }
-    unshift() {
-        return this.stream.unshift();
-    }
-    wrap() {
-        return this.stream.wrap();
-    }
-}
-export { ZipWriter };

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

@@ -1,109 +0,0 @@
-import events from "events";
-import { ZipBuilder } from "./zip/index.js";
-import { StreamBuf } from "./stream-buf.js";
-// =============================================================================
-// 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.EventEmitter {
-    constructor(options) {
-        super();
-        this.finalized = false;
-        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 StreamBuf();
-        this.zipBuilder = new ZipBuilder({ level });
-    }
-    append(data, options) {
-        let buffer;
-        if (Object.prototype.hasOwnProperty.call(options, "base64") && options.base64) {
-            // Decode base64 data - Buffer.from works in both Node.js and browser (via polyfill)
-            const base64Data = typeof data === "string" ? data : data.toString();
-            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, 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 {
-            // Assume it's already a Uint8Array or compatible type
-            buffer = data;
-        }
-        // 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);
-    }
-    async finalize() {
-        if (this.finalized) {
-            return;
-        }
-        this.finalized = true;
-        // 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");
-    }
-    // ==========================================================================
-    // Stream.Readable interface
-    read(size) {
-        return this.stream.read(size);
-    }
-    setEncoding(encoding) {
-        return this.stream.setEncoding(encoding);
-    }
-    pause() {
-        return this.stream.pause();
-    }
-    resume() {
-        return this.stream.resume();
-    }
-    isPaused() {
-        return this.stream.isPaused();
-    }
-    pipe(destination, options) {
-        return this.stream.pipe(destination, options);
-    }
-    unpipe(destination) {
-        return this.stream.unpipe(destination);
-    }
-    unshift(chunk) {
-        return this.stream.unshift(chunk);
-    }
-    wrap(stream) {
-        return this.stream.wrap(stream);
-    }
-}
-// =============================================================================
-export { ZipWriter };

package/dist/esm/xlsx/xform/base-xform.js

@@ -1,123 +0,0 @@
-import { parseSax } from "../../utils/parse-sax.js";
-import { XmlStream } from "../../utils/xml-stream.js";
-// Base class for Xforms
-class BaseXform {
-    // ============================================================
-    // Virtual Interface
-    prepare(_model, _options) {
-        // optional preparation (mutation) of model so it is ready for write
-    }
-    render(_xmlStream, _model) {
-        // convert model to xml
-    }
-    parseOpen(_node) {
-        // XML node opened
-    }
-    parseText(_text) {
-        // chunk of text encountered for current node
-    }
-    parseClose(_name) {
-        // XML node closed
-        return false;
-    }
-    reconcile(_model, _options) {
-        // optional post-parse step (opposite to prepare)
-    }
-    // ============================================================
-    reset() {
-        // to make sure parses don't bleed to next iteration
-        this.model = null;
-        // if we have a map - reset them too
-        if (this.map) {
-            Object.values(this.map).forEach(xform => {
-                if (xform instanceof BaseXform) {
-                    xform.reset();
-                }
-                else if (xform.xform) {
-                    xform.xform.reset();
-                }
-            });
-        }
-    }
-    mergeModel(obj) {
-        // set obj's props to this.model
-        this.model = Object.assign(this.model || {}, obj);
-    }
-    async parse(saxParser) {
-        for await (const events of saxParser) {
-            for (const { eventType, value } of events) {
-                if (eventType === "opentag") {
-                    this.parseOpen(value);
-                }
-                else if (eventType === "text") {
-                    this.parseText(value);
-                }
-                else if (eventType === "closetag") {
-                    if (!this.parseClose(value.name)) {
-                        return this.model;
-                    }
-                }
-            }
-        }
-        return this.model;
-    }
-    async parseStream(stream) {
-        return this.parse(parseSax(stream));
-    }
-    get xml() {
-        // convenience function to get the xml of this.model
-        // useful for manager types that are built during the prepare phase
-        return this.toXml(this.model);
-    }
-    toXml(model) {
-        const xmlStream = new XmlStream();
-        this.render(xmlStream, model);
-        return xmlStream.xml;
-    }
-    // ============================================================
-    // Useful Utilities
-    static toAttribute(value, dflt, always = false) {
-        if (value === undefined) {
-            if (always) {
-                return dflt;
-            }
-        }
-        else if (always || value !== dflt) {
-            return value.toString();
-        }
-        return undefined;
-    }
-    static toStringAttribute(value, dflt, always = false) {
-        return BaseXform.toAttribute(value, dflt, always);
-    }
-    static toStringValue(attr, dflt) {
-        return attr === undefined ? dflt : attr;
-    }
-    static toBoolAttribute(value, dflt, always = false) {
-        if (value === undefined) {
-            if (always) {
-                return dflt;
-            }
-        }
-        else if (always || value !== dflt) {
-            return value ? "1" : "0";
-        }
-        return undefined;
-    }
-    static toBoolValue(attr, dflt) {
-        return attr === undefined ? dflt : attr === "1";
-    }
-    static toIntAttribute(value, dflt, always = false) {
-        return BaseXform.toAttribute(value, dflt, always);
-    }
-    static toIntValue(attr, dflt) {
-        return attr === undefined ? dflt : parseInt(attr, 10);
-    }
-    static toFloatAttribute(value, dflt, always = false) {
-        return BaseXform.toAttribute(value, dflt, always);
-    }
-    static toFloatValue(attr, dflt) {
-        return attr === undefined ? dflt : parseFloat(attr);
-    }
-}
-export { BaseXform };

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

@@ -1,124 +0,0 @@
-import { BaseXform } from "../base-xform.js";
-import { colCache } from "../../../utils/col-cache.js";
-class DefinedNamesXform extends BaseXform {
-    constructor() {
-        super();
-        this._parsedText = [];
-    }
-    render(xmlStream, model) {
-        // <definedNames>
-        //   <definedName name="name">name.ranges.join(',')</definedName>
-        //   <definedName name="_xlnm.Print_Area" localSheetId="0">name.ranges.join(',')</definedName>
-        // </definedNames>
-        xmlStream.openNode("definedName", {
-            name: model.name,
-            localSheetId: model.localSheetId
-        });
-        xmlStream.writeText(model.ranges.join(","));
-        xmlStream.closeNode();
-    }
-    parseOpen(node) {
-        switch (node.name) {
-            case "definedName":
-                this._parsedName = node.attributes.name;
-                this._parsedLocalSheetId = node.attributes.localSheetId;
-                this._parsedText = [];
-                return true;
-            default:
-                return false;
-        }
-    }
-    parseText(text) {
-        this._parsedText.push(text);
-    }
-    parseClose() {
-        this.model = {
-            name: this._parsedName,
-            ranges: extractRanges(this._parsedText.join(""))
-        };
-        if (this._parsedLocalSheetId !== undefined) {
-            this.model.localSheetId = parseInt(this._parsedLocalSheetId, 10);
-        }
-        return false;
-    }
-}
-// 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 {
-        const decoded = 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 = "";
-    parsedText.split(",").forEach(item => {
-        if (!item) {
-            return;
-        }
-        const quotes = (item.match(/'/g) || []).length;
-        if (!quotes) {
-            if (quotesOpened) {
-                last += `${item},`;
-            }
-            else if (isValidRange(item)) {
-                ranges.push(item);
-            }
-            return;
-        }
-        const quotesEven = quotes % 2 === 0;
-        if (!quotesOpened && quotesEven && isValidRange(item)) {
-            ranges.push(item);
-        }
-        else if (quotesOpened && !quotesEven) {
-            quotesOpened = false;
-            if (isValidRange(last + item)) {
-                ranges.push(last + item);
-            }
-            last = "";
-        }
-        else {
-            quotesOpened = true;
-            last += `${item},`;
-        }
-    });
-    return ranges;
-}
-export { DefinedNamesXform };

package/dist/esm/xlsx/xform/book/sheet-xform.js

@@ -1,30 +0,0 @@
-import { xmlDecode } from "../../../utils/utils.js";
-import { BaseXform } from "../base-xform.js";
-class WorksheetXform extends BaseXform {
-    render(xmlStream, model) {
-        xmlStream.leafNode("sheet", {
-            name: model.name,
-            sheetId: model.id,
-            // Excel doesn't output state when it's 'visible' (default)
-            state: model.state === "visible" ? undefined : model.state,
-            "r:id": model.rId
-        });
-    }
-    parseOpen(node) {
-        if (node.name === "sheet") {
-            this.model = {
-                name: xmlDecode(node.attributes.name),
-                id: parseInt(node.attributes.sheetId, 10),
-                state: node.attributes.state,
-                rId: node.attributes["r:id"]
-            };
-            return true;
-        }
-        return false;
-    }
-    parseText() { }
-    parseClose() {
-        return false;
-    }
-}
-export { WorksheetXform };

package/dist/esm/xlsx/xform/book/workbook-calc-properties-xform.js

@@ -1,21 +0,0 @@
-import { BaseXform } from "../base-xform.js";
-class WorkbookCalcPropertiesXform extends BaseXform {
-    render(xmlStream, model) {
-        xmlStream.leafNode("calcPr", {
-            calcId: 171027,
-            fullCalcOnLoad: model.fullCalcOnLoad ? 1 : undefined
-        });
-    }
-    parseOpen(node) {
-        if (node.name === "calcPr") {
-            this.model = {};
-            return true;
-        }
-        return false;
-    }
-    parseText() { }
-    parseClose() {
-        return false;
-    }
-}
-export { WorkbookCalcPropertiesXform };

package/dist/esm/xlsx/xform/book/workbook-pivot-cache-xform.js

@@ -1,24 +0,0 @@
-import { BaseXform } from "../base-xform.js";
-class WorkbookPivotCacheXform extends BaseXform {
-    render(xmlStream, model) {
-        xmlStream.leafNode("pivotCache", {
-            cacheId: model.cacheId,
-            "r:id": model.rId
-        });
-    }
-    parseOpen(node) {
-        if (node.name === "pivotCache") {
-            this.model = {
-                cacheId: node.attributes.cacheId,
-                rId: node.attributes["r:id"]
-            };
-            return true;
-        }
-        return false;
-    }
-    parseText() { }
-    parseClose() {
-        return false;
-    }
-}
-export { WorkbookPivotCacheXform };

package/dist/esm/xlsx/xform/book/workbook-properties-xform.js

@@ -1,24 +0,0 @@
-import { BaseXform } from "../base-xform.js";
-class WorkbookPropertiesXform extends BaseXform {
-    render(xmlStream, model) {
-        xmlStream.leafNode("workbookPr", {
-            date1904: model.date1904 ? 1 : undefined,
-            // Excel doesn't output defaultThemeVersion
-            filterPrivacy: 1
-        });
-    }
-    parseOpen(node) {
-        if (node.name === "workbookPr") {
-            this.model = {
-                date1904: node.attributes.date1904 === "1"
-            };
-            return true;
-        }
-        return false;
-    }
-    parseText() { }
-    parseClose() {
-        return false;
-    }
-}
-export { WorkbookPropertiesXform };

package/dist/esm/xlsx/xform/book/workbook-view-xform.js

@@ -1,46 +0,0 @@
-import { BaseXform } from "../base-xform.js";
-class WorkbookViewXform extends BaseXform {
-    render(xmlStream, model) {
-        const attributes = {
-            xWindow: model.x || 0,
-            yWindow: model.y || 0,
-            windowWidth: model.width || 12000,
-            windowHeight: model.height || 24000,
-            firstSheet: model.firstSheet,
-            activeTab: model.activeTab
-        };
-        if (model.visibility && model.visibility !== "visible") {
-            attributes.visibility = model.visibility;
-        }
-        xmlStream.leafNode("workbookView", attributes);
-    }
-    parseOpen(node) {
-        if (node.name === "workbookView") {
-            const model = (this.model = {});
-            const addS = function (name, value, dflt) {
-                const s = value !== undefined ? value : dflt;
-                model[name] = s;
-            };
-            const addN = function (name, value, dflt) {
-                const n = value !== undefined ? parseInt(value, 10) : dflt;
-                if (n !== undefined) {
-                    model[name] = n;
-                }
-            };
-            addN("x", node.attributes.xWindow, 0);
-            addN("y", node.attributes.yWindow, 0);
-            addN("width", node.attributes.windowWidth, 25000);
-            addN("height", node.attributes.windowHeight, 10000);
-            addS("visibility", node.attributes.visibility, "visible");
-            addN("activeTab", node.attributes.activeTab, undefined);
-            addN("firstSheet", node.attributes.firstSheet, undefined);
-            return true;
-        }
-        return false;
-    }
-    parseText() { }
-    parseClose() {
-        return false;
-    }
-}
-export { WorkbookViewXform };