@rowsncolumns/spreadsheet-state 28.0.66

package/dist/cjs/api/immer-utils.js

@@ -0,0 +1,1633 @@
+import { __assign, __generator, __read, __values } from "tslib";
+import { isStaticNode } from "@rowsncolumns/dag";
+import { isCellCoordinate } from "@rowsncolumns/dag";
+import { tokenVocabulary } from "@rowsncolumns/fast-formula-parser";
+import { addressToCell, desanitizeSheetName, getDefaultDateFormat, getDefaultDateTimeFormat, getDefaultTimeFormat, isNil, } from "@rowsncolumns/utils";
+import { defaultCellCoords, SheetCell } from "../sheet-cell";
+import { changeDecimals, getCurrentDecimalCountInPattern, getDecimalPlaces, } from "./decimals";
+export var createSheetDraft = function (draft, sheetId, rowIndex) {
+    var _a;
+    // Get sheet reference once
+    var sheet = draft[sheetId];
+    if (!sheet) {
+        sheet = draft[sheetId] = [];
+    }
+    if (!isNil(rowIndex)) {
+        // Direct assignment, single proxy access
+        if (!((_a = sheet[rowIndex]) === null || _a === void 0 ? void 0 : _a.values)) {
+            sheet[rowIndex] = { values: [] };
+        }
+    }
+    return sheet;
+};
+// Clone entire row
+export var cloneRowWithFormatting = function (rowData) {
+    var _a;
+    if (!rowData) {
+        return { values: [] };
+    }
+    var sheetCell = new SheetCell();
+    var values = (_a = rowData === null || rowData === void 0 ? void 0 : rowData.values) === null || _a === void 0 ? void 0 : _a.map(function (cellData) {
+        sheetCell.assign(1, defaultCellCoords, cellData);
+        return sheetCell.cloneWithFormatting().getCellData();
+    });
+    return {
+        values: values,
+    };
+};
+// Clone cell
+export var cloneCellWithFormatting = function (celLData) {
+    var sheetCell = new SheetCell(1, defaultCellCoords, celLData);
+    return sheetCell.cloneWithFormatting().getCellData();
+};
+/**
+ * "Generic" precedent types — these don't carry styling intent so a
+ * later, more specific format can override them. Used by the
+ * first-specific-wins merging rule in `processPrecedentCell`.
+ */
+var isGenericNumberFormatType = function (type) { return !type || type === "NUMBER" || type === "GENERAL"; };
+/**
+ * Date-family types — when the derived (resolved) type is one of these
+ * and the precedent's type is also in this set, we preserve the
+ * precedent's exact custom pattern instead of synthesizing a locale
+ * default. Mirrors Excel's behaviour for date-arithmetic functions
+ * (EDATE, EOMONTH, …) where `=EDATE(A1, 1)` keeps A1's custom pattern.
+ */
+var isDateFamilyType = function (type) { return type === "DATE" || type === "TIME" || type === "DATE_TIME"; };
+var customNumberFormatMap = {
+    COUNT: "NUMBER",
+};
+var formatDerivationRules = {
+    SUMIFS: { type: "fixed_index", index: 0 },
+    AVERAGEIFS: { type: "fixed_index", index: 0 },
+    MINIFS: { type: "fixed_index", index: 0 },
+    MAXIFS: { type: "fixed_index", index: 0 },
+    FILTER: { type: "fixed_index", index: 0 },
+    XLOOKUP: { type: "fixed_index", index: 2 },
+    INDEX: { type: "fixed_index", index: 0 },
+    SORT: { type: "fixed_index", index: 0 },
+    SORTBY: { type: "fixed_index", index: 0 },
+    UNIQUE: { type: "fixed_index", index: 0 },
+    TAKE: { type: "fixed_index", index: 0 },
+    DROP: { type: "fixed_index", index: 0 },
+    TOCOL: { type: "fixed_index", index: 0 },
+    TOROW: { type: "fixed_index", index: 0 },
+    WRAPROWS: { type: "fixed_index", index: 0 },
+    WRAPCOLS: { type: "fixed_index", index: 0 },
+    CHOOSECOLS: { type: "fixed_index", index: 0 },
+    CHOOSEROWS: { type: "fixed_index", index: 0 },
+    TRANSPOSE: { type: "fixed_index", index: 0 },
+    SUMIF: {
+        type: "conditional_index",
+        getIndex: function (count) { return (count >= 3 ? 2 : 0); },
+    },
+    AVERAGEIF: {
+        type: "conditional_index",
+        getIndex: function (count) { return (count >= 3 ? 2 : 0); },
+    },
+    VLOOKUP: { type: "vlookup", tableIndex: 1, colIndexArg: 2 },
+    HLOOKUP: { type: "hlookup", tableIndex: 1, rowIndexArg: 2 },
+    // Statistical functions that inherit format from their data array.
+    // Excel renders `MEDIAN(currency_range)` etc. with the data's
+    // format. All take the data array as the first arg.
+    MEDIAN: { type: "fixed_index", index: 0 },
+    MODE: { type: "fixed_index", index: 0 },
+    "MODE.SNGL": { type: "fixed_index", index: 0 },
+    "MODE.MULT": { type: "fixed_index", index: 0 },
+    PERCENTILE: { type: "fixed_index", index: 0 },
+    "PERCENTILE.INC": { type: "fixed_index", index: 0 },
+    "PERCENTILE.EXC": { type: "fixed_index", index: 0 },
+    QUARTILE: { type: "fixed_index", index: 0 },
+    "QUARTILE.INC": { type: "fixed_index", index: 0 },
+    "QUARTILE.EXC": { type: "fixed_index", index: 0 },
+    LARGE: { type: "fixed_index", index: 0 },
+    SMALL: { type: "fixed_index", index: 0 },
+    TRIMMEAN: { type: "fixed_index", index: 0 },
+    GEOMEAN: { type: "fixed_index", index: 0 },
+    HARMEAN: { type: "fixed_index", index: 0 },
+    AVERAGEA: { type: "fixed_index", index: 0 },
+    MINA: { type: "fixed_index", index: 0 },
+    MAXA: { type: "fixed_index", index: 0 },
+    // VAR and STDEV: Excel keeps the data format on display (units are a
+    // formatting concern, not a value-unit concern). VAR is technically
+    // squared, but spreadsheets don't track units — match Excel.
+    VAR: { type: "fixed_index", index: 0 },
+    "VAR.S": { type: "fixed_index", index: 0 },
+    "VAR.P": { type: "fixed_index", index: 0 },
+    VARA: { type: "fixed_index", index: 0 },
+    VARPA: { type: "fixed_index", index: 0 },
+    STDEV: { type: "fixed_index", index: 0 },
+    "STDEV.S": { type: "fixed_index", index: 0 },
+    "STDEV.P": { type: "fixed_index", index: 0 },
+    STDEVA: { type: "fixed_index", index: 0 },
+    STDEVPA: { type: "fixed_index", index: 0 },
+    // FORECAST(x, known_ys, known_xs) — inherits from y values (index 1).
+    FORECAST: { type: "fixed_index", index: 1 },
+    "FORECAST.LINEAR": { type: "fixed_index", index: 1 },
+    "FORECAST.ETS": { type: "fixed_index", index: 1 },
+    // Financial functions — inherit CURRENCY from the principal arg
+    // (matches Excel's behaviour where `=PMT(rate, n, pv)` on a currency
+    // principal renders as currency). Arg positions reference the
+    // standard Excel signatures.
+    PMT: { type: "fixed_index", index: 2 }, // PMT(rate, nper, pv, [fv], [type])
+    PV: { type: "fixed_index", index: 2 }, // PV(rate, nper, pmt, [fv], [type])
+    FV: { type: "fixed_index", index: 2 }, // FV(rate, nper, pmt, [pv], [type])
+    NPV: { type: "fixed_index", index: 1 }, // NPV(rate, value1, ...)
+    XNPV: { type: "fixed_index", index: 1 }, // XNPV(rate, values, dates)
+    IPMT: { type: "fixed_index", index: 3 }, // IPMT(rate, per, nper, pv, [fv], [type])
+    PPMT: { type: "fixed_index", index: 3 }, // PPMT(rate, per, nper, pv, [fv], [type])
+    CUMIPMT: { type: "fixed_index", index: 2 }, // CUMIPMT(rate, nper, pv, start, end, type)
+    CUMPRINC: { type: "fixed_index", index: 2 }, // CUMPRINC(rate, nper, pv, start, end, type)
+    DDB: { type: "fixed_index", index: 0 }, // DDB(cost, salvage, life, period, [factor])
+    SLN: { type: "fixed_index", index: 0 }, // SLN(cost, salvage, life)
+    SYD: { type: "fixed_index", index: 0 }, // SYD(cost, salvage, life, per)
+    DB: { type: "fixed_index", index: 0 }, // DB(cost, salvage, life, period, [month])
+};
+var functionReturnTypes = {
+    // ─── Date/time — extractors (return scalar numbers) ────────────────
+    MONTH: "NUMBER",
+    YEAR: "NUMBER",
+    DAY: "NUMBER",
+    DAYS: "NUMBER",
+    HOUR: "NUMBER",
+    MINUTE: "NUMBER",
+    SECOND: "NUMBER",
+    WEEKDAY: "NUMBER",
+    WEEKNUM: "NUMBER",
+    ISOWEEKNUM: "NUMBER",
+    YEARFRAC: "NUMBER",
+    DATEDIF: "NUMBER",
+    DATEVALUE: "NUMBER",
+    TIMEVALUE: "NUMBER",
+    NETWORKDAYS: "NUMBER",
+    "NETWORKDAYS.INTL": "NUMBER",
+    DAYS360: "NUMBER",
+    // ─── Date/time — date producers (must render as DATE/TIME/DATE_TIME) ─
+    NOW: "DATE_TIME",
+    TODAY: "DATE",
+    DATE: "DATE",
+    TIME: "TIME",
+    EDATE: "DATE",
+    EOMONTH: "DATE",
+    // WORKDAY returns a date serial number — must render as DATE, not
+    // raw NUMBER (was a bug: cells showed e.g. "45292" instead of the
+    // calendar date).
+    WORKDAY: "DATE",
+    "WORKDAY.INTL": "DATE",
+    // ─── Aggregation / rounding (return NUMBER; CURRENCY precedent
+    //     preserved via the "expectedOutputType === NUMBER + numFormat
+    //     CURRENCY → keep numFormat" branch) ──────────────────────────
+    SUM: "NUMBER",
+    SUMPRODUCT: "NUMBER",
+    SUMSQ: "NUMBER",
+    ROUND: "NUMBER",
+    ROUNDUP: "NUMBER",
+    ROUNDDOWN: "NUMBER",
+    TRUNC: "NUMBER",
+    QUOTIENT: "NUMBER",
+    CEILING: "NUMBER",
+    FLOOR: "NUMBER",
+    MROUND: "NUMBER",
+    INT: "NUMBER",
+    MOD: "NUMBER",
+    // ─── Math/trig (return scalar NUMBER) ──────────────────────────────
+    POWER: "NUMBER",
+    SQRT: "NUMBER",
+    EXP: "NUMBER",
+    LN: "NUMBER",
+    LOG: "NUMBER",
+    LOG10: "NUMBER",
+    SIGN: "NUMBER",
+    SIN: "NUMBER",
+    COS: "NUMBER",
+    TAN: "NUMBER",
+    ASIN: "NUMBER",
+    ACOS: "NUMBER",
+    ATAN: "NUMBER",
+    ATAN2: "NUMBER",
+    SINH: "NUMBER",
+    COSH: "NUMBER",
+    TANH: "NUMBER",
+    ASINH: "NUMBER",
+    ACOSH: "NUMBER",
+    ATANH: "NUMBER",
+    DEGREES: "NUMBER",
+    RADIANS: "NUMBER",
+    PI: "NUMBER",
+    FACT: "NUMBER",
+    FACTDOUBLE: "NUMBER",
+    COMBIN: "NUMBER",
+    COMBINA: "NUMBER",
+    PERMUT: "NUMBER",
+    PERMUTATIONA: "NUMBER",
+    GCD: "NUMBER",
+    LCM: "NUMBER",
+    // ─── Random/value conversion ───────────────────────────────────────
+    RAND: "NUMBER",
+    RANDBETWEEN: "NUMBER",
+    VALUE: "NUMBER",
+    N: "NUMBER",
+    // ─── Statistical — scalar results (NUMBER) ─────────────────────────
+    AVEDEV: "NUMBER",
+    DEVSQ: "NUMBER",
+    KURT: "NUMBER",
+    SKEW: "NUMBER",
+    "SKEW.P": "NUMBER",
+    COVAR: "NUMBER",
+    "COVARIANCE.S": "NUMBER",
+    "COVARIANCE.P": "NUMBER",
+    CORREL: "NUMBER",
+    RSQ: "NUMBER",
+    SLOPE: "NUMBER",
+    INTERCEPT: "NUMBER",
+    STEYX: "NUMBER",
+    PEARSON: "NUMBER",
+    // ─── Financial — rate/period scalars (NUMBER); CURRENCY-returning
+    //     financial functions live in `formatDerivationRules` instead ──
+    XIRR: "NUMBER",
+    IRR: "NUMBER",
+    MIRR: "NUMBER",
+    RATE: "NUMBER",
+    NPER: "NUMBER",
+    EFFECT: "NUMBER",
+    NOMINAL: "NUMBER",
+    // ─── Counts & positions (COUNT, displays as NUMBER) ────────────────
+    MATCH: "COUNT",
+    XMATCH: "COUNT",
+    COUNT: "COUNT",
+    COUNTA: "COUNT",
+    COUNTBLANK: "COUNT",
+    COUNTIF: "COUNT",
+    COUNTIFS: "COUNT",
+    ROW: "COUNT",
+    ROWS: "COUNT",
+    COLUMN: "COUNT",
+    COLUMNS: "COUNT",
+    RANK: "COUNT",
+    "RANK.EQ": "COUNT",
+    "RANK.AVG": "COUNT",
+    FREQUENCY: "COUNT",
+    LEN: "COUNT",
+    SEARCH: "COUNT",
+    SEARCHB: "COUNT",
+    FIND: "COUNT",
+    FINDB: "COUNT",
+    // ─── Text producers ─────────────────────────────────────────────────
+    TEXT: "TEXT",
+    LEFT: "TEXT",
+    LEFTB: "TEXT",
+    RIGHT: "TEXT",
+    RIGHTB: "TEXT",
+    MID: "TEXT",
+    MIDB: "TEXT",
+    LOWER: "TEXT",
+    UPPER: "TEXT",
+    PROPER: "TEXT",
+    TRIM: "TEXT",
+    CLEAN: "TEXT",
+    SUBSTITUTE: "TEXT",
+    REPLACE: "TEXT",
+    REPLACEB: "TEXT",
+    REPT: "TEXT",
+    CONCAT: "TEXT",
+    CONCATENATE: "TEXT",
+    TEXTJOIN: "TEXT",
+    ADDRESS: "TEXT",
+    CHAR: "TEXT",
+    UNICHAR: "TEXT",
+    T: "TEXT",
+    DOLLAR: "TEXT",
+    FIXED: "TEXT",
+    BAHTTEXT: "TEXT",
+    // ─── Aggregation with formatDerivationRules entries (NUMBER base —
+    //     specific-arg inheritance is in `formatDerivationRules`) ──────
+    SUMIFS: "NUMBER",
+    SUMIF: "NUMBER",
+    AVERAGEIFS: "NUMBER",
+    AVERAGEIF: "NUMBER",
+    MINIFS: "NUMBER",
+    MAXIFS: "NUMBER",
+};
+var currencyDecimalAdjustmentFunctions = new Set([
+    "ROUND",
+    "ROUNDUP",
+    "ROUNDDOWN",
+    "TRUNC",
+    "INT",
+    "MROUND",
+    "CEILING",
+    "FLOOR",
+    "QUOTIENT",
+]);
+// Get all function names from formula
+var functionRegex = /([A-Za-z0-9_]+)\s*\(/g;
+export var getFunctionNamesFromFormula = function (formula) {
+    var match;
+    var matches = [];
+    while ((match = functionRegex.exec(formula))) {
+        var _a = __read(match, 2), _1 = _a[0], functionName = _a[1];
+        if (functionName) {
+            matches.push(functionName);
+        }
+    }
+    return matches;
+};
+var getSheetNameFromToken = function (token) {
+    if (!token)
+        return undefined;
+    if (token.tokenType.name === tokenVocabulary.Sheet.name) {
+        return token.image.slice(0, -1);
+    }
+    if (token.tokenType.name === tokenVocabulary.SheetQuoted.name) {
+        var cleanSheetName = desanitizeSheetName(token.image);
+        return cleanSheetName ? cleanSheetName.slice(0, -1) : undefined;
+    }
+    return undefined;
+};
+var getDirectReferenceBounds = function (formula, tokenizer, sheetId, getSheetId) {
+    var _a, _b, _c;
+    if (!formula)
+        return [];
+    var trimmed = formula.trim();
+    if (!trimmed.startsWith("="))
+        return [];
+    var tokens = tokenizer(trimmed.slice(1));
+    var bounds = [];
+    var pendingSheetId;
+    for (var i = 0; i < tokens.length; i++) {
+        var token = tokens[i];
+        var tokenSheetName = getSheetNameFromToken(token);
+        if (tokenSheetName) {
+            pendingSheetId = getSheetId(tokenSheetName);
+            continue;
+        }
+        if (token.tokenType.name !== tokenVocabulary.Cell.name) {
+            continue;
+        }
+        var refSheetId = token.sheetName
+            ? getSheetId(token.sheetName)
+            : pendingSheetId !== null && pendingSheetId !== void 0 ? pendingSheetId : sheetId;
+        pendingSheetId = undefined;
+        var startCell = addressToCell(token.image);
+        if (!startCell)
+            continue;
+        if (((_a = tokens[i + 1]) === null || _a === void 0 ? void 0 : _a.tokenType.name) === tokenVocabulary.Colon.name &&
+            ((_b = tokens[i + 2]) === null || _b === void 0 ? void 0 : _b.tokenType.name) === tokenVocabulary.Cell.name) {
+            var endCell = addressToCell((_c = tokens[i + 2]) === null || _c === void 0 ? void 0 : _c.image);
+            if (endCell) {
+                bounds.push({
+                    sheetId: refSheetId,
+                    minRow: Math.min(startCell.rowIndex, endCell.rowIndex),
+                    maxRow: Math.max(startCell.rowIndex, endCell.rowIndex),
+                    minCol: Math.min(startCell.columnIndex, endCell.columnIndex),
+                    maxCol: Math.max(startCell.columnIndex, endCell.columnIndex),
+                });
+                i += 2;
+                continue;
+            }
+        }
+        bounds.push({
+            sheetId: refSheetId,
+            minRow: startCell.rowIndex,
+            maxRow: startCell.rowIndex,
+            minCol: startCell.columnIndex,
+            maxCol: startCell.columnIndex,
+        });
+    }
+    return bounds;
+};
+var filterPrecedentsByBounds = function (precedents, bounds) {
+    if (bounds.length === 0)
+        return precedents;
+    var intersects = function (b, row, col) {
+        return row >= b.minRow && row <= b.maxRow && col >= b.minCol && col <= b.maxCol;
+    };
+    var rangeIntersects = function (b, startRow, startCol, endRow, endCol) {
+        return !(startRow > b.maxRow ||
+            endRow < b.minRow ||
+            startCol > b.maxCol ||
+            endCol < b.minCol);
+    };
+    var filtered = precedents.filter(function (p) {
+        var e_1, _a;
+        if (isStaticNode(p))
+            return true;
+        try {
+            for (var bounds_1 = __values(bounds), bounds_1_1 = bounds_1.next(); !bounds_1_1.done; bounds_1_1 = bounds_1.next()) {
+                var b = bounds_1_1.value;
+                if (p.position.sheetId !== b.sheetId) {
+                    continue;
+                }
+                if (isCellCoordinate(p.position)) {
+                    if (intersects(b, p.position.rowIndex, p.position.columnIndex)) {
+                        return true;
+                    }
+                }
+                else if (rangeIntersects(b, p.position.startRowIndex, p.position.startColumnIndex, p.position.endRowIndex, p.position.endColumnIndex)) {
+                    return true;
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (bounds_1_1 && !bounds_1_1.done && (_a = bounds_1.return)) _a.call(bounds_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return false;
+    });
+    return filtered.length > 0 ? filtered : precedents;
+};
+var sheetCell = new SheetCell();
+export var deriveEffectiveNumberFormatFromPrecedents = function (formula, precedents, draft, tokenizer, sheetId, rowIndex, columnIndex, locale, getSheetId, cellXfsRegistry, getDataValidationById, calculatedValue, 
+/**
+ * Optional resolver for a precedent's effective `numberFormat`. When a
+ * precedent is itself a formula cell with no `uf.numberFormat`, its
+ * format is derived (not persisted on cellData), so reading
+ * `sheetCell.getNumberFormat()` would miss it. The resolver lets the
+ * caller recurse through formula chains so `C1 = B1 = A1` inherits A1's
+ * format. When omitted, only the precedent's persisted
+ * `uf.numberFormat` is consulted.
+ */
+resolvePrecedentNumberFormat) {
+    var e_2, _a;
+    var _b, _c, _d, _e;
+    if (formula === void 0) { formula = ""; }
+    // Assign sheet cell
+    sheetCell.assign(sheetId, defaultCellCoords, (_d = (_c = (_b = draft === null || draft === void 0 ? void 0 : draft[sheetId]) === null || _b === void 0 ? void 0 : _b[rowIndex]) === null || _c === void 0 ? void 0 : _c.values) === null || _d === void 0 ? void 0 : _d[columnIndex], {
+        locale: locale,
+        cellXfsRegistry: cellXfsRegistry,
+        getDataValidationById: getDataValidationById,
+    });
+    // Check if has user entered format
+    // User entered format always has precedence over
+    // format derived from precedents
+    if ((_e = sheetCell.userEnteredFormat) === null || _e === void 0 ? void 0 : _e.numberFormat) {
+        return sheetCell.userEnteredFormat.numberFormat;
+    }
+    if (shouldSkipPrecedentFormatInheritance(formula)) {
+        return undefined;
+    }
+    // Priority
+    // NUMBER -> PERCENTAGE -> CURRENCY
+    var numFormat = undefined;
+    // Expected return type from function
+    var expectedOutputType = undefined;
+    var shouldAdjustCurrencyDecimals = false;
+    var maxDecimals = 0;
+    var match;
+    var isIndirectReference = formula
+        .trim()
+        .toUpperCase()
+        .startsWith("=INDIRECT(");
+    functionRegex.lastIndex = 0;
+    while ((match = functionRegex.exec(formula))) {
+        var _f = __read(match, 2), _2 = _f[0], functionName = _f[1];
+        var functionDefault = isIndirectReference
+            ? undefined
+            : functionReturnTypes[functionName.toUpperCase()];
+        if (currencyDecimalAdjustmentFunctions.has(functionName.toUpperCase())) {
+            shouldAdjustCurrencyDecimals = true;
+        }
+        if (!expectedOutputType) {
+            expectedOutputType = functionDefault;
+        }
+        else if (functionDefault === "NUMBER" && expectedOutputType === "DATE") {
+            // if the function returns a number but the expected type is a date,
+            // assume the output is a date
+            expectedOutputType = "DATE";
+        }
+    }
+    // Set effective format
+    var effectivePrecedents = precedents;
+    var indirectCurrentRowAddressMatch = formula
+        .trim()
+        .match(/^=INDIRECT\(\s*ADDRESS\(\s*ROW\(\)\s*,\s*(\d+)\s*\)\s*\)$/i);
+    if (indirectCurrentRowAddressMatch) {
+        effectivePrecedents = [
+            {
+                position: {
+                    sheetId: sheetId,
+                    rowIndex: rowIndex,
+                    columnIndex: Number(indirectCurrentRowAddressMatch[1]),
+                },
+            },
+        ];
+    }
+    var topLevelFunctionName;
+    var directBounds = getDirectReferenceBounds(formula, tokenizer, sheetId, getSheetId);
+    effectivePrecedents = filterPrecedentsByBounds(effectivePrecedents, directBounds);
+    var upperFormula = formula === null || formula === void 0 ? void 0 : formula.trim().toUpperCase();
+    if (upperFormula) {
+        var functionNameMatch = upperFormula.match(/^=([A-Z0-9_]+)\(/);
+        topLevelFunctionName = functionNameMatch ? functionNameMatch[1] : undefined;
+        var rule = topLevelFunctionName
+            ? formatDerivationRules[topLevelFunctionName]
+            : undefined;
+        if (rule) {
+            var args = extractTopLevelArgs(formula, upperFormula.split("(")[0]);
+            if (rule.type === "fixed_index" || rule.type === "conditional_index") {
+                var targetIndex = rule.type === "fixed_index"
+                    ? rule.index
+                    : rule.getIndex(args.length);
+                if (targetIndex >= 0 && targetIndex < args.length) {
+                    effectivePrecedents = filterPrecedentsByAddress(precedents, args[targetIndex], sheetId, getSheetId);
+                }
+            }
+            else if (rule.type === "vlookup" || rule.type === "hlookup") {
+                // VLOOKUP / HLOOKUP: Excel returns the format of the matched cell
+                // in the literal-numbered column/row of the table range. Restrict
+                // derivation to that single column/row so a currency-formatted
+                // unrelated column in the table doesn't leak its format into the
+                // result.
+                var tableArg = args[rule.tableIndex];
+                var indexArg = args[rule.type === "vlookup" ? rule.colIndexArg : rule.rowIndexArg];
+                var offset = parseLiteralInt(indexArg);
+                if (tableArg && offset && offset >= 1) {
+                    effectivePrecedents = filterPrecedentsByTableOffset(precedents, tableArg, offset, rule.type === "vlookup" ? "column" : "row", sheetId, getSheetId);
+                }
+                else if (tableArg) {
+                    // Fallback: literal index unreadable (e.g. formula expression).
+                    // Filter to the whole table — still better than walking every
+                    // precedent.
+                    effectivePrecedents = filterPrecedentsByAddress(precedents, tableArg, sheetId, getSheetId);
+                }
+            }
+        }
+    }
+    var processPrecedentCell = function (precedentSheetId, precedentRowIndex, precedentColumnIndex) {
+        var _a, _b, _c, _d;
+        sheetCell.assign(precedentSheetId, {
+            rowIndex: precedentRowIndex,
+            columnIndex: precedentColumnIndex,
+        }, (_c = (_b = (_a = draft === null || draft === void 0 ? void 0 : draft[precedentSheetId]) === null || _a === void 0 ? void 0 : _a[precedentRowIndex]) === null || _b === void 0 ? void 0 : _b.values) === null || _c === void 0 ? void 0 : _c[precedentColumnIndex], {
+            locale: locale,
+            cellXfsRegistry: cellXfsRegistry,
+            getDataValidationById: getDataValidationById,
+        });
+        // Prefer the resolver: it returns `uf.numberFormat` for plain cells
+        // and the recursively-derived format for formula cells, so chains
+        // like `C1 = B1 = A1` propagate A1's format through B1 to C1.
+        // Falls back to the precedent's persisted `uf.numberFormat` when no
+        // resolver is wired (callers without a derive-graph, e.g. exporters).
+        var curNumFormat = (_d = resolvePrecedentNumberFormat === null || resolvePrecedentNumberFormat === void 0 ? void 0 : resolvePrecedentNumberFormat(precedentSheetId, precedentRowIndex, precedentColumnIndex)) !== null && _d !== void 0 ? _d : sheetCell.getNumberFormat();
+        var currentValue = sheetCell.getEffectiveValue();
+        if (typeof currentValue === "number") {
+            maxDecimals = Math.max(maxDecimals, getDecimalPlaces(currentValue, locale));
+        }
+        if (curNumFormat) {
+            maxDecimals = Math.max(maxDecimals, getCurrentDecimalCountInPattern(curNumFormat.pattern));
+            if (curNumFormat.type === "TEXT" &&
+                numFormat &&
+                numFormat.type &&
+                numFormat.type !== "TEXT") {
+                return;
+            }
+            // Excel's rule: the **first** non-generic precedent format wins.
+            // Generic = NUMBER/GENERAL/COUNT (no specific styling intent), so a
+            // later CURRENCY/PERCENT/DATE/etc. can upgrade it; but once a
+            // specific format is locked in we don't let a different specific
+            // format override it (e.g. PERCENT then CURRENCY → keep PERCENT,
+            // matching Excel; previously priority-based merging picked the
+            // higher-priority one regardless of position).
+            if (!numFormat || isGenericNumberFormatType(numFormat.type)) {
+                numFormat = curNumFormat;
+            }
+        }
+    };
+    try {
+        for (var effectivePrecedents_1 = __values(effectivePrecedents), effectivePrecedents_1_1 = effectivePrecedents_1.next(); !effectivePrecedents_1_1.done; effectivePrecedents_1_1 = effectivePrecedents_1.next()) {
+            var precedent = effectivePrecedents_1_1.value;
+            // Ignore static node
+            if (isStaticNode(precedent)) {
+                continue;
+            }
+            var precedentSheetId = precedent.position.sheetId;
+            if (isCellCoordinate(precedent.position)) {
+                processPrecedentCell(precedentSheetId, precedent.position.rowIndex, precedent.position.columnIndex);
+                continue;
+            }
+            // Anchor-only derivation: Excel inherits a range's number format from
+            // its first cell (top-left). This makes derivation O(1) per range and
+            // keeps it consistent with the anchor-only cache fingerprint so a
+            // non-anchor format change doesn't leak a different result than what
+            // the cache would return.
+            processPrecedentCell(precedentSheetId, precedent.position.startRowIndex, precedent.position.startColumnIndex);
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (effectivePrecedents_1_1 && !effectivePrecedents_1_1.done && (_a = effectivePrecedents_1.return)) _a.call(effectivePrecedents_1);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    // Get decimal places from the calculated value
+    // This respects ROUND's output - if ROUND(x, 0) gives 456, it has 0 decimals
+    var calculatedDecimals = typeof calculatedValue === "number"
+        ? getDecimalPlaces(calculatedValue, locale)
+        : undefined;
+    if (typeof calculatedValue === "number") {
+        maxDecimals = Math.max(maxDecimals, calculatedDecimals !== null && calculatedDecimals !== void 0 ? calculatedDecimals : 0);
+    }
+    if (!numFormat && maxDecimals > 0) {
+        numFormat = { type: "NUMBER" };
+    }
+    var applyDecimalHeuristic = function (format) {
+        var _a;
+        // `#` is the implicit integer pattern inferred from plain numeric cells,
+        // but it suppresses zero. Formula results should still display a derived
+        // zero; an explicitly formatted formula cell returned above remains
+        // untouched.
+        if (calculatedValue === 0 &&
+            (format === null || format === void 0 ? void 0 : format.type) === "NUMBER" &&
+            format.pattern === "#") {
+            return __assign(__assign({}, format), { pattern: "0" });
+        }
+        // For CURRENCY type, use the calculated value's decimal places
+        // This ensures ROUND(SUM(F9), 0) shows 0 decimals even if precedent has 2
+        if ((format === null || format === void 0 ? void 0 : format.type) === "CURRENCY" &&
+            shouldAdjustCurrencyDecimals &&
+            calculatedDecimals !== undefined &&
+            format.pattern) {
+            var patternDecimals = getCurrentDecimalCountInPattern(format.pattern);
+            // Only adjust if calculated value has fewer decimals than the pattern
+            // (respects ROUND's intent to reduce decimals)
+            if (calculatedDecimals < patternDecimals) {
+                return __assign(__assign({}, format), { pattern: changeDecimals(format.pattern, calculatedDecimals, false) });
+            }
+        }
+        // Original heuristic for NUMBER type
+        if ((format === null || format === void 0 ? void 0 : format.type) === "NUMBER" && maxDecimals > 0) {
+            var basePattern = (_a = format.pattern) !== null && _a !== void 0 ? _a : "0";
+            return __assign(__assign({}, format), { pattern: changeDecimals(basePattern, Math.min(maxDecimals, 3), false) });
+        }
+        return format;
+    };
+    // Useful for Percentages
+    // 20% x 50 => number
+    if (numFormat) {
+        // Does not support structured references as of now
+        var astDerivedNumberFormat = getNumberFormatFromFormulaAst(formula, numFormat, draft, tokenizer, sheetId, getSheetId, cellXfsRegistry, getDataValidationById, locale);
+        if (astDerivedNumberFormat) {
+            return applyDecimalHeuristic(astDerivedNumberFormat);
+        }
+    }
+    // If we could not derive from function
+    if (expectedOutputType === undefined) {
+        return applyDecimalHeuristic(numFormat);
+    }
+    // Number variations
+    if (expectedOutputType === "NUMBER" &&
+        ((numFormat === null || numFormat === void 0 ? void 0 : numFormat.type) === "CURRENCY" ||
+            (numFormat === null || numFormat === void 0 ? void 0 : numFormat.type) === "PERCENT" ||
+            (numFormat === null || numFormat === void 0 ? void 0 : numFormat.type) === "SCIENTIFIC")) {
+        return numFormat;
+    }
+    // Date variations
+    if (expectedOutputType === "DATE" && (numFormat === null || numFormat === void 0 ? void 0 : numFormat.type) === "DATE_TIME") {
+        return numFormat;
+    }
+    if (expectedOutputType !== (numFormat === null || numFormat === void 0 ? void 0 : numFormat.type)) {
+        var resolvedType = expectedOutputType in customNumberFormatMap
+            ? customNumberFormatMap[expectedOutputType]
+            : expectedOutputType;
+        var resolvedNumberFormat = {
+            type: resolvedType,
+        };
+        // Date/time types need a concrete pattern — without one the renderer
+        // falls back to "General" and shows the serial number (the
+        // =TODAY() bug). When the precedent itself is a date-family format
+        // with a pattern, inherit that pattern (e.g. `=EDATE(A1, 1)` keeps
+        // A1's custom `yyyy-mm-dd` instead of falling back to the locale
+        // default). Otherwise mirror the format toolbar's default for the
+        // type.
+        if (isDateFamilyType(resolvedNumberFormat.type) &&
+            isDateFamilyType(numFormat === null || numFormat === void 0 ? void 0 : numFormat.type) &&
+            (numFormat === null || numFormat === void 0 ? void 0 : numFormat.pattern)) {
+            resolvedNumberFormat.pattern = numFormat.pattern;
+        }
+        else if (resolvedNumberFormat.type === "DATE_TIME") {
+            resolvedNumberFormat.pattern = getDefaultDateTimeFormat(locale);
+        }
+        else if (resolvedNumberFormat.type === "DATE") {
+            resolvedNumberFormat.pattern = getDefaultDateFormat(locale);
+        }
+        else if (resolvedNumberFormat.type === "TIME") {
+            resolvedNumberFormat.pattern = getDefaultTimeFormat(locale);
+        }
+        // Preserve pattern from precedent cells for CURRENCY type
+        // This ensures currency symbols (€, $, etc.) are preserved
+        if (resolvedNumberFormat.type === "CURRENCY" &&
+            (numFormat === null || numFormat === void 0 ? void 0 : numFormat.type) === "CURRENCY" &&
+            numFormat.pattern) {
+            resolvedNumberFormat.pattern = numFormat.pattern;
+        }
+        return applyDecimalHeuristic(resolvedNumberFormat);
+    }
+    return applyDecimalHeuristic(numFormat);
+};
+/**
+ * Like `deriveEffectiveNumberFormatFromPrecedents` but synthesizes the
+ * `precedents` array from the formula's direct cell/range references —
+ * used by the XLSX/ODS/CSV exporters which don't have a calc graph.
+ *
+ * Internally calls `deriveEffectiveNumberFormatFromPrecedents`, so all the
+ * function-specific rules (FILTER source range, ROUND decimals, IFERROR,
+ * function return types, etc.) are honored — render and export produce
+ * the same format for the same formula.
+ */
+export var deriveEffectiveNumberFormatFromFormula = function (formula, sheetId, rowIndex, columnIndex, draft, tokenizer, getSheetId, locale, cellXfsRegistry, getDataValidationById, calculatedValue) {
+    var e_3, _a;
+    if (!formula || !formula.trim().startsWith("="))
+        return undefined;
+    var bounds = getDirectReferenceBounds(formula, tokenizer, sheetId, getSheetId);
+    // Synthesize precedents — one CellNode per cell in each bound. The
+    // existing implementation re-filters precedents by the same bounds, so
+    // this produces identical input.
+    var precedents = [];
+    try {
+        for (var bounds_2 = __values(bounds), bounds_2_1 = bounds_2.next(); !bounds_2_1.done; bounds_2_1 = bounds_2.next()) {
+            var bound = bounds_2_1.value;
+            for (var r = bound.minRow; r <= bound.maxRow; r++) {
+                for (var c = bound.minCol; c <= bound.maxCol; c++) {
+                    precedents.push({
+                        position: {
+                            sheetId: bound.sheetId,
+                            rowIndex: r,
+                            columnIndex: c,
+                        },
+                    });
+                }
+            }
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (bounds_2_1 && !bounds_2_1.done && (_a = bounds_2.return)) _a.call(bounds_2);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    return deriveEffectiveNumberFormatFromPrecedents(formula, precedents, draft, tokenizer, sheetId, rowIndex, columnIndex, locale, getSheetId, cellXfsRegistry, getDataValidationById, calculatedValue);
+};
+var resolveResultsType = function (type) {
+    if (!type)
+        return undefined;
+    if (type in customNumberFormatMap) {
+        return customNumberFormatMap[type];
+    }
+    return type;
+};
+var parseNumberFormatAst = function (formula, tokenizer, sheetId, getSheetId) {
+    if (!formula.startsWith("=")) {
+        return undefined;
+    }
+    var tokens = tokenizer(formula.slice(1));
+    var index = 0;
+    var emptyStopTokens = new Set();
+    var peek = function () { return tokens[index]; };
+    var next = function () { return tokens[index++]; };
+    var shouldStop = function (stopTokens) {
+        return !!peek() && stopTokens.has(peek().tokenType.name);
+    };
+    var parseCellOrRange = function (cellToken, explicitSheetId) {
+        var _a, _b;
+        var startCell = addressToCell(cellToken.image);
+        if (!startCell)
+            return undefined;
+        var resolvedSheetId = cellToken.sheetName
+            ? getSheetId(cellToken.sheetName)
+            : explicitSheetId !== null && explicitSheetId !== void 0 ? explicitSheetId : sheetId;
+        if (((_a = peek()) === null || _a === void 0 ? void 0 : _a.tokenType.name) === tokenVocabulary.Colon.name &&
+            ((_b = tokens[index + 1]) === null || _b === void 0 ? void 0 : _b.tokenType.name) === tokenVocabulary.Cell.name) {
+            next();
+            var endCellToken = next();
+            var endCell = addressToCell(endCellToken.image);
+            if (!endCell) {
+                return {
+                    kind: "cell_reference",
+                    sheetId: resolvedSheetId,
+                    rowIndex: startCell.rowIndex,
+                    columnIndex: startCell.columnIndex,
+                };
+            }
+            return {
+                kind: "range_reference",
+                sheetId: resolvedSheetId,
+                startRowIndex: startCell.rowIndex,
+                startColumnIndex: startCell.columnIndex,
+                endRowIndex: endCell.rowIndex,
+                endColumnIndex: endCell.columnIndex,
+            };
+        }
+        return {
+            kind: "cell_reference",
+            sheetId: resolvedSheetId,
+            rowIndex: startCell.rowIndex,
+            columnIndex: startCell.columnIndex,
+        };
+    };
+    var parseExpression = function (stopTokens) { return parseComparison(stopTokens); };
+    var parseComparison = function (stopTokens) {
+        var _a;
+        var left = parseConcat(stopTokens);
+        while (left && !shouldStop(stopTokens)) {
+            var name_1 = (_a = peek()) === null || _a === void 0 ? void 0 : _a.tokenType.name;
+            if (name_1 === tokenVocabulary.EqOp.name ||
+                name_1 === tokenVocabulary.NeqOp.name ||
+                name_1 === tokenVocabulary.GtOp.name ||
+                name_1 === tokenVocabulary.GteOp.name ||
+                name_1 === tokenVocabulary.LtOp.name ||
+                name_1 === tokenVocabulary.LteOp.name) {
+                next();
+                var right = parseConcat(stopTokens);
+                if (!right)
+                    break;
+                left = { kind: "binary", op: "COMPARE", left: left, right: right };
+                continue;
+            }
+            break;
+        }
+        return left;
+    };
+    var parseConcat = function (stopTokens) {
+        var _a;
+        var left = parseAddSub(stopTokens);
+        while (left && !shouldStop(stopTokens)) {
+            if (((_a = peek()) === null || _a === void 0 ? void 0 : _a.tokenType.name) === tokenVocabulary.ConcatOp.name) {
+                next();
+                var right = parseAddSub(stopTokens);
+                if (!right)
+                    break;
+                left = { kind: "binary", op: "CONCAT", left: left, right: right };
+                continue;
+            }
+            break;
+        }
+        return left;
+    };
+    var parseAddSub = function (stopTokens) {
+        var _a;
+        var left = parseMulDiv(stopTokens);
+        while (left && !shouldStop(stopTokens)) {
+            var name_2 = (_a = peek()) === null || _a === void 0 ? void 0 : _a.tokenType.name;
+            if (name_2 === tokenVocabulary.PlusOp.name ||
+                name_2 === tokenVocabulary.MinOp.name) {
+                next();
+                var right = parseMulDiv(stopTokens);
+                if (!right)
+                    break;
+                left = {
+                    kind: "binary",
+                    op: name_2 === tokenVocabulary.PlusOp.name ? "ADD" : "SUB",
+                    left: left,
+                    right: right,
+                };
+                continue;
+            }
+            break;
+        }
+        return left;
+    };
+    var parseMulDiv = function (stopTokens) {
+        var _a;
+        var left = parsePower(stopTokens);
+        while (left && !shouldStop(stopTokens)) {
+            var name_3 = (_a = peek()) === null || _a === void 0 ? void 0 : _a.tokenType.name;
+            if (name_3 === tokenVocabulary.MulOp.name ||
+                name_3 === tokenVocabulary.DivOp.name) {
+                next();
+                var right = parsePower(stopTokens);
+                if (!right)
+                    break;
+                left = {
+                    kind: "binary",
+                    op: name_3 === tokenVocabulary.MulOp.name ? "MUL" : "DIV",
+                    left: left,
+                    right: right,
+                };
+                continue;
+            }
+            break;
+        }
+        return left;
+    };
+    var parsePower = function (stopTokens) {
+        var _a;
+        var left = parseUnary(stopTokens);
+        while (left && !shouldStop(stopTokens)) {
+            if (((_a = peek()) === null || _a === void 0 ? void 0 : _a.tokenType.name) === tokenVocabulary.ExOp.name) {
+                next();
+                var right = parseUnary(stopTokens);
+                if (!right)
+                    break;
+                left = { kind: "binary", op: "EXP", left: left, right: right };
+                continue;
+            }
+            break;
+        }
+        return left;
+    };
+    var parseUnary = function (stopTokens) {
+        var _a;
+        var name = (_a = peek()) === null || _a === void 0 ? void 0 : _a.tokenType.name;
+        if (name === tokenVocabulary.PlusOp.name ||
+            name === tokenVocabulary.MinOp.name) {
+            next();
+            var operand = parseUnary(stopTokens);
+            if (!operand)
+                return undefined;
+            return {
+                kind: "unary",
+                op: name === tokenVocabulary.PlusOp.name ? "PLUS" : "MINUS",
+                operand: operand,
+            };
+        }
+        return parsePostfix(stopTokens);
+    };
+    var parsePostfix = function (stopTokens) {
+        var _a;
+        var left = parsePrimary(stopTokens);
+        while (left && !shouldStop(stopTokens)) {
+            if (((_a = peek()) === null || _a === void 0 ? void 0 : _a.tokenType.name) === tokenVocabulary.PercentOp.name) {
+                next();
+                left = { kind: "postfix_percent", operand: left };
+                continue;
+            }
+            break;
+        }
+        return left;
+    };
+    var parseFunction = function () {
+        var _a, _b;
+        var token = next();
+        var functionName = token.image.slice(0, -1).toUpperCase();
+        var argStopTokens = new Set([
+            tokenVocabulary.Comma.name,
+            tokenVocabulary.CloseParen.name,
+        ]);
+        var args = [];
+        while (index < tokens.length) {
+            if (((_a = peek()) === null || _a === void 0 ? void 0 : _a.tokenType.name) === tokenVocabulary.CloseParen.name) {
+                next();
+                break;
+            }
+            var parsedArg = parseExpression(argStopTokens);
+            args.push(parsedArg !== null && parsedArg !== void 0 ? parsedArg : { kind: "unknown" });
+            var nextName = (_b = peek()) === null || _b === void 0 ? void 0 : _b.tokenType.name;
+            if (nextName === tokenVocabulary.Comma.name) {
+                next();
+                continue;
+            }
+            if (nextName === tokenVocabulary.CloseParen.name) {
+                next();
+                break;
+            }
+            if (nextName === undefined) {
+                break;
+            }
+            next();
+        }
+        return {
+            kind: "function_call",
+            name: functionName,
+            args: args,
+        };
+    };
+    var parsePrimary = function (stopTokens) {
+        var _a;
+        if (shouldStop(stopTokens)) {
+            return undefined;
+        }
+        var token = peek();
+        if (!token)
+            return undefined;
+        var name = token.tokenType.name;
+        if (name === tokenVocabulary.Number.name) {
+            next();
+            return { kind: "number_literal" };
+        }
+        if (name === tokenVocabulary.String.name) {
+            next();
+            return { kind: "string_literal" };
+        }
+        if (name === tokenVocabulary.Boolean.name) {
+            next();
+            return { kind: "boolean_literal" };
+        }
+        if (name === tokenVocabulary.Cell.name) {
+            var cellToken = next();
+            return parseCellOrRange(cellToken);
+        }
+        if (name === tokenVocabulary.Sheet.name ||
+            name === tokenVocabulary.SheetQuoted.name) {
+            var sheetToken = next();
+            var parsedSheetName = getSheetNameFromToken(sheetToken);
+            var explicitSheetId = parsedSheetName
+                ? getSheetId(parsedSheetName)
+                : sheetId;
+            var cellToken = peek();
+            if ((cellToken === null || cellToken === void 0 ? void 0 : cellToken.tokenType.name) !== tokenVocabulary.Cell.name) {
+                return { kind: "unknown" };
+            }
+            next();
+            return parseCellOrRange(cellToken, explicitSheetId);
+        }
+        if (name === tokenVocabulary.Function.name) {
+            return parseFunction();
+        }
+        if (name === tokenVocabulary.OpenParen.name) {
+            next();
+            var node = parseExpression(new Set([tokenVocabulary.CloseParen.name]));
+            if (((_a = peek()) === null || _a === void 0 ? void 0 : _a.tokenType.name) === tokenVocabulary.CloseParen.name) {
+                next();
+            }
+            return node;
+        }
+        next();
+        return { kind: "unknown" };
+    };
+    return parseExpression(emptyStopTokens);
+};
+var deriveNumberFormatTypeFromAst = function (ast, derivedNumberFormat, draft, getDataValidationById, cellXfsRegistry) {
+    var getCellFormatType = function (targetSheetId, rowIndex, columnIndex) {
+        var _a, _b, _c, _d;
+        sheetCell.assign(targetSheetId, { rowIndex: rowIndex, columnIndex: columnIndex }, (_c = (_b = (_a = draft === null || draft === void 0 ? void 0 : draft[targetSheetId]) === null || _a === void 0 ? void 0 : _a[rowIndex]) === null || _b === void 0 ? void 0 : _b.values) === null || _c === void 0 ? void 0 : _c[columnIndex], { cellXfsRegistry: cellXfsRegistry, getDataValidationById: getDataValidationById });
+        return (_d = sheetCell.getNumberFormat()) === null || _d === void 0 ? void 0 : _d.type;
+    };
+    var isDateLike = function (type) {
+        return type === "DATE" || type === "DATE_TIME" || type === "TIME";
+    };
+    var isCurrencyLike = function (type) {
+        return type === "CURRENCY" || type === "ACCOUNTING";
+    };
+    var isPercentLike = function (type) {
+        return type === "PERCENT";
+    };
+    var isNumericLike = function (type) {
+        return type === "NUMBER" ||
+            type === "GENERAL" ||
+            type === "SCIENTIFIC" ||
+            type === "FRACTION" ||
+            type === "SPECIAL" ||
+            isCurrencyLike(type) ||
+            isPercentLike(type);
+    };
+    var mergeValueTypes = function (types) {
+        var _a;
+        var filtered = types.filter(function (type) { return !!type; });
+        if (filtered.length === 0)
+            return undefined;
+        if (filtered.every(function (type) { return type === filtered[0]; })) {
+            return filtered[0];
+        }
+        if (filtered.some(isCurrencyLike)) {
+            return (_a = filtered.find(isCurrencyLike)) !== null && _a !== void 0 ? _a : filtered[0];
+        }
+        if (filtered.every(isPercentLike)) {
+            return "PERCENT";
+        }
+        if (filtered.some(isPercentLike)) {
+            return "NUMBER";
+        }
+        if (filtered.every(isDateLike)) {
+            return filtered[0];
+        }
+        return filtered[0];
+    };
+    var deriveAggregateType = function (functionName, argTypes) {
+        var _a, _b, _c, _d;
+        var filtered = argTypes.filter(function (type) { return !!type; });
+        if (filtered.length === 0)
+            return undefined;
+        var hasCurrency = filtered.some(isCurrencyLike);
+        var allPercent = filtered.every(isPercentLike);
+        var hasPercent = filtered.some(isPercentLike);
+        var allDate = filtered.every(isDateLike);
+        if (functionName === "MIN" || functionName === "MAX") {
+            if (allDate)
+                return filtered[0];
+            if (hasCurrency)
+                return (_a = filtered.find(isCurrencyLike)) !== null && _a !== void 0 ? _a : "NUMBER";
+            if (allPercent)
+                return "PERCENT";
+            if (hasPercent)
+                return "NUMBER";
+            return (_b = filtered[0]) !== null && _b !== void 0 ? _b : "NUMBER";
+        }
+        if (functionName === "SUM" || functionName === "AVERAGE") {
+            if (hasCurrency)
+                return (_c = filtered.find(isCurrencyLike)) !== null && _c !== void 0 ? _c : "NUMBER";
+            if (allPercent)
+                return "PERCENT";
+            if (hasPercent)
+                return "NUMBER";
+            if (allDate)
+                return "NUMBER";
+            return (_d = filtered[0]) !== null && _d !== void 0 ? _d : "NUMBER";
+        }
+        return filtered[0];
+    };
+    var preferNumericType = function (left, right) {
+        if (isCurrencyLike(left))
+            return left;
+        if (isCurrencyLike(right))
+            return right;
+        if (isPercentLike(left) && isPercentLike(right))
+            return "PERCENT";
+        if (isPercentLike(left))
+            return right !== null && right !== void 0 ? right : "NUMBER";
+        if (isPercentLike(right))
+            return left !== null && left !== void 0 ? left : "NUMBER";
+        return left !== null && left !== void 0 ? left : right;
+    };
+    var combineTypes = function (op, left, right) {
+        if (op === "CONCAT")
+            return "TEXT";
+        if (op === "COMPARE")
+            return "GENERAL";
+        if (op === "ADD" || op === "SUB") {
+            if (isDateLike(left) && isDateLike(right))
+                return "NUMBER";
+            if (isDateLike(left) && isNumericLike(right))
+                return left;
+            if (isDateLike(right) && isNumericLike(left))
+                return right;
+            return preferNumericType(left, right);
+        }
+        if (op === "MUL") {
+            if (isPercentLike(left) && isPercentLike(right))
+                return "NUMBER";
+            if (isPercentLike(left) && isNumericLike(right))
+                return right;
+            if (isPercentLike(right) && isNumericLike(left))
+                return left;
+            if (isDateLike(left) || isDateLike(right))
+                return "NUMBER";
+            if (isCurrencyLike(left) && isCurrencyLike(right))
+                return "NUMBER";
+            if (isCurrencyLike(left) && isNumericLike(right))
+                return left;
+            if (isCurrencyLike(right) && isNumericLike(left))
+                return right;
+            return preferNumericType(left, right);
+        }
+        if (op === "DIV") {
+            if (isDateLike(left) || isDateLike(right))
+                return "NUMBER";
+            if (isCurrencyLike(left) && isCurrencyLike(right))
+                return "NUMBER";
+            if (isCurrencyLike(left) && isNumericLike(right))
+                return left;
+            if (isCurrencyLike(right) && isNumericLike(left))
+                return "NUMBER";
+            if (isPercentLike(left) && isPercentLike(right))
+                return "NUMBER";
+            if (isPercentLike(left) && isNumericLike(right))
+                return right;
+            if (isPercentLike(right) && isNumericLike(left))
+                return left;
+            return preferNumericType(left, right);
+        }
+        if (op === "EXP")
+            return "NUMBER";
+        return left !== null && left !== void 0 ? left : right;
+    };
+    var inferNodeType = function (node) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        if (!node)
+            return undefined;
+        switch (node.kind) {
+            case "number_literal":
+                return "NUMBER";
+            case "string_literal":
+                return "TEXT";
+            case "boolean_literal":
+                return "NUMBER";
+            case "cell_reference":
+                return ((_a = getCellFormatType(node.sheetId, node.rowIndex, node.columnIndex)) !== null && _a !== void 0 ? _a : derivedNumberFormat.type);
+            case "range_reference":
+                return ((_b = getCellFormatType(node.sheetId, node.startRowIndex, node.startColumnIndex)) !== null && _b !== void 0 ? _b : derivedNumberFormat.type);
+            case "unary":
+                return inferNodeType(node.operand);
+            case "postfix_percent":
+                return "PERCENT";
+            case "binary":
+                return combineTypes(node.op, inferNodeType(node.left), inferNodeType(node.right));
+            case "function_call": {
+                var args = node.args.map(function (arg) { return inferNodeType(arg); });
+                var functionName = node.name;
+                if (functionName === "IF") {
+                    var trueType = args[1];
+                    var falseType = args[2];
+                    return ((_c = mergeValueTypes([trueType, falseType])) !== null && _c !== void 0 ? _c : derivedNumberFormat.type);
+                }
+                if (functionName === "IFS") {
+                    var valueTypes = [];
+                    for (var i = 1; i < args.length; i += 2) {
+                        valueTypes.push(args[i]);
+                    }
+                    return (_d = mergeValueTypes(valueTypes)) !== null && _d !== void 0 ? _d : derivedNumberFormat.type;
+                }
+                if (functionName === "IFERROR" || functionName === "IFNA") {
+                    return ((_e = mergeValueTypes([args[0], args[1]])) !== null && _e !== void 0 ? _e : derivedNumberFormat.type);
+                }
+                if (functionName === "CHOOSE") {
+                    // CHOOSE(index, choice1, choice2, …) — result is one of the
+                    // choices, so merge their types like IF/IFS.
+                    return ((_f = mergeValueTypes(args.slice(1))) !== null && _f !== void 0 ? _f : derivedNumberFormat.type);
+                }
+                if (functionName === "SWITCH") {
+                    // SWITCH(expression, val1, result1, [val2, result2, …], [default]).
+                    // Results sit at indices 2, 4, … and an even total arg count
+                    // means there's a trailing default at the last position.
+                    var valueTypes = [];
+                    for (var i = 2; i < args.length; i += 2) {
+                        valueTypes.push(args[i]);
+                    }
+                    if (args.length % 2 === 0) {
+                        valueTypes.push(args[args.length - 1]);
+                    }
+                    return (_g = mergeValueTypes(valueTypes)) !== null && _g !== void 0 ? _g : derivedNumberFormat.type;
+                }
+                if (functionName === "ROUND" ||
+                    functionName === "ROUNDUP" ||
+                    functionName === "ROUNDDOWN" ||
+                    functionName === "ABS" ||
+                    functionName === "INT") {
+                    return (_h = args[0]) !== null && _h !== void 0 ? _h : derivedNumberFormat.type;
+                }
+                if (functionName === "MOD" || functionName === "POWER") {
+                    return "NUMBER";
+                }
+                if (functionName === "SUMPRODUCT") {
+                    var filtered = args.filter(function (type) { return !!type; });
+                    if (filtered.some(isCurrencyLike)) {
+                        return (_j = filtered.find(isCurrencyLike)) !== null && _j !== void 0 ? _j : "NUMBER";
+                    }
+                    return "NUMBER";
+                }
+                if (functionName === "SUM" ||
+                    functionName === "AVERAGE" ||
+                    functionName === "MIN" ||
+                    functionName === "MAX") {
+                    return ((_k = deriveAggregateType(functionName, args)) !== null && _k !== void 0 ? _k : derivedNumberFormat.type);
+                }
+                var rule = formatDerivationRules[functionName];
+                if (rule) {
+                    var targetIndex = void 0;
+                    if (rule.type === "fixed_index") {
+                        targetIndex = rule.index;
+                    }
+                    else if (rule.type === "conditional_index") {
+                        targetIndex = rule.getIndex(args.length);
+                    }
+                    if (targetIndex !== undefined && args[targetIndex]) {
+                        return args[targetIndex];
+                    }
+                }
+                var defaultType = functionReturnTypes[functionName];
+                if (defaultType === "NUMBER") {
+                    if (derivedNumberFormat.type === "PERCENT" ||
+                        derivedNumberFormat.type === "CURRENCY" ||
+                        derivedNumberFormat.type === "ACCOUNTING" ||
+                        derivedNumberFormat.type === "SCIENTIFIC") {
+                        return derivedNumberFormat.type;
+                    }
+                }
+                return (_l = resolveResultsType(defaultType)) !== null && _l !== void 0 ? _l : derivedNumberFormat.type;
+            }
+            case "unknown":
+                return undefined;
+        }
+    };
+    return inferNodeType(ast);
+};
+/**
+ * Two phase inference:
+ * 1) parse formula tokens into AST
+ * 2) derive number format type from the AST semantics
+ */
+export var getNumberFormatTypeFromFormula = function (formula, derivedNumberFormat, draft, tokenizer, sheetId, getSheetId, cellXfsRegistry, getDataValidationById) {
+    var ast = parseNumberFormatAst(formula, tokenizer, sheetId, getSheetId);
+    if (!ast) {
+        return undefined;
+    }
+    return deriveNumberFormatTypeFromAst(ast, derivedNumberFormat, draft, getDataValidationById, cellXfsRegistry);
+};
+/**
+ * AST-based format derivation from formula semantics.
+ * Uses the parser-backed type analysis and preserves source pattern when
+ * the resolved type is unchanged.
+ */
+export var getNumberFormatFromFormulaAst = function (formula, derivedNumberFormat, draft, tokenizer, sheetId, getSheetId, cellXfsRegistry, getDataValidationById, locale) {
+    var resolvedType = getNumberFormatTypeFromFormula(formula, derivedNumberFormat, draft, tokenizer, sheetId, getSheetId, cellXfsRegistry, getDataValidationById);
+    if (!resolvedType) {
+        return undefined;
+    }
+    // Keep the exact source pattern for passthrough/same-type formulas
+    // (or when the source is a date-family pattern and the resolved type
+    // is also date-family — keeps `yyyy-mm-dd` etc. through date math).
+    if (resolvedType === derivedNumberFormat.type) {
+        return __assign({ type: resolvedType }, (derivedNumberFormat.pattern
+            ? { pattern: derivedNumberFormat.pattern }
+            : {}));
+    }
+    if (isDateFamilyType(resolvedType) &&
+        isDateFamilyType(derivedNumberFormat.type) &&
+        derivedNumberFormat.pattern) {
+        return { type: resolvedType, pattern: derivedNumberFormat.pattern };
+    }
+    // Date-family resolved types without an inheritable pattern need a
+    // concrete default — otherwise the renderer falls back to "General"
+    // and surfaces the serial number (`=NOW()` showed `45000.5` instead
+    // of a date-time string when the calculated-decimals heuristic above
+    // set `numFormat = { type: "NUMBER" }` and the AST then resolved to
+    // DATE_TIME, dropping the pattern).
+    if (resolvedType === "DATE_TIME") {
+        return { type: resolvedType, pattern: getDefaultDateTimeFormat(locale) };
+    }
+    if (resolvedType === "DATE") {
+        return { type: resolvedType, pattern: getDefaultDateFormat(locale) };
+    }
+    if (resolvedType === "TIME") {
+        return { type: resolvedType, pattern: getDefaultTimeFormat(locale) };
+    }
+    return { type: resolvedType };
+};
+// Seems hacky ony for percentage
+export var isPercentageType = function (token, sheetId, draft, cellXfsRegistry, getDataValidationById) {
+    var _a, _b, _c;
+    var cell = token ? addressToCell(token.image) : undefined;
+    if (cell) {
+        var sheetCell_1 = new SheetCell(sheetId, cell, (_c = (_b = (_a = draft === null || draft === void 0 ? void 0 : draft[sheetId]) === null || _a === void 0 ? void 0 : _a[cell.rowIndex]) === null || _b === void 0 ? void 0 : _b.values) === null || _c === void 0 ? void 0 : _c[cell.columnIndex], { cellXfsRegistry: cellXfsRegistry, getDataValidationById: getDataValidationById });
+        var curNumFormat = sheetCell_1.getNumberFormat();
+        return (curNumFormat === null || curNumFormat === void 0 ? void 0 : curNumFormat.type) === "PERCENT";
+    }
+    return false;
+};
+// Seems hacky ony for percentage
+export var isDateType = function (token, sheetId, draft, cellXfsRegistry, getDataValidationById) {
+    var _a, _b, _c;
+    var cell = token ? addressToCell(token.image) : undefined;
+    if (cell) {
+        var sheetCell_2 = new SheetCell(sheetId, cell, (_c = (_b = (_a = draft === null || draft === void 0 ? void 0 : draft[sheetId]) === null || _a === void 0 ? void 0 : _a[cell.rowIndex]) === null || _b === void 0 ? void 0 : _b.values) === null || _c === void 0 ? void 0 : _c[cell.columnIndex], { cellXfsRegistry: cellXfsRegistry, getDataValidationById: getDataValidationById });
+        var curNumFormat = sheetCell_2.getNumberFormat();
+        return (curNumFormat === null || curNumFormat === void 0 ? void 0 : curNumFormat.type) === "DATE" || (curNumFormat === null || curNumFormat === void 0 ? void 0 : curNumFormat.type) === "DATE_TIME";
+    }
+    return false;
+};
+var numericLiteralRegex = /^[-+]?(?:\d+(\.\d*)?|\.\d+)$/;
+var shouldSkipPrecedentFormatInheritance = function (formula) {
+    if (!formula) {
+        return false;
+    }
+    var trimmed = formula.trim();
+    var upper = trimmed.toUpperCase();
+    if (upper.startsWith("=IF(")) {
+        var args = extractTopLevelArgs(trimmed, "=IF");
+        if (args.length < 3) {
+            return false;
+        }
+        var _a = __read(args, 3), trueArg = _a[1], falseArg = _a[2];
+        return (numericLiteralRegex.test(trueArg.trim()) &&
+            numericLiteralRegex.test(falseArg.trim()));
+    }
+    if (upper.startsWith("=CHOOSE(")) {
+        var args = extractTopLevelArgs(trimmed, "=CHOOSE");
+        if (args.length < 2) {
+            return false;
+        }
+        var options = args.slice(1);
+        return options.every(function (option) { return numericLiteralRegex.test(option.trim()); });
+    }
+    return false;
+};
+var extractTopLevelArgs = function (formula, prefix) {
+    var upper = formula.toUpperCase();
+    var startIndex = upper.indexOf(prefix);
+    if (startIndex === -1) {
+        return [];
+    }
+    var parenIndex = startIndex + prefix.length;
+    if (formula[parenIndex] !== "(") {
+        return [];
+    }
+    parenIndex += 1;
+    var args = [];
+    var depth = 0;
+    var current = "";
+    var inString = false;
+    for (var i = parenIndex; i < formula.length; i++) {
+        var char = formula[i];
+        if (char === '"' && formula[i - 1] !== "\\") {
+            inString = !inString;
+        }
+        if (!inString) {
+            if (char === "(") {
+                depth++;
+            }
+            else if (char === ")") {
+                if (depth === 0) {
+                    args.push(current);
+                    break;
+                }
+                depth--;
+            }
+            else if (char === "," && depth === 0) {
+                args.push(current);
+                current = "";
+                continue;
+            }
+        }
+        current += char;
+    }
+    return args.map(function (arg) { return arg.trim(); });
+};
+/**
+ * Peek an iterable
+ * @param iterator
+ * @returns
+ */
+export var peekIterable = function (iterator) {
+    var items = Array.from(iterator); // Consume entire iterator
+    var peeked = items.length > 0
+        ? { done: false, value: items[0] }
+        : { done: true, value: undefined };
+    var rebuiltIterator = function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [5 /*yield**/, __values(items)];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    };
+    return { peeked: peeked, rebuiltIterator: rebuiltIterator };
+};
+export var deriveCellFromPrecedents = function (formula, precedents, draft, sheetId, locale, cellXfsRegistry) {
+    var e_4, _a;
+    var _b, _c, _d, _e;
+    if (formula === void 0) { formula = ""; }
+    var trimmedFormula = (_b = formula === null || formula === void 0 ? void 0 : formula.trim()) !== null && _b !== void 0 ? _b : "";
+    var directRefRegex = /^=\s*('?[^'!]+?'!)?\$?[A-Z]+\$?\d+$/i;
+    if (!directRefRegex.test(trimmedFormula)) {
+        return undefined;
+    }
+    var sheetCell = new SheetCell(sheetId, defaultCellCoords);
+    try {
+        for (var precedents_1 = __values(precedents), precedents_1_1 = precedents_1.next(); !precedents_1_1.done; precedents_1_1 = precedents_1.next()) {
+            var precedent = precedents_1_1.value;
+            // Ignore static node
+            if (isStaticNode(precedent)) {
+                continue;
+            }
+            var rowIndex = void 0;
+            var columnIndex = void 0;
+            var sheetId_1 = precedent.position.sheetId;
+            // Get the first cell from a range
+            if (isCellCoordinate(precedent.position)) {
+                rowIndex = precedent.position.rowIndex;
+                columnIndex = precedent.position.columnIndex;
+            }
+            else {
+                rowIndex = precedent.position.startRowIndex;
+                columnIndex = precedent.position.startColumnIndex;
+            }
+            sheetCell.assign(sheetId_1, {
+                rowIndex: rowIndex,
+                columnIndex: columnIndex,
+            }, (_e = (_d = (_c = draft === null || draft === void 0 ? void 0 : draft[sheetId_1]) === null || _c === void 0 ? void 0 : _c[rowIndex]) === null || _d === void 0 ? void 0 : _d.values) === null || _e === void 0 ? void 0 : _e[columnIndex], {
+                locale: locale,
+                cellXfsRegistry: cellXfsRegistry,
+            });
+            return sheetCell.getCellData();
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (precedents_1_1 && !precedents_1_1.done && (_a = precedents_1.return)) _a.call(precedents_1);
+        }
+        finally { if (e_4) throw e_4.error; }
+    }
+};
+/**
+ * Parse a literal integer from a VLOOKUP/HLOOKUP col/row-index argument.
+ * Returns undefined for non-literal expressions so the caller can fall
+ * back to a coarser filter.
+ */
+var parseLiteralInt = function (raw) {
+    if (!raw)
+        return undefined;
+    var trimmed = raw.trim();
+    if (!/^-?\d+$/.test(trimmed))
+        return undefined;
+    var n = Number(trimmed);
+    return Number.isFinite(n) ? n : undefined;
+};
+/**
+ * Filter precedents to a single anchor cell inside a table range, used by
+ * VLOOKUP (`column`) and HLOOKUP (`row`). The anchor is the cell at the
+ * table's start row + selected column (vlookup), or start column +
+ * selected row (hlookup) — matching Excel's first-cell format inheritance
+ * for the looked-up column/row. `offset` is 1-based.
+ */
+var filterPrecedentsByTableOffset = function (precedents, tableAddress, offset, axis, currentSheetId, getSheetId) {
+    var targetSheetId = currentSheetId;
+    var rangeStr = tableAddress;
+    if (tableAddress.includes("!")) {
+        var lastBang = tableAddress.lastIndexOf("!");
+        var sheetName = tableAddress
+            .substring(0, lastBang)
+            .replace(/^'|'$/g, "");
+        rangeStr = tableAddress.substring(lastBang + 1);
+        targetSheetId = getSheetId(sheetName);
+    }
+    var parts = rangeStr.split(":");
+    var start = parts.length === 2 ? addressToCell(parts[0]) : addressToCell(rangeStr);
+    var end = parts.length === 2 ? addressToCell(parts[1]) : start;
+    if (!start || !end)
+        return precedents;
+    var minRow = Math.min(start.rowIndex, end.rowIndex);
+    var maxRow = Math.max(start.rowIndex, end.rowIndex);
+    var minCol = Math.min(start.columnIndex, end.columnIndex);
+    var maxCol = Math.max(start.columnIndex, end.columnIndex);
+    // Anchor cell: table-start row × (start col + col_index - 1) for VLOOKUP,
+    // (start row + row_index - 1) × table-start col for HLOOKUP.
+    var anchorRow = axis === "row" ? minRow + (offset - 1) : minRow;
+    var anchorCol = axis === "column" ? minCol + (offset - 1) : minCol;
+    // Out-of-bounds offset → can't form an anchor; fall back to the whole
+    // table so derivation still has something to work with.
+    if (anchorRow < minRow || anchorRow > maxRow || anchorCol < minCol || anchorCol > maxCol) {
+        return filterPrecedentsByAddress(precedents, tableAddress, currentSheetId, getSheetId);
+    }
+    return precedents.filter(function (p) {
+        if (isStaticNode(p))
+            return true;
+        if (p.position.sheetId !== targetSheetId)
+            return false;
+        if (isCellCoordinate(p.position)) {
+            return (p.position.rowIndex === anchorRow &&
+                p.position.columnIndex === anchorCol);
+        }
+        var _a = p.position, startRowIndex = _a.startRowIndex, startColumnIndex = _a.startColumnIndex, endRowIndex = _a.endRowIndex, endColumnIndex = _a.endColumnIndex;
+        return (startRowIndex <= anchorRow &&
+            endRowIndex >= anchorRow &&
+            startColumnIndex <= anchorCol &&
+            endColumnIndex >= anchorCol);
+    });
+};
+var filterPrecedentsByAddress = function (precedents, address, currentSheetId, getSheetId) {
+    var targetSheetId = currentSheetId;
+    var rangeStr = address;
+    if (address.includes("!")) {
+        var lastBang = address.lastIndexOf("!");
+        var sheetName = address.substring(0, lastBang).replace(/^'|'$/g, "");
+        rangeStr = address.substring(lastBang + 1);
+        targetSheetId = getSheetId(sheetName);
+    }
+    var parts = rangeStr.split(":");
+    var start;
+    var end;
+    if (parts.length === 2) {
+        start = addressToCell(parts[0]);
+        end = addressToCell(parts[1]);
+    }
+    else {
+        start = addressToCell(rangeStr);
+        end = start;
+    }
+    if (!start || !end)
+        return precedents;
+    var bounds = {
+        minRow: Math.min(start.rowIndex, end.rowIndex),
+        maxRow: Math.max(start.rowIndex, end.rowIndex),
+        minCol: Math.min(start.columnIndex, end.columnIndex),
+        maxCol: Math.max(start.columnIndex, end.columnIndex),
+    };
+    var filtered = precedents.filter(function (p) {
+        if (isStaticNode(p))
+            return true;
+        if (p.position.sheetId !== targetSheetId)
+            return false;
+        if (isCellCoordinate(p.position)) {
+            var _a = p.position, rowIndex = _a.rowIndex, columnIndex = _a.columnIndex;
+            return (rowIndex >= bounds.minRow &&
+                rowIndex <= bounds.maxRow &&
+                columnIndex >= bounds.minCol &&
+                columnIndex <= bounds.maxCol);
+        }
+        else {
+            var _b = p.position, startRowIndex = _b.startRowIndex, startColumnIndex = _b.startColumnIndex, endRowIndex = _b.endRowIndex, endColumnIndex = _b.endColumnIndex;
+            return !(startRowIndex > bounds.maxRow ||
+                endRowIndex < bounds.minRow ||
+                startColumnIndex > bounds.maxCol ||
+                endColumnIndex < bounds.minCol);
+        }
+    });
+    return filtered.length > 0 ? filtered : precedents;
+};