@cj-tech-master/excelts 3.1.0-canary.20260102071304.d80b29d → 4.0.0-canary.20260103013222.0e5d37f

package/dist/browser/modules/excel/utils/cell-matrix.d.ts

@@ -0,0 +1,37 @@
+interface CellAddress {
+    sheetName?: string;
+    address: string;
+    row: number;
+    col: number;
+    top?: number;
+    bottom?: number;
+    left?: number;
+    right?: number;
+}
+type Cell = CellAddress & any;
+type Row = Cell[];
+type Sheet = Row[];
+type Sheets = Record<string, Sheet>;
+declare class CellMatrix {
+    template: any;
+    sheets: Sheets;
+    constructor(template?: any);
+    addCell(addressStr: string): void;
+    getCell(addressStr: string): Cell;
+    findCell(addressStr: string): Cell | undefined;
+    findCellAt(sheetName: string, rowNumber: number, colNumber: number): Cell | undefined;
+    addCellEx(address: CellAddress): void;
+    getCellEx(address: CellAddress): Cell;
+    findCellEx(address: CellAddress, create: boolean): Cell | undefined;
+    getCellAt(sheetName: string, rowNumber: number, colNumber: number): Cell;
+    removeCellEx(address: CellAddress): void;
+    forEachInSheet(sheetName: string, callback: (cell: Cell, rowNumber: number, colNumber: number) => void): void;
+    forEach(callback: (cell: Cell) => void): void;
+    map<T>(callback: (cell: Cell) => T): T[];
+    findSheet(address: CellAddress, create: boolean): Sheet | undefined;
+    findSheetRow(sheet: Sheet | undefined, address: CellAddress, create: boolean): Row | undefined;
+    findRowCell(row: Row | undefined, address: CellAddress, create: boolean): Cell | undefined;
+    spliceRows(sheetName: string, start: number, numDelete: number, numInsert: number): void;
+    spliceColumns(sheetName: string, start: number, numDelete: number, numInsert: number): void;
+}
+export { CellMatrix };

package/dist/browser/modules/excel/utils/cell-matrix.js

@@ -0,0 +1,180 @@
+import { colCache } from "./col-cache.js";
+// Helper to check for prototype pollution
+function isSafeKey(key) {
+    if (typeof key === "number") {
+        return true;
+    }
+    return key !== "__proto__" && key !== "constructor" && key !== "prototype";
+}
+// Safe deep clone that filters out prototype pollution keys
+function safeDeepClone(obj) {
+    if (obj === null || typeof obj !== "object") {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return obj.map(item => safeDeepClone(item));
+    }
+    const result = {};
+    for (const key of Object.keys(obj)) {
+        if (isSafeKey(key)) {
+            result[key] = safeDeepClone(obj[key]);
+        }
+    }
+    return result;
+}
+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) {
+        if (!isSafeKey(sheetName)) {
+            throw new Error(`Invalid sheet name: ${sheetName}`);
+        }
+        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 (!isSafeKey(name)) {
+            throw new Error(`Invalid sheet name: ${name}`);
+        }
+        if (Object.prototype.hasOwnProperty.call(this.sheets, name)) {
+            return this.sheets[name];
+        }
+        if (create) {
+            return (this.sheets[name] = []);
+        }
+        return undefined;
+    }
+    findSheetRow(sheet, address, create) {
+        const { row } = address;
+        if (!isSafeKey(row)) {
+            throw new Error(`Invalid row: ${row}`);
+        }
+        if (sheet && sheet[row]) {
+            return sheet[row];
+        }
+        if (create) {
+            return (sheet[row] = []);
+        }
+        return undefined;
+    }
+    findRowCell(row, address, create) {
+        const { col } = address;
+        if (!isSafeKey(col)) {
+            throw new Error(`Invalid column: ${col}`);
+        }
+        if (row && row[col]) {
+            return row[col];
+        }
+        if (create) {
+            return (row[col] = this.template
+                ? { ...address, ...safeDeepClone(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/browser/modules/excel/utils/col-cache.d.ts

@@ -0,0 +1,36 @@
+import type { Address, Location } from "@excel/types";
+type CachedAddress = Address & {
+    $col$row: string;
+};
+export type DecodedRange = Location & {
+    tl: string | CachedAddress;
+    br: string | CachedAddress;
+    dimensions: string;
+    sheetName?: string;
+};
+interface ErrorReference {
+    error: string;
+    sheetName?: string;
+}
+type DecodeExResult = CachedAddress | DecodedRange | ErrorReference;
+interface ColCache {
+    _dictionary: string[];
+    _l2nFill: number;
+    _l2n: Record<string, number>;
+    _n2l: string[];
+    _hash: Record<string, CachedAddress>;
+    _level(n: number): number;
+    _fill(level: number): void;
+    l2n(l: string): number;
+    n2l(n: number): string;
+    validateAddress(value: string): boolean;
+    decodeAddress(value: string): CachedAddress;
+    getAddress(r: number | string, c?: number): CachedAddress;
+    decode(value: string): CachedAddress | DecodedRange;
+    decodeEx(value: string): DecodeExResult;
+    encodeAddress(row: number, col: number): string;
+    encode(...args: number[]): string;
+    inRange(range: number[], address: number[]): boolean;
+}
+declare const colCache: ColCache;
+export { colCache };

package/dist/browser/modules/excel/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/browser/modules/excel/utils/copy-style.d.ts

@@ -0,0 +1,5 @@
+interface StyleObject {
+    [key: string]: any;
+}
+declare const copyStyle: (style: StyleObject | null | undefined) => StyleObject | null | undefined;
+export { copyStyle };

package/dist/browser/modules/excel/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/browser/modules/excel/utils/encryptor.browser.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Browser-only Encryptor
+ * Uses Web Crypto API (hardware accelerated)
+ */
+declare const Encryptor: {
+    /**
+     * Calculate hash using Web Crypto API
+     */
+    hash(algorithm: string, ...buffers: Uint8Array[]): Promise<Uint8Array>;
+    /**
+     * Convert password to hash
+     */
+    convertPasswordToHash(password: string, hashAlgorithm: string, saltValue: string, spinCount: number): Promise<string>;
+    /**
+     * Generate cryptographically strong random bytes
+     */
+    randomBytes(size: number): Uint8Array;
+};
+export { Encryptor };

package/dist/browser/modules/excel/utils/encryptor.browser.js

@@ -0,0 +1,46 @@
+/**
+ * Browser-only Encryptor
+ * Uses Web Crypto API (hardware accelerated)
+ */
+import { base64ToUint8Array, uint8ArrayToBase64, stringToUtf16Le } from "../../../utils/utils.base.js";
+import { concatUint8Arrays } from "../../stream/index.browser.js";
+// Helper to convert number to little-endian Uint8Array
+function uint32ToLe(num) {
+    const arr = new Uint8Array(4);
+    arr[0] = num & 0xff;
+    arr[1] = (num >> 8) & 0xff;
+    arr[2] = (num >> 16) & 0xff;
+    arr[3] = (num >> 24) & 0xff;
+    return arr;
+}
+const Encryptor = {
+    /**
+     * Calculate hash using Web Crypto API
+     */
+    async hash(algorithm, ...buffers) {
+        const data = concatUint8Arrays(buffers);
+        const hashBuffer = await crypto.subtle.digest(algorithm, new Uint8Array(data));
+        return new Uint8Array(hashBuffer);
+    },
+    /**
+     * Convert password to hash
+     */
+    async convertPasswordToHash(password, hashAlgorithm, saltValue, spinCount) {
+        const passwordBuffer = stringToUtf16Le(password);
+        const saltBuffer = base64ToUint8Array(saltValue);
+        let key = await this.hash(hashAlgorithm, saltBuffer, passwordBuffer);
+        for (let i = 0; i < spinCount; i++) {
+            key = await this.hash(hashAlgorithm, key, uint32ToLe(i));
+        }
+        return uint8ArrayToBase64(key);
+    },
+    /**
+     * Generate cryptographically strong random bytes
+     */
+    randomBytes(size) {
+        const bytes = new Uint8Array(size);
+        crypto.getRandomValues(bytes);
+        return bytes;
+    }
+};
+export { Encryptor };

package/dist/browser/modules/excel/utils/encryptor.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Node.js Encryptor - uses native crypto module
+ */
+declare const Encryptor: {
+    hash(algorithm: string, ...buffers: Uint8Array[]): Uint8Array;
+    convertPasswordToHash(password: string, hashAlgorithm: string, saltValue: string, spinCount: number): Promise<string>;
+    randomBytes(size: number): Uint8Array;
+};
+export { Encryptor };

package/dist/browser/modules/excel/utils/encryptor.js

@@ -0,0 +1,35 @@
+/**
+ * Node.js Encryptor - uses native crypto module
+ */
+import crypto from "crypto";
+import { base64ToUint8Array, uint8ArrayToBase64, stringToUtf16Le } from "../../../utils/utils.base.js";
+import { concatUint8Arrays } from "../../stream/index.browser.js";
+function uint32ToLe(num) {
+    const arr = new Uint8Array(4);
+    arr[0] = num & 0xff;
+    arr[1] = (num >> 8) & 0xff;
+    arr[2] = (num >> 16) & 0xff;
+    arr[3] = (num >> 24) & 0xff;
+    return arr;
+}
+const Encryptor = {
+    hash(algorithm, ...buffers) {
+        const algo = algorithm.toLowerCase().replace(/-/g, "");
+        const hash = crypto.createHash(algo);
+        hash.update(concatUint8Arrays(buffers));
+        return new Uint8Array(hash.digest());
+    },
+    async convertPasswordToHash(password, hashAlgorithm, saltValue, spinCount) {
+        const passwordBuffer = stringToUtf16Le(password);
+        const saltBuffer = base64ToUint8Array(saltValue);
+        let key = this.hash(hashAlgorithm, saltBuffer, passwordBuffer);
+        for (let i = 0; i < spinCount; i++) {
+            key = this.hash(hashAlgorithm, key, uint32ToLe(i));
+        }
+        return uint8ArrayToBase64(key);
+    },
+    randomBytes(size) {
+        return new Uint8Array(crypto.randomBytes(size));
+    }
+};
+export { Encryptor };