@alaarab/ogrid-core 2.3.0 → 2.4.1

package/dist/esm/index.js

@@ -85,6 +85,17 @@ function getCellValue(item, col) {
 function isColumnEditable(col, item) {
   return col.editable === true || typeof col.editable === "function" && col.editable(item);
 }
+function createGridDataAccessor(items, flatColumns) {
+  return {
+    getCellValue: (col, row) => {
+      if (row < 0 || row >= items.length) return null;
+      if (col < 0 || col >= flatColumns.length) return null;
+      return getCellValue(items[row], flatColumns[col]);
+    },
+    getRowCount: () => items.length,
+    getColumnCount: () => flatColumns.length
+  };
+}
 
 // src/utils/columnUtils.ts
 function isColumnGroupDef(c) {
@@ -1144,7 +1155,7 @@ var _CellDescriptorCache = class _CellDescriptorCache {
     const sr = input.selectionRange;
     const cr = input.cutRange;
     const cp = input.copyRange;
-    return (ec ? `${String(ec.rowId)}\0${ec.columnId}` : "") + "
" + (ac ? `${ac.rowIndex}\0${ac.columnIndex}` : "") + "
" + (sr ? `${sr.startRow}\0${sr.startCol}\0${sr.endRow}\0${sr.endCol}` : "") + "
" + (cr ? `${cr.startRow}\0${cr.startCol}\0${cr.endRow}\0${cr.endCol}` : "") + "
" + (cp ? `${cp.startRow}\0${cp.startCol}\0${cp.endRow}\0${cp.endCol}` : "") + "
" + (input.isDragging ? "1" : "0") + "
" + (input.editable !== false ? "1" : "0") + "
" + (input.onCellValueChanged ? "1" : "0");
+    return (ec ? `${String(ec.rowId)}\0${ec.columnId}` : "") + "
" + (ac ? `${ac.rowIndex}\0${ac.columnIndex}` : "") + "
" + (sr ? `${sr.startRow}\0${sr.startCol}\0${sr.endRow}\0${sr.endCol}` : "") + "
" + (cr ? `${cr.startRow}\0${cr.startCol}\0${cr.endRow}\0${cr.endCol}` : "") + "
" + (cp ? `${cp.startRow}\0${cp.startCol}\0${cp.endRow}\0${cp.endCol}` : "") + "
" + (input.isDragging ? "1" : "0") + "
" + (input.editable !== false ? "1" : "0") + "
" + (input.onCellValueChanged ? "1" : "0") + "
" + (input.formulaVersion ?? 0);
   }
   /**
    * Get a cached descriptor or compute a new one.
@@ -1220,6 +1231,7 @@ function computeCellDescriptor(item, col, rowIndex, colIdx, input) {
   const isPinned = col.pinned != null;
   const pinnedSide = col.pinned ?? void 0;
   const cellValue = getCellValue(item, col);
+  const formulaDisplay = input.hasFormula?.(colIdx, rowIndex) ? input.getFormulaValue?.(colIdx, rowIndex) : void 0;
   let mode = "display";
   let editorType;
   if (isEditing && canEditInline) {
@@ -1251,7 +1263,8 @@ function computeCellDescriptor(item, col, rowIndex, colIdx, input) {
     globalColIndex,
     rowId,
     rowIndex,
-    displayValue: cellValue
+    displayValue: formulaDisplay !== void 0 ? formulaDisplay : cellValue,
+    columnType: col.type
   };
 }
 function resolveCellDisplayContent(col, item, displayValue) {
@@ -1266,7 +1279,7 @@ function resolveCellDisplayContent(col, item, displayValue) {
   if (displayValue == null) return null;
   if (col.type === "date") {
     const d = new Date(String(displayValue));
-    if (!Number.isNaN(d.getTime())) return d.toLocaleDateString();
+    if (!Number.isNaN(d.getTime())) return d.toLocaleDateString(void 0, { timeZone: "UTC" });
   }
   if (col.type === "boolean") {
     return displayValue ? "True" : "False";
@@ -1392,6 +1405,8 @@ var CHECKBOX_COLUMN_WIDTH = 48;
 var ROW_NUMBER_COLUMN_WIDTH = 50;
 var DEFAULT_MIN_COLUMN_WIDTH = 80;
 var CELL_PADDING = 16;
+var ROW_NUMBER_COLUMN_MIN_WIDTH = 30;
+var ROW_NUMBER_COLUMN_ID = "__row_number__";
 var GRID_BORDER_RADIUS = 6;
 
 // src/utils/columnAutosize.ts
@@ -2063,65 +2078,6 @@ function validateRowIds(items, getRowId) {
   }
 }
 
-// src/constants/timing.ts
-var DEFAULT_DEBOUNCE_MS = 300;
-var PEOPLE_SEARCH_DEBOUNCE_MS = DEFAULT_DEBOUNCE_MS;
-var SIDEBAR_TRANSITION_MS = 300;
-
-// src/constants/zIndex.ts
-var Z_INDEX = {
-  /** Column resize drag handle */
-  RESIZE_HANDLE: 1,
-  /** Active/editing cell outline */
-  ACTIVE_CELL: 2,
-  /** Fill handle dot */
-  FILL_HANDLE: 3,
-  /** Selection range overlay (marching ants) */
-  SELECTION_OVERLAY: 4,
-  /** Row number column */
-  ROW_NUMBER: 5,
-  /** Clipboard overlay (copy/cut animation) */
-  CLIPBOARD_OVERLAY: 5,
-  /** Sticky pinned body cells */
-  PINNED: 6,
-  /** Selection checkbox column in body */
-  SELECTION_CELL: 7,
-  /** Sticky thead row */
-  THEAD: 8,
-  /** Pinned header cells (sticky both axes) */
-  PINNED_HEADER: 10,
-  /** Focused header cell */
-  HEADER_FOCUS: 11,
-  /** Checkbox column in sticky header (sticky both axes) */
-  SELECTION_HEADER_PINNED: 12,
-  /** Loading overlay within table */
-  LOADING: 2,
-  /** Column reorder drop indicator */
-  DROP_INDICATOR: 100,
-  /** Dropdown menus (column chooser, pagination size select) */
-  DROPDOWN: 1e3,
-  /** Filter popovers */
-  FILTER_POPOVER: 1e3,
-  /** Modal dialogs */
-  MODAL: 2e3,
-  /** Fullscreen grid container */
-  FULLSCREEN: 9999,
-  /** Context menus (right-click grid menu) */
-  CONTEXT_MENU: 1e4
-};
-
-// src/formula/errors.ts
-var REF_ERROR = new FormulaError("#REF!", "Invalid cell reference");
-var DIV_ZERO_ERROR = new FormulaError("#DIV/0!", "Division by zero");
-var VALUE_ERROR = new FormulaError("#VALUE!", "Wrong value type");
-var NAME_ERROR = new FormulaError("#NAME?", "Unknown function or name");
-var CIRC_ERROR = new FormulaError("#CIRC!", "Circular reference");
-var GENERAL_ERROR = new FormulaError("#ERROR!", "Formula error");
-var NA_ERROR = new FormulaError("#N/A", "No match found");
-function isFormulaError(value) {
-  return value instanceof FormulaError;
-}
-
 // src/formula/tokenizer.ts
 var CELL_REF_PATTERN = /^\$?[A-Za-z]+\$?\d+$/;
 var SINGLE_CHAR_OPERATORS = {
@@ -2244,6 +2200,12 @@ function tokenize(input) {
       while (pos < input.length && (input[pos] >= "A" && input[pos] <= "Z" || input[pos] >= "a" && input[pos] <= "z" || input[pos] >= "0" && input[pos] <= "9" || input[pos] === "$" || input[pos] === "_")) {
         pos++;
       }
+      if (pos < input.length && input[pos] === "." && pos + 1 < input.length && (input[pos + 1] >= "A" && input[pos + 1] <= "Z" || input[pos + 1] >= "a" && input[pos + 1] <= "z")) {
+        pos++;
+        while (pos < input.length && (input[pos] >= "A" && input[pos] <= "Z" || input[pos] >= "a" && input[pos] <= "z" || input[pos] >= "0" && input[pos] <= "9" || input[pos] === "_")) {
+          pos++;
+        }
+      }
       const word = input.slice(start, pos);
       if (pos < input.length && input[pos] === "!") {
         pos++;
@@ -2272,6 +2234,200 @@ function tokenize(input) {
   return tokens;
 }
 
+// src/utils/formulaBarHelpers.ts
+var CELL_REF_RE2 = /^\$?([A-Za-z]+)\$?(\d+)$/;
+function parseCellRefCoords(ref) {
+  const m = ref.match(CELL_REF_RE2);
+  if (!m) return null;
+  return { col: columnLetterToIndex(m[1]), row: parseInt(m[2], 10) - 1 };
+}
+function handleFormulaBarKeyDown(key, preventDefault, onCommit, onCancel) {
+  if (key === "Enter") {
+    preventDefault();
+    onCommit();
+  } else if (key === "Escape") {
+    preventDefault();
+    onCancel();
+  }
+}
+function processFormulaBarCommit(text, col, row, setFormula, onCellValueChanged) {
+  const trimmed = text.trim();
+  if (trimmed.startsWith("=")) {
+    setFormula(col, row, trimmed);
+  } else {
+    setFormula(col, row, null);
+    onCellValueChanged?.(col, row, trimmed);
+  }
+}
+function deriveFormulaBarText(col, row, getFormula, getRawValue) {
+  if (col == null || row == null) return "";
+  const formula = getFormula?.(col, row);
+  if (formula) return formula;
+  const raw = getRawValue?.(col, row);
+  return raw != null ? String(raw) : "";
+}
+function extractFormulaReferences(formula) {
+  if (!formula || formula[0] !== "=") return [];
+  const refs = [];
+  let colorIdx = 0;
+  try {
+    const tokens = tokenize(formula.substring(1));
+    for (let i = 0; i < tokens.length; i++) {
+      const tok = tokens[i];
+      if (tok.type === "CELL_REF") {
+        if (i + 2 < tokens.length && tokens[i + 1].type === "COLON" && tokens[i + 2].type === "CELL_REF") {
+          const start = parseCellRefCoords(tok.value);
+          const end = parseCellRefCoords(tokens[i + 2].value);
+          if (start && end) {
+            refs.push({
+              type: "range",
+              col: start.col,
+              row: start.row,
+              endCol: end.col,
+              endRow: end.row,
+              colorIndex: colorIdx++ % 6
+            });
+            i += 2;
+            continue;
+          }
+        }
+        const coords = parseCellRefCoords(tok.value);
+        if (coords) {
+          refs.push({
+            type: "cell",
+            col: coords.col,
+            row: coords.row,
+            colorIndex: colorIdx++ % 6
+          });
+        }
+      }
+    }
+  } catch {
+  }
+  return refs;
+}
+
+// src/constants/timing.ts
+var DEFAULT_DEBOUNCE_MS = 300;
+var PEOPLE_SEARCH_DEBOUNCE_MS = DEFAULT_DEBOUNCE_MS;
+var SIDEBAR_TRANSITION_MS = 300;
+
+// src/constants/zIndex.ts
+var Z_INDEX = {
+  /** Column resize drag handle */
+  RESIZE_HANDLE: 1,
+  /** Active/editing cell outline */
+  ACTIVE_CELL: 2,
+  /** Fill handle dot */
+  FILL_HANDLE: 3,
+  /** Selection range overlay (marching ants) */
+  SELECTION_OVERLAY: 4,
+  /** Row number column */
+  ROW_NUMBER: 5,
+  /** Clipboard overlay (copy/cut animation) */
+  CLIPBOARD_OVERLAY: 5,
+  /** Sticky pinned body cells */
+  PINNED: 6,
+  /** Selection checkbox column in body */
+  SELECTION_CELL: 7,
+  /** Sticky thead row */
+  THEAD: 8,
+  /** Pinned header cells (sticky both axes) */
+  PINNED_HEADER: 10,
+  /** Focused header cell */
+  HEADER_FOCUS: 11,
+  /** Checkbox column in sticky header (sticky both axes) */
+  SELECTION_HEADER_PINNED: 12,
+  /** Loading overlay within table */
+  LOADING: 2,
+  /** Column reorder drop indicator */
+  DROP_INDICATOR: 100,
+  /** Dropdown menus (column chooser, pagination size select) */
+  DROPDOWN: 1e3,
+  /** Filter popovers */
+  FILTER_POPOVER: 1e3,
+  /** Modal dialogs */
+  MODAL: 2e3,
+  /** Fullscreen grid container */
+  FULLSCREEN: 9999,
+  /** Context menus (right-click grid menu) */
+  CONTEXT_MENU: 1e4
+};
+
+// src/constants/formulaBar.ts
+var FORMULA_REF_COLORS = [
+  "var(--ogrid-formula-ref-0, #4285f4)",
+  "var(--ogrid-formula-ref-1, #ea4335)",
+  "var(--ogrid-formula-ref-2, #34a853)",
+  "var(--ogrid-formula-ref-3, #9334e6)",
+  "var(--ogrid-formula-ref-4, #ff6d01)",
+  "var(--ogrid-formula-ref-5, #46bdc6)"
+];
+var FORMULA_BAR_CSS = {
+  bar: "display:flex;align-items:center;border-bottom:1px solid var(--ogrid-border, #e0e0e0);background:var(--ogrid-bg, #fff);min-height:28px;font-size:13px;",
+  nameBox: "font-family:monospace;font-size:12px;font-weight:500;padding:2px 8px;border-right:1px solid var(--ogrid-border, #e0e0e0);background:var(--ogrid-bg, #fff);color:var(--ogrid-fg, #242424);min-width:52px;text-align:center;line-height:24px;user-select:none;white-space:nowrap;",
+  fxLabel: "padding:2px 8px;font-style:italic;font-weight:600;color:var(--ogrid-muted-fg, #888);user-select:none;border-right:1px solid var(--ogrid-border, #e0e0e0);line-height:24px;font-size:12px;",
+  input: "flex:1;border:none;outline:none;padding:2px 8px;font-family:monospace;font-size:12px;line-height:24px;background:transparent;color:var(--ogrid-fg, #242424);min-width:0;"
+};
+var FORMULA_BAR_STYLES = {
+  bar: {
+    display: "flex",
+    alignItems: "center",
+    borderBottom: "1px solid var(--ogrid-border, #e0e0e0)",
+    background: "var(--ogrid-bg, #fff)",
+    minHeight: "28px",
+    fontSize: "13px"
+  },
+  nameBox: {
+    fontFamily: "monospace",
+    fontSize: "12px",
+    fontWeight: 500,
+    padding: "2px 8px",
+    borderRight: "1px solid var(--ogrid-border, #e0e0e0)",
+    background: "var(--ogrid-bg, #fff)",
+    color: "var(--ogrid-fg, #242424)",
+    minWidth: "52px",
+    textAlign: "center",
+    lineHeight: "24px",
+    userSelect: "none",
+    whiteSpace: "nowrap"
+  },
+  fxLabel: {
+    padding: "2px 8px",
+    fontStyle: "italic",
+    fontWeight: 600,
+    color: "var(--ogrid-muted-fg, #888)",
+    userSelect: "none",
+    borderRight: "1px solid var(--ogrid-border, #e0e0e0)",
+    lineHeight: "24px",
+    fontSize: "12px"
+  },
+  input: {
+    flex: 1,
+    border: "none",
+    outline: "none",
+    padding: "2px 8px",
+    fontFamily: "monospace",
+    fontSize: "12px",
+    lineHeight: "24px",
+    background: "transparent",
+    color: "var(--ogrid-fg, #242424)",
+    minWidth: 0
+  }
+};
+
+// src/formula/errors.ts
+var REF_ERROR = new FormulaError("#REF!", "Invalid cell reference");
+var DIV_ZERO_ERROR = new FormulaError("#DIV/0!", "Division by zero");
+var VALUE_ERROR = new FormulaError("#VALUE!", "Wrong value type");
+var NAME_ERROR = new FormulaError("#NAME?", "Unknown function or name");
+var CIRC_ERROR = new FormulaError("#CIRC!", "Circular reference");
+var GENERAL_ERROR = new FormulaError("#ERROR!", "Formula error");
+var NA_ERROR = new FormulaError("#N/A", "No match found");
+function isFormulaError(value) {
+  return value instanceof FormulaError;
+}
+
 // src/formula/parser.ts
 function parse(tokens, namedRanges) {
   let pos = 0;
@@ -2923,7 +3079,7 @@ var DependencyGraph = class {
       if (cellDependents) {
         for (const dependent of cellDependents) {
           if (affected.has(dependent)) {
-            const newDegree = inDegree.get(dependent) - 1;
+            const newDegree = (inDegree.get(dependent) ?? 0) - 1;
             inDegree.set(dependent, newDegree);
             if (newDegree === 0) {
               queue.push(dependent);
@@ -3235,7 +3391,7 @@ function registerMathFunctions(registry) {
   registry.set("SUMPRODUCT", {
     minArgs: 1,
     maxArgs: -1,
-    evaluate(args, context, evaluator) {
+    evaluate(args, context, _evaluator) {
       const arrays = [];
       for (const arg of args) {
         if (arg.kind !== "range") {
@@ -3454,6 +3610,162 @@ function registerMathFunctions(registry) {
       return Math.floor(Math.random() * (hi - lo + 1)) + lo;
     }
   });
+  registry.set("MROUND", {
+    minArgs: 2,
+    maxArgs: 2,
+    evaluate(args, context, evaluator) {
+      const rawNum = evaluator.evaluate(args[0], context);
+      if (rawNum instanceof FormulaError) return rawNum;
+      const num = toNumber(rawNum);
+      if (num instanceof FormulaError) return num;
+      const rawMul = evaluator.evaluate(args[1], context);
+      if (rawMul instanceof FormulaError) return rawMul;
+      const multiple = toNumber(rawMul);
+      if (multiple instanceof FormulaError) return multiple;
+      if (multiple === 0) return 0;
+      if (num > 0 && multiple < 0 || num < 0 && multiple > 0) {
+        return new FormulaError("#NUM!", "MROUND: number and multiple must have the same sign");
+      }
+      return Math.round(num / multiple) * multiple;
+    }
+  });
+  registry.set("QUOTIENT", {
+    minArgs: 2,
+    maxArgs: 2,
+    evaluate(args, context, evaluator) {
+      const rawNum = evaluator.evaluate(args[0], context);
+      if (rawNum instanceof FormulaError) return rawNum;
+      const num = toNumber(rawNum);
+      if (num instanceof FormulaError) return num;
+      const rawDen = evaluator.evaluate(args[1], context);
+      if (rawDen instanceof FormulaError) return rawDen;
+      const den = toNumber(rawDen);
+      if (den instanceof FormulaError) return den;
+      if (den === 0) return new FormulaError("#DIV/0!", "QUOTIENT: division by zero");
+      return Math.trunc(num / den);
+    }
+  });
+  registry.set("COMBIN", {
+    minArgs: 2,
+    maxArgs: 2,
+    evaluate(args, context, evaluator) {
+      const rawN = evaluator.evaluate(args[0], context);
+      if (rawN instanceof FormulaError) return rawN;
+      const n = toNumber(rawN);
+      if (n instanceof FormulaError) return n;
+      const rawK = evaluator.evaluate(args[1], context);
+      if (rawK instanceof FormulaError) return rawK;
+      const k = toNumber(rawK);
+      if (k instanceof FormulaError) return k;
+      const ni = Math.trunc(n);
+      const ki = Math.trunc(k);
+      if (ni < 0 || ki < 0) return new FormulaError("#NUM!", "COMBIN: n and k must be non-negative");
+      if (ki > ni) return new FormulaError("#NUM!", "COMBIN: k must be <= n");
+      if (ki === 0 || ki === ni) return 1;
+      const kk = Math.min(ki, ni - ki);
+      let result = 1;
+      for (let i = 0; i < kk; i++) {
+        result = result * (ni - i) / (i + 1);
+      }
+      return Math.round(result);
+    }
+  });
+  registry.set("PERMUT", {
+    minArgs: 2,
+    maxArgs: 2,
+    evaluate(args, context, evaluator) {
+      const rawN = evaluator.evaluate(args[0], context);
+      if (rawN instanceof FormulaError) return rawN;
+      const n = toNumber(rawN);
+      if (n instanceof FormulaError) return n;
+      const rawK = evaluator.evaluate(args[1], context);
+      if (rawK instanceof FormulaError) return rawK;
+      const k = toNumber(rawK);
+      if (k instanceof FormulaError) return k;
+      const ni = Math.trunc(n);
+      const ki = Math.trunc(k);
+      if (ni < 0 || ki < 0) return new FormulaError("#NUM!", "PERMUT: n and k must be non-negative");
+      if (ki > ni) return new FormulaError("#NUM!", "PERMUT: k must be <= n");
+      let result = 1;
+      for (let i = 0; i < ki; i++) {
+        result *= ni - i;
+      }
+      return result;
+    }
+  });
+  registry.set("FACT", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const rawVal = evaluator.evaluate(args[0], context);
+      if (rawVal instanceof FormulaError) return rawVal;
+      const num = toNumber(rawVal);
+      if (num instanceof FormulaError) return num;
+      const n = Math.trunc(num);
+      if (n < 0) return new FormulaError("#NUM!", "FACT: argument must be non-negative");
+      if (n > 170) return new FormulaError("#NUM!", "FACT: argument too large (>170)");
+      let result = 1;
+      for (let i = 2; i <= n; i++) {
+        result *= i;
+      }
+      return result;
+    }
+  });
+  registry.set("GCD", {
+    minArgs: 1,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      const nums = [];
+      for (const arg of args) {
+        const rawVal = evaluator.evaluate(arg, context);
+        if (rawVal instanceof FormulaError) return rawVal;
+        const v = toNumber(rawVal);
+        if (v instanceof FormulaError) return v;
+        const n = Math.trunc(Math.abs(v));
+        nums.push(n);
+      }
+      if (nums.length === 0) return new FormulaError("#NUM!", "GCD: no arguments");
+      let result = nums[0];
+      for (let i = 1; i < nums.length; i++) {
+        result = gcdTwo(result, nums[i]);
+      }
+      return result;
+    }
+  });
+  registry.set("LCM", {
+    minArgs: 1,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      const nums = [];
+      for (const arg of args) {
+        const rawVal = evaluator.evaluate(arg, context);
+        if (rawVal instanceof FormulaError) return rawVal;
+        const v = toNumber(rawVal);
+        if (v instanceof FormulaError) return v;
+        const n = Math.trunc(Math.abs(v));
+        nums.push(n);
+      }
+      if (nums.length === 0) return new FormulaError("#NUM!", "LCM: no arguments");
+      let result = nums[0];
+      for (let i = 1; i < nums.length; i++) {
+        const g = gcdTwo(result, nums[i]);
+        if (g === 0) {
+          result = 0;
+          break;
+        }
+        result = result / g * nums[i];
+      }
+      return result;
+    }
+  });
+}
+function gcdTwo(a, b) {
+  while (b !== 0) {
+    const t = b;
+    b = a % b;
+    a = t;
+  }
+  return a;
 }
 
 // src/formula/functions/logical.ts
@@ -4294,36 +4606,182 @@ function registerTextFunctions(registry) {
       return parts.join(delimiter);
     }
   });
-}
-
-// src/formula/functions/date.ts
-function toDate(val) {
-  if (val instanceof FormulaError) return val;
-  if (val instanceof Date) {
-    if (isNaN(val.getTime())) return new FormulaError("#VALUE!", "Invalid date");
-    return val;
-  }
-  if (typeof val === "string") {
-    const d = new Date(val);
-    if (isNaN(d.getTime())) return new FormulaError("#VALUE!", `Cannot parse "${val}" as date`);
-    return d;
-  }
-  if (typeof val === "number") {
-    const d = new Date(val);
-    if (isNaN(d.getTime())) return new FormulaError("#VALUE!", "Invalid numeric date");
-    return d;
-  }
-  return new FormulaError("#VALUE!", "Cannot convert value to date");
-}
-function registerDateFunctions(registry) {
-  registry.set("TODAY", {
-    minArgs: 0,
-    maxArgs: 0,
-    evaluate(_args, context) {
-      const now = context.now();
-      return new Date(now.getFullYear(), now.getMonth(), now.getDate());
-    }
-  });
+  registry.set("DOLLAR", {
+    minArgs: 1,
+    maxArgs: 2,
+    evaluate(args, context, evaluator) {
+      const rawNum = evaluator.evaluate(args[0], context);
+      if (rawNum instanceof FormulaError) return rawNum;
+      const num = toNumber(rawNum);
+      if (num instanceof FormulaError) return num;
+      let decimals = 2;
+      if (args.length >= 2) {
+        const rawDec = evaluator.evaluate(args[1], context);
+        if (rawDec instanceof FormulaError) return rawDec;
+        const d = toNumber(rawDec);
+        if (d instanceof FormulaError) return d;
+        decimals = Math.trunc(d);
+      }
+      const absNum = Math.abs(num);
+      const rounded = decimals >= 0 ? absNum.toFixed(decimals) : (Math.round(absNum / Math.pow(10, -decimals)) * Math.pow(10, -decimals)).toFixed(0);
+      const [intPart, decPart] = rounded.split(".");
+      const withCommas = intPart.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+      const formatted = decPart !== void 0 ? `${withCommas}.${decPart}` : withCommas;
+      return num < 0 ? `($${formatted})` : `$${formatted}`;
+    }
+  });
+  registry.set("FIXED", {
+    minArgs: 1,
+    maxArgs: 3,
+    evaluate(args, context, evaluator) {
+      const rawNum = evaluator.evaluate(args[0], context);
+      if (rawNum instanceof FormulaError) return rawNum;
+      const num = toNumber(rawNum);
+      if (num instanceof FormulaError) return num;
+      let decimals = 2;
+      if (args.length >= 2) {
+        const rawDec = evaluator.evaluate(args[1], context);
+        if (rawDec instanceof FormulaError) return rawDec;
+        const d = toNumber(rawDec);
+        if (d instanceof FormulaError) return d;
+        decimals = Math.trunc(d);
+      }
+      let noCommas = false;
+      if (args.length >= 3) {
+        const rawNoCommas = evaluator.evaluate(args[2], context);
+        if (rawNoCommas instanceof FormulaError) return rawNoCommas;
+        noCommas = !!rawNoCommas;
+      }
+      const absNum = Math.abs(num);
+      const rounded = decimals >= 0 ? absNum.toFixed(decimals) : (Math.round(absNum / Math.pow(10, -decimals)) * Math.pow(10, -decimals)).toFixed(0);
+      if (noCommas) {
+        return num < 0 ? `-${rounded}` : rounded;
+      }
+      const [intPart, decPart] = rounded.split(".");
+      const withCommas = intPart.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+      const formatted = decPart !== void 0 ? `${withCommas}.${decPart}` : withCommas;
+      return num < 0 ? `-${formatted}` : formatted;
+    }
+  });
+  registry.set("T", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      if (val instanceof FormulaError) return val;
+      return typeof val === "string" ? val : "";
+    }
+  });
+  registry.set("N", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      if (val instanceof FormulaError) return val;
+      if (typeof val === "number") return val;
+      if (typeof val === "boolean") return val ? 1 : 0;
+      if (val instanceof Date) return val.getTime();
+      return 0;
+    }
+  });
+  registry.set("FORMULATEXT", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, _evaluator) {
+      const arg = args[0];
+      if (arg.kind !== "cellRef") {
+        return new FormulaError("#N/A", "FORMULATEXT requires a cell reference");
+      }
+      if (!context.getCellFormula) {
+        return new FormulaError("#N/A", "FORMULATEXT not supported in this context");
+      }
+      const formula = context.getCellFormula(arg.address);
+      if (formula === void 0) {
+        return new FormulaError("#N/A", "Cell does not contain a formula");
+      }
+      return formula;
+    }
+  });
+  registry.set("NUMBERVALUE", {
+    minArgs: 1,
+    maxArgs: 3,
+    evaluate(args, context, evaluator) {
+      const rawText = evaluator.evaluate(args[0], context);
+      if (rawText instanceof FormulaError) return rawText;
+      if (typeof rawText === "number") return rawText;
+      let text = toString(rawText).trim();
+      let decimalSep = ".";
+      let groupSep = ",";
+      const hasDecimalArg = args.length >= 2;
+      const hasGroupArg = args.length >= 3;
+      if (hasDecimalArg) {
+        const rawDec = evaluator.evaluate(args[1], context);
+        if (rawDec instanceof FormulaError) return rawDec;
+        decimalSep = toString(rawDec);
+        if (decimalSep.length !== 1) return new FormulaError("#VALUE!", "NUMBERVALUE decimal separator must be 1 character");
+        if (!hasGroupArg) {
+          groupSep = decimalSep === "," ? "." : ",";
+        }
+      }
+      if (hasGroupArg) {
+        const rawGrp = evaluator.evaluate(args[2], context);
+        if (rawGrp instanceof FormulaError) return rawGrp;
+        groupSep = toString(rawGrp);
+        if (groupSep.length !== 1) return new FormulaError("#VALUE!", "NUMBERVALUE group separator must be 1 character");
+      }
+      if (decimalSep === groupSep) return new FormulaError("#VALUE!", "NUMBERVALUE separators must be different");
+      const isPercent = text.endsWith("%");
+      if (isPercent) text = text.slice(0, -1).trim();
+      const escapedGroup = groupSep.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      text = text.replace(new RegExp(escapedGroup, "g"), "");
+      if (decimalSep !== ".") {
+        const escapedDec = decimalSep.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        text = text.replace(new RegExp(escapedDec), ".");
+      }
+      const n = Number(text);
+      if (isNaN(n)) return new FormulaError("#VALUE!", `NUMBERVALUE cannot parse "${toString(rawText)}"`);
+      return isPercent ? n / 100 : n;
+    }
+  });
+  registry.set("PHONETIC", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      if (val instanceof FormulaError) return val;
+      return toString(val);
+    }
+  });
+}
+
+// src/formula/functions/date.ts
+function toDate(val) {
+  if (val instanceof FormulaError) return val;
+  if (val instanceof Date) {
+    if (isNaN(val.getTime())) return new FormulaError("#VALUE!", "Invalid date");
+    return val;
+  }
+  if (typeof val === "string") {
+    const d = new Date(val);
+    if (isNaN(d.getTime())) return new FormulaError("#VALUE!", `Cannot parse "${val}" as date`);
+    return d;
+  }
+  if (typeof val === "number") {
+    const d = new Date(val);
+    if (isNaN(d.getTime())) return new FormulaError("#VALUE!", "Invalid numeric date");
+    return d;
+  }
+  return new FormulaError("#VALUE!", "Cannot convert value to date");
+}
+function registerDateFunctions(registry) {
+  registry.set("TODAY", {
+    minArgs: 0,
+    maxArgs: 0,
+    evaluate(_args, context) {
+      const now = context.now();
+      return new Date(now.getFullYear(), now.getMonth(), now.getDate());
+    }
+  });
   registry.set("NOW", {
     minArgs: 0,
     maxArgs: 0,
@@ -4543,6 +5001,311 @@ function registerDateFunctions(registry) {
       return count * sign;
     }
   });
+  registry.set("DAYS", {
+    minArgs: 2,
+    maxArgs: 2,
+    evaluate(args, context, evaluator) {
+      const rawEnd = evaluator.evaluate(args[0], context);
+      if (rawEnd instanceof FormulaError) return rawEnd;
+      const endDate = toDate(rawEnd);
+      if (endDate instanceof FormulaError) return endDate;
+      const rawStart = evaluator.evaluate(args[1], context);
+      if (rawStart instanceof FormulaError) return rawStart;
+      const startDate = toDate(rawStart);
+      if (startDate instanceof FormulaError) return startDate;
+      const endMs = Date.UTC(endDate.getFullYear(), endDate.getMonth(), endDate.getDate());
+      const startMs = Date.UTC(startDate.getFullYear(), startDate.getMonth(), startDate.getDate());
+      return Math.round((endMs - startMs) / 864e5);
+    }
+  });
+  registry.set("DAYS360", {
+    minArgs: 2,
+    maxArgs: 3,
+    evaluate(args, context, evaluator) {
+      const rawStart = evaluator.evaluate(args[0], context);
+      if (rawStart instanceof FormulaError) return rawStart;
+      const startDate = toDate(rawStart);
+      if (startDate instanceof FormulaError) return startDate;
+      const rawEnd = evaluator.evaluate(args[1], context);
+      if (rawEnd instanceof FormulaError) return rawEnd;
+      const endDate = toDate(rawEnd);
+      if (endDate instanceof FormulaError) return endDate;
+      let method = false;
+      if (args.length >= 3) {
+        const rawMethod = evaluator.evaluate(args[2], context);
+        if (rawMethod instanceof FormulaError) return rawMethod;
+        method = !!rawMethod;
+      }
+      const sm = startDate.getMonth() + 1;
+      const em = endDate.getMonth() + 1;
+      let sd = startDate.getDate();
+      let ed = endDate.getDate();
+      const sy = startDate.getFullYear();
+      const ey = endDate.getFullYear();
+      if (!method) {
+        if (sd === 31) sd = 30;
+        if (ed === 31 && sd === 30) ed = 30;
+      } else {
+        if (sd === 31) sd = 30;
+        if (ed === 31) ed = 30;
+      }
+      return (ey - sy) * 360 + (em - sm) * 30 + (ed - sd);
+    }
+  });
+  registry.set("ISOWEEKNUM", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const rawDate = evaluator.evaluate(args[0], context);
+      if (rawDate instanceof FormulaError) return rawDate;
+      const date = toDate(rawDate);
+      if (date instanceof FormulaError) return date;
+      const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
+      const day = d.getUTCDay() || 7;
+      d.setUTCDate(d.getUTCDate() + 4 - day);
+      const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
+      return Math.ceil(((d.getTime() - yearStart.getTime()) / 864e5 + 1) / 7);
+    }
+  });
+  registry.set("YEARFRAC", {
+    minArgs: 2,
+    maxArgs: 3,
+    evaluate(args, context, evaluator) {
+      const rawStart = evaluator.evaluate(args[0], context);
+      if (rawStart instanceof FormulaError) return rawStart;
+      const startDate = toDate(rawStart);
+      if (startDate instanceof FormulaError) return startDate;
+      const rawEnd = evaluator.evaluate(args[1], context);
+      if (rawEnd instanceof FormulaError) return rawEnd;
+      const endDate = toDate(rawEnd);
+      if (endDate instanceof FormulaError) return endDate;
+      let basis = 0;
+      if (args.length >= 3) {
+        const rawBasis = evaluator.evaluate(args[2], context);
+        if (rawBasis instanceof FormulaError) return rawBasis;
+        const b = toNumber(rawBasis);
+        if (b instanceof FormulaError) return b;
+        basis = Math.trunc(b);
+      }
+      const sy = startDate.getFullYear();
+      const sm = startDate.getMonth() + 1;
+      const sd = startDate.getDate();
+      const ey = endDate.getFullYear();
+      const em = endDate.getMonth() + 1;
+      const ed = endDate.getDate();
+      switch (basis) {
+        case 0: {
+          const startDay = sd === 31 ? 30 : sd;
+          const endDay = ed === 31 && startDay === 30 ? 30 : ed;
+          const days360 = (ey - sy) * 360 + (em - sm) * 30 + (endDay - startDay);
+          return days360 / 360;
+        }
+        case 1: {
+          const diffMs = Date.UTC(ey, em - 1, ed) - Date.UTC(sy, sm - 1, sd);
+          const diffDays = diffMs / 864e5;
+          const avgYear = ey === sy ? isLeapYear(sy) ? 366 : 365 : (Date.UTC(ey + 1, 0, 1) - Date.UTC(sy, 0, 1)) / 864e5 / (ey - sy + 1);
+          return diffDays / avgYear;
+        }
+        case 3: {
+          const diffMs = Date.UTC(ey, em - 1, ed) - Date.UTC(sy, sm - 1, sd);
+          return diffMs / 864e5 / 365;
+        }
+        default:
+          return new FormulaError("#VALUE!", "YEARFRAC basis must be 0, 1, or 3");
+      }
+    }
+  });
+  registry.set("DATEVALUE", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const rawVal = evaluator.evaluate(args[0], context);
+      if (rawVal instanceof FormulaError) return rawVal;
+      const str = typeof rawVal === "string" ? rawVal : String(rawVal);
+      const d = new Date(str);
+      if (isNaN(d.getTime())) return new FormulaError("#VALUE!", `DATEVALUE cannot parse "${str}"`);
+      return new Date(d.getFullYear(), d.getMonth(), d.getDate());
+    }
+  });
+  registry.set("TIMEVALUE", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const rawVal = evaluator.evaluate(args[0], context);
+      if (rawVal instanceof FormulaError) return rawVal;
+      const str = typeof rawVal === "string" ? rawVal : String(rawVal);
+      const match = str.match(/^(\d{1,2}):(\d{2})(?::(\d{2}))?(?:\s*(AM|PM))?$/i);
+      if (!match) return new FormulaError("#VALUE!", `TIMEVALUE cannot parse "${str}"`);
+      let hours = parseInt(match[1], 10);
+      const minutes = parseInt(match[2], 10);
+      const seconds = match[3] ? parseInt(match[3], 10) : 0;
+      const ampm = match[4] ? match[4].toUpperCase() : null;
+      if (ampm === "PM" && hours < 12) hours += 12;
+      if (ampm === "AM" && hours === 12) hours = 0;
+      if (hours > 23 || minutes > 59 || seconds > 59) {
+        return new FormulaError("#VALUE!", "TIMEVALUE: invalid time component");
+      }
+      return (hours * 3600 + minutes * 60 + seconds) / 86400;
+    }
+  });
+  registry.set("TIME", {
+    minArgs: 3,
+    maxArgs: 3,
+    evaluate(args, context, evaluator) {
+      const rawH = evaluator.evaluate(args[0], context);
+      if (rawH instanceof FormulaError) return rawH;
+      const h = toNumber(rawH);
+      if (h instanceof FormulaError) return h;
+      const rawM = evaluator.evaluate(args[1], context);
+      if (rawM instanceof FormulaError) return rawM;
+      const m = toNumber(rawM);
+      if (m instanceof FormulaError) return m;
+      const rawS = evaluator.evaluate(args[2], context);
+      if (rawS instanceof FormulaError) return rawS;
+      const s = toNumber(rawS);
+      if (s instanceof FormulaError) return s;
+      const totalSeconds = Math.trunc(h) * 3600 + Math.trunc(m) * 60 + Math.trunc(s);
+      return totalSeconds % 86400 / 86400;
+    }
+  });
+  registry.set("WORKDAY", {
+    minArgs: 2,
+    maxArgs: 3,
+    evaluate(args, context, evaluator) {
+      const rawStart = evaluator.evaluate(args[0], context);
+      if (rawStart instanceof FormulaError) return rawStart;
+      const startDate = toDate(rawStart);
+      if (startDate instanceof FormulaError) return startDate;
+      const rawDays = evaluator.evaluate(args[1], context);
+      if (rawDays instanceof FormulaError) return rawDays;
+      const daysNum = toNumber(rawDays);
+      if (daysNum instanceof FormulaError) return daysNum;
+      const days = Math.trunc(daysNum);
+      const holidaySet = /* @__PURE__ */ new Set();
+      if (args.length >= 3) {
+        const rawHol = args[2];
+        let holVals;
+        if (rawHol.kind === "range") {
+          holVals = context.getRangeValues({ start: rawHol.start, end: rawHol.end }).flat();
+        } else {
+          holVals = [evaluator.evaluate(rawHol, context)];
+        }
+        for (const hv of holVals) {
+          if (hv === null || hv === void 0) continue;
+          const hd = toDate(hv);
+          if (!(hd instanceof FormulaError)) {
+            holidaySet.add(`${hd.getFullYear()}-${hd.getMonth()}-${hd.getDate()}`);
+          }
+        }
+      }
+      const current = new Date(startDate.getFullYear(), startDate.getMonth(), startDate.getDate());
+      const step = days >= 0 ? 1 : -1;
+      let remaining = Math.abs(days);
+      while (remaining > 0) {
+        current.setDate(current.getDate() + step);
+        const dow = current.getDay();
+        if (dow === 0 || dow === 6) continue;
+        const key = `${current.getFullYear()}-${current.getMonth()}-${current.getDate()}`;
+        if (holidaySet.has(key)) continue;
+        remaining--;
+      }
+      return current;
+    }
+  });
+  registry.set("WORKDAY.INTL", {
+    minArgs: 2,
+    maxArgs: 4,
+    evaluate(args, context, evaluator) {
+      const rawStart = evaluator.evaluate(args[0], context);
+      if (rawStart instanceof FormulaError) return rawStart;
+      const startDate = toDate(rawStart);
+      if (startDate instanceof FormulaError) return startDate;
+      const rawDays = evaluator.evaluate(args[1], context);
+      if (rawDays instanceof FormulaError) return rawDays;
+      const daysNum = toNumber(rawDays);
+      if (daysNum instanceof FormulaError) return daysNum;
+      const days = Math.trunc(daysNum);
+      let weekendMask = [false, false, false, false, false, true, true];
+      if (args.length >= 3) {
+        const rawWeekend = evaluator.evaluate(args[2], context);
+        if (rawWeekend instanceof FormulaError) return rawWeekend;
+        if (typeof rawWeekend === "string" && /^[01]{7}$/.test(rawWeekend)) {
+          weekendMask = rawWeekend.split("").map((c) => c === "1");
+        } else {
+          const wn = toNumber(rawWeekend);
+          if (wn instanceof FormulaError) return wn;
+          const parsed = parseWeekendNumber(Math.trunc(wn));
+          if (!parsed) return new FormulaError("#VALUE!", "WORKDAY.INTL invalid weekend number");
+          weekendMask = parsed;
+        }
+      }
+      const holidaySet = /* @__PURE__ */ new Set();
+      if (args.length >= 4) {
+        const rawHol = args[3];
+        let holVals;
+        if (rawHol.kind === "range") {
+          holVals = context.getRangeValues({ start: rawHol.start, end: rawHol.end }).flat();
+        } else {
+          holVals = [evaluator.evaluate(rawHol, context)];
+        }
+        for (const hv of holVals) {
+          if (hv === null || hv === void 0) continue;
+          const hd = toDate(hv);
+          if (!(hd instanceof FormulaError)) {
+            holidaySet.add(`${hd.getFullYear()}-${hd.getMonth()}-${hd.getDate()}`);
+          }
+        }
+      }
+      const current = new Date(startDate.getFullYear(), startDate.getMonth(), startDate.getDate());
+      const step = days >= 0 ? 1 : -1;
+      let remaining = Math.abs(days);
+      while (remaining > 0) {
+        current.setDate(current.getDate() + step);
+        const dow = current.getDay();
+        const maskIndex = dow === 0 ? 6 : dow - 1;
+        if (weekendMask[maskIndex]) continue;
+        const key = `${current.getFullYear()}-${current.getMonth()}-${current.getDate()}`;
+        if (holidaySet.has(key)) continue;
+        remaining--;
+      }
+      return current;
+    }
+  });
+}
+function isLeapYear(year) {
+  return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
+}
+function parseWeekendNumber(n) {
+  const twoDay = [
+    [5, 6],
+    // 1: Sat+Sun
+    [6, 0],
+    // 2: Sun+Mon  (Sun=index6, Mon=index0)
+    [0, 1],
+    // 3: Mon+Tue
+    [1, 2],
+    // 4: Tue+Wed
+    [2, 3],
+    // 5: Wed+Thu
+    [3, 4],
+    // 6: Thu+Fri
+    [4, 5]
+    // 7: Fri+Sat
+  ];
+  if (n >= 1 && n <= 7) {
+    const mask = [false, false, false, false, false, false, false];
+    const [a, b] = twoDay[n - 1];
+    mask[a] = true;
+    mask[b] = true;
+    return mask;
+  }
+  if (n >= 11 && n <= 17) {
+    const mask = [false, false, false, false, false, false, false];
+    const singleDay = [6, 0, 1, 2, 3, 4, 5];
+    mask[singleDay[n - 11]] = true;
+    return mask;
+  }
+  return null;
 }
 
 // src/formula/functions/stats.ts
@@ -4906,18 +5669,1067 @@ function registerInfoFunctions(registry) {
       return 1;
     }
   });
+  registry.set("ISODD", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      if (val instanceof FormulaError) return val;
+      if (typeof val === "boolean") return new FormulaError("#VALUE!", "ISODD requires a number");
+      const n = toNumber(val);
+      if (n instanceof FormulaError) return n;
+      return Math.trunc(n) % 2 !== 0;
+    }
+  });
+  registry.set("ISEVEN", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      if (val instanceof FormulaError) return val;
+      if (typeof val === "boolean") return new FormulaError("#VALUE!", "ISEVEN requires a number");
+      const n = toNumber(val);
+      if (n instanceof FormulaError) return n;
+      return Math.trunc(n) % 2 === 0;
+    }
+  });
+  registry.set("ISFORMULA", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, _evaluator) {
+      const arg = args[0];
+      if (arg.kind !== "cellRef") return false;
+      if (!context.getCellFormula) return false;
+      const formula = context.getCellFormula(arg.address);
+      return formula !== void 0;
+    }
+  });
+  registry.set("ISLOGICAL", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      if (val instanceof FormulaError) return false;
+      return typeof val === "boolean";
+    }
+  });
+  registry.set("ISNONTEXT", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      if (val instanceof FormulaError) return true;
+      return typeof val !== "string";
+    }
+  });
+  registry.set("ISREF", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, _context, _evaluator) {
+      const arg = args[0];
+      return arg.kind === "cellRef" || arg.kind === "range";
+    }
+  });
 }
 
-// src/formula/functions/index.ts
-function createBuiltInFunctions() {
-  const registry = /* @__PURE__ */ new Map();
-  registerMathFunctions(registry);
-  registerLogicalFunctions(registry);
-  registerLookupFunctions(registry);
+// src/formula/functions/financial.ts
+function registerFinancialFunctions(registry) {
+  registry.set("PMT", {
+    minArgs: 3,
+    maxArgs: 5,
+    evaluate(args, context, evaluator) {
+      const rawRate = evaluator.evaluate(args[0], context);
+      if (rawRate instanceof FormulaError) return rawRate;
+      const rate = toNumber(rawRate);
+      if (rate instanceof FormulaError) return rate;
+      const rawNper = evaluator.evaluate(args[1], context);
+      if (rawNper instanceof FormulaError) return rawNper;
+      const nper = toNumber(rawNper);
+      if (nper instanceof FormulaError) return nper;
+      const rawPv = evaluator.evaluate(args[2], context);
+      if (rawPv instanceof FormulaError) return rawPv;
+      const pv = toNumber(rawPv);
+      if (pv instanceof FormulaError) return pv;
+      let fv = 0;
+      if (args.length >= 4) {
+        const rawFv = evaluator.evaluate(args[3], context);
+        if (rawFv instanceof FormulaError) return rawFv;
+        const fvNum = toNumber(rawFv);
+        if (fvNum instanceof FormulaError) return fvNum;
+        fv = fvNum;
+      }
+      let type = 0;
+      if (args.length >= 5) {
+        const rawType = evaluator.evaluate(args[4], context);
+        if (rawType instanceof FormulaError) return rawType;
+        const typeNum = toNumber(rawType);
+        if (typeNum instanceof FormulaError) return typeNum;
+        type = typeNum;
+      }
+      if (nper === 0) return new FormulaError("#NUM!", "PMT: nper cannot be 0");
+      if (rate === 0) {
+        return -(pv + fv) / nper;
+      }
+      const factor = Math.pow(1 + rate, nper);
+      const typeAdj = type !== 0 ? 1 + rate : 1;
+      return -(pv * factor + fv) / ((factor - 1) / rate * typeAdj);
+    }
+  });
+  registry.set("FV", {
+    minArgs: 3,
+    maxArgs: 5,
+    evaluate(args, context, evaluator) {
+      const rawRate = evaluator.evaluate(args[0], context);
+      if (rawRate instanceof FormulaError) return rawRate;
+      const rate = toNumber(rawRate);
+      if (rate instanceof FormulaError) return rate;
+      const rawNper = evaluator.evaluate(args[1], context);
+      if (rawNper instanceof FormulaError) return rawNper;
+      const nper = toNumber(rawNper);
+      if (nper instanceof FormulaError) return nper;
+      const rawPmt = evaluator.evaluate(args[2], context);
+      if (rawPmt instanceof FormulaError) return rawPmt;
+      const pmt = toNumber(rawPmt);
+      if (pmt instanceof FormulaError) return pmt;
+      let pv = 0;
+      if (args.length >= 4) {
+        const rawPv = evaluator.evaluate(args[3], context);
+        if (rawPv instanceof FormulaError) return rawPv;
+        const pvNum = toNumber(rawPv);
+        if (pvNum instanceof FormulaError) return pvNum;
+        pv = pvNum;
+      }
+      let type = 0;
+      if (args.length >= 5) {
+        const rawType = evaluator.evaluate(args[4], context);
+        if (rawType instanceof FormulaError) return rawType;
+        const typeNum = toNumber(rawType);
+        if (typeNum instanceof FormulaError) return typeNum;
+        type = typeNum;
+      }
+      if (rate === 0) {
+        return -(pv + pmt * nper);
+      }
+      const factor = Math.pow(1 + rate, nper);
+      const typeAdj = type !== 0 ? 1 + rate : 1;
+      return -(pv * factor + pmt * typeAdj * (factor - 1) / rate);
+    }
+  });
+  registry.set("PV", {
+    minArgs: 3,
+    maxArgs: 5,
+    evaluate(args, context, evaluator) {
+      const rawRate = evaluator.evaluate(args[0], context);
+      if (rawRate instanceof FormulaError) return rawRate;
+      const rate = toNumber(rawRate);
+      if (rate instanceof FormulaError) return rate;
+      const rawNper = evaluator.evaluate(args[1], context);
+      if (rawNper instanceof FormulaError) return rawNper;
+      const nper = toNumber(rawNper);
+      if (nper instanceof FormulaError) return nper;
+      const rawPmt = evaluator.evaluate(args[2], context);
+      if (rawPmt instanceof FormulaError) return rawPmt;
+      const pmt = toNumber(rawPmt);
+      if (pmt instanceof FormulaError) return pmt;
+      let fv = 0;
+      if (args.length >= 4) {
+        const rawFv = evaluator.evaluate(args[3], context);
+        if (rawFv instanceof FormulaError) return rawFv;
+        const fvNum = toNumber(rawFv);
+        if (fvNum instanceof FormulaError) return fvNum;
+        fv = fvNum;
+      }
+      let type = 0;
+      if (args.length >= 5) {
+        const rawType = evaluator.evaluate(args[4], context);
+        if (rawType instanceof FormulaError) return rawType;
+        const typeNum = toNumber(rawType);
+        if (typeNum instanceof FormulaError) return typeNum;
+        type = typeNum;
+      }
+      if (rate === 0) {
+        return -pmt * nper - fv;
+      }
+      const factor = Math.pow(1 + rate, nper);
+      const typeAdj = type !== 0 ? 1 + rate : 1;
+      return -(fv + pmt * typeAdj * (factor - 1) / rate) / factor;
+    }
+  });
+  registry.set("NPER", {
+    minArgs: 3,
+    maxArgs: 5,
+    evaluate(args, context, evaluator) {
+      const rawRate = evaluator.evaluate(args[0], context);
+      if (rawRate instanceof FormulaError) return rawRate;
+      const rate = toNumber(rawRate);
+      if (rate instanceof FormulaError) return rate;
+      const rawPmt = evaluator.evaluate(args[1], context);
+      if (rawPmt instanceof FormulaError) return rawPmt;
+      const pmt = toNumber(rawPmt);
+      if (pmt instanceof FormulaError) return pmt;
+      const rawPv = evaluator.evaluate(args[2], context);
+      if (rawPv instanceof FormulaError) return rawPv;
+      const pv = toNumber(rawPv);
+      if (pv instanceof FormulaError) return pv;
+      let fv = 0;
+      if (args.length >= 4) {
+        const rawFv = evaluator.evaluate(args[3], context);
+        if (rawFv instanceof FormulaError) return rawFv;
+        const fvNum = toNumber(rawFv);
+        if (fvNum instanceof FormulaError) return fvNum;
+        fv = fvNum;
+      }
+      let type = 0;
+      if (args.length >= 5) {
+        const rawType = evaluator.evaluate(args[4], context);
+        if (rawType instanceof FormulaError) return rawType;
+        const typeNum = toNumber(rawType);
+        if (typeNum instanceof FormulaError) return typeNum;
+        type = typeNum;
+      }
+      if (rate === 0) {
+        if (pmt === 0) return new FormulaError("#NUM!", "NPER: pmt cannot be 0 when rate is 0");
+        return -(pv + fv) / pmt;
+      }
+      const typeAdj = type !== 0 ? 1 + rate : 1;
+      const pmtAdj = pmt * typeAdj;
+      const num = pmtAdj - fv * rate;
+      const den = pmtAdj + pv * rate;
+      if (den === 0) return new FormulaError("#DIV/0!", "NPER: division by zero");
+      if (num / den <= 0) return new FormulaError("#NUM!", "NPER: logarithm of non-positive number");
+      return Math.log(num / den) / Math.log(1 + rate);
+    }
+  });
+  registry.set("RATE", {
+    minArgs: 3,
+    maxArgs: 6,
+    evaluate(args, context, evaluator) {
+      const rawNper = evaluator.evaluate(args[0], context);
+      if (rawNper instanceof FormulaError) return rawNper;
+      const nper = toNumber(rawNper);
+      if (nper instanceof FormulaError) return nper;
+      const rawPmt = evaluator.evaluate(args[1], context);
+      if (rawPmt instanceof FormulaError) return rawPmt;
+      const pmt = toNumber(rawPmt);
+      if (pmt instanceof FormulaError) return pmt;
+      const rawPv = evaluator.evaluate(args[2], context);
+      if (rawPv instanceof FormulaError) return rawPv;
+      const pv = toNumber(rawPv);
+      if (pv instanceof FormulaError) return pv;
+      let fv = 0;
+      if (args.length >= 4) {
+        const rawFv = evaluator.evaluate(args[3], context);
+        if (rawFv instanceof FormulaError) return rawFv;
+        const fvNum = toNumber(rawFv);
+        if (fvNum instanceof FormulaError) return fvNum;
+        fv = fvNum;
+      }
+      let type = 0;
+      if (args.length >= 5) {
+        const rawType = evaluator.evaluate(args[4], context);
+        if (rawType instanceof FormulaError) return rawType;
+        const typeNum = toNumber(rawType);
+        if (typeNum instanceof FormulaError) return typeNum;
+        type = typeNum;
+      }
+      let guess = 0.1;
+      if (args.length >= 6) {
+        const rawGuess = evaluator.evaluate(args[5], context);
+        if (rawGuess instanceof FormulaError) return rawGuess;
+        const guessNum = toNumber(rawGuess);
+        if (guessNum instanceof FormulaError) return guessNum;
+        guess = guessNum;
+      }
+      const MAX_ITER = 20;
+      const TOLERANCE = 1e-7;
+      let r = guess;
+      for (let i = 0; i < MAX_ITER; i++) {
+        if (r <= -1) return new FormulaError("#NUM!", "RATE: rate converged to invalid value");
+        const factor = Math.pow(1 + r, nper);
+        const typeAdj = type !== 0 ? 1 + r : 1;
+        let f;
+        let df;
+        if (Math.abs(r) < 1e-10) {
+          f = pv + pmt * nper + fv;
+          df = pv * nper + pmt * nper * (nper - 1) / 2;
+        } else {
+          f = pv * factor + pmt * typeAdj * (factor - 1) / r + fv;
+          const dfactor = nper * Math.pow(1 + r, nper - 1);
+          const dTypeAdj = type !== 0 ? 1 : 0;
+          df = pv * dfactor + pmt * (dTypeAdj * (factor - 1) / r + typeAdj * (dfactor * r - (factor - 1)) / (r * r));
+        }
+        if (Math.abs(df) < 1e-15) return new FormulaError("#NUM!", "RATE: derivative too small, no convergence");
+        const delta = f / df;
+        r = r - delta;
+        if (Math.abs(delta) < TOLERANCE) return r;
+      }
+      return new FormulaError("#NUM!", "RATE: did not converge");
+    }
+  });
+  registry.set("NPV", {
+    minArgs: 2,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      const rawRate = evaluator.evaluate(args[0], context);
+      if (rawRate instanceof FormulaError) return rawRate;
+      const rate = toNumber(rawRate);
+      if (rate instanceof FormulaError) return rate;
+      const values = flattenArgs(args.slice(1), context, evaluator);
+      let npv = 0;
+      let period = 1;
+      for (const val of values) {
+        if (val instanceof FormulaError) return val;
+        if (typeof val === "number" || typeof val === "boolean") {
+          const n = typeof val === "boolean" ? val ? 1 : 0 : val;
+          npv += n / Math.pow(1 + rate, period);
+          period++;
+        }
+      }
+      return npv;
+    }
+  });
+  registry.set("IRR", {
+    minArgs: 1,
+    maxArgs: 2,
+    evaluate(args, context, evaluator) {
+      const cashFlows = flattenArgs([args[0]], context, evaluator);
+      const nums = [];
+      for (const val of cashFlows) {
+        if (val instanceof FormulaError) return val;
+        if (typeof val === "number") nums.push(val);
+        else if (typeof val === "boolean") nums.push(val ? 1 : 0);
+      }
+      if (nums.length === 0) return new FormulaError("#NUM!", "IRR: no values");
+      let guess = 0.1;
+      if (args.length >= 2) {
+        const rawGuess = evaluator.evaluate(args[1], context);
+        if (rawGuess instanceof FormulaError) return rawGuess;
+        const guessNum = toNumber(rawGuess);
+        if (guessNum instanceof FormulaError) return guessNum;
+        guess = guessNum;
+      }
+      const MAX_ITER = 20;
+      const TOLERANCE = 1e-7;
+      let r = guess;
+      for (let i = 0; i < MAX_ITER; i++) {
+        if (r <= -1) return new FormulaError("#NUM!", "IRR: rate converged below -1");
+        let f = 0;
+        let df = 0;
+        for (let j = 0; j < nums.length; j++) {
+          const factor = Math.pow(1 + r, j);
+          f += nums[j] / factor;
+          if (j > 0) {
+            df -= j * nums[j] / Math.pow(1 + r, j + 1);
+          }
+        }
+        if (Math.abs(df) < 1e-15) return new FormulaError("#NUM!", "IRR: derivative too small");
+        const delta = f / df;
+        r = r - delta;
+        if (Math.abs(delta) < TOLERANCE) return r;
+      }
+      return new FormulaError("#NUM!", "IRR: did not converge");
+    }
+  });
+  registry.set("SLN", {
+    minArgs: 3,
+    maxArgs: 3,
+    evaluate(args, context, evaluator) {
+      const rawCost = evaluator.evaluate(args[0], context);
+      if (rawCost instanceof FormulaError) return rawCost;
+      const cost = toNumber(rawCost);
+      if (cost instanceof FormulaError) return cost;
+      const rawSalvage = evaluator.evaluate(args[1], context);
+      if (rawSalvage instanceof FormulaError) return rawSalvage;
+      const salvage = toNumber(rawSalvage);
+      if (salvage instanceof FormulaError) return salvage;
+      const rawLife = evaluator.evaluate(args[2], context);
+      if (rawLife instanceof FormulaError) return rawLife;
+      const life = toNumber(rawLife);
+      if (life instanceof FormulaError) return life;
+      if (life === 0) return new FormulaError("#DIV/0!", "SLN: life cannot be 0");
+      return (cost - salvage) / life;
+    }
+  });
+}
+
+// src/formula/functions/statistical-extended.ts
+function extractNums(args, context, evaluator) {
+  const values = flattenArgs(args, context, evaluator);
+  const nums = [];
+  for (const val of values) {
+    if (val instanceof FormulaError) return val;
+    if (typeof val === "number") nums.push(val);
+    else if (typeof val === "boolean") nums.push(val ? 1 : 0);
+  }
+  return nums;
+}
+function mean(nums) {
+  let sum = 0;
+  for (const n of nums) sum += n;
+  return sum / nums.length;
+}
+function registerStatisticalExtendedFunctions(registry) {
+  const stdevImpl = {
+    minArgs: 1,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      const nums = extractNums(args, context, evaluator);
+      if (nums instanceof FormulaError) return nums;
+      if (nums.length < 2) return new FormulaError("#DIV/0!", "STDEV requires at least 2 values");
+      const m = mean(nums);
+      let sum = 0;
+      for (const n of nums) sum += (n - m) * (n - m);
+      return Math.sqrt(sum / (nums.length - 1));
+    }
+  };
+  registry.set("STDEV", stdevImpl);
+  registry.set("STDEV.S", stdevImpl);
+  const stdevpImpl = {
+    minArgs: 1,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      const nums = extractNums(args, context, evaluator);
+      if (nums instanceof FormulaError) return nums;
+      if (nums.length === 0) return new FormulaError("#DIV/0!", "STDEVP requires at least 1 value");
+      const m = mean(nums);
+      let sum = 0;
+      for (const n of nums) sum += (n - m) * (n - m);
+      return Math.sqrt(sum / nums.length);
+    }
+  };
+  registry.set("STDEVP", stdevpImpl);
+  registry.set("STDEV.P", stdevpImpl);
+  const varImpl = {
+    minArgs: 1,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      const nums = extractNums(args, context, evaluator);
+      if (nums instanceof FormulaError) return nums;
+      if (nums.length < 2) return new FormulaError("#DIV/0!", "VAR requires at least 2 values");
+      const m = mean(nums);
+      let sum = 0;
+      for (const n of nums) sum += (n - m) * (n - m);
+      return sum / (nums.length - 1);
+    }
+  };
+  registry.set("VAR", varImpl);
+  registry.set("VAR.S", varImpl);
+  const varpImpl = {
+    minArgs: 1,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      const nums = extractNums(args, context, evaluator);
+      if (nums instanceof FormulaError) return nums;
+      if (nums.length === 0) return new FormulaError("#DIV/0!", "VARP requires at least 1 value");
+      const m = mean(nums);
+      let sum = 0;
+      for (const n of nums) sum += (n - m) * (n - m);
+      return sum / nums.length;
+    }
+  };
+  registry.set("VARP", varpImpl);
+  registry.set("VAR.P", varpImpl);
+  registry.set("CORREL", {
+    minArgs: 2,
+    maxArgs: 2,
+    evaluate(args, context, evaluator) {
+      const nums1 = extractNums([args[0]], context, evaluator);
+      if (nums1 instanceof FormulaError) return nums1;
+      const nums2 = extractNums([args[1]], context, evaluator);
+      if (nums2 instanceof FormulaError) return nums2;
+      if (nums1.length !== nums2.length) {
+        return new FormulaError("#N/A", "CORREL: arrays must have same number of values");
+      }
+      if (nums1.length < 2) {
+        return new FormulaError("#DIV/0!", "CORREL requires at least 2 paired values");
+      }
+      const m1 = mean(nums1);
+      const m2 = mean(nums2);
+      let cov = 0;
+      let var1 = 0;
+      let var2 = 0;
+      for (let i = 0; i < nums1.length; i++) {
+        const d1 = nums1[i] - m1;
+        const d2 = nums2[i] - m2;
+        cov += d1 * d2;
+        var1 += d1 * d1;
+        var2 += d2 * d2;
+      }
+      const denom = Math.sqrt(var1 * var2);
+      if (denom === 0) return new FormulaError("#DIV/0!", "CORREL: zero variance");
+      return cov / denom;
+    }
+  });
+  function percentileCalc(nums, k) {
+    if (k < 0 || k > 1) return new FormulaError("#NUM!", "PERCENTILE: k must be between 0 and 1");
+    if (nums.length === 0) return new FormulaError("#NUM!", "PERCENTILE: empty array");
+    const sorted = [...nums].sort((a, b) => a - b);
+    const idx = k * (sorted.length - 1);
+    const low = Math.floor(idx);
+    const high = Math.ceil(idx);
+    if (low === high) return sorted[low];
+    const frac = idx - low;
+    return sorted[low] + frac * (sorted[high] - sorted[low]);
+  }
+  const percentileImpl = {
+    minArgs: 2,
+    maxArgs: 2,
+    evaluate(args, context, evaluator) {
+      const nums = extractNums([args[0]], context, evaluator);
+      if (nums instanceof FormulaError) return nums;
+      const rawK = evaluator.evaluate(args[1], context);
+      if (rawK instanceof FormulaError) return rawK;
+      const k = toNumber(rawK);
+      if (k instanceof FormulaError) return k;
+      return percentileCalc(nums, k);
+    }
+  };
+  registry.set("PERCENTILE", percentileImpl);
+  registry.set("PERCENTILE.INC", percentileImpl);
+  const quartileImpl = {
+    minArgs: 2,
+    maxArgs: 2,
+    evaluate(args, context, evaluator) {
+      const nums = extractNums([args[0]], context, evaluator);
+      if (nums instanceof FormulaError) return nums;
+      const rawQuart = evaluator.evaluate(args[1], context);
+      if (rawQuart instanceof FormulaError) return rawQuart;
+      const quart = toNumber(rawQuart);
+      if (quart instanceof FormulaError) return quart;
+      const quartInt = Math.trunc(quart);
+      if (quartInt < 0 || quartInt > 4) {
+        return new FormulaError("#NUM!", "QUARTILE: quart must be 0, 1, 2, 3, or 4");
+      }
+      return percentileCalc(nums, quartInt * 0.25);
+    }
+  };
+  registry.set("QUARTILE", quartileImpl);
+  registry.set("QUARTILE.INC", quartileImpl);
+  const modeImpl = {
+    minArgs: 1,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      const nums = extractNums(args, context, evaluator);
+      if (nums instanceof FormulaError) return nums;
+      if (nums.length === 0) return new FormulaError("#N/A", "MODE: no numeric values");
+      const freq = /* @__PURE__ */ new Map();
+      for (const n of nums) {
+        freq.set(n, (freq.get(n) ?? 0) + 1);
+      }
+      let maxFreq = 0;
+      let modeVal = null;
+      for (const n of nums) {
+        const f = freq.get(n) ?? 0;
+        if (f > maxFreq) {
+          maxFreq = f;
+          modeVal = n;
+        }
+      }
+      if (maxFreq < 1 || modeVal === null) return new FormulaError("#N/A", "MODE: no values");
+      return modeVal;
+    }
+  };
+  registry.set("MODE", modeImpl);
+  registry.set("MODE.SNGL", modeImpl);
+  registry.set("GEOMEAN", {
+    minArgs: 1,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      const nums = extractNums(args, context, evaluator);
+      if (nums instanceof FormulaError) return nums;
+      if (nums.length === 0) return new FormulaError("#NUM!", "GEOMEAN: no numeric values");
+      let sumLn = 0;
+      for (const n of nums) {
+        if (n <= 0) return new FormulaError("#NUM!", "GEOMEAN: all values must be positive");
+        sumLn += Math.log(n);
+      }
+      return Math.exp(sumLn / nums.length);
+    }
+  });
+  registry.set("HARMEAN", {
+    minArgs: 1,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      const nums = extractNums(args, context, evaluator);
+      if (nums instanceof FormulaError) return nums;
+      if (nums.length === 0) return new FormulaError("#NUM!", "HARMEAN: no numeric values");
+      let sumRecip = 0;
+      for (const n of nums) {
+        if (n <= 0) return new FormulaError("#NUM!", "HARMEAN: all values must be positive");
+        sumRecip += 1 / n;
+      }
+      if (sumRecip === 0) return new FormulaError("#DIV/0!", "HARMEAN: sum of reciprocals is zero");
+      return nums.length / sumRecip;
+    }
+  });
+}
+
+// src/formula/functions/reference.ts
+function registerReferenceFunctions(registry) {
+  registry.set("INDIRECT", {
+    minArgs: 1,
+    maxArgs: 2,
+    evaluate(args, context, evaluator) {
+      const rawRef = evaluator.evaluate(args[0], context);
+      if (rawRef instanceof FormulaError) return rawRef;
+      const refText = String(rawRef ?? "");
+      const range = parseRange(refText);
+      if (range) {
+        const start = range.start;
+        const end = range.end;
+        if (start.row === end.row && start.col === end.col) {
+          return context.getCellValue(start);
+        }
+        return context.getCellValue(start);
+      }
+      const addr = parseCellRef(refText);
+      if (!addr) {
+        return new FormulaError("#REF!", `INDIRECT: invalid reference "${refText}"`);
+      }
+      return context.getCellValue(addr);
+    }
+  });
+  registry.set("OFFSET", {
+    minArgs: 3,
+    maxArgs: 5,
+    evaluate(args, context, evaluator) {
+      let baseCol;
+      let baseRow;
+      if (args[0].kind === "cellRef") {
+        baseCol = args[0].address.col;
+        baseRow = args[0].address.row;
+      } else if (args[0].kind === "range") {
+        baseCol = args[0].start.col;
+        baseRow = args[0].start.row;
+      } else {
+        return new FormulaError("#VALUE!", "OFFSET: first argument must be a cell reference");
+      }
+      const rawRows = evaluator.evaluate(args[1], context);
+      if (rawRows instanceof FormulaError) return rawRows;
+      const rowOffset = toNumber(rawRows);
+      if (rowOffset instanceof FormulaError) return rowOffset;
+      const rawCols = evaluator.evaluate(args[2], context);
+      if (rawCols instanceof FormulaError) return rawCols;
+      const colOffset = toNumber(rawCols);
+      if (colOffset instanceof FormulaError) return colOffset;
+      const targetRow = baseRow + Math.trunc(rowOffset);
+      const targetCol = baseCol + Math.trunc(colOffset);
+      if (targetRow < 0 || targetCol < 0) {
+        return new FormulaError("#REF!", "OFFSET: reference out of bounds");
+      }
+      let height = 1;
+      if (args.length >= 4) {
+        const rawH = evaluator.evaluate(args[3], context);
+        if (rawH instanceof FormulaError) return rawH;
+        const h = toNumber(rawH);
+        if (h instanceof FormulaError) return h;
+        height = Math.trunc(h);
+      }
+      let width = 1;
+      if (args.length >= 5) {
+        const rawW = evaluator.evaluate(args[4], context);
+        if (rawW instanceof FormulaError) return rawW;
+        const w = toNumber(rawW);
+        if (w instanceof FormulaError) return w;
+        width = Math.trunc(w);
+      }
+      if (height <= 0 || width <= 0) {
+        return new FormulaError("#VALUE!", "OFFSET: height and width must be >= 1");
+      }
+      if (height === 1 && width === 1) {
+        return context.getCellValue({ col: targetCol, row: targetRow, absCol: false, absRow: false });
+      }
+      return context.getCellValue({ col: targetCol, row: targetRow, absCol: false, absRow: false });
+    }
+  });
+  registry.set("ADDRESS", {
+    minArgs: 2,
+    maxArgs: 5,
+    evaluate(args, context, evaluator) {
+      const rawRow = evaluator.evaluate(args[0], context);
+      if (rawRow instanceof FormulaError) return rawRow;
+      const rowNum = toNumber(rawRow);
+      if (rowNum instanceof FormulaError) return rowNum;
+      const rawCol = evaluator.evaluate(args[1], context);
+      if (rawCol instanceof FormulaError) return rawCol;
+      const colNum = toNumber(rawCol);
+      if (colNum instanceof FormulaError) return colNum;
+      const row = Math.trunc(rowNum);
+      const col = Math.trunc(colNum);
+      if (row < 1 || col < 1) {
+        return new FormulaError("#VALUE!", "ADDRESS: row and column must be >= 1");
+      }
+      let absNum = 1;
+      if (args.length >= 3) {
+        const rawAbs = evaluator.evaluate(args[2], context);
+        if (rawAbs instanceof FormulaError) return rawAbs;
+        const a = toNumber(rawAbs);
+        if (a instanceof FormulaError) return a;
+        absNum = Math.trunc(a);
+      }
+      let sheetText = "";
+      if (args.length >= 5) {
+        const rawSheet = evaluator.evaluate(args[4], context);
+        if (rawSheet instanceof FormulaError) return rawSheet;
+        if (rawSheet !== null && rawSheet !== void 0 && rawSheet !== false) {
+          sheetText = String(rawSheet);
+        }
+      }
+      const colLetter = indexToColumnLetter(col - 1);
+      let address;
+      switch (absNum) {
+        case 1:
+          address = `$${colLetter}$${row}`;
+          break;
+        // $A$1
+        case 2:
+          address = `${colLetter}$${row}`;
+          break;
+        // A$1
+        case 3:
+          address = `$${colLetter}${row}`;
+          break;
+        // $A1
+        case 4:
+          address = `${colLetter}${row}`;
+          break;
+        // A1
+        default:
+          address = `$${colLetter}$${row}`;
+      }
+      if (sheetText) {
+        const quoted = sheetText.includes(" ") ? `'${sheetText}'` : sheetText;
+        return `${quoted}!${address}`;
+      }
+      return address;
+    }
+  });
+  registry.set("ROW", {
+    minArgs: 0,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      if (args.length === 0) {
+        return 1;
+      }
+      const arg = args[0];
+      if (arg.kind === "cellRef") {
+        return arg.address.row + 1;
+      }
+      if (arg.kind === "range") {
+        return arg.start.row + 1;
+      }
+      const rawRef = evaluator.evaluate(arg, context);
+      if (rawRef instanceof FormulaError) return rawRef;
+      const refText = String(rawRef ?? "");
+      const addr = parseCellRef(refText);
+      if (!addr) {
+        const rng = parseRange(refText);
+        if (rng) return rng.start.row + 1;
+        return new FormulaError("#VALUE!", "ROW: invalid reference");
+      }
+      return addr.row + 1;
+    }
+  });
+  registry.set("COLUMN", {
+    minArgs: 0,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      if (args.length === 0) {
+        return 1;
+      }
+      const arg = args[0];
+      if (arg.kind === "cellRef") {
+        return arg.address.col + 1;
+      }
+      if (arg.kind === "range") {
+        return arg.start.col + 1;
+      }
+      const rawRef = evaluator.evaluate(arg, context);
+      if (rawRef instanceof FormulaError) return rawRef;
+      const refText = String(rawRef ?? "");
+      const addr = parseCellRef(refText);
+      if (!addr) {
+        const rng = parseRange(refText);
+        if (rng) return rng.start.col + 1;
+        return new FormulaError("#VALUE!", "COLUMN: invalid reference");
+      }
+      return addr.col + 1;
+    }
+  });
+  registry.set("ROWS", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, _context, _evaluator) {
+      const arg = args[0];
+      if (arg.kind === "range") {
+        return Math.abs(arg.end.row - arg.start.row) + 1;
+      }
+      if (arg.kind === "cellRef") {
+        return 1;
+      }
+      return new FormulaError("#VALUE!", "ROWS: argument must be a range reference");
+    }
+  });
+  registry.set("COLUMNS", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, _context, _evaluator) {
+      const arg = args[0];
+      if (arg.kind === "range") {
+        return Math.abs(arg.end.col - arg.start.col) + 1;
+      }
+      if (arg.kind === "cellRef") {
+        return 1;
+      }
+      return new FormulaError("#VALUE!", "COLUMNS: argument must be a range reference");
+    }
+  });
+  registry.set("SEQUENCE", {
+    minArgs: 1,
+    maxArgs: 4,
+    evaluate(args, context, evaluator) {
+      const rawRows = evaluator.evaluate(args[0], context);
+      if (rawRows instanceof FormulaError) return rawRows;
+      const rows = toNumber(rawRows);
+      if (rows instanceof FormulaError) return rows;
+      let cols = 1;
+      if (args.length >= 2) {
+        const rawCols = evaluator.evaluate(args[1], context);
+        if (rawCols instanceof FormulaError) return rawCols;
+        const c = toNumber(rawCols);
+        if (c instanceof FormulaError) return c;
+        cols = Math.trunc(c);
+      }
+      let start = 1;
+      if (args.length >= 3) {
+        const rawStart = evaluator.evaluate(args[2], context);
+        if (rawStart instanceof FormulaError) return rawStart;
+        const s = toNumber(rawStart);
+        if (s instanceof FormulaError) return s;
+        start = s;
+      }
+      let step = 1;
+      if (args.length >= 4) {
+        const rawStep = evaluator.evaluate(args[3], context);
+        if (rawStep instanceof FormulaError) return rawStep;
+        const st = toNumber(rawStep);
+        if (st instanceof FormulaError) return st;
+        step = st;
+      }
+      const rowCount = Math.trunc(rows);
+      const colCount = Math.max(1, cols);
+      if (rowCount < 1) {
+        return new FormulaError("#VALUE!", "SEQUENCE: rows must be >= 1");
+      }
+      const result = [];
+      let current = start;
+      for (let r = 0; r < rowCount; r++) {
+        const row = [];
+        for (let c = 0; c < colCount; c++) {
+          row.push(current);
+          current += step;
+        }
+        result.push(row);
+      }
+      if (rowCount === 1 && colCount === 1) {
+        return result[0][0];
+      }
+      return result[0][0];
+    }
+  });
+  registry.set("TRANSPOSE", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, _evaluator) {
+      if (args[0].kind !== "range") {
+        return new FormulaError("#VALUE!", "TRANSPOSE: argument must be a range");
+      }
+      const data = context.getRangeValues({ start: args[0].start, end: args[0].end });
+      if (data.length === 0) return null;
+      const rows = data.length;
+      const cols = data[0].length;
+      const transposed = [];
+      for (let c = 0; c < cols; c++) {
+        const newRow = [];
+        for (let r = 0; r < rows; r++) {
+          newRow.push(data[r][c]);
+        }
+        transposed.push(newRow);
+      }
+      return transposed[0][0] ?? null;
+    }
+  });
+  registry.set("MMULT", {
+    minArgs: 2,
+    maxArgs: 2,
+    evaluate(args, context, _evaluator) {
+      if (args[0].kind !== "range") {
+        return new FormulaError("#VALUE!", "MMULT: array1 must be a range");
+      }
+      if (args[1].kind !== "range") {
+        return new FormulaError("#VALUE!", "MMULT: array2 must be a range");
+      }
+      const a = context.getRangeValues({ start: args[0].start, end: args[0].end });
+      const b = context.getRangeValues({ start: args[1].start, end: args[1].end });
+      if (a.length === 0 || b.length === 0) {
+        return new FormulaError("#VALUE!", "MMULT: empty array");
+      }
+      const aRows = a.length;
+      const aCols = a[0].length;
+      const bRows = b.length;
+      const bCols = b[0].length;
+      if (aCols !== bRows) {
+        return new FormulaError("#VALUE!", `MMULT: columns of array1 (${aCols}) must equal rows of array2 (${bRows})`);
+      }
+      const result = [];
+      for (let r = 0; r < aRows; r++) {
+        const row = [];
+        for (let c = 0; c < bCols; c++) {
+          let sum = 0;
+          for (let k = 0; k < aCols; k++) {
+            const av = toNumber(a[r][k]);
+            const bv = toNumber(b[k][c]);
+            if (av instanceof FormulaError) return av;
+            if (bv instanceof FormulaError) return bv;
+            sum += av * bv;
+          }
+          row.push(sum);
+        }
+        result.push(row);
+      }
+      return result[0][0];
+    }
+  });
+  registry.set("MDETERM", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, _evaluator) {
+      if (args[0].kind !== "range") {
+        return new FormulaError("#VALUE!", "MDETERM: argument must be a range");
+      }
+      const data = context.getRangeValues({ start: args[0].start, end: args[0].end });
+      if (data.length === 0) return new FormulaError("#VALUE!", "MDETERM: empty array");
+      const n = data.length;
+      if (data.some((row) => row.length !== n)) {
+        return new FormulaError("#VALUE!", "MDETERM: array must be square");
+      }
+      const matrix = [];
+      for (let r = 0; r < n; r++) {
+        const row = [];
+        for (let c = 0; c < n; c++) {
+          const v = toNumber(data[r][c]);
+          if (v instanceof FormulaError) return v;
+          row.push(v);
+        }
+        matrix.push(row);
+      }
+      return determinant(matrix);
+    }
+  });
+  registry.set("MINVERSE", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, _evaluator) {
+      if (args[0].kind !== "range") {
+        return new FormulaError("#VALUE!", "MINVERSE: argument must be a range");
+      }
+      const data = context.getRangeValues({ start: args[0].start, end: args[0].end });
+      if (data.length === 0) return new FormulaError("#VALUE!", "MINVERSE: empty array");
+      const n = data.length;
+      if (data.some((row) => row.length !== n)) {
+        return new FormulaError("#VALUE!", "MINVERSE: array must be square");
+      }
+      const matrix = [];
+      for (let r = 0; r < n; r++) {
+        const row = [];
+        for (let c = 0; c < n; c++) {
+          const v = toNumber(data[r][c]);
+          if (v instanceof FormulaError) return v;
+          row.push(v);
+        }
+        matrix.push(row);
+      }
+      const inv = matrixInverse(matrix, n);
+      if (inv instanceof FormulaError) return inv;
+      return inv[0][0];
+    }
+  });
+}
+function determinant(m) {
+  const n = m.length;
+  if (n === 1) return m[0][0];
+  if (n === 2) return m[0][0] * m[1][1] - m[0][1] * m[1][0];
+  let det = 0;
+  for (let c = 0; c < n; c++) {
+    const minor = [];
+    for (let r = 1; r < n; r++) {
+      const row = [];
+      for (let cc = 0; cc < n; cc++) {
+        if (cc !== c) row.push(m[r][cc]);
+      }
+      minor.push(row);
+    }
+    det += (c % 2 === 0 ? 1 : -1) * m[0][c] * determinant(minor);
+  }
+  return det;
+}
+function matrixInverse(m, n) {
+  const aug = [];
+  for (let r = 0; r < n; r++) {
+    const row = [...m[r]];
+    for (let c = 0; c < n; c++) {
+      row.push(c === r ? 1 : 0);
+    }
+    aug.push(row);
+  }
+  for (let col = 0; col < n; col++) {
+    let pivotRow = -1;
+    let pivotVal = 0;
+    for (let r = col; r < n; r++) {
+      if (Math.abs(aug[r][col]) > Math.abs(pivotVal)) {
+        pivotVal = aug[r][col];
+        pivotRow = r;
+      }
+    }
+    if (pivotRow === -1 || Math.abs(pivotVal) < 1e-12) {
+      return new FormulaError("#NUM!", "MINVERSE: matrix is singular");
+    }
+    if (pivotRow !== col) {
+      [aug[col], aug[pivotRow]] = [aug[pivotRow], aug[col]];
+    }
+    const scale = aug[col][col];
+    for (let c = 0; c < 2 * n; c++) {
+      aug[col][c] /= scale;
+    }
+    for (let r = 0; r < n; r++) {
+      if (r !== col) {
+        const factor = aug[r][col];
+        for (let c = 0; c < 2 * n; c++) {
+          aug[r][c] -= factor * aug[col][c];
+        }
+      }
+    }
+  }
+  const result = [];
+  for (let r = 0; r < n; r++) {
+    result.push(aug[r].slice(n));
+  }
+  return result;
+}
+
+// src/formula/functions/index.ts
+function createBuiltInFunctions() {
+  const registry = /* @__PURE__ */ new Map();
+  registerMathFunctions(registry);
+  registerLogicalFunctions(registry);
+  registerLookupFunctions(registry);
   registerTextFunctions(registry);
   registerDateFunctions(registry);
   registerStatsFunctions(registry);
   registerInfoFunctions(registry);
+  registerFinancialFunctions(registry);
+  registerStatisticalExtendedFunctions(registry);
+  registerReferenceFunctions(registry);
   return registry;
 }
 
@@ -5272,8 +7084,7 @@ var FormulaEngine = class {
     return {
       getCellValue: (addr) => {
         const key = toCellKey(addr.col, addr.row, addr.sheet);
-        const cached = this.values.get(key);
-        if (cached !== void 0) return cached;
+        if (this.values.has(key)) return this.values.get(key);
         if (addr.sheet) {
           const sheetAccessor = this.sheetAccessors.get(addr.sheet);
           if (!sheetAccessor) return new FormulaError("#REF!", `Unknown sheet: ${addr.sheet}`);
@@ -5296,18 +7107,21 @@ var FormulaEngine = class {
           const row = [];
           for (let c = minCol; c <= maxCol; c++) {
             const key = toCellKey(c, r, sheet);
-            const cached = this.values.get(key);
-            if (cached !== void 0) {
-              row.push(cached);
+            if (this.values.has(key)) {
+              row.push(this.values.get(key));
             } else {
-              row.push(rangeAccessor.getCellValue(c, r));
+              row.push(rangeAccessor?.getCellValue(c, r));
             }
           }
           result.push(row);
         }
         return result;
       },
-      now: () => contextNow
+      now: () => contextNow,
+      getCellFormula: (addr) => {
+        const key = toCellKey(addr.col, addr.row, addr.sheet);
+        return this.formulas.get(key);
+      }
     };
   }
   recalcCells(order, accessor, updatedCells) {
@@ -5333,4 +7147,4 @@ var FormulaEngine = class {
   }
 };
 
-export { AUTOSIZE_EXTRA_PX, AUTOSIZE_MAX_PX, CELL_PADDING, CHECKBOX_COLUMN_WIDTH, CIRC_ERROR, COLUMN_HEADER_MENU_ITEMS, CellDescriptorCache, DEFAULT_DEBOUNCE_MS, DEFAULT_MIN_COLUMN_WIDTH, DIV_ZERO_ERROR, DependencyGraph, FormulaEngine, FormulaError, FormulaEvaluator, GENERAL_ERROR, GRID_BORDER_RADIUS, GRID_CONTEXT_MENU_ITEMS, MAX_PAGE_BUTTONS, NAME_ERROR, NA_ERROR, PAGE_SIZE_OPTIONS, PEOPLE_SEARCH_DEBOUNCE_MS, REF_ERROR, ROW_NUMBER_COLUMN_WIDTH, SIDEBAR_TRANSITION_MS, UndoRedoStack, VALUE_ERROR, Z_INDEX, adjustFormulaReferences, applyCellDeletion, applyCutClear, applyFillValues, applyPastedValues, applyRangeRowSelection, areGridRowPropsEqual, booleanParser, buildCellIndex, buildCsvHeader, buildCsvRows, buildHeaderRows, buildInlineEditorProps, buildPopoverEditorProps, calculateDropTarget, clampSelectionToBounds, columnLetterToIndex, computeAggregations, computeArrowNavigation, computeAutoScrollSpeed, computeNextSortState, computeRowSelectionState, computeTabNavigation, computeTotalHeight, computeVisibleColumnRange, computeVisibleRange, createBuiltInFunctions, createSortFilterWorker, currencyParser, dateParser, debounce, deriveFilterOptionsFromData, emailParser, escapeCsvValue, exportToCsv, extractValueMatrix, findCtrlArrowTarget, flattenArgs, flattenColumns, formatAddress, formatCellReference, formatCellValueForTsv, formatSelectionAsTsv, formatShortcut, toString as formulaToString, fromCellKey, getCellRenderDescriptor, getCellValue, getColumnHeaderMenuItems, getContextMenuHandlers, getDataGridStatusBarConfig, getFilterField, getHeaderFilterConfig, getMultiSelectFilterFields, getPaginationViewModel, getPinStateForColumn, getScrollTopForRow, getStatusBarParts, indexToColumnLetter, injectGlobalStyles, isColumnEditable, isFilterConfig, isFormulaError, isInSelectionRange, isRowInRange, measureColumnContentWidth, measureRange, mergeFilter, normalizeSelectionRange, numberParser, parse, parseCellRef, parseRange, parseTsvClipboard, parseValue, partitionColumnsForVirtualization, processClientSideData, processClientSideDataAsync, rangesEqual, reorderColumnArray, resolveCellDisplayContent, resolveCellStyle, terminateSortFilterWorker, toBoolean, toCellKey, toNumber, toUserLike, tokenize, triggerCsvDownload, validateColumns, validateRowIds, validateVirtualScrollConfig };
+export { AUTOSIZE_EXTRA_PX, AUTOSIZE_MAX_PX, CELL_PADDING, CHECKBOX_COLUMN_WIDTH, CIRC_ERROR, COLUMN_HEADER_MENU_ITEMS, CellDescriptorCache, DEFAULT_DEBOUNCE_MS, DEFAULT_MIN_COLUMN_WIDTH, DIV_ZERO_ERROR, DependencyGraph, FORMULA_BAR_CSS, FORMULA_BAR_STYLES, FORMULA_REF_COLORS, FormulaEngine, FormulaError, FormulaEvaluator, GENERAL_ERROR, GRID_BORDER_RADIUS, GRID_CONTEXT_MENU_ITEMS, MAX_PAGE_BUTTONS, NAME_ERROR, NA_ERROR, PAGE_SIZE_OPTIONS, PEOPLE_SEARCH_DEBOUNCE_MS, REF_ERROR, ROW_NUMBER_COLUMN_ID, ROW_NUMBER_COLUMN_MIN_WIDTH, ROW_NUMBER_COLUMN_WIDTH, SIDEBAR_TRANSITION_MS, UndoRedoStack, VALUE_ERROR, Z_INDEX, adjustFormulaReferences, applyCellDeletion, applyCutClear, applyFillValues, applyPastedValues, applyRangeRowSelection, areGridRowPropsEqual, booleanParser, buildCellIndex, buildCsvHeader, buildCsvRows, buildHeaderRows, buildInlineEditorProps, buildPopoverEditorProps, calculateDropTarget, clampSelectionToBounds, columnLetterToIndex, computeAggregations, computeArrowNavigation, computeAutoScrollSpeed, computeNextSortState, computeRowSelectionState, computeTabNavigation, computeTotalHeight, computeVisibleColumnRange, computeVisibleRange, createBuiltInFunctions, createGridDataAccessor, createSortFilterWorker, currencyParser, dateParser, debounce, deriveFilterOptionsFromData, deriveFormulaBarText, emailParser, escapeCsvValue, exportToCsv, extractFormulaReferences, extractValueMatrix, findCtrlArrowTarget, flattenArgs, flattenColumns, formatAddress, formatCellReference, formatCellValueForTsv, formatSelectionAsTsv, formatShortcut, toString as formulaToString, fromCellKey, getCellRenderDescriptor, getCellValue, getColumnHeaderMenuItems, getContextMenuHandlers, getDataGridStatusBarConfig, getFilterField, getHeaderFilterConfig, getMultiSelectFilterFields, getPaginationViewModel, getPinStateForColumn, getScrollTopForRow, getStatusBarParts, handleFormulaBarKeyDown, indexToColumnLetter, injectGlobalStyles, isColumnEditable, isFilterConfig, isFormulaError, isInSelectionRange, isRowInRange, measureColumnContentWidth, measureRange, mergeFilter, normalizeSelectionRange, numberParser, parse, parseCellRef, parseRange, parseTsvClipboard, parseValue, partitionColumnsForVirtualization, processClientSideData, processClientSideDataAsync, processFormulaBarCommit, rangesEqual, reorderColumnArray, resolveCellDisplayContent, resolveCellStyle, terminateSortFilterWorker, toBoolean, toCellKey, toNumber, toUserLike, tokenize, triggerCsvDownload, validateColumns, validateRowIds, validateVirtualScrollConfig };