@rowsncolumns/toolkit 24.4.1

package/dist/cjs/excel-parser/cfb-encryptor.js

@@ -0,0 +1,200 @@
+import { __awaiter, __generator, __read, __spreadArray, __values } from "tslib";
+/// <reference path="../xlsx.d.ts" />
+import { CFB } from "xlsx/xlsx.mjs";
+import { sha512 } from "@noble/hashes/sha512";
+import { hmac } from "@noble/hashes/hmac";
+import { cbc } from "@noble/ciphers/aes";
+var BLOCK_SIZE = 16;
+var KEY_SIZE = 32; // AES-256
+var HASH_SIZE = 64; // SHA-512
+var SEGMENT_LENGTH = 4096;
+var SPIN_COUNT_DEFAULT = 100000;
+var BLOCK_KEY_VERIFIER_INPUT = new Uint8Array([
+    0xfe, 0xa7, 0xd2, 0x76, 0x3b, 0x4b, 0x9e, 0x79,
+]);
+var BLOCK_KEY_VERIFIER_HASH = new Uint8Array([
+    0xd7, 0xaa, 0x0f, 0x6d, 0x30, 0x61, 0x34, 0x4e,
+]);
+var BLOCK_KEY_ENCRYPTION_KEY = new Uint8Array([
+    0x14, 0x6e, 0x0b, 0xe7, 0xab, 0xac, 0xd0, 0xd6,
+]);
+var BLOCK_KEY_DATA_INTEGRITY_KEY = new Uint8Array([
+    0x5f, 0xb2, 0xad, 0x01, 0x0c, 0xb9, 0xe1, 0xf6,
+]);
+var BLOCK_KEY_DATA_INTEGRITY_VALUE = new Uint8Array([
+    0xa0, 0x67, 0x7f, 0x02, 0xb2, 0x2c, 0x84, 0x33,
+]);
+var CFBEncryptor = /** @class */ (function () {
+    function CFBEncryptor() {
+    }
+    CFBEncryptor.encrypt = function (source_1, password_1) {
+        return __awaiter(this, arguments, void 0, function (source, password, options) {
+            var packageData, spinCount, passwordSalt, packageSalt, verifierInput, encryptionKey, hmacKey, passwordDerivedKey, keyForVerifierInput, keyForVerifierHash, keyForEncryptionKey, verifierHash, encryptedVerifierHashInput, encryptedVerifierHashValue, encryptedKeyValue, encryptedPackageData, encryptedPackageStream, encryptedHmacKey, hmacValue, encryptedHmacValue, encryptionXml, encryptionInfo, cfb, result;
+            var _a;
+            if (options === void 0) { options = {}; }
+            return __generator(this, function (_b) {
+                packageData = source instanceof Uint8Array ? source : new Uint8Array(source);
+                spinCount = (_a = options.spinCount) !== null && _a !== void 0 ? _a : SPIN_COUNT_DEFAULT;
+                passwordSalt = this.randomBytes(BLOCK_SIZE);
+                packageSalt = this.randomBytes(BLOCK_SIZE);
+                verifierInput = this.randomBytes(BLOCK_SIZE);
+                encryptionKey = this.randomBytes(KEY_SIZE);
+                hmacKey = this.randomBytes(HASH_SIZE);
+                passwordDerivedKey = this.derivePasswordKey(password, passwordSalt, spinCount);
+                keyForVerifierInput = this.deriveAgileBlockKey(passwordDerivedKey, BLOCK_KEY_VERIFIER_INPUT);
+                keyForVerifierHash = this.deriveAgileBlockKey(passwordDerivedKey, BLOCK_KEY_VERIFIER_HASH);
+                keyForEncryptionKey = this.deriveAgileBlockKey(passwordDerivedKey, BLOCK_KEY_ENCRYPTION_KEY);
+                verifierHash = this.sha512Hash(verifierInput);
+                encryptedVerifierHashInput = this.encryptAESNoPadding(verifierInput, keyForVerifierInput, passwordSalt);
+                encryptedVerifierHashValue = this.encryptAESNoPadding(verifierHash, keyForVerifierHash, passwordSalt);
+                encryptedKeyValue = this.encryptAESNoPadding(encryptionKey, keyForEncryptionKey, passwordSalt);
+                encryptedPackageData = this.encryptPackage(packageData, encryptionKey, packageSalt);
+                encryptedPackageStream = this.buildEncryptedPackageStream(packageData.length, encryptedPackageData);
+                encryptedHmacKey = this.encryptDataIntegrityValue(hmacKey, encryptionKey, packageSalt, BLOCK_KEY_DATA_INTEGRITY_KEY);
+                hmacValue = this.hmacSha512(encryptedPackageStream, hmacKey);
+                encryptedHmacValue = this.encryptDataIntegrityValue(hmacValue, encryptionKey, packageSalt, BLOCK_KEY_DATA_INTEGRITY_VALUE);
+                encryptionXml = this.buildEncryptionXml({
+                    spinCount: spinCount,
+                    passwordSalt: passwordSalt,
+                    packageSalt: packageSalt,
+                    encryptedVerifierHashInput: encryptedVerifierHashInput,
+                    encryptedVerifierHashValue: encryptedVerifierHashValue,
+                    encryptedKeyValue: encryptedKeyValue,
+                    encryptedHmacKey: encryptedHmacKey,
+                    encryptedHmacValue: encryptedHmacValue,
+                });
+                encryptionInfo = this.buildEncryptionInfoStream(encryptionXml);
+                cfb = CFB.utils.cfb_new({ root: "Root Entry" });
+                CFB.utils.cfb_add(cfb, "EncryptionInfo", encryptionInfo);
+                CFB.utils.cfb_add(cfb, "EncryptedPackage", encryptedPackageStream);
+                result = CFB.write(cfb, { type: "array" });
+                return [2 /*return*/, result instanceof Uint8Array ? result : new Uint8Array(result)];
+            });
+        });
+    };
+    CFBEncryptor.buildEncryptionInfoStream = function (xml) {
+        var xmlBytes = new TextEncoder().encode(xml);
+        var info = new Uint8Array(8 + xmlBytes.length);
+        var view = new DataView(info.buffer);
+        view.setUint16(0, 4, true); // vMajor
+        view.setUint16(2, 4, true); // vMinor (Agile)
+        view.setUint32(4, 0x40, true); // reserved
+        info.set(xmlBytes, 8);
+        return info;
+    };
+    CFBEncryptor.buildEncryptedPackageStream = function (originalSize, encryptedData) {
+        var out = new Uint8Array(8 + encryptedData.length);
+        var view = new DataView(out.buffer);
+        view.setBigUint64(0, BigInt(originalSize), true);
+        out.set(encryptedData, 8);
+        return out;
+    };
+    CFBEncryptor.encryptPackage = function (data, key, packageSalt) {
+        var chunks = [];
+        for (var index = 0; index * SEGMENT_LENGTH < data.length; index++) {
+            var start = index * SEGMENT_LENGTH;
+            var end = Math.min(start + SEGMENT_LENGTH, data.length);
+            var segment = data.slice(start, end);
+            var paddedSegment = this.padToBlockSize(segment, BLOCK_SIZE);
+            var blockNumber = new Uint8Array(4);
+            new DataView(blockNumber.buffer).setUint32(0, index, true);
+            var iv = this.sha512Hash(this.concatArrays(packageSalt, blockNumber)).slice(0, BLOCK_SIZE);
+            chunks.push(this.encryptAESNoPadding(paddedSegment, key, iv));
+        }
+        return this.concatArrays.apply(this, __spreadArray([], __read(chunks), false));
+    };
+    CFBEncryptor.buildEncryptionXml = function (_a) {
+        var spinCount = _a.spinCount, passwordSalt = _a.passwordSalt, packageSalt = _a.packageSalt, encryptedVerifierHashInput = _a.encryptedVerifierHashInput, encryptedVerifierHashValue = _a.encryptedVerifierHashValue, encryptedKeyValue = _a.encryptedKeyValue, encryptedHmacKey = _a.encryptedHmacKey, encryptedHmacValue = _a.encryptedHmacValue;
+        return "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n<encryption xmlns=\"http://schemas.microsoft.com/office/2006/encryption\" xmlns:p=\"http://schemas.microsoft.com/office/2006/keyEncryptor/password\" xmlns:c=\"http://schemas.microsoft.com/office/2006/keyEncryptor/certificate\">\n  <keyData saltSize=\"".concat(BLOCK_SIZE, "\" blockSize=\"").concat(BLOCK_SIZE, "\" keyBits=\"").concat(KEY_SIZE * 8, "\" hashSize=\"").concat(HASH_SIZE, "\" cipherAlgorithm=\"AES\" cipherChaining=\"ChainingModeCBC\" hashAlgorithm=\"SHA512\" saltValue=\"").concat(this.toBase64(packageSalt), "\"/>\n  <dataIntegrity encryptedHmacKey=\"").concat(this.toBase64(encryptedHmacKey), "\" encryptedHmacValue=\"").concat(this.toBase64(encryptedHmacValue), "\"/>\n  <keyEncryptors>\n    <keyEncryptor uri=\"http://schemas.microsoft.com/office/2006/keyEncryptor/password\">\n      <p:encryptedKey spinCount=\"").concat(spinCount, "\" saltSize=\"").concat(BLOCK_SIZE, "\" blockSize=\"").concat(BLOCK_SIZE, "\" keyBits=\"").concat(KEY_SIZE * 8, "\" hashSize=\"").concat(HASH_SIZE, "\" cipherAlgorithm=\"AES\" cipherChaining=\"ChainingModeCBC\" hashAlgorithm=\"SHA512\" saltValue=\"").concat(this.toBase64(passwordSalt), "\" encryptedVerifierHashInput=\"").concat(this.toBase64(encryptedVerifierHashInput), "\" encryptedVerifierHashValue=\"").concat(this.toBase64(encryptedVerifierHashValue), "\" encryptedKeyValue=\"").concat(this.toBase64(encryptedKeyValue), "\"/>\n    </keyEncryptor>\n  </keyEncryptors>\n</encryption>");
+    };
+    CFBEncryptor.derivePasswordKey = function (password, passwordSalt, spinCount) {
+        var passwordBytes = this.stringToUtf16LE(password);
+        var hash = this.sha512Hash(this.concatArrays(passwordSalt, passwordBytes));
+        for (var i = 0; i < spinCount; i++) {
+            var iterator = new Uint8Array(4);
+            new DataView(iterator.buffer).setUint32(0, i, true);
+            hash = this.sha512Hash(this.concatArrays(iterator, hash));
+        }
+        return hash;
+    };
+    CFBEncryptor.deriveAgileBlockKey = function (passwordDerivedKey, blockKey) {
+        return this.sha512Hash(this.concatArrays(passwordDerivedKey, blockKey)).slice(0, KEY_SIZE);
+    };
+    CFBEncryptor.encryptDataIntegrityValue = function (data, encryptionKey, packageSalt, blockKey) {
+        var iv = this.sha512Hash(this.concatArrays(packageSalt, blockKey)).slice(0, BLOCK_SIZE);
+        return this.encryptAESNoPadding(this.padToBlockSize(data, BLOCK_SIZE), encryptionKey, iv);
+    };
+    CFBEncryptor.encryptAESNoPadding = function (data, key, iv) {
+        var cipher = cbc(key, iv, { disablePadding: true });
+        return cipher.encrypt(data);
+    };
+    CFBEncryptor.sha512Hash = function (data) {
+        return sha512(data);
+    };
+    CFBEncryptor.hmacSha512 = function (data, key) {
+        return hmac(sha512, key, data);
+    };
+    CFBEncryptor.toBase64 = function (data) {
+        var binary = "";
+        for (var i = 0; i < data.length; i++) {
+            binary += String.fromCharCode(data[i]);
+        }
+        return btoa(binary);
+    };
+    CFBEncryptor.padToBlockSize = function (data, blockSize) {
+        var remainder = data.length % blockSize;
+        if (remainder === 0)
+            return data;
+        var out = new Uint8Array(data.length + (blockSize - remainder));
+        out.set(data);
+        return out;
+    };
+    CFBEncryptor.stringToUtf16LE = function (value) {
+        var bytes = new Uint8Array(value.length * 2);
+        for (var i = 0; i < value.length; i++) {
+            var code = value.charCodeAt(i);
+            bytes[i * 2] = code & 0xff;
+            bytes[i * 2 + 1] = (code >> 8) & 0xff;
+        }
+        return bytes;
+    };
+    CFBEncryptor.concatArrays = function () {
+        var e_1, _a;
+        var arrays = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            arrays[_i] = arguments[_i];
+        }
+        var total = arrays.reduce(function (sum, arr) { return sum + arr.length; }, 0);
+        var out = new Uint8Array(total);
+        var offset = 0;
+        try {
+            for (var arrays_1 = __values(arrays), arrays_1_1 = arrays_1.next(); !arrays_1_1.done; arrays_1_1 = arrays_1.next()) {
+                var arr = arrays_1_1.value;
+                out.set(arr, offset);
+                offset += arr.length;
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (arrays_1_1 && !arrays_1_1.done && (_a = arrays_1.return)) _a.call(arrays_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return out;
+    };
+    CFBEncryptor.randomBytes = function (length) {
+        var out = new Uint8Array(length);
+        if (typeof globalThis.crypto !== "undefined" &&
+            globalThis.crypto.getRandomValues) {
+            globalThis.crypto.getRandomValues(out);
+            return out;
+        }
+        for (var i = 0; i < length; i++) {
+            out[i] = Math.floor(Math.random() * 256);
+        }
+        return out;
+    };
+    return CFBEncryptor;
+}());
+export { CFBEncryptor };

package/dist/cjs/excel-parser/dv-cell-stamp.d.ts

@@ -0,0 +1,29 @@
+import type { CellData, DataValidationRuleRecord } from "@rowsncolumns/spreadsheet";
+export declare class SheetDataValidationStamper {
+    private readonly rules;
+    private materializeBudget;
+    /** Rows that streamed out of the parser (only tracked when rules exist),
+     * so trailing materialization doesn't duplicate them. */
+    private readonly emittedRows;
+    constructor(allRules: DataValidationRuleRecord[], sheetId: number);
+    get hasRules(): boolean;
+    /** First rule (rule-list order, matching `updateRule`/grid semantics) whose
+     * ranges contain the cell. */
+    private ruleIdAt;
+    /**
+     * Stamp an emitted row in place: covered existing cells get
+     * `dataValidation: <ruleId>`, and covered holes inside small ranges get a
+     * phantom `{ dataValidation }` cell (budget-capped).
+     */
+    stampRow(rowIndex: number, values: (CellData | null | undefined)[]): void;
+    /**
+     * Rows covered by small ranges that never streamed out of the file at all
+     * (fully blank template rows). Returns sparse phantom rows to append to the
+     * sheet's final chunk, in ascending row order.
+     */
+    trailingRows(): Array<{
+        rowIndex: number;
+        values: (CellData | null | undefined)[];
+    }>;
+}
+//# sourceMappingURL=dv-cell-stamp.d.ts.map

package/dist/cjs/excel-parser/dv-cell-stamp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dv-cell-stamp.d.ts","sourceRoot":"","sources":["../../../excel-parser/dv-cell-stamp.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EACR,wBAAwB,EACzB,MAAM,2BAA2B,CAAC;AA+CnC,qBAAa,0BAA0B;IACrC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAmB;IACzC,OAAO,CAAC,iBAAiB,CAA8B;IACvD;6DACyD;IACzD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAqB;gBAG/C,QAAQ,EAAE,wBAAwB,EAAE,EACpC,OAAO,EAAE,MAAM;IAsCjB,IAAI,QAAQ,IAAI,OAAO,CAEtB;IAED;kCAC8B;IAC9B,OAAO,CAAC,QAAQ;IAmBhB;;;;OAIG;IACH,QAAQ,CACN,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,CAAC,QAAQ,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,GACtC,IAAI;IAgCP;;;;OAIG;IACH,YAAY,IAAI,KAAK,CAAC;QACpB,QAAQ,EAAE,MAAM,CAAC;QACjB,MAAM,EAAE,CAAC,QAAQ,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,CAAC;KACzC,CAAC;CAmCH"}

package/dist/cjs/excel-parser/dv-cell-stamp.js

@@ -0,0 +1,239 @@
+import { __assign, __read, __spreadArray, __values } from "tslib";
+/**
+ * Per-sheet stamping of `cellData.dataValidation` during `processSheetData`
+ * streaming.
+ *
+ * Spreadsheet files store validations at the worksheet level (a rule + the
+ * ranges it applies to), but `useSpreadsheetState.getDataValidation` resolves a
+ * cell's rule ONLY through the per-cell `cellData.dataValidation` reference —
+ * there is no range-membership fallback. Consumers that build documents
+ * straight from `processSheetData` (e.g. server-side xlsx→Y.Doc conversion)
+ * therefore need the streamed cells to already carry the rule id, or the grid
+ * never shows dropdown arrows / enforces the rule even though the rule list
+ * itself round-tripped.
+ *
+ * The stamped id MUST be the id of the same rule object the plugin returns
+ * from `getDataValidations()` (ids are minted per parse), so plugins must
+ * feed this class from a single cached parse shared with that API.
+ */
+/** A cell is only materialized (created solely to carry the stamp) for ranges
+ * up to this many cells — whole-column/row sqrefs would otherwise bloat the
+ * output with millions of phantom cells. Cells that exist anyway are stamped
+ * regardless of range size. */
+var DV_MATERIALIZE_RANGE_CELL_CAP = 20000;
+/** Upper bound on phantom cells materialized per sheet across all ranges. */
+var DV_MATERIALIZE_CELL_BUDGET = 100000;
+var isFiniteIndex = function (value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0;
+};
+var SheetDataValidationStamper = /** @class */ (function () {
+    function SheetDataValidationStamper(allRules, sheetId) {
+        var e_1, _a, e_2, _b;
+        var _c;
+        this.rules = [];
+        this.materializeBudget = DV_MATERIALIZE_CELL_BUDGET;
+        /** Rows that streamed out of the parser (only tracked when rules exist),
+         * so trailing materialization doesn't duplicate them. */
+        this.emittedRows = new Set();
+        try {
+            for (var allRules_1 = __values(allRules), allRules_1_1 = allRules_1.next(); !allRules_1_1.done; allRules_1_1 = allRules_1.next()) {
+                var rule = allRules_1_1.value;
+                if (rule.id === undefined || rule.id === null)
+                    continue;
+                var ranges = [];
+                var materialize = [];
+                try {
+                    for (var _d = (e_2 = void 0, __values((_c = rule.ranges) !== null && _c !== void 0 ? _c : [])), _e = _d.next(); !_e.done; _e = _d.next()) {
+                        var range = _e.value;
+                        if (range.sheetId !== sheetId)
+                            continue;
+                        var _f = range, startRowIndex = _f.startRowIndex, endRowIndex = _f.endRowIndex, startColumnIndex = _f.startColumnIndex, endColumnIndex = _f.endColumnIndex;
+                        if (!isFiniteIndex(startRowIndex) ||
+                            !isFiniteIndex(endRowIndex) ||
+                            !isFiniteIndex(startColumnIndex) ||
+                            !isFiniteIndex(endColumnIndex) ||
+                            endRowIndex < startRowIndex ||
+                            endColumnIndex < startColumnIndex) {
+                            continue;
+                        }
+                        ranges.push({
+                            startRowIndex: startRowIndex,
+                            endRowIndex: endRowIndex,
+                            startColumnIndex: startColumnIndex,
+                            endColumnIndex: endColumnIndex,
+                        });
+                        materialize.push((endRowIndex - startRowIndex + 1) *
+                            (endColumnIndex - startColumnIndex + 1) <=
+                            DV_MATERIALIZE_RANGE_CELL_CAP);
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (_e && !_e.done && (_b = _d.return)) _b.call(_d);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+                if (ranges.length) {
+                    this.rules.push({ id: rule.id, ranges: ranges, materialize: materialize });
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (allRules_1_1 && !allRules_1_1.done && (_a = allRules_1.return)) _a.call(allRules_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    }
+    Object.defineProperty(SheetDataValidationStamper.prototype, "hasRules", {
+        get: function () {
+            return this.rules.length > 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /** First rule (rule-list order, matching `updateRule`/grid semantics) whose
+     * ranges contain the cell. */
+    SheetDataValidationStamper.prototype.ruleIdAt = function (rowIndex, columnIndex) {
+        var e_3, _a, e_4, _b;
+        try {
+            for (var _c = __values(this.rules), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var rule = _d.value;
+                try {
+                    for (var _e = (e_4 = void 0, __values(rule.ranges)), _f = _e.next(); !_f.done; _f = _e.next()) {
+                        var range = _f.value;
+                        if (rowIndex >= range.startRowIndex &&
+                            rowIndex <= range.endRowIndex &&
+                            columnIndex >= range.startColumnIndex &&
+                            columnIndex <= range.endColumnIndex) {
+                            return rule.id;
+                        }
+                    }
+                }
+                catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                finally {
+                    try {
+                        if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                    }
+                    finally { if (e_4) throw e_4.error; }
+                }
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        return undefined;
+    };
+    /**
+     * Stamp an emitted row in place: covered existing cells get
+     * `dataValidation: <ruleId>`, and covered holes inside small ranges get a
+     * phantom `{ dataValidation }` cell (budget-capped).
+     */
+    SheetDataValidationStamper.prototype.stampRow = function (rowIndex, values) {
+        var e_5, _a;
+        var _this = this;
+        if (!this.hasRules)
+            return;
+        this.emittedRows.add(rowIndex);
+        // Existing cells first — bounded by real data, so range size is irrelevant.
+        values.forEach(function (cell, columnIndex) {
+            if (!cell || cell.dataValidation != null)
+                return;
+            var id = _this.ruleIdAt(rowIndex, columnIndex);
+            if (id !== undefined) {
+                values[columnIndex] = __assign(__assign({}, cell), { dataValidation: id });
+            }
+        });
+        try {
+            // Then materialize covered holes (first rule wins via the null check).
+            for (var _b = __values(this.rules), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var rule = _c.value;
+                for (var i = 0; i < rule.ranges.length; i++) {
+                    if (!rule.materialize[i])
+                        continue;
+                    var range = rule.ranges[i];
+                    if (rowIndex < range.startRowIndex || rowIndex > range.endRowIndex) {
+                        continue;
+                    }
+                    for (var columnIndex = range.startColumnIndex; columnIndex <= range.endColumnIndex && this.materializeBudget > 0; columnIndex++) {
+                        if (values[columnIndex] != null)
+                            continue;
+                        values[columnIndex] = { dataValidation: rule.id };
+                        this.materializeBudget--;
+                    }
+                }
+            }
+        }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_5) throw e_5.error; }
+        }
+    };
+    /**
+     * Rows covered by small ranges that never streamed out of the file at all
+     * (fully blank template rows). Returns sparse phantom rows to append to the
+     * sheet's final chunk, in ascending row order.
+     */
+    SheetDataValidationStamper.prototype.trailingRows = function () {
+        var e_6, _a;
+        if (!this.hasRules)
+            return [];
+        var rowsByIndex = new Map();
+        try {
+            for (var _b = __values(this.rules), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var rule = _c.value;
+                for (var i = 0; i < rule.ranges.length; i++) {
+                    if (!rule.materialize[i])
+                        continue;
+                    var range = rule.ranges[i];
+                    for (var rowIndex = range.startRowIndex; rowIndex <= range.endRowIndex; rowIndex++) {
+                        if (this.emittedRows.has(rowIndex))
+                            continue;
+                        var values = rowsByIndex.get(rowIndex);
+                        if (!values) {
+                            values = [];
+                            rowsByIndex.set(rowIndex, values);
+                        }
+                        for (var columnIndex = range.startColumnIndex; columnIndex <= range.endColumnIndex && this.materializeBudget > 0; columnIndex++) {
+                            if (values[columnIndex] != null)
+                                continue;
+                            values[columnIndex] = { dataValidation: rule.id };
+                            this.materializeBudget--;
+                        }
+                    }
+                }
+            }
+        }
+        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_6) throw e_6.error; }
+        }
+        return __spreadArray([], __read(rowsByIndex.entries()), false).filter(function (_a) {
+            var _b = __read(_a, 2), values = _b[1];
+            return values.length > 0;
+        })
+            .sort(function (_a, _b) {
+            var _c = __read(_a, 1), a = _c[0];
+            var _d = __read(_b, 1), b = _d[0];
+            return a - b;
+        })
+            .map(function (_a) {
+            var _b = __read(_a, 2), rowIndex = _b[0], values = _b[1];
+            return ({ rowIndex: rowIndex, values: values });
+        });
+    };
+    return SheetDataValidationStamper;
+}());
+export { SheetDataValidationStamper };

package/dist/cjs/excel-parser/helpers.d.ts

@@ -0,0 +1,28 @@
+import type { GridRange } from "@rowsncolumns/common-types";
+import type { FilterSpec } from "@rowsncolumns/spreadsheet";
+export declare const getRangeFromAddressRef: (ref: string) => GridRange | undefined;
+/**
+ * Convert an xlsx column width (in units of max-digit-width of the
+ * default workbook font, Calibri 11 → MDW=7px) to pixels.
+ *
+ * Excel's effective rendered pixel count includes a 5-pixel padding
+ * baked into the column box: `pixels = floor(width × MDW + padding)`.
+ * The default width "8.43" renders as 64 px (8.43 × 7 + 5 ≈ 64.01),
+ * matching Excel exactly. The "pure" ECMA-376 §18.3.1.13 formula omits
+ * the 5px padding; we keep the +5 form so our pixel output matches
+ * Excel's rendered widths and round-trips with our exporter.
+ */
+export declare function excelColumnWidthToPixels(width: number): number;
+export declare function findMax(arr: number[]): number;
+export declare function createFilterSpecsFromAutoFilter(autoFilter: any, 
+/**
+ * Optional dxf resolver — called with (dxfId, cellColor) to return a
+ * hex color string. When omitted, `<colorFilter>` entries are skipped
+ * (caller doesn't have access to workbook dxfs).
+ */
+resolveDxfColor?: (dxfId: number, cellColor: boolean) => string | undefined): FilterSpec[];
+/**
+ * Reads an Excel file and extracts sheet metadata
+ */
+export declare function readExcelFile(file: File | ArrayBuffer): Promise<ArrayBuffer>;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/cjs/excel-parser/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../excel-parser/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,KAAK,EAAY,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAStE,eAAO,MAAM,sBAAsB,GAAI,KAAK,MAAM,KAAG,SAAS,GAAG,SAIhE,CAAC;AAEF;;;;;;;;;;GAUG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,UAIrD;AAED,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,UAMpC;AAuBD,wBAAgB,+BAA+B,CAC7C,UAAU,EAAE,GAAG;AACf;;;;GAIG;AACH,eAAe,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,KAAK,MAAM,GAAG,SAAS,gBA8F5E;AAED;;GAEG;AACH,wBAAsB,aAAa,CAAC,IAAI,EAAE,IAAI,GAAG,WAAW,wBAkB3D"}