@cj-tech-master/excelts 0.1.0-canary.20251025023400.dff1908

package/dist/esm/utils/cell-matrix.js

@@ -0,0 +1,145 @@
+import { colCache } from "./col-cache.js";
+class CellMatrix {
+    constructor(template) {
+        this.template = template;
+        this.sheets = {};
+    }
+    addCell(addressStr) {
+        this.addCellEx(colCache.decodeEx(addressStr));
+    }
+    getCell(addressStr) {
+        return this.findCellEx(colCache.decodeEx(addressStr), true);
+    }
+    findCell(addressStr) {
+        return this.findCellEx(colCache.decodeEx(addressStr), false);
+    }
+    findCellAt(sheetName, rowNumber, colNumber) {
+        const sheet = this.sheets[sheetName];
+        const row = sheet && sheet[rowNumber];
+        return row && row[colNumber];
+    }
+    addCellEx(address) {
+        if (address.top !== undefined) {
+            for (let row = address.top; row <= address.bottom; row++) {
+                for (let col = address.left; col <= address.right; col++) {
+                    this.getCellAt(address.sheetName, row, col);
+                }
+            }
+        }
+        else {
+            this.findCellEx(address, true);
+        }
+    }
+    getCellEx(address) {
+        return this.findCellEx(address, true);
+    }
+    findCellEx(address, create) {
+        const sheet = this.findSheet(address, create);
+        const row = this.findSheetRow(sheet, address, create);
+        return this.findRowCell(row, address, create);
+    }
+    getCellAt(sheetName, rowNumber, colNumber) {
+        const sheet = this.sheets[sheetName] || (this.sheets[sheetName] = []);
+        const row = sheet[rowNumber] || (sheet[rowNumber] = []);
+        const cell = row[colNumber] ||
+            (row[colNumber] = {
+                sheetName,
+                address: colCache.n2l(colNumber) + rowNumber,
+                row: rowNumber,
+                col: colNumber
+            });
+        return cell;
+    }
+    removeCellEx(address) {
+        const sheet = this.findSheet(address, false);
+        if (!sheet) {
+            return;
+        }
+        const row = this.findSheetRow(sheet, address, false);
+        if (!row) {
+            return;
+        }
+        delete row[address.col];
+    }
+    forEachInSheet(sheetName, callback) {
+        const sheet = this.sheets[sheetName];
+        if (sheet) {
+            sheet.forEach((row, rowNumber) => {
+                if (row) {
+                    row.forEach((cell, colNumber) => {
+                        if (cell) {
+                            callback(cell, rowNumber, colNumber);
+                        }
+                    });
+                }
+            });
+        }
+    }
+    forEach(callback) {
+        Object.keys(this.sheets).forEach(sheetName => {
+            this.forEachInSheet(sheetName, callback);
+        });
+    }
+    map(callback) {
+        const results = [];
+        this.forEach(cell => {
+            results.push(callback(cell));
+        });
+        return results;
+    }
+    findSheet(address, create) {
+        const name = address.sheetName;
+        if (this.sheets[name]) {
+            return this.sheets[name];
+        }
+        if (create) {
+            return (this.sheets[name] = []);
+        }
+        return undefined;
+    }
+    findSheetRow(sheet, address, create) {
+        const { row } = address;
+        if (sheet && sheet[row]) {
+            return sheet[row];
+        }
+        if (create) {
+            return (sheet[row] = []);
+        }
+        return undefined;
+    }
+    findRowCell(row, address, create) {
+        const { col } = address;
+        if (row && row[col]) {
+            return row[col];
+        }
+        if (create) {
+            return (row[col] = this.template
+                ? Object.assign(address, JSON.parse(JSON.stringify(this.template)))
+                : address);
+        }
+        return undefined;
+    }
+    spliceRows(sheetName, start, numDelete, numInsert) {
+        const sheet = this.sheets[sheetName];
+        if (sheet) {
+            const inserts = [];
+            for (let i = 0; i < numInsert; i++) {
+                inserts.push([]);
+            }
+            sheet.splice(start, numDelete, ...inserts);
+        }
+    }
+    spliceColumns(sheetName, start, numDelete, numInsert) {
+        const sheet = this.sheets[sheetName];
+        if (sheet) {
+            const inserts = [];
+            for (let i = 0; i < numInsert; i++) {
+                inserts.push(null);
+            }
+            Object.values(sheet).forEach((row) => {
+                row.splice(start, numDelete, ...inserts);
+            });
+        }
+    }
+}
+export { CellMatrix };

package/dist/esm/utils/col-cache.js

@@ -0,0 +1,278 @@
+const addressRegex = /^[A-Z]+\d+$/;
+// =========================================================================
+// Column Letter to Number conversion
+const colCache = {
+    _dictionary: [
+        "A",
+        "B",
+        "C",
+        "D",
+        "E",
+        "F",
+        "G",
+        "H",
+        "I",
+        "J",
+        "K",
+        "L",
+        "M",
+        "N",
+        "O",
+        "P",
+        "Q",
+        "R",
+        "S",
+        "T",
+        "U",
+        "V",
+        "W",
+        "X",
+        "Y",
+        "Z"
+    ],
+    _l2nFill: 0,
+    _l2n: {},
+    _n2l: [],
+    _level(n) {
+        if (n <= 26) {
+            return 1;
+        }
+        if (n <= 26 * 26) {
+            return 2;
+        }
+        return 3;
+    },
+    _fill(level) {
+        let c;
+        let v;
+        let l1;
+        let l2;
+        let l3;
+        let n = 1;
+        if (level >= 4) {
+            throw new Error("Out of bounds. Excel supports columns from 1 to 16384");
+        }
+        if (this._l2nFill < 1 && level >= 1) {
+            while (n <= 26) {
+                c = this._dictionary[n - 1];
+                this._n2l[n] = c;
+                this._l2n[c] = n;
+                n++;
+            }
+            this._l2nFill = 1;
+        }
+        if (this._l2nFill < 2 && level >= 2) {
+            n = 27;
+            while (n <= 26 + 26 * 26) {
+                v = n - (26 + 1);
+                l1 = v % 26;
+                l2 = Math.floor(v / 26);
+                c = this._dictionary[l2] + this._dictionary[l1];
+                this._n2l[n] = c;
+                this._l2n[c] = n;
+                n++;
+            }
+            this._l2nFill = 2;
+        }
+        if (this._l2nFill < 3 && level >= 3) {
+            n = 26 + 26 * 26 + 1;
+            while (n <= 16384) {
+                v = n - (26 * 26 + 26 + 1);
+                l1 = v % 26;
+                l2 = Math.floor(v / 26) % 26;
+                l3 = Math.floor(v / (26 * 26));
+                c = this._dictionary[l3] + this._dictionary[l2] + this._dictionary[l1];
+                this._n2l[n] = c;
+                this._l2n[c] = n;
+                n++;
+            }
+            this._l2nFill = 3;
+        }
+    },
+    l2n(l) {
+        if (!this._l2n[l]) {
+            this._fill(l.length);
+        }
+        if (!this._l2n[l]) {
+            throw new Error(`Out of bounds. Invalid column letter: ${l}`);
+        }
+        return this._l2n[l];
+    },
+    n2l(n) {
+        if (n < 1 || n > 16384) {
+            throw new Error(`${n} is out of bounds. Excel supports columns from 1 to 16384`);
+        }
+        if (!this._n2l[n]) {
+            this._fill(this._level(n));
+        }
+        return this._n2l[n];
+    },
+    // =========================================================================
+    // Address processing
+    _hash: {},
+    // check if value looks like an address
+    validateAddress(value) {
+        if (!addressRegex.test(value)) {
+            throw new Error(`Invalid Address: ${value}`);
+        }
+        return true;
+    },
+    // convert address string into structure
+    decodeAddress(value) {
+        const addr = value.length < 5 && this._hash[value];
+        if (addr) {
+            return addr;
+        }
+        let hasCol = false;
+        let col = "";
+        let colNumber = 0;
+        let hasRow = false;
+        let row = "";
+        let rowNumber = 0;
+        for (let i = 0, char; i < value.length; i++) {
+            char = value.charCodeAt(i);
+            // col should before row
+            if (!hasRow && char >= 65 && char <= 90) {
+                // 65 = 'A'.charCodeAt(0)
+                // 90 = 'Z'.charCodeAt(0)
+                hasCol = true;
+                col += value[i];
+                // colNumber starts from 1
+                colNumber = colNumber * 26 + char - 64;
+            }
+            else if (char >= 48 && char <= 57) {
+                // 48 = '0'.charCodeAt(0)
+                // 57 = '9'.charCodeAt(0)
+                hasRow = true;
+                row += value[i];
+                // rowNumber starts from 0
+                rowNumber = rowNumber * 10 + char - 48;
+            }
+            else if (hasRow && hasCol && char !== 36) {
+                // 36 = '$'.charCodeAt(0)
+                break;
+            }
+        }
+        if (!hasCol) {
+            colNumber = undefined;
+        }
+        else if (colNumber > 16384) {
+            throw new Error(`Out of bounds. Invalid column letter: ${col}`);
+        }
+        if (!hasRow) {
+            rowNumber = undefined;
+        }
+        // in case $row$col
+        value = col + row;
+        const address = {
+            address: value,
+            col: colNumber,
+            row: rowNumber,
+            $col$row: `$${col}$${row}`
+        };
+        // mem fix - cache only the tl 100x100 square
+        if (colNumber <= 100 && rowNumber <= 100) {
+            this._hash[value] = address;
+            this._hash[address.$col$row] = address;
+        }
+        return address;
+    },
+    // convert r,c into structure (if only 1 arg, assume r is address string)
+    getAddress(r, c) {
+        if (c) {
+            const address = this.n2l(c) + r;
+            return this.decodeAddress(address);
+        }
+        return this.decodeAddress(r);
+    },
+    // convert [address], [tl:br] into address structures
+    decode(value) {
+        const parts = value.split(":");
+        if (parts.length === 2) {
+            const tl = this.decodeAddress(parts[0]);
+            const br = this.decodeAddress(parts[1]);
+            const result = {
+                top: Math.min(tl.row, br.row),
+                left: Math.min(tl.col, br.col),
+                bottom: Math.max(tl.row, br.row),
+                right: Math.max(tl.col, br.col),
+                tl: "",
+                br: "",
+                dimensions: ""
+            };
+            // reconstruct tl, br and dimensions
+            result.tl = this.n2l(result.left) + result.top;
+            result.br = this.n2l(result.right) + result.bottom;
+            result.dimensions = `${result.tl}:${result.br}`;
+            return result;
+        }
+        return this.decodeAddress(value);
+    },
+    // convert [sheetName!][$]col[$]row[[$]col[$]row] into address or range structures
+    decodeEx(value) {
+        // Use possessive quantifiers to prevent catastrophic backtracking (ReDoS)
+        const groups = value.match(/^(?:(?:(?:'((?:[^']|'')+?)')|([^'^ !]+?))!)?(.*)$/);
+        const sheetName = groups[1] || groups[2]; // Quoted and unquoted groups
+        const reference = groups[3]; // Remaining address
+        const parts = reference.split(":");
+        if (parts.length > 1) {
+            const tl = this.decodeAddress(parts[0]);
+            const br = this.decodeAddress(parts[1]);
+            const top = Math.min(tl.row, br.row);
+            const left = Math.min(tl.col, br.col);
+            const bottom = Math.max(tl.row, br.row);
+            const right = Math.max(tl.col, br.col);
+            const tlStr = this.n2l(left) + top;
+            const brStr = this.n2l(right) + bottom;
+            return {
+                top,
+                left,
+                bottom,
+                right,
+                sheetName,
+                tl: {
+                    address: tlStr,
+                    col: left,
+                    row: top,
+                    $col$row: `$${this.n2l(left)}$${top}`,
+                    sheetName
+                },
+                br: {
+                    address: brStr,
+                    col: right,
+                    row: bottom,
+                    $col$row: `$${this.n2l(right)}$${bottom}`,
+                    sheetName
+                },
+                dimensions: `${tlStr}:${brStr}`
+            };
+        }
+        if (reference.indexOf("#") === 0) {
+            return sheetName ? { sheetName, error: reference } : { error: reference };
+        }
+        const address = this.decodeAddress(reference);
+        return sheetName ? { sheetName, ...address } : address;
+    },
+    // convert row,col into address string
+    encodeAddress(row, col) {
+        return colCache.n2l(col) + row;
+    },
+    // convert row,col into string address or t,l,b,r into range
+    encode(...args) {
+        switch (args.length) {
+            case 2:
+                return colCache.encodeAddress(args[0], args[1]);
+            case 4:
+                return `${colCache.encodeAddress(args[0], args[1])}:${colCache.encodeAddress(args[2], args[3])}`;
+            default:
+                throw new Error("Can only encode with 2 or 4 arguments");
+        }
+    },
+    // return true if address is contained within range
+    inRange(range, address) {
+        const [left, top, , right, bottom] = range;
+        const [col, row] = address;
+        return col >= left && col <= right && row >= top && row <= bottom;
+    }
+};
+export { colCache };

package/dist/esm/utils/copy-style.js

@@ -0,0 +1,43 @@
+const oneDepthCopy = (obj, nestKeys) => ({
+    ...obj,
+    ...nestKeys.reduce((memo, key) => {
+        if (obj[key]) {
+            memo[key] = { ...obj[key] };
+        }
+        return memo;
+    }, {})
+});
+const setIfExists = (src, dst, key, nestKeys = []) => {
+    if (src[key]) {
+        dst[key] = oneDepthCopy(src[key], nestKeys);
+    }
+};
+const isEmptyObj = (obj) => Object.keys(obj).length === 0;
+const copyStyle = (style) => {
+    if (!style) {
+        return style;
+    }
+    if (isEmptyObj(style)) {
+        return {};
+    }
+    const copied = { ...style };
+    setIfExists(style, copied, "font", ["color"]);
+    setIfExists(style, copied, "alignment");
+    setIfExists(style, copied, "protection");
+    if (style.border) {
+        setIfExists(style, copied, "border");
+        setIfExists(style.border, copied.border, "top", ["color"]);
+        setIfExists(style.border, copied.border, "left", ["color"]);
+        setIfExists(style.border, copied.border, "bottom", ["color"]);
+        setIfExists(style.border, copied.border, "right", ["color"]);
+        setIfExists(style.border, copied.border, "diagonal", ["color"]);
+    }
+    if (style.fill) {
+        setIfExists(style, copied, "fill", ["fgColor", "bgColor", "center"]);
+        if (style.fill.stops) {
+            copied.fill.stops = style.fill.stops.map((s) => oneDepthCopy(s, ["color"]));
+        }
+    }
+    return copied;
+};
+export { copyStyle };

package/dist/esm/utils/encryptor.js

@@ -0,0 +1,49 @@
+import crypto from "crypto";
+const Encryptor = {
+    /**
+     * Calculate a hash of the concatenated buffers with the given algorithm.
+     * @param algorithm - The hash algorithm.
+     * @returns The hash
+     */
+    hash(algorithm, ...buffers) {
+        const hash = crypto.createHash(algorithm);
+        hash.update(Buffer.concat(buffers));
+        return hash.digest();
+    },
+    /**
+     * Convert a password into an encryption key
+     * @param password - The password
+     * @param hashAlgorithm - The hash algoritm
+     * @param saltValue - The salt value
+     * @param spinCount - The spin count
+     * @returns The encryption key
+     */
+    convertPasswordToHash(password, hashAlgorithm, saltValue, spinCount) {
+        hashAlgorithm = hashAlgorithm.toLowerCase();
+        const hashes = crypto.getHashes();
+        if (hashes.indexOf(hashAlgorithm) < 0) {
+            throw new Error(`Hash algorithm '${hashAlgorithm}' not supported!`);
+        }
+        // Password must be in unicode buffer
+        const passwordBuffer = Buffer.from(password, "utf16le");
+        // Generate the initial hash
+        let key = this.hash(hashAlgorithm, Buffer.from(saltValue, "base64"), passwordBuffer);
+        // Now regenerate until spin count
+        for (let i = 0; i < spinCount; i++) {
+            const iterator = Buffer.alloc(4);
+            // this is the 'special' element of Excel password hashing
+            // that stops us from using crypto.pbkdf2()
+            iterator.writeUInt32LE(i, 0);
+            key = this.hash(hashAlgorithm, key, iterator);
+        }
+        return key.toString("base64");
+    },
+    /**
+     * Generates cryptographically strong pseudo-random data.
+     * @param size The size argument is a number indicating the number of bytes to generate.
+     */
+    randomBytes(size) {
+        return crypto.randomBytes(size);
+    }
+};
+export { Encryptor };

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

@@ -0,0 +1,55 @@
+async function* iterateStream(stream) {
+    const contents = [];
+    let resolveDataPromise = null;
+    const onData = (data) => {
+        contents.push(data);
+        if (resolveDataPromise) {
+            resolveDataPromise();
+            resolveDataPromise = null;
+        }
+    };
+    stream.on("data", onData);
+    let ended = false;
+    const onEnd = () => {
+        ended = true;
+        if (resolveDataPromise) {
+            resolveDataPromise();
+            resolveDataPromise = null;
+        }
+    };
+    stream.on("end", onEnd);
+    let error = false;
+    const onError = (err) => {
+        error = err;
+        if (resolveDataPromise) {
+            resolveDataPromise();
+            resolveDataPromise = null;
+        }
+    };
+    stream.on("error", onError);
+    try {
+        while (!ended || contents.length > 0) {
+            if (contents.length === 0) {
+                stream.resume();
+                await new Promise(resolve => {
+                    resolveDataPromise = resolve;
+                });
+            }
+            else {
+                stream.pause();
+                const data = contents.shift();
+                yield data;
+            }
+            if (error) {
+                throw error;
+            }
+        }
+    }
+    finally {
+        // Clean up listeners
+        stream.removeListener("data", onData);
+        stream.removeListener("end", onEnd);
+        stream.removeListener("error", onError);
+    }
+}
+export { iterateStream };

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

@@ -0,0 +1,29 @@
+import { SaxesParser } from "saxes";
+import { bufferToString } from "./browser-buffer-decode.js";
+async function* parseSax(iterable) {
+    const saxesParser = new SaxesParser({
+        xmlns: false,
+        defaultXMLVersion: "1.0"
+    });
+    let error;
+    saxesParser.on("error", (err) => {
+        error = err;
+    });
+    let events = [];
+    saxesParser.on("opentag", (value) => events.push({ eventType: "opentag", value }));
+    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(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) {
+            throw error;
+        }
+        // As a performance optimization, we gather all events instead of passing
+        // them one by one, which would cause each event to go through the event queue
+        yield events;
+        events = [];
+    }
+}
+export { parseSax };

package/dist/esm/utils/shared-formula.js

@@ -0,0 +1,36 @@
+import { colCache } from "./col-cache.js";
+// const cellRefRegex = /(([a-z_\-0-9]*)!)?[$]?([a-z]+)[$]?([1-9][0-9]*)/i;
+const replacementCandidateRx = /(([a-z_\-0-9]*)!)?([a-z0-9_$]{2,})([(])?/gi;
+const CRrx = /^([$])?([a-z]+)([$])?([1-9][0-9]*)$/i;
+function slideFormula(formula, fromCell, toCell) {
+    const offset = colCache.decode(fromCell);
+    const to = colCache.decode(toCell);
+    return formula.replace(replacementCandidateRx, (refMatch, sheet, sheetMaybe, addrPart, trailingParen) => {
+        if (trailingParen) {
+            return refMatch;
+        }
+        const match = CRrx.exec(addrPart);
+        if (match) {
+            const colDollar = match[1];
+            const colStr = match[2].toUpperCase();
+            const rowDollar = match[3];
+            const rowStr = match[4];
+            if (colStr.length > 3 || (colStr.length === 3 && colStr > "XFD")) {
+                // > XFD is the highest col number in excel 2007 and beyond, so this is a named range
+                return refMatch;
+            }
+            let col = colCache.l2n(colStr);
+            let row = parseInt(rowStr, 10);
+            if (!colDollar) {
+                col += to.col - offset.col;
+            }
+            if (!rowDollar) {
+                row += to.row - offset.row;
+            }
+            const res = (sheet || "") + (colDollar || "") + colCache.n2l(col) + (rowDollar || "") + row;
+            return res;
+        }
+        return refMatch;
+    });
+}
+export { slideFormula };

package/dist/esm/utils/shared-strings.js

@@ -0,0 +1,29 @@
+class SharedStrings {
+    constructor() {
+        this._values = [];
+        this._totalRefs = 0;
+        this._hash = Object.create(null);
+    }
+    get count() {
+        return this._values.length;
+    }
+    get values() {
+        return this._values;
+    }
+    get totalRefs() {
+        return this._totalRefs;
+    }
+    getString(index) {
+        return this._values[index];
+    }
+    add(value) {
+        let index = this._hash[value];
+        if (index === undefined) {
+            index = this._hash[value] = this._values.length;
+            this._values.push(value);
+        }
+        this._totalRefs++;
+        return index;
+    }
+}
+export { SharedStrings };