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

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

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CellMatrix = void 0;
+const col_cache_1 = require("@excel/utils/col-cache");
+// 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(col_cache_1.colCache.decodeEx(addressStr));
+    }
+    getCell(addressStr) {
+        return this.findCellEx(col_cache_1.colCache.decodeEx(addressStr), true);
+    }
+    findCell(addressStr) {
+        return this.findCellEx(col_cache_1.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: col_cache_1.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);
+            });
+        }
+    }
+}
+exports.CellMatrix = CellMatrix;

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

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * Browser-only Encryptor
+ * Uses Web Crypto API (hardware accelerated)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Encryptor = void 0;
+const utils_base_1 = require("@utils/utils.base");
+const _stream_1 = require("@stream");
+// 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 = (0, _stream_1.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 = (0, utils_base_1.stringToUtf16Le)(password);
+        const saltBuffer = (0, utils_base_1.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 (0, utils_base_1.uint8ArrayToBase64)(key);
+    },
+    /**
+     * Generate cryptographically strong random bytes
+     */
+    randomBytes(size) {
+        const bytes = new Uint8Array(size);
+        crypto.getRandomValues(bytes);
+        return bytes;
+    }
+};
+exports.Encryptor = Encryptor;

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

@@ -0,0 +1,41 @@
+"use strict";
+/**
+ * Node.js Encryptor - uses native crypto module
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Encryptor = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const utils_base_1 = require("@utils/utils.base");
+const _stream_1 = require("@stream");
+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_1.default.createHash(algo);
+        hash.update((0, _stream_1.concatUint8Arrays)(buffers));
+        return new Uint8Array(hash.digest());
+    },
+    async convertPasswordToHash(password, hashAlgorithm, saltValue, spinCount) {
+        const passwordBuffer = (0, utils_base_1.stringToUtf16Le)(password);
+        const saltBuffer = (0, utils_base_1.base64ToUint8Array)(saltValue);
+        let key = this.hash(hashAlgorithm, saltBuffer, passwordBuffer);
+        for (let i = 0; i < spinCount; i++) {
+            key = this.hash(hashAlgorithm, key, uint32ToLe(i));
+        }
+        return (0, utils_base_1.uint8ArrayToBase64)(key);
+    },
+    randomBytes(size) {
+        return new Uint8Array(crypto_1.default.randomBytes(size));
+    }
+};
+exports.Encryptor = Encryptor;

package/dist/cjs/modules/excel/utils/ooxml-paths.js

@@ -0,0 +1,260 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OOXML_REL_TARGETS = exports.OOXML_PATHS = void 0;
+exports.normalizeZipPath = normalizeZipPath;
+exports.getWorksheetNoFromWorksheetPath = getWorksheetNoFromWorksheetPath;
+exports.getWorksheetNoFromWorksheetRelsPath = getWorksheetNoFromWorksheetRelsPath;
+exports.isMediaPath = isMediaPath;
+exports.getMediaFilenameFromPath = getMediaFilenameFromPath;
+exports.isThemePath = isThemePath;
+exports.getThemeNameFromPath = getThemeNameFromPath;
+exports.isBinaryEntryPath = isBinaryEntryPath;
+exports.getDrawingNameFromPath = getDrawingNameFromPath;
+exports.getDrawingNameFromRelsPath = getDrawingNameFromRelsPath;
+exports.getVmlDrawingNameFromPath = getVmlDrawingNameFromPath;
+exports.getCommentsIndexFromPath = getCommentsIndexFromPath;
+exports.getTableNameFromPath = getTableNameFromPath;
+exports.getPivotTableNameFromPath = getPivotTableNameFromPath;
+exports.getPivotTableNameFromRelsPath = getPivotTableNameFromRelsPath;
+exports.getPivotCacheDefinitionNameFromPath = getPivotCacheDefinitionNameFromPath;
+exports.getPivotCacheDefinitionNameFromRelsPath = getPivotCacheDefinitionNameFromRelsPath;
+exports.getPivotCacheRecordsNameFromPath = getPivotCacheRecordsNameFromPath;
+exports.toContentTypesPartName = toContentTypesPartName;
+exports.themePath = themePath;
+exports.mediaPath = mediaPath;
+exports.worksheetPath = worksheetPath;
+exports.worksheetRelsPath = worksheetRelsPath;
+exports.worksheetRelTarget = worksheetRelTarget;
+exports.commentsPath = commentsPath;
+exports.commentsPathFromName = commentsPathFromName;
+exports.vmlDrawingPath = vmlDrawingPath;
+exports.tablePath = tablePath;
+exports.drawingPath = drawingPath;
+exports.drawingRelsPath = drawingRelsPath;
+exports.pivotCacheDefinitionPath = pivotCacheDefinitionPath;
+exports.pivotCacheDefinitionRelsPath = pivotCacheDefinitionRelsPath;
+exports.pivotCacheRecordsPath = pivotCacheRecordsPath;
+exports.pivotCacheRecordsRelTarget = pivotCacheRecordsRelTarget;
+exports.pivotTablePath = pivotTablePath;
+exports.pivotTableRelsPath = pivotTableRelsPath;
+exports.pivotCacheDefinitionRelTargetFromPivotTable = pivotCacheDefinitionRelTargetFromPivotTable;
+exports.pivotCacheDefinitionRelTargetFromWorkbook = pivotCacheDefinitionRelTargetFromWorkbook;
+exports.commentsRelTargetFromWorksheet = commentsRelTargetFromWorksheet;
+exports.vmlDrawingRelTargetFromWorksheet = vmlDrawingRelTargetFromWorksheet;
+exports.drawingRelTargetFromWorksheet = drawingRelTargetFromWorksheet;
+exports.vmlDrawingRelTargetFromWorksheetName = vmlDrawingRelTargetFromWorksheetName;
+exports.commentsRelTargetFromWorksheetName = commentsRelTargetFromWorksheetName;
+exports.pivotTableRelTargetFromWorksheet = pivotTableRelTargetFromWorksheet;
+exports.pivotTableRelTargetFromWorksheetName = pivotTableRelTargetFromWorksheetName;
+exports.tableRelTargetFromWorksheet = tableRelTargetFromWorksheet;
+exports.tableRelTargetFromWorksheetName = tableRelTargetFromWorksheetName;
+exports.mediaRelTargetFromRels = mediaRelTargetFromRels;
+exports.OOXML_PATHS = {
+    contentTypes: "[Content_Types].xml",
+    rootRels: "_rels/.rels",
+    docPropsApp: "docProps/app.xml",
+    docPropsCore: "docProps/core.xml",
+    xlWorkbook: "xl/workbook.xml",
+    xlWorkbookRels: "xl/_rels/workbook.xml.rels",
+    xlSharedStrings: "xl/sharedStrings.xml",
+    xlStyles: "xl/styles.xml",
+    xlTheme1: "xl/theme/theme1.xml"
+};
+const worksheetXmlRegex = /^xl\/worksheets\/sheet(\d+)[.]xml$/;
+const worksheetRelsXmlRegex = /^xl\/worksheets\/_rels\/sheet(\d+)[.]xml[.]rels$/;
+const themeXmlRegex = /^xl\/theme\/[a-zA-Z0-9]+[.]xml$/;
+const mediaFilenameRegex = /^xl\/media\/([a-zA-Z0-9]+[.][a-zA-Z0-9]{3,4})$/;
+const drawingXmlRegex = /^xl\/drawings\/(drawing\d+)[.]xml$/;
+const drawingRelsXmlRegex = /^xl\/drawings\/_rels\/(drawing\d+)[.]xml[.]rels$/;
+const vmlDrawingRegex = /^xl\/drawings\/(vmlDrawing\d+)[.]vml$/;
+const commentsXmlRegex = /^xl\/comments(\d+)[.]xml$/;
+const tableXmlRegex = /^xl\/tables\/(table\d+)[.]xml$/;
+const pivotTableXmlRegex = /^xl\/pivotTables\/(pivotTable\d+)[.]xml$/;
+const pivotTableRelsXmlRegex = /^xl\/pivotTables\/_rels\/(pivotTable\d+)[.]xml[.]rels$/;
+const pivotCacheDefinitionXmlRegex = /^xl\/pivotCache\/(pivotCacheDefinition\d+)[.]xml$/;
+const pivotCacheDefinitionRelsXmlRegex = /^xl\/pivotCache\/_rels\/(pivotCacheDefinition\d+)[.]xml[.]rels$/;
+const pivotCacheRecordsXmlRegex = /^xl\/pivotCache\/(pivotCacheRecords\d+)[.]xml$/;
+function normalizeZipPath(path) {
+    return path.startsWith("/") ? path.slice(1) : path;
+}
+function getWorksheetNoFromWorksheetPath(path) {
+    const match = worksheetXmlRegex.exec(path);
+    if (!match) {
+        return undefined;
+    }
+    return parseInt(match[1], 10);
+}
+function getWorksheetNoFromWorksheetRelsPath(path) {
+    const match = worksheetRelsXmlRegex.exec(path);
+    if (!match) {
+        return undefined;
+    }
+    return parseInt(match[1], 10);
+}
+function isMediaPath(path) {
+    return path.startsWith("xl/media/");
+}
+function getMediaFilenameFromPath(path) {
+    const match = mediaFilenameRegex.exec(path);
+    return match ? match[1] : undefined;
+}
+function isThemePath(path) {
+    return themeXmlRegex.test(path);
+}
+function getThemeNameFromPath(path) {
+    const match = /^xl\/theme\/([a-zA-Z0-9]+)[.]xml$/.exec(path);
+    return match ? match[1] : undefined;
+}
+function isBinaryEntryPath(path) {
+    // Media and themes should be treated as binary in the legacy buffer-based reader.
+    // Everything else is parsed as text XML.
+    return isMediaPath(path) || isThemePath(path);
+}
+function getDrawingNameFromPath(path) {
+    const match = drawingXmlRegex.exec(path);
+    return match ? match[1] : undefined;
+}
+function getDrawingNameFromRelsPath(path) {
+    const match = drawingRelsXmlRegex.exec(path);
+    return match ? match[1] : undefined;
+}
+function getVmlDrawingNameFromPath(path) {
+    const match = vmlDrawingRegex.exec(path);
+    return match ? match[1] : undefined;
+}
+function getCommentsIndexFromPath(path) {
+    const match = commentsXmlRegex.exec(path);
+    return match ? match[1] : undefined;
+}
+function getTableNameFromPath(path) {
+    const match = tableXmlRegex.exec(path);
+    return match ? match[1] : undefined;
+}
+function getPivotTableNameFromPath(path) {
+    const match = pivotTableXmlRegex.exec(path);
+    return match ? match[1] : undefined;
+}
+function getPivotTableNameFromRelsPath(path) {
+    const match = pivotTableRelsXmlRegex.exec(path);
+    return match ? match[1] : undefined;
+}
+function getPivotCacheDefinitionNameFromPath(path) {
+    const match = pivotCacheDefinitionXmlRegex.exec(path);
+    return match ? match[1] : undefined;
+}
+function getPivotCacheDefinitionNameFromRelsPath(path) {
+    const match = pivotCacheDefinitionRelsXmlRegex.exec(path);
+    return match ? match[1] : undefined;
+}
+function getPivotCacheRecordsNameFromPath(path) {
+    const match = pivotCacheRecordsXmlRegex.exec(path);
+    return match ? match[1] : undefined;
+}
+function toContentTypesPartName(zipPath) {
+    // ContentTypes uses leading slash PartName (e.g. "/xl/workbook.xml").
+    return zipPath.startsWith("/") ? zipPath : `/${zipPath}`;
+}
+function themePath(themeName) {
+    return `xl/theme/${themeName}.xml`;
+}
+function mediaPath(filename) {
+    return `xl/media/${filename}`;
+}
+function worksheetPath(sheetId) {
+    return `xl/worksheets/sheet${sheetId}.xml`;
+}
+function worksheetRelsPath(sheetId) {
+    return `xl/worksheets/_rels/sheet${sheetId}.xml.rels`;
+}
+function worksheetRelTarget(sheetId) {
+    return `worksheets/sheet${sheetId}.xml`;
+}
+function commentsPath(sheetId) {
+    return `xl/comments${sheetId}.xml`;
+}
+function commentsPathFromName(commentName) {
+    // For comments when the caller already has the logical name (e.g. "comments1").
+    return `xl/${commentName}.xml`;
+}
+function vmlDrawingPath(sheetId) {
+    return `xl/drawings/vmlDrawing${sheetId}.vml`;
+}
+function tablePath(target) {
+    return `xl/tables/${target}`;
+}
+function drawingPath(drawingName) {
+    return `xl/drawings/${drawingName}.xml`;
+}
+function drawingRelsPath(drawingName) {
+    return `xl/drawings/_rels/${drawingName}.xml.rels`;
+}
+function pivotCacheDefinitionPath(n) {
+    return `xl/pivotCache/pivotCacheDefinition${n}.xml`;
+}
+function pivotCacheDefinitionRelsPath(n) {
+    return `xl/pivotCache/_rels/pivotCacheDefinition${n}.xml.rels`;
+}
+function pivotCacheRecordsPath(n) {
+    return `xl/pivotCache/pivotCacheRecords${n}.xml`;
+}
+function pivotCacheRecordsRelTarget(n) {
+    return `pivotCacheRecords${n}.xml`;
+}
+function pivotTablePath(n) {
+    return `xl/pivotTables/pivotTable${n}.xml`;
+}
+function pivotTableRelsPath(n) {
+    return `xl/pivotTables/_rels/pivotTable${n}.xml.rels`;
+}
+function pivotCacheDefinitionRelTargetFromPivotTable(n) {
+    return `../pivotCache/pivotCacheDefinition${n}.xml`;
+}
+exports.OOXML_REL_TARGETS = {
+    // Targets inside xl/_rels/workbook.xml.rels (base: xl/)
+    workbookStyles: "styles.xml",
+    workbookSharedStrings: "sharedStrings.xml",
+    workbookTheme1: "theme/theme1.xml"
+};
+function pivotCacheDefinitionRelTargetFromWorkbook(n) {
+    // Target inside xl/_rels/workbook.xml.rels (base: xl/)
+    return `pivotCache/pivotCacheDefinition${n}.xml`;
+}
+function commentsRelTargetFromWorksheet(sheetId) {
+    // Target inside xl/worksheets/_rels/sheetN.xml.rels (base: xl/worksheets/)
+    return `../comments${sheetId}.xml`;
+}
+function vmlDrawingRelTargetFromWorksheet(sheetId) {
+    // Target inside xl/worksheets/_rels/sheetN.xml.rels (base: xl/worksheets/)
+    return `../drawings/vmlDrawing${sheetId}.vml`;
+}
+function drawingRelTargetFromWorksheet(drawingName) {
+    // Target inside xl/worksheets/_rels/sheetN.xml.rels (base: xl/worksheets/)
+    return `../drawings/${drawingName}.xml`;
+}
+function vmlDrawingRelTargetFromWorksheetName(vmlName) {
+    // For VML drawings when the caller already has the logical name (e.g. "vmlDrawing1").
+    return `../drawings/${vmlName}.vml`;
+}
+function commentsRelTargetFromWorksheetName(commentName) {
+    // For comments when the caller already has the logical name (e.g. "comments1").
+    return `../${commentName}.xml`;
+}
+function pivotTableRelTargetFromWorksheet(n) {
+    // Target inside xl/worksheets/_rels/sheetN.xml.rels (base: xl/worksheets/)
+    return `../pivotTables/pivotTable${n}.xml`;
+}
+function pivotTableRelTargetFromWorksheetName(pivotName) {
+    // For pivot tables when the caller already has the logical name (e.g. "pivotTable1").
+    return `../pivotTables/${pivotName}.xml`;
+}
+function tableRelTargetFromWorksheet(target) {
+    // Target inside xl/worksheets/_rels/sheetN.xml.rels (base: xl/worksheets/)
+    return `../tables/${target}`;
+}
+function tableRelTargetFromWorksheetName(name) {
+    return `../tables/${name}.xml`;
+}
+function mediaRelTargetFromRels(filename) {
+    // Target from a rels file located under xl/*/_rels (base is one level deeper than xl/)
+    return `../media/${filename}`;
+}