@alaarab/ogrid-react 2.3.0 → 2.4.1

package/dist/esm/index.js

@@ -1,7 +1,7 @@
 import * as React5 from 'react';
-import { useRef, useState, useCallback, useEffect, useMemo, useImperativeHandle, useLayoutEffect, forwardRef } from 'react';
-import { createPortal, flushSync } from 'react-dom';
+import { memo as memo$1, useState, useRef, useCallback, useEffect, useMemo, useImperativeHandle, useLayoutEffect, forwardRef } from 'react';
 import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import { createPortal, flushSync } from 'react-dom';
 
 // ../core/dist/esm/index.js
 function toUserLike(u) {
@@ -86,6 +86,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
+  };
+}
 function isColumnGroupDef(c) {
   return "children" in c && Array.isArray(c.children);
 }
@@ -1086,7 +1097,7 @@ var _CellDescriptorCache = class _CellDescriptorCache2 {
     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.
@@ -1157,6 +1168,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) {
@@ -1188,7 +1200,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) {
@@ -1203,7 +1216,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";
@@ -1302,6 +1315,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;
 var AUTOSIZE_EXTRA_PX = 16;
 var AUTOSIZE_MAX_PX = 520;
@@ -1944,8 +1959,6 @@ function validateRowIds(items, getRowId) {
     ids.add(id);
   }
 }
-var DEFAULT_DEBOUNCE_MS = 300;
-var PEOPLE_SEARCH_DEBOUNCE_MS = DEFAULT_DEBOUNCE_MS;
 var CELL_REF_PATTERN = /^\$?[A-Za-z]+\$?\d+$/;
 var SINGLE_CHAR_OPERATORS = {
   "+": "PLUS",
@@ -2067,6 +2080,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++;
@@ -2094,6 +2113,133 @@ function tokenize(input) {
   tokens.push({ type: "EOF", value: "", position: pos });
   return tokens;
 }
+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;
+}
+var DEFAULT_DEBOUNCE_MS = 300;
+var PEOPLE_SEARCH_DEBOUNCE_MS = DEFAULT_DEBOUNCE_MS;
+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_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
+  }
+};
 function parse(tokens, namedRanges) {
   let pos = 0;
   function peek() {
@@ -2728,7 +2874,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);
@@ -3038,7 +3184,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") {
@@ -3257,6 +3403,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;
 }
 function flattenArgs2(args, context, evaluator) {
   const result = [];
@@ -4091,6 +4393,152 @@ function registerTextFunctions(registry) {
       return parts.join(delimiter);
     }
   });
+  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);
+    }
+  });
 }
 function toDate(val) {
   if (val instanceof FormulaError) return val;
@@ -4338,70 +4786,375 @@ function registerDateFunctions(registry) {
       return count * sign;
     }
   });
-}
-function makeCriteria(op, value) {
-  return { op, value, valueLower: typeof value === "string" ? value.toLowerCase() : null };
-}
-function parseCriteria(criteria) {
-  if (typeof criteria === "number") {
-    return makeCriteria("=", criteria);
-  }
-  if (typeof criteria !== "string") {
-    return makeCriteria("=", criteria);
-  }
-  const str = criteria.trim();
-  if (str.startsWith(">=")) {
-    return makeCriteria(">=", parseNumericOrString(str.substring(2).trim()));
-  }
-  if (str.startsWith("<=")) {
-    return makeCriteria("<=", parseNumericOrString(str.substring(2).trim()));
-  }
-  if (str.startsWith("<>")) {
-    return makeCriteria("<>", parseNumericOrString(str.substring(2).trim()));
-  }
-  if (str.startsWith(">")) {
-    return makeCriteria(">", parseNumericOrString(str.substring(1).trim()));
-  }
-  if (str.startsWith("<")) {
-    return makeCriteria("<", parseNumericOrString(str.substring(1).trim()));
-  }
-  if (str.startsWith("=")) {
-    return makeCriteria("=", parseNumericOrString(str.substring(1).trim()));
-  }
-  return makeCriteria("=", parseNumericOrString(str));
-}
-function parseNumericOrString(s) {
-  const n = Number(s);
-  if (!isNaN(n) && s !== "") return n;
-  return s;
-}
-function matchesCriteria(cellValue, criteria) {
-  const { op, value } = criteria;
-  let comparableCell = cellValue;
-  if (typeof value === "number" && typeof cellValue !== "number") {
-    const n = toNumber(cellValue);
-    if (n instanceof FormulaError) return false;
-    comparableCell = n;
-  }
-  if (typeof comparableCell === "string" && criteria.valueLower !== null) {
-    const a = comparableCell.toLowerCase();
-    const b = criteria.valueLower;
-    switch (op) {
-      case "=":
-        return a === b;
-      case "<>":
-        return a !== b;
-      case ">":
-        return a > b;
-      case "<":
-        return a < b;
-      case ">=":
-        return a >= b;
-      case "<=":
-        return a <= b;
+  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);
     }
-  }
-  if (typeof comparableCell === "number" && typeof value === "number") {
+  });
+  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;
+}
+function makeCriteria(op, value) {
+  return { op, value, valueLower: typeof value === "string" ? value.toLowerCase() : null };
+}
+function parseCriteria(criteria) {
+  if (typeof criteria === "number") {
+    return makeCriteria("=", criteria);
+  }
+  if (typeof criteria !== "string") {
+    return makeCriteria("=", criteria);
+  }
+  const str = criteria.trim();
+  if (str.startsWith(">=")) {
+    return makeCriteria(">=", parseNumericOrString(str.substring(2).trim()));
+  }
+  if (str.startsWith("<=")) {
+    return makeCriteria("<=", parseNumericOrString(str.substring(2).trim()));
+  }
+  if (str.startsWith("<>")) {
+    return makeCriteria("<>", parseNumericOrString(str.substring(2).trim()));
+  }
+  if (str.startsWith(">")) {
+    return makeCriteria(">", parseNumericOrString(str.substring(1).trim()));
+  }
+  if (str.startsWith("<")) {
+    return makeCriteria("<", parseNumericOrString(str.substring(1).trim()));
+  }
+  if (str.startsWith("=")) {
+    return makeCriteria("=", parseNumericOrString(str.substring(1).trim()));
+  }
+  return makeCriteria("=", parseNumericOrString(str));
+}
+function parseNumericOrString(s) {
+  const n = Number(s);
+  if (!isNaN(n) && s !== "") return n;
+  return s;
+}
+function matchesCriteria(cellValue, criteria) {
+  const { op, value } = criteria;
+  let comparableCell = cellValue;
+  if (typeof value === "number" && typeof cellValue !== "number") {
+    const n = toNumber(cellValue);
+    if (n instanceof FormulaError) return false;
+    comparableCell = n;
+  }
+  if (typeof comparableCell === "string" && criteria.valueLower !== null) {
+    const a = comparableCell.toLowerCase();
+    const b = criteria.valueLower;
+    switch (op) {
+      case "=":
+        return a === b;
+      case "<>":
+        return a !== b;
+      case ">":
+        return a > b;
+      case "<":
+        return a < b;
+      case ">=":
+        return a >= b;
+      case "<=":
+        return a <= b;
+    }
+  }
+  if (typeof comparableCell === "number" && typeof value === "number") {
     switch (op) {
       case "=":
         return comparableCell === value;
@@ -4652,52 +5405,1092 @@ function registerInfoFunctions(registry) {
       return val === null || val === void 0 || val === "";
     }
   });
-  registry.set("ISNUMBER", {
+  registry.set("ISNUMBER", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      return typeof val === "number" && !isNaN(val);
+    }
+  });
+  registry.set("ISTEXT", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      return typeof val === "string";
+    }
+  });
+  registry.set("ISERROR", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      return val instanceof FormulaError;
+    }
+  });
+  registry.set("ISNA", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      return val instanceof FormulaError && val.type === "#N/A";
+    }
+  });
+  registry.set("TYPE", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      if (val instanceof FormulaError) return 16;
+      if (typeof val === "number") return 1;
+      if (typeof val === "string") return 2;
+      if (typeof val === "boolean") return 4;
+      if (val === null || val === void 0) return 1;
+      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";
+    }
+  });
+}
+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;
+    }
+  });
+}
+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;
+    }
+  });
+}
+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 val = evaluator.evaluate(args[0], context);
-      return typeof val === "number" && !isNaN(val);
+    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("ISTEXT", {
+  registry.set("SEQUENCE", {
     minArgs: 1,
-    maxArgs: 1,
+    maxArgs: 4,
     evaluate(args, context, evaluator) {
-      const val = evaluator.evaluate(args[0], context);
-      return typeof val === "string";
+      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("ISERROR", {
+  registry.set("TRANSPOSE", {
     minArgs: 1,
     maxArgs: 1,
-    evaluate(args, context, evaluator) {
-      const val = evaluator.evaluate(args[0], context);
-      return val instanceof FormulaError;
+    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("ISNA", {
+  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) {
-      const val = evaluator.evaluate(args[0], context);
-      return val instanceof FormulaError && val.type === "#N/A";
+    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("TYPE", {
+  registry.set("MINVERSE", {
     minArgs: 1,
     maxArgs: 1,
-    evaluate(args, context, evaluator) {
-      const val = evaluator.evaluate(args[0], context);
-      if (val instanceof FormulaError) return 16;
-      if (typeof val === "number") return 1;
-      if (typeof val === "string") return 2;
-      if (typeof val === "boolean") return 4;
-      if (val === null || val === void 0) return 1;
-      return 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;
+}
 function createBuiltInFunctions() {
   const registry = /* @__PURE__ */ new Map();
   registerMathFunctions(registry);
@@ -4707,6 +6500,9 @@ function createBuiltInFunctions() {
   registerDateFunctions(registry);
   registerStatsFunctions(registry);
   registerInfoFunctions(registry);
+  registerFinancialFunctions(registry);
+  registerStatisticalExtendedFunctions(registry);
+  registerReferenceFunctions(registry);
   return registry;
 }
 function extractDependencies(node) {
@@ -5059,8 +6855,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}`);
@@ -5083,18 +6878,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) {
@@ -5256,19 +7054,10 @@ function useFormulaEngine(params) {
       }
     };
   }, [sheets]);
-  const createAccessor = useCallback(() => {
-    const currentItems = itemsRef.current;
-    const currentCols = flatColumnsRef.current;
-    return {
-      getCellValue: (col, row) => {
-        if (row < 0 || row >= currentItems.length) return null;
-        if (col < 0 || col >= currentCols.length) return null;
-        return getCellValue(currentItems[row], currentCols[col]);
-      },
-      getRowCount: () => currentItems.length,
-      getColumnCount: () => currentCols.length
-    };
-  }, [itemsRef, flatColumnsRef]);
+  const createAccessor = useCallback(
+    () => createGridDataAccessor(itemsRef.current, flatColumnsRef.current),
+    [itemsRef, flatColumnsRef]
+  );
   const initialLoadedRef = useRef(false);
   useEffect(() => {
     if (formulas && engineRef.current && initialFormulas && !initialLoadedRef.current) {
@@ -5314,20 +7103,192 @@ function useFormulaEngine(params) {
   const getAuditTrail = useCallback((col, row) => {
     return engineRef.current?.getAuditTrail(col, row) ?? null;
   }, []);
-  return useMemo(() => {
-    if (!formulas) return NOOP_RESULT;
-    return {
-      getFormulaValue,
-      hasFormula,
-      getFormula,
-      setFormula,
-      onCellChanged,
-      getPrecedents,
-      getDependents,
-      getAuditTrail,
-      enabled: true
-    };
-  }, [formulas, getFormulaValue, hasFormula, getFormula, setFormula, onCellChanged, getPrecedents, getDependents, getAuditTrail]);
+  if (!formulas) return NOOP_RESULT;
+  return {
+    getFormulaValue,
+    hasFormula,
+    getFormula,
+    setFormula,
+    onCellChanged,
+    getPrecedents,
+    getDependents,
+    getAuditTrail,
+    enabled: true
+  };
+}
+function useFormulaBar(params) {
+  const { activeCol, activeRow, activeCellRef, getFormula, getRawValue, setFormula, onCellValueChanged } = params;
+  const [isEditing, setIsEditing] = useState(false);
+  const [editText, setEditText] = useState("");
+  const isFormulaBarEditing = useRef(false);
+  const displayText = useMemo(
+    () => deriveFormulaBarText(activeCol, activeRow, getFormula, getRawValue),
+    [activeCol, activeRow, getFormula, getRawValue]
+  );
+  useEffect(() => {
+    setIsEditing(false);
+    isFormulaBarEditing.current = false;
+  }, [activeCol, activeRow]);
+  const startEditing = useCallback(() => {
+    setEditText(displayText);
+    setIsEditing(true);
+    isFormulaBarEditing.current = true;
+  }, [displayText]);
+  const onInputChange = useCallback((text) => {
+    setEditText(text);
+  }, []);
+  const onCommit = useCallback(() => {
+    if (activeCol == null || activeRow == null || !setFormula) return;
+    processFormulaBarCommit(editText, activeCol, activeRow, setFormula, onCellValueChanged);
+    setIsEditing(false);
+    isFormulaBarEditing.current = false;
+  }, [activeCol, activeRow, editText, setFormula, onCellValueChanged]);
+  const onCancel = useCallback(() => {
+    setIsEditing(false);
+    isFormulaBarEditing.current = false;
+    setEditText("");
+  }, []);
+  const currentText = isEditing ? editText : displayText;
+  const referencedCells = useMemo(
+    () => extractFormulaReferences(currentText),
+    [currentText]
+  );
+  return {
+    cellRef: activeCellRef,
+    formulaText: isEditing ? editText : displayText,
+    isEditing,
+    onInputChange,
+    onCommit,
+    onCancel,
+    startEditing,
+    referencedCells,
+    isFormulaBarEditing
+  };
+}
+function FormulaBar({
+  cellRef,
+  formulaText,
+  isEditing,
+  onInputChange,
+  onCommit,
+  onCancel,
+  startEditing
+}) {
+  const inputRef = useRef(null);
+  useEffect(() => {
+    if (isEditing && inputRef.current) {
+      inputRef.current.focus();
+    }
+  }, [isEditing]);
+  return /* @__PURE__ */ jsxs("div", { style: FORMULA_BAR_STYLES.bar, role: "toolbar", "aria-label": "Formula bar", children: [
+    /* @__PURE__ */ jsx("div", { style: FORMULA_BAR_STYLES.nameBox, "aria-label": "Active cell reference", children: cellRef ?? "\u2014" }),
+    /* @__PURE__ */ jsx("div", { style: FORMULA_BAR_STYLES.fxLabel, "aria-hidden": "true", children: "fx" }),
+    /* @__PURE__ */ jsx(
+      "input",
+      {
+        ref: inputRef,
+        type: "text",
+        style: FORMULA_BAR_STYLES.input,
+        value: formulaText,
+        readOnly: !isEditing,
+        onChange: (e) => onInputChange(e.target.value),
+        onKeyDown: (e) => handleFormulaBarKeyDown(e.key, () => e.preventDefault(), onCommit, onCancel),
+        onClick: () => {
+          if (!isEditing) startEditing();
+        },
+        onDoubleClick: () => {
+          if (!isEditing) startEditing();
+        },
+        "aria-label": "Formula input",
+        spellCheck: false,
+        autoComplete: "off"
+      }
+    )
+  ] });
+}
+var barStyle = {
+  display: "flex",
+  alignItems: "center",
+  borderTop: "1px solid var(--ogrid-border, #e0e0e0)",
+  background: "var(--ogrid-header-bg, #f5f5f5)",
+  minHeight: 30,
+  overflowX: "auto",
+  overflowY: "hidden",
+  gap: 0,
+  fontSize: 12
+};
+var addBtnStyle = {
+  background: "none",
+  border: "none",
+  cursor: "pointer",
+  padding: "4px 10px",
+  fontSize: 16,
+  lineHeight: "22px",
+  color: "var(--ogrid-fg-secondary, #666)",
+  flexShrink: 0
+};
+var tabBaseStyle = {
+  background: "none",
+  border: "none",
+  borderBottom: "2px solid transparent",
+  cursor: "pointer",
+  padding: "4px 16px",
+  fontSize: 12,
+  lineHeight: "22px",
+  color: "var(--ogrid-fg, #242424)",
+  whiteSpace: "nowrap",
+  position: "relative"
+};
+var activeTabStyle = {
+  ...tabBaseStyle,
+  fontWeight: 600,
+  borderBottomColor: "var(--ogrid-primary, #217346)",
+  background: "var(--ogrid-bg, #fff)"
+};
+function SheetTabs({
+  sheets,
+  activeSheet,
+  onSheetChange,
+  onSheetAdd
+}) {
+  const handleTabClick = useCallback(
+    (e) => {
+      const id = e.currentTarget.dataset.sheetId;
+      if (id) onSheetChange(id);
+    },
+    [onSheetChange]
+  );
+  return /* @__PURE__ */ jsxs("div", { style: barStyle, role: "tablist", "aria-label": "Sheet tabs", children: [
+    onSheetAdd && /* @__PURE__ */ jsx(
+      "button",
+      {
+        type: "button",
+        style: addBtnStyle,
+        onClick: onSheetAdd,
+        title: "Add sheet",
+        "aria-label": "Add sheet",
+        children: "+"
+      }
+    ),
+    sheets.map((sheet) => {
+      const isActive = sheet.id === activeSheet;
+      const base = isActive ? activeTabStyle : tabBaseStyle;
+      const style = sheet.color ? { ...base, borderBottomColor: sheet.color } : base;
+      return /* @__PURE__ */ jsx(
+        "button",
+        {
+          type: "button",
+          role: "tab",
+          "aria-selected": isActive,
+          style,
+          "data-sheet-id": sheet.id,
+          onClick: handleTabClick,
+          children: sheet.name
+        },
+        sheet.id
+      );
+    })
+  ] });
 }
 function useOGridPagination(params) {
   const { controlledPage, controlledPageSize, defaultPageSize, onPageChange, onPageSizeChange } = params;
@@ -5658,6 +7619,10 @@ function useOGrid(props, ref) {
     formulaFunctions,
     namedRanges,
     sheets,
+    sheetDefs,
+    activeSheet,
+    onSheetChange,
+    onSheetAdd,
     "aria-label": ariaLabel,
     "aria-labelledby": ariaLabelledBy
   } = props;
@@ -5964,22 +7929,56 @@ function useOGrid(props, ref) {
     filtersState.handleFilterChange,
     filtersState.clientFilterOptions
   ]);
+  const [formulaVersion, setFormulaVersion] = useState(0);
+  const wrappedOnFormulaRecalc = useCallback((result) => {
+    setFormulaVersion((v) => v + 1);
+    onFormulaRecalc?.(result);
+  }, [onFormulaRecalc]);
   const formulaEngine = useFormulaEngine({
     formulas,
     items: dataFetchingState.displayItems,
     flatColumns: columns,
     initialFormulas,
-    onFormulaRecalc,
+    onFormulaRecalc: wrappedOnFormulaRecalc,
     formulaFunctions,
     namedRanges,
     sheets
   });
   const clearAllFilters = useCallback(() => filtersState.setFilters({}), [filtersState]);
   const isLoadingResolved = isServerSide && dataFetchingState.serverLoading || displayLoading;
+  const showRowNumbersResolved = showRowNumbers || cellReferences || formulas;
+  const showColumnLettersResolved = !!(cellReferences || formulas);
+  const showNameBox = !!cellReferences && !formulas;
+  const showActiveCellChange = !!(cellReferences || formulas);
   const [activeCellRef, setActiveCellRef] = useState(null);
+  const [activeCellCoords, setActiveCellCoords] = useState(null);
   const onActiveCellChange = useCallback((ref2) => {
     setActiveCellRef(ref2);
+    if (ref2) {
+      const m = ref2.match(/^([A-Z]+)(\d+)$/);
+      if (m) {
+        setActiveCellCoords({ col: columnLetterToIndex(m[1]), row: parseInt(m[2], 10) - 1 });
+      } else {
+        setActiveCellCoords(null);
+      }
+    } else {
+      setActiveCellCoords(null);
+    }
   }, []);
+  const getRawValue = useCallback((col, row) => {
+    const items = displayItemsRef.current;
+    const cols = columnsRef.current;
+    if (row < 0 || row >= items.length || col < 0 || col >= cols.length) return void 0;
+    return getCellValue(items[row], cols[col]);
+  }, [displayItemsRef, columnsRef]);
+  const formulaBarState = useFormulaBar({
+    activeCol: activeCellCoords?.col ?? null,
+    activeRow: activeCellCoords?.row ?? null,
+    activeCellRef,
+    getFormula: formulaEngine.enabled ? formulaEngine.getFormula : void 0,
+    getRawValue,
+    setFormula: formulaEngine.enabled ? formulaEngine.setFormula : void 0
+  });
   const dataGridProps = useMemo(() => ({
     items: dataFetchingState.displayItems,
     columns: columnsProp,
@@ -6004,10 +8003,10 @@ function useOGrid(props, ref) {
     rowSelection,
     selectedRows: effectiveSelectedRows,
     onSelectionChange: handleSelectionChange,
-    showRowNumbers: showRowNumbers || cellReferences,
-    showColumnLetters: !!cellReferences,
-    showNameBox: !!cellReferences,
-    onActiveCellChange: cellReferences ? onActiveCellChange : void 0,
+    showRowNumbers: showRowNumbersResolved,
+    showColumnLetters: showColumnLettersResolved,
+    showNameBox,
+    onActiveCellChange: showActiveCellChange ? onActiveCellChange : void 0,
     currentPage: paginationState.page,
     pageSize: paginationState.pageSize,
     statusBar: statusBarConfig,
@@ -6041,7 +8040,9 @@ function useOGrid(props, ref) {
     onFormulaCellChanged: formulaEngine.enabled ? formulaEngine.onCellChanged : void 0,
     getPrecedents: formulaEngine.enabled ? formulaEngine.getPrecedents : void 0,
     getDependents: formulaEngine.enabled ? formulaEngine.getDependents : void 0,
-    getAuditTrail: formulaEngine.enabled ? formulaEngine.getAuditTrail : void 0
+    getAuditTrail: formulaEngine.enabled ? formulaEngine.getAuditTrail : void 0,
+    formulaVersion,
+    formulaReferences: formulaBarState.referencedCells.length > 0 ? formulaBarState.referencedCells : void 0
   }), [
     dataFetchingState.displayItems,
     columnsProp,
@@ -6066,8 +8067,10 @@ function useOGrid(props, ref) {
     rowSelection,
     effectiveSelectedRows,
     handleSelectionChange,
-    showRowNumbers,
-    cellReferences,
+    showRowNumbersResolved,
+    showColumnLettersResolved,
+    showNameBox,
+    showActiveCellChange,
     onActiveCellChange,
     paginationState.page,
     paginationState.pageSize,
@@ -6091,7 +8094,9 @@ function useOGrid(props, ref) {
     clearAllFilters,
     emptyState,
     formulas,
-    formulaEngine
+    formulaEngine,
+    formulaVersion,
+    formulaBarState.referencedCells
   ]);
   const pagination = useMemo(() => ({
     page: paginationState.page,
@@ -6109,20 +8114,42 @@ function useOGrid(props, ref) {
     onSetVisibleColumns: setVisibleColumns,
     placement: columnChooserPlacement
   }), [columnChooserColumns, visibleColumns, handleVisibilityChange, setVisibleColumns, columnChooserPlacement]);
-  const showNameBox = !!cellReferences;
   const nameBoxEl = useMemo(() => showNameBox ? React5.createElement("div", {
     style: NAME_BOX_STYLE,
     "aria-label": "Active cell reference"
   }, activeCellRef ?? "\u2014") : null, [showNameBox, activeCellRef]);
   const resolvedToolbar = useMemo(() => showNameBox ? React5.createElement(React5.Fragment, null, nameBoxEl, toolbar) : toolbar, [showNameBox, nameBoxEl, toolbar]);
+  const formulaBarEl = useMemo(() => {
+    if (!formulas) return void 0;
+    return React5.createElement(FormulaBar, {
+      cellRef: formulaBarState.cellRef,
+      formulaText: formulaBarState.formulaText,
+      isEditing: formulaBarState.isEditing,
+      onInputChange: formulaBarState.onInputChange,
+      onCommit: formulaBarState.onCommit,
+      onCancel: formulaBarState.onCancel,
+      startEditing: formulaBarState.startEditing
+    });
+  }, [formulas, formulaBarState.cellRef, formulaBarState.formulaText, formulaBarState.isEditing, formulaBarState.onInputChange, formulaBarState.onCommit, formulaBarState.onCancel, formulaBarState.startEditing]);
+  const sheetTabsEl = useMemo(() => {
+    if (!sheetDefs || sheetDefs.length === 0 || !activeSheet || !onSheetChange) return void 0;
+    return React5.createElement(SheetTabs, {
+      sheets: sheetDefs,
+      activeSheet,
+      onSheetChange,
+      onSheetAdd
+    });
+  }, [sheetDefs, activeSheet, onSheetChange, onSheetAdd]);
   const layout = useMemo(() => ({
     toolbar: resolvedToolbar,
     toolbarBelow,
     className,
     emptyState,
     sideBarProps,
-    fullScreen
-  }), [resolvedToolbar, toolbarBelow, className, emptyState, sideBarProps, fullScreen]);
+    fullScreen,
+    formulaBar: formulaBarEl,
+    sheetTabs: sheetTabsEl
+  }), [resolvedToolbar, toolbarBelow, className, emptyState, sideBarProps, fullScreen, formulaBarEl, sheetTabsEl]);
   const filtersResult = useMemo(() => ({
     hasActiveFilters: filtersState.hasActiveFilters,
     setFilters: filtersState.setFilters
@@ -6779,6 +8806,7 @@ function useKeyboardNavigation(params) {
         case "ArrowUp":
         case "ArrowRight":
         case "ArrowLeft": {
+          if (editingCell != null) break;
           e.preventDefault();
           const { newRowIndex, newColumnIndex, newRange } = computeArrowNavigation({
             direction: e.key,
@@ -7109,6 +9137,9 @@ function useFillHandle(params) {
   const rafRef = useRef(0);
   const liveFillRangeRef = useRef(null);
   const colOffsetRef = useLatestRef(colOffset);
+  const itemsRef = useLatestRef(items);
+  const visibleColsRef = useLatestRef(visibleCols);
+  const formulaOptionsRef = useLatestRef(formulaOptions);
   useEffect(() => {
     if (!fillDrag || editable === false || !onCellValueChangedRef.current || !wrapperRef.current) return;
     fillDragEndRef.current = { endRow: fillDrag.startRow, endCol: fillDrag.startCol };
@@ -7207,7 +9238,7 @@ function useFillHandle(params) {
       });
       setSelectionRange(norm);
       setActiveCell({ rowIndex: fillDrag.startRow, columnIndex: fillDrag.startCol + colOffsetRef.current });
-      const fillEvents = applyFillValues(norm, fillDrag.startRow, fillDrag.startCol, items, visibleCols, formulaOptions);
+      const fillEvents = applyFillValues(norm, fillDrag.startRow, fillDrag.startCol, items, visibleCols, formulaOptionsRef.current);
       if (fillEvents.length > 0) {
         beginBatch?.();
         for (const evt of fillEvents) onCellValueChangedRef.current?.(evt);
@@ -7234,7 +9265,8 @@ function useFillHandle(params) {
     endBatch,
     colOffsetRef,
     wrapperRef,
-    onCellValueChangedRef
+    onCellValueChangedRef,
+    formulaOptionsRef
   ]);
   const selectionRangeRef = useRef(selectionRange);
   selectionRangeRef.current = selectionRange;
@@ -7251,8 +9283,6 @@ function useFillHandle(params) {
     },
     []
   );
-  const itemsRef = useLatestRef(items);
-  const visibleColsRef = useLatestRef(visibleCols);
   const fillDown = useCallback(() => {
     const range = selectionRangeRef.current;
     if (!range || editable === false || !onCellValueChangedRef.current) return;
@@ -7263,14 +9293,14 @@ function useFillHandle(params) {
       norm.startCol,
       itemsRef.current,
       visibleColsRef.current,
-      formulaOptions
+      formulaOptionsRef.current
     );
     if (fillEvents.length > 0) {
       beginBatch?.();
       for (const evt of fillEvents) onCellValueChangedRef.current(evt);
       endBatch?.();
     }
-  }, [editable, beginBatch, endBatch, onCellValueChangedRef, itemsRef, visibleColsRef]);
+  }, [editable, beginBatch, endBatch, onCellValueChangedRef, itemsRef, visibleColsRef, formulaOptionsRef]);
   return { fillDrag, setFillDrag, handleFillHandleMouseDown, fillDown };
 }
 function useTableLayout(params) {
@@ -7518,6 +9548,27 @@ function useColumnHeaderMenuState(params) {
     isResizable
   };
 }
+function getColumnHeaderMenuProps(headerMenu) {
+  return {
+    isOpen: headerMenu.isOpen,
+    anchorElement: headerMenu.anchorElement,
+    onClose: headerMenu.close,
+    onPinLeft: headerMenu.handlePinLeft,
+    onPinRight: headerMenu.handlePinRight,
+    onUnpin: headerMenu.handleUnpin,
+    onSortAsc: headerMenu.handleSortAsc,
+    onSortDesc: headerMenu.handleSortDesc,
+    onClearSort: headerMenu.handleClearSort,
+    onAutosizeThis: headerMenu.handleAutosizeThis,
+    onAutosizeAll: headerMenu.handleAutosizeAll,
+    canPinLeft: headerMenu.canPinLeft,
+    canPinRight: headerMenu.canPinRight,
+    canUnpin: headerMenu.canUnpin,
+    currentSort: headerMenu.currentSort,
+    isSortable: headerMenu.isSortable,
+    isResizable: headerMenu.isResizable
+  };
+}
 
 // src/hooks/useDataGridLayout.ts
 function useDataGridLayout(params) {
@@ -8176,7 +10227,10 @@ function useDataGridState(params) {
       getRowId,
       editable,
       onCellValueChanged,
-      isDragging: cellSelection ? isDragging : false
+      isDragging: cellSelection ? isDragging : false,
+      getFormulaValue: props.getFormulaValue,
+      hasFormula: props.hasFormula,
+      formulaVersion: props.formulaVersion
     }),
     [
       editingCell,
@@ -8190,7 +10244,10 @@ function useDataGridState(params) {
       editable,
       onCellValueChanged,
       cellSelection,
-      isDragging
+      isDragging,
+      props.getFormulaValue,
+      props.hasFormula,
+      props.formulaVersion
     ]
   );
   const aggregation = useMemo(
@@ -8270,8 +10327,9 @@ function useMultiSelectFilterState(params) {
     }
   }, [isFilterOpen, safeSelectedValues]);
   const filteredOptions = useMemo(() => {
-    if (!debouncedSearchText.trim()) return safeOptions;
-    const searchLower = debouncedSearchText.toLowerCase().trim();
+    const trimmed = debouncedSearchText.trim();
+    if (!trimmed) return safeOptions;
+    const searchLower = trimmed.toLowerCase();
     return safeOptions.filter((opt) => opt.toLowerCase().includes(searchLower));
   }, [safeOptions, debouncedSearchText]);
   const handleCheckboxChange = useCallback((option, checked) => {
@@ -8283,7 +10341,11 @@ function useMultiSelectFilterState(params) {
     });
   }, []);
   const handleSelectAll = useCallback(() => {
-    setTempSelected((prev) => /* @__PURE__ */ new Set([...prev, ...filteredOptions]));
+    setTempSelected((prev) => {
+      const next = new Set(prev);
+      for (const opt of filteredOptions) next.add(opt);
+      return next;
+    });
   }, [filteredOptions]);
   const handleClearSelection = useCallback(() => setTempSelected(/* @__PURE__ */ new Set()), []);
   const handleApplyMultiSelect = useCallback(() => {
@@ -8638,9 +10700,14 @@ function useColumnChooserState(params) {
 }
 function useInlineCellEditorState(params) {
   const { value, editorType, onCommit, onCancel } = params;
-  const [localValue, setLocalValue] = useState(
-    value !== null && value !== void 0 ? String(value) : ""
-  );
+  const [localValue, setLocalValue] = useState(() => {
+    if (value === null || value === void 0) return "";
+    if (editorType === "date") {
+      const str = String(value);
+      return str.match(/^\d{4}-\d{2}-\d{2}/) ? str.substring(0, 10) : str;
+    }
+    return String(value);
+  });
   const handleKeyDown = useCallback(
     (e) => {
       if (e.key === "Escape") {
@@ -8729,9 +10796,10 @@ function useColumnResize({
         [columnId]: { widthPx: latestWidth }
       }));
     };
+    const effectiveMinWidth = columnId === ROW_NUMBER_COLUMN_ID ? ROW_NUMBER_COLUMN_MIN_WIDTH : minWidth;
     const onMove = (moveEvent) => {
       const deltaX = moveEvent.clientX - startX;
-      latestWidth = Math.max(minWidth, startWidth + deltaX);
+      latestWidth = Math.max(effectiveMinWidth, startWidth + deltaX);
       if (!rafRef.current) {
         rafRef.current = requestAnimationFrame(() => {
           rafRef.current = 0;
@@ -8792,9 +10860,14 @@ function getSelectDisplayText(value, formatValue) {
   return value != null ? String(value) : "";
 }
 function useRichSelectState(params) {
-  const { values, formatValue, onCommit, onCancel } = params;
+  const { values, formatValue, initialValue, onCommit, onCancel } = params;
   const [searchText, setSearchText] = useState("");
-  const [highlightedIndex, setHighlightedIndex] = useState(0);
+  const initialIndex = values.findIndex((v) => String(v) === String(initialValue));
+  const [highlightedIndex, setHighlightedIndex] = useState(Math.max(initialIndex, 0));
+  useEffect(() => {
+    const idx = values.findIndex((v) => String(v) === String(initialValue));
+    setHighlightedIndex(Math.max(idx, 0));
+  }, [initialValue, values]);
   const getDisplayText = useCallback(
     (value) => getSelectDisplayText(value, formatValue),
     [formatValue]
@@ -8856,6 +10929,10 @@ function useSelectState(params) {
   );
   const initialIndex = values.findIndex((v) => String(v) === String(initialValue));
   const [highlightedIndex, setHighlightedIndex] = useState(Math.max(initialIndex, 0));
+  useEffect(() => {
+    const idx = values.findIndex((v) => String(v) === String(initialValue));
+    setHighlightedIndex(Math.max(idx, 0));
+  }, [initialValue, values]);
   useEffect(() => {
     const dropdown = dropdownRef.current;
     if (!dropdown) return;
@@ -10169,11 +12246,11 @@ function useDataGridTableOrchestration(params) {
     if (!onActiveCellChangeRef.current) return;
     const ac = interaction.activeCell;
     if (ac) {
-      onActiveCellChangeRef.current(formatCellReference(ac.columnIndex, rowNumberOffset + ac.rowIndex + 1));
+      onActiveCellChangeRef.current(formatCellReference(ac.columnIndex - colOffset, rowNumberOffset + ac.rowIndex + 1));
     } else {
       onActiveCellChangeRef.current(null);
     }
-  }, [interaction.activeCell, rowNumberOffset]);
+  }, [interaction.activeCell, rowNumberOffset, colOffset]);
   const { handleResizeStart, handleResizeDoubleClick, getColumnWidth } = useColumnResize({
     columnSizingOverrides,
     setColumnSizingOverrides
@@ -10784,7 +12861,9 @@ function OGridLayout(props) {
     children,
     pagination,
     sideBar,
-    fullScreen
+    fullScreen,
+    formulaBar,
+    sheetTabs
   } = props;
   const [isFullScreen, setIsFullScreen] = useState(false);
   const toggleFullScreen = useCallback(() => {
@@ -10827,11 +12906,13 @@ function OGridLayout(props) {
           ] })
         ] }),
         toolbarBelow && /* @__PURE__ */ jsx("div", { style: toolbarBelowStyle, children: toolbarBelow }),
+        formulaBar,
         hasSideBar ? /* @__PURE__ */ jsxs("div", { style: gridAreaFlexStyle, children: [
           sideBarPosition === "left" && /* @__PURE__ */ jsx(SideBar, { ...sideBar }),
           /* @__PURE__ */ jsx("div", { style: gridChildStyle, children }),
           sideBarPosition !== "left" && /* @__PURE__ */ jsx(SideBar, { ...sideBar })
         ] }) : /* @__PURE__ */ jsx("div", { style: gridAreaSoloStyle, children }),
+        sheetTabs,
         pagination && /* @__PURE__ */ jsx("div", { style: footerStripStyle, children: pagination })
       ] })
     }
@@ -10929,6 +13010,7 @@ function BaseInlineCellEditor(props) {
   const richSelect = useRichSelectState({
     values: editorValues,
     formatValue: editorFormatValue,
+    initialValue: value,
     onCommit,
     onCancel
   });
@@ -11120,6 +13202,8 @@ function GridContextMenu(props) {
   );
 }
 var MARCHING_ANTS_ANIMATION = { animation: "ogrid-marching-ants 0.5s linear infinite" };
+var CRISP_EDGES = { shapeRendering: "crispEdges" };
+var MARCHING_ANTS_RECT_STYLE = { ...MARCHING_ANTS_ANIMATION, shapeRendering: "crispEdges" };
 function MarchingAntsOverlay({
   containerRef,
   selectionRange,
@@ -11202,7 +13286,7 @@ function MarchingAntsOverlay({
             fill: "none",
             stroke: "var(--ogrid-selection, #217346)",
             strokeWidth: "2",
-            style: { shapeRendering: "crispEdges" }
+            style: CRISP_EDGES
           }
         )
       }
@@ -11232,13 +13316,97 @@ function MarchingAntsOverlay({
             stroke: "var(--ogrid-selection, #217346)",
             strokeWidth: "2",
             strokeDasharray: "4 4",
-            style: { ...MARCHING_ANTS_ANIMATION, shapeRendering: "crispEdges" }
+            style: MARCHING_ANTS_RECT_STYLE
           }
         )
       }
     )
   ] });
 }
+var CRISP_EDGES2 = { shapeRendering: "crispEdges" };
+function measureRef(container, ref, colOffset) {
+  const startCol = ref.col + colOffset;
+  const endCol = (ref.endCol ?? ref.col) + colOffset;
+  const endRow = ref.endRow ?? ref.row;
+  const tl = container.querySelector(
+    `[data-row-index="${ref.row}"][data-col-index="${startCol}"]`
+  );
+  const br = container.querySelector(
+    `[data-row-index="${endRow}"][data-col-index="${endCol}"]`
+  );
+  if (!tl || !br) return null;
+  const cRect = container.getBoundingClientRect();
+  const tlRect = tl.getBoundingClientRect();
+  const brRect = br.getBoundingClientRect();
+  return {
+    top: Math.round(tlRect.top - cRect.top),
+    left: Math.round(tlRect.left - cRect.left),
+    width: Math.round(brRect.right - tlRect.left),
+    height: Math.round(brRect.bottom - tlRect.top),
+    color: FORMULA_REF_COLORS[ref.colorIndex % FORMULA_REF_COLORS.length]
+  };
+}
+function FormulaRefOverlayInner({
+  containerRef,
+  references,
+  colOffset
+}) {
+  const [rects, setRects] = useState([]);
+  const rafRef = useRef(0);
+  const measureAll = useCallback(() => {
+    const container = containerRef.current;
+    if (!container || references.length === 0) {
+      setRects([]);
+      return;
+    }
+    const measured = [];
+    for (const ref of references) {
+      const r = measureRef(container, ref, colOffset);
+      if (r) measured.push(r);
+    }
+    setRects(measured);
+  }, [references, containerRef, colOffset]);
+  useEffect(() => {
+    if (references.length === 0) {
+      setRects([]);
+      return;
+    }
+    rafRef.current = requestAnimationFrame(measureAll);
+    return () => cancelAnimationFrame(rafRef.current);
+  }, [references, measureAll]);
+  if (rects.length === 0) return null;
+  return /* @__PURE__ */ jsx(Fragment, { children: rects.map((r, i) => /* @__PURE__ */ jsx(
+    "svg",
+    {
+      style: {
+        position: "absolute",
+        top: r.top,
+        left: r.left,
+        width: r.width,
+        height: r.height,
+        pointerEvents: "none",
+        zIndex: 3,
+        overflow: "visible"
+      },
+      "aria-hidden": "true",
+      children: /* @__PURE__ */ jsx(
+        "rect",
+        {
+          x: "1",
+          y: "1",
+          width: Math.max(0, r.width - 2),
+          height: Math.max(0, r.height - 2),
+          fill: "none",
+          stroke: r.color,
+          strokeWidth: "2",
+          style: CRISP_EDGES2
+        }
+      )
+    },
+    i
+  )) });
+}
+var FormulaRefOverlay = memo$1(FormulaRefOverlayInner);
 function BaseColumnHeaderMenu(props) {
   const {
     isOpen,
@@ -11351,6 +13519,155 @@ function BaseColumnHeaderMenu(props) {
     portalTarget
   );
 }
+var PaginationControlsBase = React5.memo((props) => {
+  const {
+    currentPage,
+    pageSize,
+    totalCount,
+    onPageChange,
+    onPageSizeChange,
+    pageSizeOptions,
+    entityLabelPlural,
+    className,
+    slots,
+    classNames: cn = {}
+  } = props;
+  const { labelPlural, vm, handlePageSizeChange } = usePaginationControls({
+    currentPage,
+    pageSize,
+    totalCount,
+    onPageSizeChange,
+    pageSizeOptions,
+    entityLabelPlural
+  });
+  if (!vm) return null;
+  const { pageNumbers, showStartEllipsis, showEndEllipsis, totalPages, startItem, endItem } = vm;
+  const {
+    NavButton,
+    PageButton,
+    PageSizeSelect,
+    OuterContainer,
+    InfoText,
+    NavButtonsContainer,
+    PageSizeContainer,
+    PageSizeLabel,
+    Ellipsis
+  } = slots;
+  const infoContent = `Showing ${startItem} to ${endItem} of ${totalCount.toLocaleString()} ${labelPlural}`;
+  const infoNode = InfoText ? /* @__PURE__ */ jsx(InfoText, { children: infoContent }) : /* @__PURE__ */ jsx("div", { className: cn.paginationInfo, children: infoContent });
+  const ellipsisNode = Ellipsis ? /* @__PURE__ */ jsx(Ellipsis, {}) : /* @__PURE__ */ jsx("span", { className: cn.ellipsis, "aria-hidden": true, children: "\u2026" });
+  const pageSizeLabelNode = PageSizeLabel ? /* @__PURE__ */ jsx(PageSizeLabel, {}) : /* @__PURE__ */ jsx("span", { className: cn.pageSizeLabel, children: "Rows" });
+  const pageNumbersNode = /* @__PURE__ */ jsxs("div", { className: cn.pageNumbers, children: [
+    showStartEllipsis && /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(PageButton, { onClick: () => onPageChange(1), active: false, "aria-label": "Page 1", className: cn.pageBtn, children: "1" }),
+      ellipsisNode
+    ] }),
+    pageNumbers.map((pageNum) => /* @__PURE__ */ jsx(
+      PageButton,
+      {
+        onClick: () => onPageChange(pageNum),
+        active: currentPage === pageNum,
+        "aria-label": `Page ${pageNum}`,
+        "aria-current": currentPage === pageNum ? "page" : void 0,
+        className: cn.pageBtn,
+        children: pageNum
+      },
+      pageNum
+    )),
+    showEndEllipsis && /* @__PURE__ */ jsxs(Fragment, { children: [
+      ellipsisNode,
+      /* @__PURE__ */ jsx(PageButton, { onClick: () => onPageChange(totalPages), active: false, "aria-label": `Page ${totalPages}`, className: cn.pageBtn, children: totalPages })
+    ] })
+  ] });
+  const navContent = /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(NavButton, { variant: "first", onClick: () => onPageChange(1), disabled: currentPage === 1, "aria-label": "First page", className: cn.navBtn }),
+    /* @__PURE__ */ jsx(NavButton, { variant: "prev", onClick: () => onPageChange(currentPage - 1), disabled: currentPage === 1, "aria-label": "Previous page", className: cn.navBtn }),
+    pageNumbersNode,
+    /* @__PURE__ */ jsx(NavButton, { variant: "next", onClick: () => onPageChange(currentPage + 1), disabled: currentPage >= totalPages, "aria-label": "Next page", className: cn.navBtn }),
+    /* @__PURE__ */ jsx(NavButton, { variant: "last", onClick: () => onPageChange(totalPages), disabled: currentPage >= totalPages, "aria-label": "Last page", className: cn.navBtn })
+  ] });
+  const navNode = NavButtonsContainer ? /* @__PURE__ */ jsx(NavButtonsContainer, { className: cn.paginationControls, children: navContent }) : /* @__PURE__ */ jsx("div", { className: cn.paginationControls, children: navContent });
+  const pageSizeContent = /* @__PURE__ */ jsxs(Fragment, { children: [
+    pageSizeLabelNode,
+    /* @__PURE__ */ jsx(
+      PageSizeSelect,
+      {
+        value: pageSize,
+        options: vm.pageSizeOptions,
+        onChange: handlePageSizeChange,
+        "aria-label": "Rows per page",
+        className: cn.pageSizeSelect
+      }
+    )
+  ] });
+  const pageSizeNode = PageSizeContainer ? /* @__PURE__ */ jsx(PageSizeContainer, { className: cn.pageSizeSelector, children: pageSizeContent }) : /* @__PURE__ */ jsx("div", { className: cn.pageSizeSelector, children: pageSizeContent });
+  const outerClass = `${cn.pagination ?? ""} ${className || ""}`.trim();
+  const outerRole = "navigation";
+  const outerLabel = "Pagination";
+  if (OuterContainer) {
+    return /* @__PURE__ */ jsxs(OuterContainer, { className: outerClass, role: outerRole, "aria-label": outerLabel, children: [
+      infoNode,
+      navNode,
+      pageSizeNode
+    ] });
+  }
+  return /* @__PURE__ */ jsxs("div", { className: outerClass, role: outerRole, "aria-label": outerLabel, children: [
+    infoNode,
+    navNode,
+    pageSizeNode
+  ] });
+});
+PaginationControlsBase.displayName = "PaginationControlsBase";
+var ColumnChooserContent = ({
+  columns,
+  visibleColumns,
+  visibleCount,
+  totalCount,
+  handleSelectAll,
+  handleClearAll,
+  handleCheckboxChange,
+  CheckboxItem,
+  classNames: cn = {},
+  Header,
+  OptionsListContainer,
+  OptionItemContainer,
+  Actions
+}) => {
+  const headerNode = Header ? /* @__PURE__ */ jsx(Header, { visibleCount, totalCount }) : /* @__PURE__ */ jsxs("div", { className: cn.header, children: [
+    "Select Columns (",
+    visibleCount,
+    " of ",
+    totalCount,
+    ")"
+  ] });
+  const optionItems = columns.map((column) => {
+    const checkboxItem = /* @__PURE__ */ jsx(
+      CheckboxItem,
+      {
+        columnId: column.columnId,
+        columnName: column.name,
+        checked: visibleColumns.has(column.columnId),
+        disabled: column.required === true,
+        onChange: handleCheckboxChange(column.columnId)
+      }
+    );
+    if (OptionItemContainer) {
+      return /* @__PURE__ */ jsx(OptionItemContainer, { columnId: column.columnId, children: checkboxItem }, column.columnId);
+    }
+    return /* @__PURE__ */ jsx("div", { className: cn.optionItem, children: checkboxItem }, column.columnId);
+  });
+  const listNode = OptionsListContainer ? /* @__PURE__ */ jsx(OptionsListContainer, { children: optionItems }) : /* @__PURE__ */ jsx("div", { className: cn.optionsList, children: optionItems });
+  const actionsNode = Actions ? /* @__PURE__ */ jsx(Actions, { onClearAll: handleClearAll, onSelectAll: handleSelectAll }) : /* @__PURE__ */ jsxs("div", { className: cn.actions, children: [
+    /* @__PURE__ */ jsx("button", { type: "button", className: cn.clearButton, onClick: handleClearAll, children: "Clear All" }),
+    /* @__PURE__ */ jsx("button", { type: "button", className: cn.selectAllButton, onClick: handleSelectAll, children: "Select All" })
+  ] });
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    headerNode,
+    listNode,
+    actionsNode
+  ] });
+};
+ColumnChooserContent.displayName = "ColumnChooserContent";
 function createOGrid(components) {
   const {
     DataGridTable,
@@ -11371,6 +13688,8 @@ function createOGrid(components) {
         toolbar: layout.toolbar,
         toolbarBelow: layout.toolbarBelow,
         fullScreen: layout.fullScreen,
+        formulaBar: layout.formulaBar,
+        sheetTabs: layout.sheetTabs,
         toolbarEnd: columnChooser.placement === "toolbar" ? /* @__PURE__ */ jsx(
           ColumnChooser,
           {
@@ -11477,6 +13796,9 @@ function BaseDropIndicator({ dropIndicatorX, wrapperLeft, className }) {
     }
   );
 }
+var dateContainerStyle2 = { padding: "8px 12px", display: "flex", flexDirection: "column", gap: 6 };
+var dateLabelStyle2 = { display: "flex", alignItems: "center", gap: 6, fontSize: 12 };
+var dateInputFlexStyle = { flex: 1 };
 var DateFilterContent = ({
   tempDateFrom,
   setTempDateFrom,
@@ -11486,14 +13808,14 @@ var DateFilterContent = ({
   onClear,
   classNames
 }) => /* @__PURE__ */ jsxs(Fragment, { children: [
-  /* @__PURE__ */ jsxs("div", { style: { padding: "8px 12px", display: "flex", flexDirection: "column", gap: 6 }, children: [
-    /* @__PURE__ */ jsxs("label", { style: { display: "flex", alignItems: "center", gap: 6, fontSize: 12 }, children: [
+  /* @__PURE__ */ jsxs("div", { style: dateContainerStyle2, children: [
+    /* @__PURE__ */ jsxs("label", { style: dateLabelStyle2, children: [
       "From:",
-      /* @__PURE__ */ jsx("input", { type: "date", value: tempDateFrom, onChange: (e) => setTempDateFrom(e.target.value), style: { flex: 1 } })
+      /* @__PURE__ */ jsx("input", { type: "date", value: tempDateFrom, onChange: (e) => setTempDateFrom(e.target.value), style: dateInputFlexStyle })
     ] }),
-    /* @__PURE__ */ jsxs("label", { style: { display: "flex", alignItems: "center", gap: 6, fontSize: 12 }, children: [
+    /* @__PURE__ */ jsxs("label", { style: dateLabelStyle2, children: [
       "To:",
-      /* @__PURE__ */ jsx("input", { type: "date", value: tempDateTo, onChange: (e) => setTempDateTo(e.target.value), style: { flex: 1 } })
+      /* @__PURE__ */ jsx("input", { type: "date", value: tempDateTo, onChange: (e) => setTempDateTo(e.target.value), style: dateInputFlexStyle })
     ] })
   ] }),
   /* @__PURE__ */ jsxs("div", { className: classNames?.popoverActions, children: [
@@ -11530,8 +13852,6 @@ function getDateFilterContentProps(state, classNames) {
     classNames
   };
 }
-
-// src/components/ColumnHeaderFilterRenderers.tsx
 function renderFilterContent(filterType, state, options, isLoadingOptions, selectedUser, renderers) {
   if (filterType === "multiSelect") {
     return renderers.renderMultiSelect({
@@ -11579,5 +13899,13 @@ function renderFilterContent(filterType, state, options, isLoadingOptions, selec
   }
   return null;
 }
+function createBaseFilterRenderers(components, dateClassNames) {
+  return {
+    renderMultiSelect: (p) => /* @__PURE__ */ jsx(components.MultiSelectFilterPopover, { ...p }),
+    renderText: (p) => /* @__PURE__ */ jsx(components.TextFilterPopover, { ...p }),
+    renderPeople: (p) => /* @__PURE__ */ jsx(components.PeopleFilterPopover, { ...p }),
+    renderDate: (p) => /* @__PURE__ */ jsx(DateFilterContent, { ...p, classNames: dateClassNames })
+  };
+}
 
-export { BaseColumnHeaderMenu, BaseDropIndicator, BaseEmptyState, BaseInlineCellEditor, BaseLoadingOverlay, CELL_PADDING, CHECKBOX_COLUMN_WIDTH, COLUMN_HEADER_MENU_ITEMS, CURSOR_CELL_STYLE, CellDescriptorCache, CellErrorBoundary, DEFAULT_MIN_COLUMN_WIDTH, DateFilterContent, EmptyState, GRID_BORDER_RADIUS, GRID_CONTEXT_MENU_ITEMS, GRID_ROOT_STYLE, GridContextMenu, MAX_PAGE_BUTTONS, MarchingAntsOverlay, NOOP3 as NOOP, OGridLayout, PAGE_SIZE_OPTIONS, POPOVER_ANCHOR_STYLE, PREVENT_DEFAULT, ROW_NUMBER_COLUMN_WIDTH, STOP_PROPAGATION, SideBar, StatusBar, UndoRedoStack, areGridRowPropsEqual, booleanParser, buildCsvHeader, buildCsvRows, buildHeaderRows, buildInlineEditorProps2 as buildInlineEditorProps, buildPopoverEditorProps2 as buildPopoverEditorProps, clampSelectionToBounds, computeAggregations, computeAutoScrollSpeed, computeTabNavigation, createOGrid, currencyParser, dateParser, deriveFilterOptionsFromData, editorInputStyle, editorWrapperStyle, emailParser, escapeCsvValue, exportToCsv, findCtrlArrowTarget, flattenColumns, formatCellReference, formatCellValueForTsv, formatSelectionAsTsv, formatShortcut, getCellInteractionProps, getCellRenderDescriptor, getCellValue, getColumnHeaderFilterStateParams, getColumnHeaderMenuItems, getContextMenuHandlers, getDataGridStatusBarConfig, getDateFilterContentProps, getFilterField, getHeaderFilterConfig, getMultiSelectFilterFields, getPaginationViewModel, getStatusBarParts, indexToColumnLetter, isInSelectionRange, isRowInRange, mergeFilter, normalizeSelectionRange, numberParser, parseTsvClipboard, parseValue, partitionColumnsForVirtualization, processClientSideData, rangesEqual, renderFilterContent, resolveCellDisplayContent2 as resolveCellDisplayContent, resolveCellStyle2 as resolveCellStyle, richSelectDropdownStyle, richSelectNoMatchesStyle, richSelectOptionHighlightedStyle, richSelectOptionStyle, richSelectWrapperStyle, selectChevronStyle, selectDisplayStyle, selectEditorStyle, toUserLike, triggerCsvDownload, useActiveCell, useCellEditing, useCellSelection, useClipboard, useColumnChooserState, useColumnHeaderFilterState, useColumnMeta, useColumnReorder, useColumnResize, useContextMenu, useDataGridState, useDataGridTableOrchestration, useDateFilterState, useDebounce, useFillHandle, useFilterOptions, useFormulaEngine, useInlineCellEditorState, useKeyboardNavigation, useLatestRef, useListVirtualizer, useMultiSelectFilterState, useOGrid, usePaginationControls, usePeopleFilterState, useRichSelectState, useRowSelection, useSelectState, useSideBarState, useTableLayout, useTextFilterState, useUndoRedo, useVirtualScroll };
+export { BaseColumnHeaderMenu, BaseDropIndicator, BaseEmptyState, BaseInlineCellEditor, BaseLoadingOverlay, CELL_PADDING, CHECKBOX_COLUMN_WIDTH, COLUMN_HEADER_MENU_ITEMS, CURSOR_CELL_STYLE, CellDescriptorCache, CellErrorBoundary, ColumnChooserContent, DEFAULT_MIN_COLUMN_WIDTH, DateFilterContent, EmptyState, FormulaBar, FormulaRefOverlay, GRID_BORDER_RADIUS, GRID_CONTEXT_MENU_ITEMS, GRID_ROOT_STYLE, GridContextMenu, MAX_PAGE_BUTTONS, MarchingAntsOverlay, NOOP3 as NOOP, OGridLayout, PAGE_SIZE_OPTIONS, POPOVER_ANCHOR_STYLE, PREVENT_DEFAULT, PaginationControlsBase, ROW_NUMBER_COLUMN_ID, ROW_NUMBER_COLUMN_MIN_WIDTH, ROW_NUMBER_COLUMN_WIDTH, STOP_PROPAGATION, SheetTabs, SideBar, StatusBar, UndoRedoStack, areGridRowPropsEqual, booleanParser, buildCsvHeader, buildCsvRows, buildHeaderRows, buildInlineEditorProps2 as buildInlineEditorProps, buildPopoverEditorProps2 as buildPopoverEditorProps, clampSelectionToBounds, computeAggregations, computeAutoScrollSpeed, computeTabNavigation, createBaseFilterRenderers, createOGrid, currencyParser, dateParser, deriveFilterOptionsFromData, editorInputStyle, editorWrapperStyle, emailParser, escapeCsvValue, exportToCsv, findCtrlArrowTarget, flattenColumns, formatCellReference, formatCellValueForTsv, formatSelectionAsTsv, formatShortcut, getCellInteractionProps, getCellRenderDescriptor, getCellValue, getColumnHeaderFilterStateParams, getColumnHeaderMenuItems, getColumnHeaderMenuProps, getContextMenuHandlers, getDataGridStatusBarConfig, getDateFilterContentProps, getFilterField, getHeaderFilterConfig, getMultiSelectFilterFields, getPaginationViewModel, getStatusBarParts, indexToColumnLetter, isInSelectionRange, isRowInRange, mergeFilter, normalizeSelectionRange, numberParser, parseTsvClipboard, parseValue, partitionColumnsForVirtualization, processClientSideData, rangesEqual, renderFilterContent, resolveCellDisplayContent2 as resolveCellDisplayContent, resolveCellStyle2 as resolveCellStyle, richSelectDropdownStyle, richSelectNoMatchesStyle, richSelectOptionHighlightedStyle, richSelectOptionStyle, richSelectWrapperStyle, selectChevronStyle, selectDisplayStyle, selectEditorStyle, toUserLike, triggerCsvDownload, useActiveCell, useCellEditing, useCellSelection, useClipboard, useColumnChooserState, useColumnHeaderFilterState, useColumnMeta, useColumnReorder, useColumnResize, useContextMenu, useDataGridState, useDataGridTableOrchestration, useDateFilterState, useDebounce, useFillHandle, useFilterOptions, useFormulaBar, useFormulaEngine, useInlineCellEditorState, useKeyboardNavigation, useLatestRef, useListVirtualizer, useMultiSelectFilterState, useOGrid, usePaginationControls, usePeopleFilterState, useRichSelectState, useRowSelection, useSelectState, useSideBarState, useTableLayout, useTextFilterState, useUndoRedo, useVirtualScroll };