@rowsncolumns/toolkit 24.4.1

package/dist/esm/excel-parser/plugins/xlsb/rgce-parser.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Parse Rgce (Reverse Polish Notation Compiled Expression) - binary formula format in XLSB
+ * This converts binary Ptg (Parsed Token) tokens into a formula string
+ *
+ * @param rgceBytes - The binary formula data
+ * @returns The formula string (without leading "=")
+ */
+/**
+ * Parse Rgce with sheet names for cross-sheet references
+ * @param rgceBytes - The binary formula data
+ * @param sheetNames - Array of sheet names for resolving external references
+ * @returns The formula string (without leading "=")
+ */
+export declare function parseRgce(rgceBytes: Uint8Array, sheetRefResolver?: string[] | ((ixti: number) => string | undefined), baseCell?: {
+    row: number;
+    col: number;
+}, debug?: boolean): string;
+//# sourceMappingURL=rgce-parser.d.ts.map

package/dist/esm/excel-parser/plugins/xlsb/rgce-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rgce-parser.d.ts","sourceRoot":"","sources":["../../../../../excel-parser/plugins/xlsb/rgce-parser.ts"],"names":[],"mappings":"AAuHA;;;;;;GAMG;AACH;;;;;GAKG;AACH,wBAAgB,SAAS,CACvB,SAAS,EAAE,UAAU,EACrB,gBAAgB,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC,EACpE,QAAQ,CAAC,EAAE;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,EACvC,KAAK,UAAQ,GACZ,MAAM,CAqaR"}

package/dist/esm/excel-parser/plugins/xlsb/rgce-parser.js

@@ -0,0 +1,522 @@
+import { number2Alpha } from "@rowsncolumns/utils";
+/**
+ * Reader class for parsing Rgce bytes
+ */
+class RgceReader {
+    view;
+    offset = 0;
+    bytes;
+    constructor(bytes) {
+        this.bytes = bytes;
+        this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    }
+    readUInt8() {
+        const value = this.view.getUint8(this.offset);
+        this.offset += 1;
+        return value;
+    }
+    readUInt16LE() {
+        const value = this.view.getUint16(this.offset, true);
+        this.offset += 2;
+        return value;
+    }
+    readUInt32LE() {
+        const value = this.view.getUint32(this.offset, true);
+        this.offset += 4;
+        return value;
+    }
+    readInt32LE() {
+        const value = this.view.getInt32(this.offset, true);
+        this.offset += 4;
+        return value;
+    }
+    readInt16LE() {
+        const value = this.view.getInt16(this.offset, true);
+        this.offset += 2;
+        return value;
+    }
+    readFloat64LE() {
+        const value = this.view.getFloat64(this.offset, true);
+        this.offset += 8;
+        return value;
+    }
+    readUtf16Chars(charCount) {
+        if (charCount <= 0)
+            return "";
+        const byteCount = charCount * 2;
+        const slice = this.bytes.subarray(this.offset, this.offset + byteCount);
+        this.offset += byteCount;
+        return new TextDecoder("utf-16le").decode(slice);
+    }
+    readXLWideString() {
+        const cch = this.readUInt32LE();
+        return cch === 0 ? "" : this.readUtf16Chars(cch);
+    }
+}
+// Common Excel function names by ID (ftab index)
+const FUNCTION_NAMES = {
+    0: "COUNT", 1: "IF", 2: "ISNA", 3: "ISERROR", 4: "SUM", 5: "AVERAGE",
+    6: "MIN", 7: "MAX", 8: "ROW", 9: "COLUMN", 10: "NA", 11: "NPV",
+    12: "STDEV", 13: "DOLLAR", 14: "FIXED", 15: "SIN", 16: "COS",
+    17: "TAN", 18: "ATAN", 19: "PI", 20: "SQRT", 21: "EXP", 22: "LN",
+    23: "LOG10", 24: "ABS", 25: "INT", 26: "SIGN", 27: "ROUND",
+    28: "LOOKUP", 29: "INDEX", 30: "REPT", 31: "MID", 32: "LEN",
+    33: "VALUE", 34: "TRUE", 35: "FALSE", 36: "AND", 37: "OR",
+    38: "NOT", 39: "MOD", 40: "DCOUNT", 41: "DSUM", 42: "DAVERAGE",
+    43: "DMIN", 44: "DMAX", 45: "DSTDEV", 46: "VAR", 47: "DVAR",
+    48: "TEXT", 49: "LINEST", 50: "TREND", 51: "LOGEST", 52: "GROWTH",
+    61: "MIRR", 62: "IRR", 63: "RAND", 64: "MATCH", 65: "DATE",
+    66: "TIME", 67: "DAY", 68: "MONTH", 69: "YEAR", 70: "WEEKDAY",
+    71: "HOUR", 72: "MINUTE", 73: "SECOND", 74: "NOW", 75: "AREAS",
+    76: "ROWS", 77: "COLUMNS", 78: "OFFSET", 82: "SEARCH", 83: "TRANSPOSE",
+    86: "TYPE", 97: "ATAN2", 98: "ASIN", 99: "ACOS", 100: "CHOOSE",
+    101: "HLOOKUP", 102: "VLOOKUP", 103: "ISREF", 104: "LOG",
+    105: "CHAR", 106: "LOWER", 107: "UPPER", 108: "PROPER", 109: "LEFT",
+    110: "RIGHT", 111: "EXACT", 112: "TRIM", 113: "REPLACE", 114: "SUBSTITUTE",
+    115: "CODE", 116: "NAMES", 117: "DIRECTORY", 118: "FIND", 119: "CELL",
+    120: "ISERR", 121: "ISTEXT", 122: "ISNUMBER", 123: "ISBLANK",
+    124: "T", 125: "N", 127: "ISNONTEXT", 128: "ISODD", 129: "ISEVEN",
+    162: "CLEAN", 163: "MDETERM", 164: "MINVERSE", 165: "MMULT",
+    167: "IPMT", 168: "PPMT", 169: "COUNTA", 183: "PRODUCT",
+    184: "FACT", 189: "DPRODUCT", 190: "ISNONTEXT",
+    193: "STDEVP", 194: "VARP", 195: "DSTDEVP", 196: "DVARP",
+    197: "TRUNC", 198: "ISLOGICAL", 199: "DCOUNTA", 200: "DELETEBAR",
+    216: "RANK", 219: "ADDRESS", 220: "DAYS360", 221: "TODAY",
+    222: "VDB", 227: "MEDIAN", 228: "SUMPRODUCT", 229: "SINH",
+    230: "COSH", 231: "TANH", 232: "ASINH", 233: "ACOSH", 234: "ATANH",
+    235: "DGET", 244: "INFO", 247: "DB", 252: "FREQUENCY",
+    261: "ERROR.TYPE", 269: "AVEDEV", 270: "BETADIST", 271: "GAMMALN",
+    272: "BETAINV", 273: "BINOMDIST", 274: "CHIDIST", 275: "CHIINV",
+    276: "COMBIN", 277: "CONFIDENCE", 278: "CRITBINOM", 279: "EVEN",
+    280: "EXPONDIST", 281: "FDIST", 282: "FINV", 283: "FISHER",
+    284: "FISHERINV", 285: "FLOOR", 286: "GAMMADIST", 287: "GAMMAINV",
+    288: "CEILING", 289: "HYPGEOMDIST", 290: "LOGNORMDIST", 291: "LOGINV",
+    292: "NEGBINOMDIST", 293: "NORMDIST", 294: "NORMSDIST", 295: "NORMINV",
+    296: "NORMSINV", 297: "STANDARDIZE", 298: "ODD", 299: "PERMUT",
+    300: "POISSON", 301: "TDIST", 302: "WEIBULL", 303: "SUMXMY2",
+    304: "SUMX2MY2", 305: "SUMX2PY2", 306: "CHITEST", 307: "CORREL",
+    308: "COVAR", 309: "FORECAST", 310: "FTEST", 311: "INTERCEPT",
+    312: "PEARSON", 313: "RSQ", 314: "STEYX", 315: "SLOPE", 316: "TTEST",
+    317: "PROB", 318: "DEVSQ", 319: "GEOMEAN", 320: "HARMEAN",
+    321: "SUMSQ", 322: "KURT", 323: "SKEW", 324: "ZTEST", 325: "LARGE",
+    326: "SMALL", 327: "QUARTILE", 328: "PERCENTILE", 329: "PERCENTRANK",
+    330: "MODE", 331: "TRIMMEAN", 332: "TINV", 334: "CONCATENATE",
+    335: "POWER", 336: "RADIANS", 337: "DEGREES", 338: "SUBTOTAL",
+    339: "SUMIF", 340: "COUNTIF", 341: "COUNTBLANK", 342: "HYPERLINK",
+    343: "PHONETIC", 344: "AVERAGEA", 345: "MAXA", 346: "MINA",
+    347: "STDEVPA", 348: "VARPA", 349: "STDEVA", 350: "VARA",
+};
+/**
+ * Parse Rgce (Reverse Polish Notation Compiled Expression) - binary formula format in XLSB
+ * This converts binary Ptg (Parsed Token) tokens into a formula string
+ *
+ * @param rgceBytes - The binary formula data
+ * @returns The formula string (without leading "=")
+ */
+/**
+ * Parse Rgce with sheet names for cross-sheet references
+ * @param rgceBytes - The binary formula data
+ * @param sheetNames - Array of sheet names for resolving external references
+ * @returns The formula string (without leading "=")
+ */
+export function parseRgce(rgceBytes, sheetRefResolver, baseCell, debug = false) {
+    if (!rgceBytes || rgceBytes.length === 0)
+        return "";
+    const reader = new RgceReader(rgceBytes);
+    const stack = [];
+    if (debug) {
+        console.log("[Rgce] Parsing", rgceBytes.length, "bytes:", Array.from(rgceBytes.slice(0, Math.min(30, rgceBytes.length)))
+            .map(b => `0x${b.toString(16).padStart(2, '0')}`)
+            .join(' '));
+    }
+    const fixedArgCounts = {
+        15: 1, // SIN
+        16: 1, // COS
+        17: 1, // TAN
+        19: 0, // PI
+        20: 1, // SQRT
+        21: 1, // EXP
+        22: 1, // LN
+        24: 1, // ABS
+        25: 1, // INT
+        27: 2, // ROUND
+        31: 3, // MID
+        32: 1, // LEN
+        34: 0, // TRUE
+        35: 0, // FALSE
+        39: 2, // MOD
+        65: 3, // DATE
+        66: 3, // TIME
+        67: 1, // DAY
+        68: 1, // MONTH
+        69: 1, // YEAR
+        71: 1, // HOUR
+        72: 1, // MINUTE
+        73: 1, // SECOND
+        74: 0, // NOW
+        105: 1, // CHAR
+        106: 1, // LOWER
+        107: 1, // UPPER
+        109: 2, // LEFT
+        110: 2, // RIGHT
+        111: 2, // EXACT
+        112: 1, // TRIM
+        115: 1, // CODE
+        183: 1, // PRODUCT
+        197: 2, // TRUNC
+        221: 0, // TODAY
+        335: 2, // POWER
+        336: 1, // RADIANS
+        337: 1, // DEGREES
+    };
+    const canRead = (n) => reader.offset + n <= rgceBytes.length;
+    const quoteSheetName = (name) => /[\s!'[\]]/.test(name) ? `'${name.replace(/'/g, "''")}'` : name;
+    const resolveSheetName = (ixti) => {
+        if (typeof sheetRefResolver === "function") {
+            return sheetRefResolver(ixti);
+        }
+        return sheetRefResolver?.[ixti];
+    };
+    const popArgs = (count) => {
+        const args = [];
+        for (let i = 0; i < count; i++)
+            args.unshift(stack.pop() || "");
+        return args;
+    };
+    const pushFixedFunction = (ftabIndex) => {
+        const funcName = FUNCTION_NAMES[ftabIndex] || `FUNC${ftabIndex}`;
+        const cargs = fixedArgCounts[ftabIndex] ?? 0;
+        stack.push(`${funcName}(${popArgs(cargs).join(",")})`);
+    };
+    const pushVariableFunction = (cargs, ftabIndex) => {
+        const funcName = FUNCTION_NAMES[ftabIndex] || `FUNC${ftabIndex}`;
+        stack.push(`${funcName}(${popArgs(cargs).join(",")})`);
+    };
+    const formatRef = (rowZero, colZero, rowRel, colRel) => {
+        const row = Math.max(0, rowZero);
+        const col = Math.max(0, colZero);
+        return `${colRel ? "" : "$"}${number2Alpha(col)}${rowRel ? "" : "$"}${row + 1}`;
+    };
+    const readShortRef = () => {
+        const row = reader.readUInt32LE();
+        const col = reader.readUInt16LE();
+        const rowRel = (col & 0x8000) !== 0;
+        const colRel = (col & 0x4000) !== 0;
+        return formatRef(row & 0x000fffff, col & 0x3fff, rowRel, colRel);
+    };
+    const readShortArea = () => {
+        const rowFirst = reader.readUInt32LE();
+        const rowLast = reader.readUInt32LE();
+        const colFirst = reader.readUInt16LE();
+        const colLast = reader.readUInt16LE();
+        const refFirst = formatRef(rowFirst & 0x000fffff, colFirst & 0x3fff, (colFirst & 0x8000) !== 0, (colFirst & 0x4000) !== 0);
+        const refLast = formatRef(rowLast & 0x000fffff, colLast & 0x3fff, (colLast & 0x8000) !== 0, (colLast & 0x4000) !== 0);
+        return `${refFirst}:${refLast}`;
+    };
+    const readRelShortRef = () => {
+        const rowOffset = reader.readInt32LE();
+        const colRaw = reader.readInt16LE();
+        const colOffset14 = colRaw & 0x3fff;
+        const colOffset = (colOffset14 << 18) >> 18;
+        const baseRowZero = Math.max(0, (baseCell?.row ?? 1) - 1);
+        const baseColZero = Math.max(0, (baseCell?.col ?? 1) - 1);
+        return formatRef(baseRowZero + rowOffset, baseColZero + colOffset, true, true);
+    };
+    const readRelShortArea = () => {
+        const rowFirstOffset = reader.readInt32LE();
+        const rowLastOffset = reader.readInt32LE();
+        const colFirstRaw = reader.readInt16LE();
+        const colLastRaw = reader.readInt16LE();
+        const colFirstOffset = ((colFirstRaw & 0x3fff) << 18) >> 18;
+        const colLastOffset = ((colLastRaw & 0x3fff) << 18) >> 18;
+        const baseRowZero = Math.max(0, (baseCell?.row ?? 1) - 1);
+        const baseColZero = Math.max(0, (baseCell?.col ?? 1) - 1);
+        const refFirst = formatRef(baseRowZero + rowFirstOffset, baseColZero + colFirstOffset, true, true);
+        const refLast = formatRef(baseRowZero + rowLastOffset, baseColZero + colLastOffset, true, true);
+        return `${refFirst}:${refLast}`;
+    };
+    try {
+        while (reader.offset < rgceBytes.length) {
+            const ptgOffset = reader.offset;
+            const ptg = reader.readUInt8();
+            if (debug) {
+                console.log(`[Rgce] @${ptgOffset}: ptg=0x${ptg.toString(16).padStart(2, '0')} stack=[${stack.join(', ')}]`);
+            }
+            // Handle token based on value
+            // Operators are 0x00-0x1f (no class bits)
+            // References/functions are 0x20-0x7f (have class bits in bits 5-6)
+            if (ptg === 0x03) {
+                // PtgAdd
+                const right = stack.pop() || "0";
+                const left = stack.pop() || "0";
+                stack.push(`${left}+${right}`);
+            }
+            else if (ptg === 0x04) {
+                // PtgSub - subtraction operator
+                const right = stack.pop() || "0";
+                const left = stack.pop() || "0";
+                stack.push(`${left}-${right}`);
+            }
+            else if (ptg === 0x05) {
+                // PtgMul - multiplication operator
+                const right = stack.pop() || "0";
+                const left = stack.pop() || "0";
+                stack.push(`${left}*${right}`);
+            }
+            else if (ptg === 0x06) {
+                // PtgDiv
+                const right = stack.pop() || "0";
+                const left = stack.pop() || "0";
+                stack.push(`${left}/${right}`);
+            }
+            else if (ptg === 0x07) {
+                // PtgPower
+                const right = stack.pop() || "0";
+                const left = stack.pop() || "0";
+                stack.push(`${left}^${right}`);
+            }
+            else if (ptg === 0x08) {
+                // PtgConcat
+                const right = stack.pop() || '""';
+                const left = stack.pop() || '""';
+                stack.push(`${left}&${right}`);
+            }
+            else if (ptg === 0x09) {
+                // PtgLT
+                const right = stack.pop() || "0";
+                const left = stack.pop() || "0";
+                stack.push(`${left}<${right}`);
+            }
+            else if (ptg === 0x0a) {
+                // PtgLE
+                const right = stack.pop() || "0";
+                const left = stack.pop() || "0";
+                stack.push(`${left}<=${right}`);
+            }
+            else if (ptg === 0x0b) {
+                // PtgEQ
+                const right = stack.pop() || "0";
+                const left = stack.pop() || "0";
+                stack.push(`${left}=${right}`);
+            }
+            else if (ptg === 0x0c) {
+                // PtgGE
+                const right = stack.pop() || "0";
+                const left = stack.pop() || "0";
+                stack.push(`${left}>=${right}`);
+            }
+            else if (ptg === 0x0d) {
+                // PtgGT
+                const right = stack.pop() || "0";
+                const left = stack.pop() || "0";
+                stack.push(`${left}>${right}`);
+            }
+            else if (ptg === 0x0e) {
+                // PtgNE
+                const right = stack.pop() || "0";
+                const left = stack.pop() || "0";
+                stack.push(`${left}<>${right}`);
+            }
+            else if (ptg === 0x12) {
+                // PtgUPlus
+                const operand = stack.pop() || "0";
+                stack.push(`+${operand}`);
+            }
+            else if (ptg === 0x13) {
+                // PtgUMinus
+                const operand = stack.pop() || "0";
+                stack.push(`-${operand}`);
+            }
+            else if (ptg === 0x14) {
+                // PtgPercent
+                const operand = stack.pop() || "0";
+                stack.push(`${operand}%`);
+            }
+            else if (ptg === 0x15) {
+                // PtgParen
+                const operand = stack.pop() || "";
+                stack.push(`(${operand})`);
+            }
+            else if (ptg === 0x16) {
+                // PtgMissArg - missing argument (empty between commas)
+                stack.push("");
+            }
+            else if (ptg === 0x17) {
+                // PtgStr - string constant
+                const str = reader.readXLWideString();
+                stack.push(`"${str.replace(/"/g, '""')}"`);
+            }
+            else if (ptg === 0x1d) {
+                // PtgBool - boolean constant
+                const value = reader.readUInt8();
+                stack.push(value ? "TRUE" : "FALSE");
+            }
+            else if (ptg === 0x1e) {
+                // PtgInt - integer constant
+                const value = reader.readUInt16LE();
+                stack.push(String(value));
+            }
+            else if (ptg === 0x1f) {
+                // PtgNum - float constant
+                const value = reader.readFloat64LE();
+                stack.push(String(value));
+            }
+            else if (ptg === 0x18) {
+                // PtgErr - error constant
+                if (!canRead(1))
+                    break;
+                const code = reader.readUInt8();
+                const errorValues = {
+                    0x00: "#NULL!",
+                    0x07: "#DIV/0!",
+                    0x0f: "#VALUE!",
+                    0x17: "#REF!",
+                    0x1d: "#NAME?",
+                    0x24: "#NUM!",
+                    0x2a: "#N/A",
+                    0x2b: "#GETTING_DATA",
+                };
+                stack.push(errorValues[code] || "#VALUE!");
+            }
+            else if (ptg === 0x19) {
+                // PtgAttr: 1 byte flags + 2 bytes data
+                if (!canRead(3))
+                    break;
+                const flags = reader.readUInt8();
+                const data = reader.readUInt16LE();
+                // Handle various PtgAttr flags
+                if ((flags & 0x10) !== 0) {
+                    // fSum: treat previous operand as SUM(operand)
+                    const operand = stack.pop() || "";
+                    stack.push(`SUM(${operand})`);
+                }
+                // Note: Other flags (fIf=0x02, fChoose=0x04, fSkip=0x08, fGoto=0x01)
+                // are for control flow and typically don't affect the formula string
+                // They just affect how bytes are skipped during parsing
+            }
+            else if (ptg === 0x01) {
+                // Ambiguous in some XLSB streams:
+                // - PtgExp (4-byte payload)
+                // - PtgFunc ref-class variant (2-byte payload)
+                if (canRead(4)) {
+                    const srcRow = reader.readUInt16LE() + 1;
+                    const srcCol = reader.readUInt16LE() + 1;
+                    stack.push(`__PTGEXP__:${srcRow}:${srcCol}`);
+                }
+                else if (canRead(2)) {
+                    pushFixedFunction(reader.readUInt16LE());
+                }
+                else {
+                    break;
+                }
+            }
+            else if (ptg === 0x02) {
+                // PtgFuncVar reference-class variant (0x02)
+                // In practice, 0x02 is PtgFuncVar, not PtgTbl
+                if (canRead(3)) {
+                    const cargs = reader.readUInt8();
+                    pushVariableFunction(cargs, reader.readUInt16LE());
+                }
+                else {
+                    break;
+                }
+            }
+            else if (ptg === 0x1a || ptg === 0x3a || ptg === 0x5a || ptg === 0x7a) {
+                // PtgRef3d - cross-sheet cell reference
+                if (!canRead(8))
+                    break;
+                const ixti = reader.readUInt16LE(); // External sheet index
+                const cellRef = readShortRef();
+                // Get sheet name if available
+                const sheetName = resolveSheetName(ixti);
+                if (sheetName) {
+                    const quotedName = quoteSheetName(sheetName);
+                    stack.push(`${quotedName}!${cellRef}`);
+                }
+                else {
+                    stack.push(cellRef);
+                }
+            }
+            else if (ptg === 0x1b || ptg === 0x3b || ptg === 0x5b || ptg === 0x7b) {
+                // PtgArea3d - cross-sheet range reference
+                if (!canRead(14))
+                    break;
+                const ixti = reader.readUInt16LE(); // External sheet index
+                const rangeRef = readShortArea();
+                // Get sheet name if available
+                const sheetName = resolveSheetName(ixti);
+                if (sheetName) {
+                    const quotedName = quoteSheetName(sheetName);
+                    stack.push(`${quotedName}!${rangeRef}`);
+                }
+                else {
+                    stack.push(rangeRef);
+                }
+            }
+            // References and functions have class bits
+            else if (ptg >= 0x20) {
+                const basePtg = ptg & 0x1f;
+                if (basePtg === 0x01) {
+                    // PtgFunc - function with fixed args
+                    if (!canRead(2))
+                        break;
+                    pushFixedFunction(reader.readUInt16LE());
+                }
+                else if (basePtg === 0x02) {
+                    // PtgFuncVar - function with variable args
+                    if (!canRead(3))
+                        break;
+                    const cargs = reader.readUInt8();
+                    pushVariableFunction(cargs, reader.readUInt16LE());
+                }
+                else if (basePtg === 0x04) {
+                    // PtgRef - cell reference
+                    if (!canRead(6))
+                        break;
+                    stack.push(readShortRef());
+                }
+                else if (basePtg === 0x05) {
+                    // PtgArea - range reference
+                    if (!canRead(12))
+                        break;
+                    stack.push(readShortArea());
+                }
+                else if (basePtg === 0x0c) {
+                    // PtgRefN - relative cell reference (commonly used in shared formulas)
+                    if (!canRead(6))
+                        break;
+                    stack.push(readRelShortRef());
+                }
+                else if (basePtg === 0x0d) {
+                    // PtgAreaN - relative range reference
+                    if (!canRead(12))
+                        break;
+                    stack.push(readRelShortArea());
+                }
+                else {
+                    // Unknown class token: break to avoid stream desync.
+                    break;
+                }
+            }
+            else {
+                // Unknown non-class token: break to avoid stream desync.
+                if (debug) {
+                    console.log(`[Rgce] Unknown token 0x${ptg.toString(16)}, stopping parse`);
+                }
+                break;
+            }
+        }
+    }
+    catch (err) {
+        // Parse error - return what we have so far
+        if (debug) {
+            console.error("[Rgce] Parse error:", err);
+        }
+        return stack.length > 0 ? stack[stack.length - 1] : "";
+    }
+    const result = stack.length > 0 ? stack[stack.length - 1] : "";
+    if (debug) {
+        console.log("[Rgce] Final result:", result);
+    }
+    return result;
+}

package/dist/esm/excel-parser/plugins/xlsm/index.d.ts

@@ -0,0 +1,5 @@
+import { XlsxPlugin } from "../xlsx/index";
+export declare class XlsmPlugin extends XlsxPlugin {
+    constructor();
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/excel-parser/plugins/xlsm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../excel-parser/plugins/xlsm/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,qBAAa,UAAW,SAAQ,UAAU;;CAIzC"}

package/dist/esm/excel-parser/plugins/xlsm/index.js

@@ -0,0 +1,6 @@
+import { XlsxPlugin } from "../xlsx/index";
+export class XlsmPlugin extends XlsxPlugin {
+    constructor() {
+        super();
+    }
+}

package/dist/esm/excel-parser/plugins/xlsx/charts.d.ts

@@ -0,0 +1,60 @@
+import type { ChartData, EmbeddedChart, EmbeddedObjectPosition, HIDDEN_DIMENSION_STRATEGY, SheetRange } from "@rowsncolumns/spreadsheet";
+import type { StreamingZipParser } from "../../zip-parser-streaming";
+/**
+ * Resolver from a sheet name (as it appears inside chart formula refs,
+ * e.g. `'Data for the Chart'!$A$7:$A$26`) to the numeric sheetId in the
+ * workbook. Returns `undefined` when the sheet can't be found — the
+ * caller then falls back to the host sheetId, preserving the legacy
+ * behaviour (chart pinned to its own sheet) for malformed refs.
+ */
+export type ResolveSheetId = (sheetName: string | undefined) => number | undefined;
+export declare function processChart(chartTarget: string, drawingPath: string, anchor: any, sheetId: number, zipParser: StreamingZipParser, xmlParser: any, sheetDimensions?: SheetDimensions, resolveSheetId?: ResolveSheetId): Promise<EmbeddedChart | null>;
+export declare function extractChartDataRange(plotArea: any, chartType: string, sheetId: number, resolveSheetId?: ResolveSheetId): SheetRange | null;
+/**
+ * Extract hidden dimension strategy from plotVisOnly attribute
+ * In Excel: plotVisOnly="1" means skip hidden rows/columns, "0" means show all
+ */
+export declare function extractHiddenDimensionStrategy(chart: any): HIDDEN_DIMENSION_STRATEGY | undefined;
+export declare function extractChartTitle(chart: any): string;
+export declare function determineChartType(chart: any): "bar" | "column" | "line" | "pie" | "doughnut" | "area" | "radar" | "stock" | "scatter" | "bubble" | "treemap" | "sunburst" | "histogram" | "boxplot" | "waterfall" | "funnel";
+/**
+ * Phase 5.5 — pull binCount out of the c15:histogramChart extension
+ * marker. Returns undefined if absent.
+ */
+export declare function extractC15HistogramBinCount(plotArea: any): number | undefined;
+export declare function extractChartSeries(plotArea: any, chartType: string, sheetId: number, resolveSheetId?: ResolveSheetId): ChartData[];
+export declare function extractChartDomains(plotArea: any, chartType: string, sheetId: number, resolveSheetId?: ResolveSheetId): ChartData[];
+/**
+ * Bubble charts have a third dimension — bubble size — referenced
+ * via `<c:bubbleSize><c:numRef><c:f>` on each series. Returns one
+ * `ChartData` entry per series (matches the shape used by `domains` /
+ * `series`).
+ */
+export declare function extractChartBubbleSizes(plotArea: any, sheetId: number, resolveSheetId?: ResolveSheetId): ChartData[];
+export type SheetDimensions = {
+    columnWidths?: Map<number, number>;
+    rowHeights?: Map<number, number>;
+    defaultColumnWidth?: number;
+    defaultRowHeight?: number;
+};
+export declare function extractChartPosition(anchor: any, sheetId: number, sheetDimensions?: SheetDimensions): EmbeddedObjectPosition | null;
+export declare function extractAxisOptions(plotArea: any): {
+    valueAxisOptions: any;
+    secondaryValueAxisOptions: any;
+    categoryAxisOptions: any;
+};
+/**
+ * Pie-of-pie / bar-of-pie — extract the of-pie layout fields from
+ * `<c:ofPieChart>`. Returns undefined for plain pies. `splitType`
+ * maps the OOXML tokens (`pos`/`val`/`percent`) to the spec vocabulary;
+ * `auto` and `cust` (custom point assignment, carried in `<c:custSplit>`
+ * which the spec cannot represent) are omitted so the renderer applies
+ * Excel's default rule (position, last 3 values).
+ */
+export declare function extractOfPieOptions(plotArea: any): {
+    ofPieType: "pie" | "bar";
+    splitType?: "position" | "value" | "percent";
+    splitPos?: number;
+    secondPieSize?: number;
+} | undefined;
+//# sourceMappingURL=charts.d.ts.map

package/dist/esm/excel-parser/plugins/xlsx/charts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"charts.d.ts","sourceRoot":"","sources":["../../../../../excel-parser/plugins/xlsx/charts.ts"],"names":[],"mappings":"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"}