@alaarab/ogrid-core 2.2.0 → 2.3.0

package/dist/esm/index.js

@@ -38,14 +38,23 @@ function escapeCsvValue(value) {
 function buildCsvHeader(columns) {
   return columns.map((c) => escapeCsvValue(c.name)).join(",");
 }
-function buildCsvRows(items, columns, getValue) {
+function buildCsvRows(items, columns, getValue, formulaOptions) {
   return items.map(
-    (item) => columns.map((c) => escapeCsvValue(getValue(item, c.columnId))).join(",")
+    (item, rowIdx) => columns.map((col) => {
+      if (formulaOptions?.exportMode === "formulas" && formulaOptions.hasFormula && formulaOptions.getFormula && formulaOptions.columnIdToIndex) {
+        const colIdx = formulaOptions.columnIdToIndex.get(col.columnId);
+        if (colIdx !== void 0 && formulaOptions.hasFormula(colIdx, rowIdx)) {
+          const formula = formulaOptions.getFormula(colIdx, rowIdx);
+          if (formula) return escapeCsvValue(formula);
+        }
+      }
+      return escapeCsvValue(getValue(item, col.columnId));
+    }).join(",")
   );
 }
-function exportToCsv(items, columns, getValue, filename) {
+function exportToCsv(items, columns, getValue, filename, formulaOptions) {
   const header = buildCsvHeader(columns);
-  const rows = buildCsvRows(items, columns, getValue);
+  const rows = buildCsvRows(items, columns, getValue, formulaOptions);
   const csv = [header, ...rows].join("\n");
   triggerCsvDownload(csv, filename ?? `export_${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}.csv`);
 }
@@ -1059,6 +1068,17 @@ function processClientSideDataAsync(data, columns, filters, sortBy, sortDirectio
   });
 }
 
+// src/formula/types.ts
+var FormulaError = class {
+  constructor(type, message) {
+    this.type = type;
+    this.message = message;
+  }
+  toString() {
+    return this.type;
+  }
+};
+
 // src/utils/dataGridViewModel.ts
 function getHeaderFilterConfig(col, input) {
   const filterable = isFilterConfig(col.filterable) ? col.filterable : null;
@@ -1192,7 +1212,8 @@ function computeCellDescriptor(item, col, rowIndex, colIdx, input) {
   const canEditAny = canEditInline || canEditPopup;
   const isEditing = input.editingCell?.rowId === rowId && input.editingCell?.columnId === col.columnId;
   const isActive = !input.isDragging && input.activeCell?.rowIndex === rowIndex && input.activeCell?.columnIndex === globalColIndex;
-  const isInRange = input.selectionRange != null && isInSelectionRange(input.selectionRange, rowIndex, colIdx);
+  const isSingleCellRange = input.selectionRange != null && input.selectionRange.startRow === input.selectionRange.endRow && input.selectionRange.startCol === input.selectionRange.endCol;
+  const isInRange = input.selectionRange != null && !isSingleCellRange && isInSelectionRange(input.selectionRange, rowIndex, colIdx);
   const isInCutRange = input.cutRange != null && isInSelectionRange(input.cutRange, rowIndex, colIdx);
   const isInCopyRange = input.copyRange != null && isInSelectionRange(input.copyRange, rowIndex, colIdx);
   const isSelectionEndCell = !input.isDragging && input.copyRange == null && input.cutRange == null && input.selectionRange != null && rowIndex === input.selectionRange.endRow && colIdx === input.selectionRange.endCol;
@@ -1234,6 +1255,9 @@ function computeCellDescriptor(item, col, rowIndex, colIdx, input) {
   };
 }
 function resolveCellDisplayContent(col, item, displayValue) {
+  if (displayValue instanceof FormulaError) {
+    return displayValue.toString();
+  }
   const c = col;
   if (c.renderCell && typeof c.renderCell === "function") {
     return c.renderCell(item);
@@ -1249,10 +1273,14 @@ function resolveCellDisplayContent(col, item, displayValue) {
   }
   return String(displayValue);
 }
-function resolveCellStyle(col, item) {
+function resolveCellStyle(col, item, displayValue) {
   const c = col;
-  if (!c.cellStyle) return void 0;
-  return typeof c.cellStyle === "function" ? c.cellStyle(item) : c.cellStyle;
+  const isError = displayValue instanceof FormulaError;
+  const base = c.cellStyle ? typeof c.cellStyle === "function" ? c.cellStyle(item) : c.cellStyle : void 0;
+  if (isError) {
+    return { ...base, color: "var(--ogrid-formula-error-color, #d32f2f)" };
+  }
+  return base;
 }
 function buildInlineEditorProps(item, col, descriptor, callbacks) {
   return {
@@ -1372,6 +1400,7 @@ var AUTOSIZE_MAX_PX = 520;
 function measureHeaderWidth(th) {
   const cs = getComputedStyle(th);
   const thPadding = (parseFloat(cs.paddingLeft) || 0) + (parseFloat(cs.paddingRight) || 0);
+  const thBorders = (parseFloat(cs.borderLeftWidth) || 0) + (parseFloat(cs.borderRightWidth) || 0);
   let resizeHandleWidth = 0;
   for (let i = 0; i < th.children.length; i++) {
     const child = th.children[i];
@@ -1394,12 +1423,14 @@ function measureHeaderWidth(th) {
           overflow: child.style.overflow,
           flexShrink: child.style.flexShrink,
           width: child.style.width,
-          minWidth: child.style.minWidth
+          minWidth: child.style.minWidth,
+          maxWidth: child.style.maxWidth
         });
         child.style.overflow = "visible";
         child.style.flexShrink = "0";
         child.style.width = "max-content";
         child.style.minWidth = "max-content";
+        child.style.maxWidth = "none";
       }
       expandDescendants(child);
     }
@@ -1417,8 +1448,9 @@ function measureHeaderWidth(th) {
     m.el.style.flexShrink = m.flexShrink;
     m.el.style.width = m.width;
     m.el.style.minWidth = m.minWidth;
+    m.el.style.maxWidth = m.maxWidth;
   }
-  return expandedWidth + resizeHandleWidth + thPadding;
+  return expandedWidth + resizeHandleWidth + thPadding + thBorders;
 }
 function measureColumnContentWidth(columnId, minWidth, container) {
   const minW = minWidth ?? DEFAULT_MIN_COLUMN_WIDTH;
@@ -1635,7 +1667,7 @@ function formatCellValueForTsv(raw, formatted) {
     return "[Object]";
   }
 }
-function formatSelectionAsTsv(items, visibleCols, range) {
+function formatSelectionAsTsv(items, visibleCols, range, formulaOptions) {
   const norm = normalizeSelectionRange(range);
   const rows = [];
   for (let r = norm.startRow; r <= norm.endRow; r++) {
@@ -1644,6 +1676,16 @@ function formatSelectionAsTsv(items, visibleCols, range) {
       if (r >= items.length || c >= visibleCols.length) break;
       const item = items[r];
       const col = visibleCols[c];
+      if (formulaOptions?.hasFormula && formulaOptions?.getFormula) {
+        const flatColIndex = formulaOptions.flatColumns.findIndex((fc) => fc.columnId === col.columnId);
+        if (flatColIndex >= 0 && formulaOptions.hasFormula(flatColIndex, r)) {
+          const formulaStr = formulaOptions.getFormula(flatColIndex, r);
+          if (formulaStr) {
+            cells.push(formulaStr);
+            continue;
+          }
+        }
+      }
       const raw = getCellValue(item, col);
       const clipboard = col.clipboardFormatter ? col.clipboardFormatter(raw, item) : null;
       const formatted = clipboard ?? (col.valueFormatter ? col.valueFormatter(raw, item) : raw);
@@ -1658,7 +1700,7 @@ function parseTsvClipboard(text) {
   const lines = text.split(/\r?\n/).filter((l) => l.length > 0);
   return lines.map((line) => line.split("	"));
 }
-function applyPastedValues(parsedRows, anchorRow, anchorCol, items, visibleCols) {
+function applyPastedValues(parsedRows, anchorRow, anchorCol, items, visibleCols, formulaOptions) {
   const events = [];
   for (let r = 0; r < parsedRows.length; r++) {
     const cells = parsedRows[r];
@@ -1669,9 +1711,16 @@ function applyPastedValues(parsedRows, anchorRow, anchorCol, items, visibleCols)
       const item = items[targetRow];
       const col = visibleCols[targetCol];
       if (!isColumnEditable(col, item)) continue;
-      const rawValue = cells[c] ?? "";
+      const cellText = cells[c] ?? "";
+      if (cellText.startsWith("=") && formulaOptions?.setFormula) {
+        const flatColIndex = formulaOptions.flatColumns.findIndex((fc) => fc.columnId === col.columnId);
+        if (flatColIndex >= 0) {
+          formulaOptions.setFormula(flatColIndex, targetRow, cellText);
+          continue;
+        }
+      }
       const oldValue = getCellValue(item, col);
-      const result = parseValue(rawValue, oldValue, item, col);
+      const result = parseValue(cellText, oldValue, item, col);
       if (!result.valid) continue;
       events.push({
         item,
@@ -1707,13 +1756,116 @@ function applyCutClear(cutRange, items, visibleCols) {
   return events;
 }
 
+// src/utils/cellReference.ts
+function indexToColumnLetter(index) {
+  let result = "";
+  let n = index;
+  while (n >= 0) {
+    result = String.fromCharCode(n % 26 + 65) + result;
+    n = Math.floor(n / 26) - 1;
+  }
+  return result;
+}
+function formatCellReference(colIndex, rowNumber) {
+  return `${indexToColumnLetter(colIndex)}${rowNumber}`;
+}
+
+// src/formula/cellAddressUtils.ts
+function columnLetterToIndex(letters) {
+  let result = 0;
+  const upper = letters.toUpperCase();
+  for (let i = 0; i < upper.length; i++) {
+    result = result * 26 + (upper.charCodeAt(i) - 64);
+  }
+  return result - 1;
+}
+var CELL_REF_RE = /^(\$?)([A-Za-z]+)(\$?)(\d+)$/;
+var ADJUST_REF_RE = /(?:'[^']*'!|[A-Za-z_]\w*!)?(\$?)([A-Z]+)(\$?)(\d+)/g;
+function parseCellRef(ref) {
+  const m = ref.match(CELL_REF_RE);
+  if (!m) return null;
+  const absCol = m[1] === "$";
+  const colLetters = m[2];
+  const absRow = m[3] === "$";
+  const rowNum = parseInt(m[4], 10);
+  if (rowNum < 1) return null;
+  return {
+    col: columnLetterToIndex(colLetters),
+    row: rowNum - 1,
+    // 0-based internally
+    absCol,
+    absRow
+  };
+}
+function parseRange(rangeStr) {
+  const parts = rangeStr.split(":");
+  if (parts.length !== 2) return null;
+  const start = parseCellRef(parts[0]);
+  const end = parseCellRef(parts[1]);
+  if (!start || !end) return null;
+  return { start, end };
+}
+function formatAddress(addr) {
+  const colStr = (addr.absCol ? "$" : "") + indexToColumnLetter(addr.col);
+  const rowStr = (addr.absRow ? "$" : "") + (addr.row + 1);
+  const cellStr = colStr + rowStr;
+  if (addr.sheet) {
+    const sheetStr = addr.sheet.includes(" ") ? `'${addr.sheet}'` : addr.sheet;
+    return `${sheetStr}!${cellStr}`;
+  }
+  return cellStr;
+}
+function adjustFormulaReferences(formula, colDelta, rowDelta) {
+  ADJUST_REF_RE.lastIndex = 0;
+  return formula.replace(ADJUST_REF_RE, (match, colAbs, colLetters, rowAbs, rowDigits) => {
+    const cellRefStart = match.indexOf(colAbs + colLetters);
+    const sheetPrefix = cellRefStart > 0 ? match.substring(0, cellRefStart) : "";
+    let newCol = colLetters;
+    let newRow = rowDigits;
+    if (colAbs !== "$") {
+      const colIdx = columnLetterToIndex(colLetters) + colDelta;
+      if (colIdx < 0) return "#REF!";
+      newCol = indexToColumnLetter(colIdx);
+    }
+    if (rowAbs !== "$") {
+      const rowNum = parseInt(rowDigits, 10) + rowDelta;
+      if (rowNum < 1) return "#REF!";
+      newRow = String(rowNum);
+    }
+    return `${sheetPrefix}${colAbs}${newCol}${rowAbs}${newRow}`;
+  });
+}
+function toCellKey(col, row, sheet) {
+  if (sheet) return `${sheet}:${col},${row}`;
+  return `${col},${row}`;
+}
+function fromCellKey(key) {
+  const colonIdx = key.indexOf(":");
+  if (colonIdx >= 0 && isNaN(parseInt(key.substring(0, colonIdx), 10))) {
+    const sheet = key.substring(0, colonIdx);
+    const rest = key.substring(colonIdx + 1);
+    const commaIdx = rest.indexOf(",");
+    return {
+      col: parseInt(rest.substring(0, commaIdx), 10),
+      row: parseInt(rest.substring(commaIdx + 1), 10),
+      sheet
+    };
+  }
+  const i = key.indexOf(",");
+  return {
+    col: parseInt(key.substring(0, i), 10),
+    row: parseInt(key.substring(i + 1), 10)
+  };
+}
+
 // src/utils/fillHelpers.ts
-function applyFillValues(range, sourceRow, sourceCol, items, visibleCols) {
+function applyFillValues(range, sourceRow, sourceCol, items, visibleCols, formulaOptions) {
   const events = [];
   const startItem = items[range.startRow];
   const startColDef = visibleCols[range.startCol];
   if (!startItem || !startColDef) return events;
   const startValue = getCellValue(startItem, startColDef);
+  const srcFlatColIndex = formulaOptions ? formulaOptions.flatColumns.findIndex((c) => c.columnId === startColDef.columnId) : -1;
   for (let row = range.startRow; row <= range.endRow; row++) {
     for (let col = range.startCol; col <= range.endCol; col++) {
       if (row === sourceRow && col === sourceCol) continue;
@@ -1721,6 +1873,19 @@ function applyFillValues(range, sourceRow, sourceCol, items, visibleCols) {
       const item = items[row];
       const colDef = visibleCols[col];
       if (!isColumnEditable(colDef, item)) continue;
+      if (formulaOptions && formulaOptions.hasFormula && formulaOptions.getFormula && formulaOptions.setFormula && srcFlatColIndex >= 0 && formulaOptions.hasFormula(srcFlatColIndex, sourceRow)) {
+        const srcFormula = formulaOptions.getFormula(srcFlatColIndex, sourceRow);
+        if (srcFormula) {
+          const rowDelta = row - sourceRow;
+          const colDelta = col - sourceCol;
+          const adjusted = adjustFormulaReferences(srcFormula, colDelta, rowDelta);
+          const targetFlatColIdx = formulaOptions.flatColumns.findIndex((c) => c.columnId === colDef.columnId);
+          if (targetFlatColIdx >= 0) {
+            formulaOptions.setFormula(targetFlatColIdx, row, adjusted);
+            continue;
+          }
+        }
+      }
       const oldValue = getCellValue(item, colDef);
       const result = parseValue(startValue, oldValue, item, colDef);
       if (!result.valid) continue;
@@ -1945,4 +2110,3227 @@ var Z_INDEX = {
   CONTEXT_MENU: 1e4
 };
 
-export { AUTOSIZE_EXTRA_PX, AUTOSIZE_MAX_PX, CELL_PADDING, CHECKBOX_COLUMN_WIDTH, COLUMN_HEADER_MENU_ITEMS, CellDescriptorCache, DEFAULT_DEBOUNCE_MS, DEFAULT_MIN_COLUMN_WIDTH, GRID_BORDER_RADIUS, GRID_CONTEXT_MENU_ITEMS, MAX_PAGE_BUTTONS, PAGE_SIZE_OPTIONS, PEOPLE_SEARCH_DEBOUNCE_MS, ROW_NUMBER_COLUMN_WIDTH, SIDEBAR_TRANSITION_MS, UndoRedoStack, Z_INDEX, applyCellDeletion, applyCutClear, applyFillValues, applyPastedValues, applyRangeRowSelection, areGridRowPropsEqual, booleanParser, buildCellIndex, buildCsvHeader, buildCsvRows, buildHeaderRows, buildInlineEditorProps, buildPopoverEditorProps, calculateDropTarget, clampSelectionToBounds, computeAggregations, computeArrowNavigation, computeAutoScrollSpeed, computeNextSortState, computeRowSelectionState, computeTabNavigation, computeTotalHeight, computeVisibleColumnRange, computeVisibleRange, createSortFilterWorker, currencyParser, dateParser, debounce, deriveFilterOptionsFromData, emailParser, escapeCsvValue, exportToCsv, extractValueMatrix, findCtrlArrowTarget, flattenColumns, formatCellValueForTsv, formatSelectionAsTsv, formatShortcut, getCellRenderDescriptor, getCellValue, getColumnHeaderMenuItems, getContextMenuHandlers, getDataGridStatusBarConfig, getFilterField, getHeaderFilterConfig, getMultiSelectFilterFields, getPaginationViewModel, getPinStateForColumn, getScrollTopForRow, getStatusBarParts, injectGlobalStyles, isColumnEditable, isFilterConfig, isInSelectionRange, isRowInRange, measureColumnContentWidth, measureRange, mergeFilter, normalizeSelectionRange, numberParser, parseTsvClipboard, parseValue, partitionColumnsForVirtualization, processClientSideData, processClientSideDataAsync, rangesEqual, reorderColumnArray, resolveCellDisplayContent, resolveCellStyle, terminateSortFilterWorker, toUserLike, triggerCsvDownload, validateColumns, validateRowIds, validateVirtualScrollConfig };
+// src/formula/errors.ts
+var REF_ERROR = new FormulaError("#REF!", "Invalid cell reference");
+var DIV_ZERO_ERROR = new FormulaError("#DIV/0!", "Division by zero");
+var VALUE_ERROR = new FormulaError("#VALUE!", "Wrong value type");
+var NAME_ERROR = new FormulaError("#NAME?", "Unknown function or name");
+var CIRC_ERROR = new FormulaError("#CIRC!", "Circular reference");
+var GENERAL_ERROR = new FormulaError("#ERROR!", "Formula error");
+var NA_ERROR = new FormulaError("#N/A", "No match found");
+function isFormulaError(value) {
+  return value instanceof FormulaError;
+}
+
+// src/formula/tokenizer.ts
+var CELL_REF_PATTERN = /^\$?[A-Za-z]+\$?\d+$/;
+var SINGLE_CHAR_OPERATORS = {
+  "+": "PLUS",
+  "-": "MINUS",
+  "*": "MULTIPLY",
+  "/": "DIVIDE",
+  "^": "POWER",
+  "%": "PERCENT",
+  "&": "AMPERSAND",
+  "=": "EQ"
+};
+var DELIMITERS = {
+  "(": "LPAREN",
+  ")": "RPAREN",
+  ",": "COMMA",
+  ":": "COLON"
+};
+function tokenize(input) {
+  const tokens = [];
+  let pos = 0;
+  while (pos < input.length) {
+    const ch = input[pos];
+    if (ch === " " || ch === "	" || ch === "\r" || ch === "\n") {
+      pos++;
+      continue;
+    }
+    if (ch >= "0" && ch <= "9" || ch === "." && pos + 1 < input.length && input[pos + 1] >= "0" && input[pos + 1] <= "9") {
+      const start = pos;
+      while (pos < input.length && input[pos] >= "0" && input[pos] <= "9") {
+        pos++;
+      }
+      if (pos < input.length && input[pos] === ".") {
+        pos++;
+        while (pos < input.length && input[pos] >= "0" && input[pos] <= "9") {
+          pos++;
+        }
+      }
+      tokens.push({ type: "NUMBER", value: input.slice(start, pos), position: start });
+      continue;
+    }
+    if (ch === "'") {
+      const start = pos;
+      pos++;
+      const nameStart = pos;
+      while (pos < input.length && input[pos] !== "'") {
+        pos++;
+      }
+      const sheetName = input.slice(nameStart, pos);
+      if (pos < input.length && input[pos] === "'") {
+        pos++;
+        if (pos < input.length && input[pos] === "!") {
+          pos++;
+          tokens.push({ type: "SHEET_REF", value: sheetName, position: start });
+          continue;
+        }
+      }
+      throw new FormulaError("#ERROR!", `Invalid sheet reference at position ${start}`);
+    }
+    if (ch === '"') {
+      const start = pos;
+      pos++;
+      const scanStart = pos;
+      let hasEscapes = false;
+      while (pos < input.length) {
+        if (input[pos] === '"') {
+          if (pos + 1 < input.length && input[pos + 1] === '"') {
+            hasEscapes = true;
+            pos += 2;
+          } else {
+            break;
+          }
+        } else {
+          pos++;
+        }
+      }
+      let value;
+      if (!hasEscapes) {
+        value = input.slice(scanStart, pos);
+      } else {
+        value = input.slice(scanStart, pos).replace(/""/g, '"');
+      }
+      if (pos < input.length) pos++;
+      tokens.push({ type: "STRING", value, position: start });
+      continue;
+    }
+    if (ch === ">" && pos + 1 < input.length && input[pos + 1] === "=") {
+      tokens.push({ type: "GTE", value: ">=", position: pos });
+      pos += 2;
+      continue;
+    }
+    if (ch === "<" && pos + 1 < input.length && input[pos + 1] === "=") {
+      tokens.push({ type: "LTE", value: "<=", position: pos });
+      pos += 2;
+      continue;
+    }
+    if (ch === "<" && pos + 1 < input.length && input[pos + 1] === ">") {
+      tokens.push({ type: "NEQ", value: "<>", position: pos });
+      pos += 2;
+      continue;
+    }
+    if (ch === ">" || ch === "<") {
+      const type = ch === ">" ? "GT" : "LT";
+      tokens.push({ type, value: ch, position: pos });
+      pos++;
+      continue;
+    }
+    if (SINGLE_CHAR_OPERATORS[ch]) {
+      tokens.push({ type: SINGLE_CHAR_OPERATORS[ch], value: ch, position: pos });
+      pos++;
+      continue;
+    }
+    if (DELIMITERS[ch]) {
+      tokens.push({ type: DELIMITERS[ch], value: ch, position: pos });
+      pos++;
+      continue;
+    }
+    if (ch === "$" || ch >= "A" && ch <= "Z" || ch >= "a" && ch <= "z") {
+      const start = 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] === "$" || input[pos] === "_")) {
+        pos++;
+      }
+      const word = input.slice(start, pos);
+      if (pos < input.length && input[pos] === "!") {
+        pos++;
+        tokens.push({ type: "SHEET_REF", value: word, position: start });
+        continue;
+      }
+      if (pos < input.length && input[pos] === "(") {
+        tokens.push({ type: "FUNCTION", value: word, position: start });
+        continue;
+      }
+      const upper = word.toUpperCase();
+      if (upper === "TRUE" || upper === "FALSE") {
+        tokens.push({ type: "BOOLEAN", value: upper, position: start });
+        continue;
+      }
+      if (CELL_REF_PATTERN.test(word)) {
+        tokens.push({ type: "CELL_REF", value: word, position: start });
+        continue;
+      }
+      tokens.push({ type: "IDENTIFIER", value: word, position: start });
+      continue;
+    }
+    throw new FormulaError("#ERROR!", `Unexpected character: ${ch}`);
+  }
+  tokens.push({ type: "EOF", value: "", position: pos });
+  return tokens;
+}
+
+// src/formula/parser.ts
+function parse(tokens, namedRanges) {
+  let pos = 0;
+  function peek() {
+    return tokens[pos];
+  }
+  function advance() {
+    const token = tokens[pos];
+    pos++;
+    return token;
+  }
+  function expect(type) {
+    const token = peek();
+    if (token && token.type === type) {
+      return advance();
+    }
+    return null;
+  }
+  function errorNode(message) {
+    return { kind: "error", error: new FormulaError("#ERROR!", message) };
+  }
+  function expression() {
+    return comparison();
+  }
+  function comparison() {
+    let left = concat();
+    while (peek()) {
+      const t = peek();
+      let op = null;
+      if (t.type === "GT") op = ">";
+      else if (t.type === "LT") op = "<";
+      else if (t.type === "GTE") op = ">=";
+      else if (t.type === "LTE") op = "<=";
+      else if (t.type === "EQ") op = "=";
+      else if (t.type === "NEQ") op = "<>";
+      else break;
+      advance();
+      const right = concat();
+      left = { kind: "binaryOp", op, left, right };
+    }
+    return left;
+  }
+  function concat() {
+    let left = addition();
+    while (peek() && peek().type === "AMPERSAND") {
+      advance();
+      const right = addition();
+      left = { kind: "binaryOp", op: "&", left, right };
+    }
+    return left;
+  }
+  function addition() {
+    let left = multiplication();
+    while (peek()) {
+      const t = peek();
+      let op = null;
+      if (t.type === "PLUS") op = "+";
+      else if (t.type === "MINUS") op = "-";
+      else break;
+      advance();
+      const right = multiplication();
+      left = { kind: "binaryOp", op, left, right };
+    }
+    return left;
+  }
+  function multiplication() {
+    let left = power();
+    while (peek()) {
+      const t = peek();
+      let op = null;
+      if (t.type === "MULTIPLY") op = "*";
+      else if (t.type === "DIVIDE") op = "/";
+      else break;
+      advance();
+      const right = power();
+      left = { kind: "binaryOp", op, left, right };
+    }
+    return left;
+  }
+  function power() {
+    let left = unary();
+    while (peek() && peek().type === "POWER") {
+      advance();
+      const right = unary();
+      left = { kind: "binaryOp", op: "^", left, right };
+    }
+    return left;
+  }
+  function unary() {
+    const t = peek();
+    if (t && (t.type === "MINUS" || t.type === "PLUS")) {
+      const op = t.type === "MINUS" ? "-" : "+";
+      advance();
+      const operand = unary();
+      return { kind: "unaryOp", op, operand };
+    }
+    return postfix();
+  }
+  function postfix() {
+    let node = primary();
+    if (peek() && peek().type === "PERCENT") {
+      advance();
+      node = { kind: "binaryOp", op: "%", left: node, right: { kind: "number", value: 100 } };
+    }
+    return node;
+  }
+  function primary() {
+    const t = peek();
+    if (!t || t.type === "EOF") {
+      return errorNode("Unexpected end of expression");
+    }
+    if (t.type === "NUMBER") {
+      advance();
+      return { kind: "number", value: parseFloat(t.value) };
+    }
+    if (t.type === "STRING") {
+      advance();
+      return { kind: "string", value: t.value };
+    }
+    if (t.type === "BOOLEAN") {
+      advance();
+      return { kind: "boolean", value: t.value.toUpperCase() === "TRUE" };
+    }
+    if (t.type === "CELL_REF") {
+      return cellRefOrRange();
+    }
+    if (t.type === "FUNCTION") {
+      return functionCall();
+    }
+    if (t.type === "IDENTIFIER") {
+      return namedRangeRef();
+    }
+    if (t.type === "SHEET_REF") {
+      return sheetRef();
+    }
+    if (t.type === "LPAREN") {
+      advance();
+      const node = expression();
+      if (!expect("RPAREN")) {
+        return errorNode("Expected closing parenthesis");
+      }
+      return node;
+    }
+    advance();
+    return errorNode(`Unexpected token: ${t.value}`);
+  }
+  function cellRefOrRange() {
+    const refToken = advance();
+    const address = parseCellRef(refToken.value);
+    if (!address) {
+      return errorNode(`Invalid cell reference: ${refToken.value}`);
+    }
+    if (peek() && peek().type === "COLON") {
+      advance();
+      const endToken = expect("CELL_REF");
+      if (!endToken) {
+        return errorNode('Expected cell reference after ":"');
+      }
+      const endAddress = parseCellRef(endToken.value);
+      if (!endAddress) {
+        return errorNode(`Invalid cell reference: ${endToken.value}`);
+      }
+      return {
+        kind: "range",
+        start: address,
+        end: endAddress,
+        raw: `${refToken.value}:${endToken.value}`
+      };
+    }
+    return {
+      kind: "cellRef",
+      address,
+      raw: refToken.value
+    };
+  }
+  function functionCall() {
+    const nameToken = advance();
+    const name = nameToken.value.toUpperCase();
+    if (!expect("LPAREN")) {
+      return errorNode(`Expected "(" after function name "${name}"`);
+    }
+    const args = [];
+    if (peek() && peek().type !== "RPAREN" && peek().type !== "EOF") {
+      args.push(expression());
+      while (peek() && peek().type === "COMMA") {
+        advance();
+        args.push(expression());
+      }
+    }
+    if (!expect("RPAREN")) {
+      return errorNode(`Expected ")" after function arguments for "${name}"`);
+    }
+    return { kind: "functionCall", name, args };
+  }
+  function namedRangeRef() {
+    const nameToken = advance();
+    const name = nameToken.value.toUpperCase();
+    const ref = namedRanges?.get(name);
+    if (!ref) {
+      return { kind: "error", error: new FormulaError("#NAME?", `Unknown name: ${nameToken.value}`) };
+    }
+    if (ref.includes(":")) {
+      const rangeRef = parseRange(ref);
+      if (rangeRef) {
+        return { kind: "range", start: rangeRef.start, end: rangeRef.end, raw: ref };
+      }
+    }
+    const cellRef = parseCellRef(ref);
+    if (cellRef) {
+      return { kind: "cellRef", address: cellRef, raw: ref };
+    }
+    return { kind: "error", error: new FormulaError("#REF!", `Invalid named range reference: ${ref}`) };
+  }
+  function sheetRef() {
+    const sheetToken = advance();
+    const sheetName = sheetToken.value;
+    const cellToken = expect("CELL_REF");
+    if (!cellToken) {
+      return errorNode(`Expected cell reference after sheet "${sheetName}!"`);
+    }
+    const address = parseCellRef(cellToken.value);
+    if (!address) {
+      return errorNode(`Invalid cell reference: ${cellToken.value}`);
+    }
+    address.sheet = sheetName;
+    if (peek() && peek().type === "COLON") {
+      advance();
+      const endToken = expect("CELL_REF");
+      if (!endToken) {
+        return errorNode('Expected cell reference after ":"');
+      }
+      const endAddress = parseCellRef(endToken.value);
+      if (!endAddress) {
+        return errorNode(`Invalid cell reference: ${endToken.value}`);
+      }
+      endAddress.sheet = sheetName;
+      return {
+        kind: "range",
+        start: address,
+        end: endAddress,
+        raw: `${sheetName}!${cellToken.value}:${endToken.value}`
+      };
+    }
+    return {
+      kind: "cellRef",
+      address,
+      raw: `${sheetName}!${cellToken.value}`
+    };
+  }
+  const result = expression();
+  if (peek() && peek().type !== "EOF") {
+    return errorNode(`Unexpected token after expression: ${peek().value}`);
+  }
+  return result;
+}
+
+// src/formula/evaluator.ts
+function toNumber(val) {
+  if (val instanceof FormulaError) return val;
+  if (val === null || val === void 0 || val === "") return 0;
+  if (typeof val === "boolean") return val ? 1 : 0;
+  if (typeof val === "number") return val;
+  if (val instanceof Date) return val.getTime();
+  const n = Number(val);
+  if (isNaN(n)) return new FormulaError("#VALUE!", `Cannot convert "${val}" to number`);
+  return n;
+}
+function toString(val) {
+  if (val === null || val === void 0) return "";
+  if (val instanceof FormulaError) return val.toString();
+  if (val instanceof Date) return val.toLocaleDateString();
+  return String(val);
+}
+function toBoolean(val) {
+  if (typeof val === "boolean") return val;
+  if (typeof val === "number") return val !== 0;
+  if (typeof val === "string") {
+    if (val.toUpperCase() === "TRUE") return true;
+    if (val.toUpperCase() === "FALSE") return false;
+    return val.length > 0;
+  }
+  return val !== null && val !== void 0;
+}
+function flattenArgs(args, context, evaluator) {
+  const result = [];
+  for (const arg of args) {
+    if (arg.kind === "range") {
+      const values = context.getRangeValues({ start: arg.start, end: arg.end });
+      for (const row of values) {
+        for (const val of row) {
+          result.push(val);
+        }
+      }
+    } else {
+      result.push(evaluator.evaluate(arg, context));
+    }
+  }
+  return result;
+}
+var FormulaEvaluator = class {
+  constructor(builtInFunctions) {
+    this.functions = new Map(builtInFunctions);
+  }
+  registerFunction(name, fn) {
+    this.functions.set(name.toUpperCase(), fn);
+  }
+  evaluate(node, context) {
+    switch (node.kind) {
+      case "number":
+        return node.value;
+      case "string":
+        return node.value;
+      case "boolean":
+        return node.value;
+      case "error":
+        return node.error;
+      case "cellRef": {
+        const val = context.getCellValue(node.address);
+        return val;
+      }
+      case "range":
+        return context.getCellValue(node.start);
+      case "functionCall":
+        return this.evaluateFunction(node.name, node.args, context);
+      case "binaryOp":
+        return this.evaluateBinaryOp(node.op, node.left, node.right, context);
+      case "unaryOp":
+        return this.evaluateUnaryOp(node.op, node.operand, context);
+    }
+  }
+  evaluateFunction(name, args, context) {
+    const fn = this.functions.get(name);
+    if (!fn) {
+      return new FormulaError("#NAME?", `Unknown function: ${name}`);
+    }
+    if (args.length < fn.minArgs) {
+      return new FormulaError("#ERROR!", `${name} requires at least ${fn.minArgs} argument(s)`);
+    }
+    if (fn.maxArgs >= 0 && args.length > fn.maxArgs) {
+      return new FormulaError("#ERROR!", `${name} accepts at most ${fn.maxArgs} argument(s)`);
+    }
+    return fn.evaluate(args, context, this);
+  }
+  evaluateBinaryOp(op, left, right, context) {
+    if (op === "&") {
+      const l = this.evaluate(left, context);
+      if (l instanceof FormulaError) return l;
+      const r = this.evaluate(right, context);
+      if (r instanceof FormulaError) return r;
+      return toString(l) + toString(r);
+    }
+    if (op === ">" || op === "<" || op === ">=" || op === "<=" || op === "=" || op === "<>") {
+      const l = this.evaluate(left, context);
+      if (l instanceof FormulaError) return l;
+      const r = this.evaluate(right, context);
+      if (r instanceof FormulaError) return r;
+      return this.compare(op, l, r);
+    }
+    const lVal = this.evaluate(left, context);
+    if (lVal instanceof FormulaError) return lVal;
+    const rVal = this.evaluate(right, context);
+    if (rVal instanceof FormulaError) return rVal;
+    const lNum = toNumber(lVal);
+    if (lNum instanceof FormulaError) return lNum;
+    const rNum = toNumber(rVal);
+    if (rNum instanceof FormulaError) return rNum;
+    switch (op) {
+      case "+":
+        return lNum + rNum;
+      case "-":
+        return lNum - rNum;
+      case "*":
+        return lNum * rNum;
+      case "/":
+        if (rNum === 0) return new FormulaError("#DIV/0!");
+        return lNum / rNum;
+      case "^":
+        return Math.pow(lNum, rNum);
+      case "%":
+        return lNum * rNum / 100;
+      default:
+        return new FormulaError("#ERROR!", `Unknown operator: ${op}`);
+    }
+  }
+  evaluateUnaryOp(op, operand, context) {
+    const val = this.evaluate(operand, context);
+    if (val instanceof FormulaError) return val;
+    const num = toNumber(val);
+    if (num instanceof FormulaError) return num;
+    return op === "-" ? -num : num;
+  }
+  compare(op, left, right) {
+    if (typeof left === "number" && typeof right === "number") {
+      return this.numCompare(op, left, right);
+    }
+    if (typeof left === "string" && typeof right === "string") {
+      return this.strCompare(op, left, right);
+    }
+    if (typeof left === "boolean" && typeof right === "boolean") {
+      return this.numCompare(op, left ? 1 : 0, right ? 1 : 0);
+    }
+    const lNum = toNumber(left);
+    const rNum = toNumber(right);
+    if (typeof lNum === "number" && typeof rNum === "number") {
+      return this.numCompare(op, lNum, rNum);
+    }
+    return this.strCompare(op, toString(left), toString(right));
+  }
+  numCompare(op, a, b) {
+    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;
+      default:
+        return false;
+    }
+  }
+  strCompare(op, a, b) {
+    const al = a.toLowerCase();
+    const bl = b.toLowerCase();
+    switch (op) {
+      case ">":
+        return al > bl;
+      case "<":
+        return al < bl;
+      case ">=":
+        return al >= bl;
+      case "<=":
+        return al <= bl;
+      case "=":
+        return al === bl;
+      case "<>":
+        return al !== bl;
+      default:
+        return false;
+    }
+  }
+};
+
+// src/formula/dependencyGraph.ts
+var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
+var DependencyGraph = class {
+  constructor() {
+    /** cell -> set of cells it depends on (references in its formula) */
+    this.dependencies = /* @__PURE__ */ new Map();
+    /** cell -> set of cells that depend on it (reverse index) */
+    this.dependents = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Set the dependencies for a cell, replacing any previous ones.
+   * Updates both the forward (dependencies) and reverse (dependents) maps.
+   */
+  setDependencies(cell, deps) {
+    this.removeDependenciesInternal(cell);
+    this.dependencies.set(cell, deps);
+    for (const dep of deps) {
+      let depSet = this.dependents.get(dep);
+      if (!depSet) {
+        depSet = /* @__PURE__ */ new Set();
+        this.dependents.set(dep, depSet);
+      }
+      depSet.add(cell);
+    }
+  }
+  /**
+   * Remove all dependency information for a cell from both maps.
+   */
+  removeDependencies(cell) {
+    this.removeDependenciesInternal(cell);
+    this.dependencies.delete(cell);
+  }
+  /**
+   * Get all cells that directly or transitively depend on `changedCell`,
+   * returned in topological order (a cell appears AFTER all cells it depends on).
+   *
+   * Uses Kahn's algorithm. If a cycle is detected, cycle participants are
+   * appended at the end (the engine will assign #CIRC! to them).
+   */
+  getRecalcOrder(changedCell) {
+    return this.topologicalSort(/* @__PURE__ */ new Set([changedCell]));
+  }
+  /**
+   * Same as getRecalcOrder but for multiple changed cells.
+   * Union of all transitive dependents, topologically sorted.
+   */
+  getRecalcOrderBatch(changedCells) {
+    return this.topologicalSort(new Set(changedCells));
+  }
+  /**
+   * Check if adding dependencies from `cell` to `deps` would create a cycle.
+   * DFS from each dep: if we can reach `cell`, it would create a cycle.
+   */
+  wouldCreateCycle(cell, deps) {
+    if (deps.has(cell)) {
+      return true;
+    }
+    const visited = /* @__PURE__ */ new Set();
+    for (const dep of deps) {
+      if (this.canReach(dep, cell, visited)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Return direct dependents of a cell (cells whose formulas reference this cell).
+   * Returns an empty set if none.
+   */
+  getDependents(cell) {
+    return this.dependents.get(cell) ?? EMPTY_SET;
+  }
+  /**
+   * Return direct dependencies of a cell (cells referenced in this cell's formula).
+   * Returns an empty set if none.
+   */
+  getDependencies(cell) {
+    return this.dependencies.get(cell) ?? EMPTY_SET;
+  }
+  /**
+   * Clear both maps entirely.
+   */
+  clear() {
+    this.dependencies.clear();
+    this.dependents.clear();
+  }
+  // ---------------------------------------------------------------------------
+  // Private helpers
+  // ---------------------------------------------------------------------------
+  /**
+   * Remove `cell` from the forward dependencies map and clean up reverse
+   * references in the dependents map.
+   */
+  removeDependenciesInternal(cell) {
+    const oldDeps = this.dependencies.get(cell);
+    if (!oldDeps) {
+      return;
+    }
+    for (const oldDep of oldDeps) {
+      const depSet = this.dependents.get(oldDep);
+      if (depSet) {
+        depSet.delete(cell);
+        if (depSet.size === 0) {
+          this.dependents.delete(oldDep);
+        }
+      }
+    }
+    this.dependencies.delete(cell);
+  }
+  /**
+   * Iterative DFS: check if `target` is reachable from `start` by following
+   * the dependency chain. Iterative to avoid stack overflow for deep chains.
+   */
+  canReach(start, target, visited) {
+    if (start === target) return true;
+    if (visited.has(start)) return false;
+    const stack = [start];
+    visited.add(start);
+    while (stack.length > 0) {
+      const current = stack.pop();
+      const deps = this.dependencies.get(current);
+      if (!deps) continue;
+      for (const dep of deps) {
+        if (dep === target) return true;
+        if (!visited.has(dep)) {
+          visited.add(dep);
+          stack.push(dep);
+        }
+      }
+    }
+    return false;
+  }
+  /**
+   * Topological sort using Kahn's algorithm.
+   *
+   * 1. Collect all cells transitively dependent on the changed cell(s).
+   * 2. Build in-degree map for these cells (count how many of their
+   *    dependencies are in the affected set).
+   * 3. Start with cells whose in-degree is 0 (only depend on unaffected
+   *    cells or the changed cells themselves).
+   * 4. Process queue: for each cell, reduce in-degree of its dependents,
+   *    add to queue when in-degree reaches 0.
+   * 5. If any cells remain unprocessed, they're in a cycle — append them
+   *    at the end (engine marks as #CIRC!).
+   */
+  topologicalSort(changedCells) {
+    const affected = /* @__PURE__ */ new Set();
+    const bfsQueue = [];
+    for (const changed of changedCells) {
+      const directDependents = this.dependents.get(changed);
+      if (directDependents) {
+        for (const dep of directDependents) {
+          if (!affected.has(dep)) {
+            affected.add(dep);
+            bfsQueue.push(dep);
+          }
+        }
+      }
+    }
+    let head = 0;
+    while (head < bfsQueue.length) {
+      const current = bfsQueue[head++];
+      const currentDependents = this.dependents.get(current);
+      if (currentDependents) {
+        for (const dep of currentDependents) {
+          if (!affected.has(dep)) {
+            affected.add(dep);
+            bfsQueue.push(dep);
+          }
+        }
+      }
+    }
+    if (affected.size === 0) {
+      return [];
+    }
+    const inDegree = /* @__PURE__ */ new Map();
+    for (const cell of affected) {
+      let degree = 0;
+      const deps = this.dependencies.get(cell);
+      if (deps) {
+        for (const dep of deps) {
+          if (affected.has(dep)) {
+            degree++;
+          }
+        }
+      }
+      inDegree.set(cell, degree);
+    }
+    const queue = [];
+    for (const [cell, degree] of inDegree) {
+      if (degree === 0) {
+        queue.push(cell);
+      }
+    }
+    const result = [];
+    let queueHead = 0;
+    while (queueHead < queue.length) {
+      const cell = queue[queueHead++];
+      result.push(cell);
+      const cellDependents = this.dependents.get(cell);
+      if (cellDependents) {
+        for (const dependent of cellDependents) {
+          if (affected.has(dependent)) {
+            const newDegree = inDegree.get(dependent) - 1;
+            inDegree.set(dependent, newDegree);
+            if (newDegree === 0) {
+              queue.push(dependent);
+            }
+          }
+        }
+      }
+    }
+    if (result.length < affected.size) {
+      const resultSet = new Set(result);
+      for (const cell of affected) {
+        if (!resultSet.has(cell)) {
+          result.push(cell);
+        }
+      }
+    }
+    return result;
+  }
+};
+
+// src/formula/functions/math.ts
+function registerMathFunctions(registry) {
+  registry.set("SUM", {
+    minArgs: 1,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      const values = flattenArgs(args, context, evaluator);
+      let sum = 0;
+      for (const val of values) {
+        if (val instanceof FormulaError) return val;
+        if (typeof val === "number") {
+          sum += val;
+        } else if (typeof val === "boolean") {
+          sum += val ? 1 : 0;
+        }
+      }
+      return sum;
+    }
+  });
+  registry.set("AVERAGE", {
+    minArgs: 1,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      const values = flattenArgs(args, context, evaluator);
+      let sum = 0;
+      let count = 0;
+      for (const val of values) {
+        if (val instanceof FormulaError) return val;
+        if (typeof val === "number") {
+          sum += val;
+          count++;
+        } else if (typeof val === "boolean") {
+          sum += val ? 1 : 0;
+          count++;
+        }
+      }
+      if (count === 0) return new FormulaError("#DIV/0!", "No numeric values for AVERAGE");
+      return sum / count;
+    }
+  });
+  registry.set("MIN", {
+    minArgs: 1,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      const values = flattenArgs(args, context, evaluator);
+      let min = Infinity;
+      for (const val of values) {
+        if (val instanceof FormulaError) return val;
+        if (typeof val === "number") {
+          if (val < min) min = val;
+        } else if (typeof val === "boolean") {
+          const n = val ? 1 : 0;
+          if (n < min) min = n;
+        }
+      }
+      return min === Infinity ? 0 : min;
+    }
+  });
+  registry.set("MAX", {
+    minArgs: 1,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      const values = flattenArgs(args, context, evaluator);
+      let max = -Infinity;
+      for (const val of values) {
+        if (val instanceof FormulaError) return val;
+        if (typeof val === "number") {
+          if (val > max) max = val;
+        } else if (typeof val === "boolean") {
+          const n = val ? 1 : 0;
+          if (n > max) max = n;
+        }
+      }
+      return max === -Infinity ? 0 : max;
+    }
+  });
+  registry.set("COUNT", {
+    minArgs: 1,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      const values = flattenArgs(args, context, evaluator);
+      let count = 0;
+      for (const val of values) {
+        if (val instanceof FormulaError) return val;
+        if (typeof val === "number") {
+          count++;
+        }
+      }
+      return count;
+    }
+  });
+  registry.set("COUNTA", {
+    minArgs: 1,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      const values = flattenArgs(args, context, evaluator);
+      let count = 0;
+      for (const val of values) {
+        if (val instanceof FormulaError) return val;
+        if (val !== null && val !== void 0 && val !== "") {
+          count++;
+        }
+      }
+      return count;
+    }
+  });
+  registry.set("ROUND", {
+    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 rawDigits = evaluator.evaluate(args[1], context);
+      if (rawDigits instanceof FormulaError) return rawDigits;
+      const digits = toNumber(rawDigits);
+      if (digits instanceof FormulaError) return digits;
+      const factor = Math.pow(10, Math.trunc(digits));
+      return Math.round(num * factor) / factor;
+    }
+  });
+  registry.set("ABS", {
+    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;
+      return Math.abs(num);
+    }
+  });
+  registry.set("CEILING", {
+    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 rawSig = evaluator.evaluate(args[1], context);
+      if (rawSig instanceof FormulaError) return rawSig;
+      const significance = toNumber(rawSig);
+      if (significance instanceof FormulaError) return significance;
+      if (significance === 0) return 0;
+      return Math.ceil(num / significance) * significance;
+    }
+  });
+  registry.set("FLOOR", {
+    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 rawSig = evaluator.evaluate(args[1], context);
+      if (rawSig instanceof FormulaError) return rawSig;
+      const significance = toNumber(rawSig);
+      if (significance instanceof FormulaError) return significance;
+      if (significance === 0) return 0;
+      return Math.floor(num / significance) * significance;
+    }
+  });
+  registry.set("MOD", {
+    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 rawDiv = evaluator.evaluate(args[1], context);
+      if (rawDiv instanceof FormulaError) return rawDiv;
+      const divisor = toNumber(rawDiv);
+      if (divisor instanceof FormulaError) return divisor;
+      if (divisor === 0) return new FormulaError("#DIV/0!", "Division by zero in MOD");
+      return num % divisor;
+    }
+  });
+  registry.set("POWER", {
+    minArgs: 2,
+    maxArgs: 2,
+    evaluate(args, context, evaluator) {
+      const rawBase = evaluator.evaluate(args[0], context);
+      if (rawBase instanceof FormulaError) return rawBase;
+      const base = toNumber(rawBase);
+      if (base instanceof FormulaError) return base;
+      const rawExp = evaluator.evaluate(args[1], context);
+      if (rawExp instanceof FormulaError) return rawExp;
+      const exponent = toNumber(rawExp);
+      if (exponent instanceof FormulaError) return exponent;
+      return Math.pow(base, exponent);
+    }
+  });
+  registry.set("SQRT", {
+    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;
+      if (num < 0) return new FormulaError("#VALUE!", "Cannot take square root of negative number");
+      return Math.sqrt(num);
+    }
+  });
+  registry.set("ROUNDUP", {
+    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 rawDigits = evaluator.evaluate(args[1], context);
+      if (rawDigits instanceof FormulaError) return rawDigits;
+      const digits = toNumber(rawDigits);
+      if (digits instanceof FormulaError) return digits;
+      const factor = Math.pow(10, Math.trunc(digits));
+      return num >= 0 ? Math.ceil(num * factor) / factor : Math.floor(num * factor) / factor;
+    }
+  });
+  registry.set("ROUNDDOWN", {
+    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 rawDigits = evaluator.evaluate(args[1], context);
+      if (rawDigits instanceof FormulaError) return rawDigits;
+      const digits = toNumber(rawDigits);
+      if (digits instanceof FormulaError) return digits;
+      const factor = Math.pow(10, Math.trunc(digits));
+      return Math.trunc(num * factor) / factor;
+    }
+  });
+  registry.set("INT", {
+    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;
+      return Math.floor(num);
+    }
+  });
+  registry.set("TRUNC", {
+    minArgs: 1,
+    maxArgs: 2,
+    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;
+      let digits = 0;
+      if (args.length >= 2) {
+        const rawD = evaluator.evaluate(args[1], context);
+        if (rawD instanceof FormulaError) return rawD;
+        const d = toNumber(rawD);
+        if (d instanceof FormulaError) return d;
+        digits = Math.trunc(d);
+      }
+      const factor = Math.pow(10, digits);
+      return Math.trunc(num * factor) / factor;
+    }
+  });
+  registry.set("PRODUCT", {
+    minArgs: 1,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      const values = flattenArgs(args, context, evaluator);
+      let product = 1;
+      let hasNumber = false;
+      for (const val of values) {
+        if (val instanceof FormulaError) return val;
+        if (typeof val === "number") {
+          product *= val;
+          hasNumber = true;
+        }
+      }
+      return hasNumber ? product : 0;
+    }
+  });
+  registry.set("SUMPRODUCT", {
+    minArgs: 1,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      const arrays = [];
+      for (const arg of args) {
+        if (arg.kind !== "range") {
+          return new FormulaError("#VALUE!", "SUMPRODUCT arguments must be ranges");
+        }
+        arrays.push(context.getRangeValues({ start: arg.start, end: arg.end }));
+      }
+      if (arrays.length === 0) return 0;
+      const rows = arrays[0].length;
+      const cols = rows > 0 ? arrays[0][0].length : 0;
+      for (let a = 1; a < arrays.length; a++) {
+        if (arrays[a].length !== rows || rows > 0 && arrays[a][0].length !== cols) {
+          return new FormulaError("#VALUE!", "SUMPRODUCT arrays must have same dimensions");
+        }
+      }
+      let sum = 0;
+      for (let r = 0; r < rows; r++) {
+        for (let c = 0; c < cols; c++) {
+          let product = 1;
+          for (let a = 0; a < arrays.length; a++) {
+            const v = toNumber(arrays[a][r][c]);
+            if (v instanceof FormulaError) {
+              product = 0;
+              break;
+            }
+            product *= v;
+          }
+          sum += product;
+        }
+      }
+      return sum;
+    }
+  });
+  registry.set("MEDIAN", {
+    minArgs: 1,
+    maxArgs: -1,
+    evaluate(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);
+      }
+      if (nums.length === 0) return new FormulaError("#NUM!", "No numeric values for MEDIAN");
+      nums.sort((a, b) => a - b);
+      const mid = Math.floor(nums.length / 2);
+      return nums.length % 2 !== 0 ? nums[mid] : (nums[mid - 1] + nums[mid]) / 2;
+    }
+  });
+  registry.set("LARGE", {
+    minArgs: 2,
+    maxArgs: 2,
+    evaluate(args, context, evaluator) {
+      if (args[0].kind !== "range") {
+        return new FormulaError("#VALUE!", "LARGE first argument must be a range");
+      }
+      const rangeData = context.getRangeValues({ start: args[0].start, end: args[0].end });
+      const rawK = evaluator.evaluate(args[1], context);
+      if (rawK instanceof FormulaError) return rawK;
+      const k = toNumber(rawK);
+      if (k instanceof FormulaError) return k;
+      const nums = [];
+      for (const row of rangeData) {
+        for (const cell of row) {
+          if (typeof cell === "number") nums.push(cell);
+        }
+      }
+      const ki = Math.trunc(k);
+      if (ki < 1 || ki > nums.length) return new FormulaError("#NUM!", "LARGE k out of range");
+      nums.sort((a, b) => b - a);
+      return nums[ki - 1];
+    }
+  });
+  registry.set("SMALL", {
+    minArgs: 2,
+    maxArgs: 2,
+    evaluate(args, context, evaluator) {
+      if (args[0].kind !== "range") {
+        return new FormulaError("#VALUE!", "SMALL first argument must be a range");
+      }
+      const rangeData = context.getRangeValues({ start: args[0].start, end: args[0].end });
+      const rawK = evaluator.evaluate(args[1], context);
+      if (rawK instanceof FormulaError) return rawK;
+      const k = toNumber(rawK);
+      if (k instanceof FormulaError) return k;
+      const nums = [];
+      for (const row of rangeData) {
+        for (const cell of row) {
+          if (typeof cell === "number") nums.push(cell);
+        }
+      }
+      const ki = Math.trunc(k);
+      if (ki < 1 || ki > nums.length) return new FormulaError("#NUM!", "SMALL k out of range");
+      nums.sort((a, b) => a - b);
+      return nums[ki - 1];
+    }
+  });
+  registry.set("RANK", {
+    minArgs: 2,
+    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;
+      if (args[1].kind !== "range") {
+        return new FormulaError("#VALUE!", "RANK second argument must be a range");
+      }
+      const rangeData = context.getRangeValues({ start: args[1].start, end: args[1].end });
+      let order = 0;
+      if (args.length >= 3) {
+        const rawO = evaluator.evaluate(args[2], context);
+        if (rawO instanceof FormulaError) return rawO;
+        const o = toNumber(rawO);
+        if (o instanceof FormulaError) return o;
+        order = o;
+      }
+      const nums = [];
+      for (const row of rangeData) {
+        for (const cell of row) {
+          if (typeof cell === "number") nums.push(cell);
+        }
+      }
+      if (!nums.includes(num)) return new FormulaError("#N/A", "RANK value not found in range");
+      let rank = 1;
+      for (const n of nums) {
+        if (order === 0 ? n > num : n < num) rank++;
+      }
+      return rank;
+    }
+  });
+  registry.set("SIGN", {
+    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;
+      return num > 0 ? 1 : num < 0 ? -1 : 0;
+    }
+  });
+  registry.set("LOG", {
+    minArgs: 1,
+    maxArgs: 2,
+    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;
+      if (num <= 0) return new FormulaError("#NUM!", "LOG requires a positive number");
+      let base = 10;
+      if (args.length >= 2) {
+        const rawB = evaluator.evaluate(args[1], context);
+        if (rawB instanceof FormulaError) return rawB;
+        const b = toNumber(rawB);
+        if (b instanceof FormulaError) return b;
+        if (b <= 0 || b === 1) return new FormulaError("#NUM!", "LOG base must be positive and not 1");
+        base = b;
+      }
+      return Math.log(num) / Math.log(base);
+    }
+  });
+  registry.set("LN", {
+    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;
+      if (num <= 0) return new FormulaError("#NUM!", "LN requires a positive number");
+      return Math.log(num);
+    }
+  });
+  registry.set("EXP", {
+    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;
+      return Math.exp(num);
+    }
+  });
+  registry.set("PI", {
+    minArgs: 0,
+    maxArgs: 0,
+    evaluate() {
+      return Math.PI;
+    }
+  });
+  registry.set("RAND", {
+    minArgs: 0,
+    maxArgs: 0,
+    evaluate() {
+      return Math.random();
+    }
+  });
+  registry.set("RANDBETWEEN", {
+    minArgs: 2,
+    maxArgs: 2,
+    evaluate(args, context, evaluator) {
+      const rawLow = evaluator.evaluate(args[0], context);
+      if (rawLow instanceof FormulaError) return rawLow;
+      const low = toNumber(rawLow);
+      if (low instanceof FormulaError) return low;
+      const rawHigh = evaluator.evaluate(args[1], context);
+      if (rawHigh instanceof FormulaError) return rawHigh;
+      const high = toNumber(rawHigh);
+      if (high instanceof FormulaError) return high;
+      const lo = Math.ceil(low);
+      const hi = Math.floor(high);
+      if (lo > hi) return new FormulaError("#NUM!", "RANDBETWEEN bottom must be <= top");
+      return Math.floor(Math.random() * (hi - lo + 1)) + lo;
+    }
+  });
+}
+
+// src/formula/functions/logical.ts
+function flattenArgs2(args, context, evaluator) {
+  const result = [];
+  for (const arg of args) {
+    if (arg.kind === "range") {
+      const values = context.getRangeValues({ start: arg.start, end: arg.end });
+      for (const row of values) {
+        for (const cell of row) {
+          result.push(cell);
+        }
+      }
+    } else {
+      result.push(evaluator.evaluate(arg, context));
+    }
+  }
+  return result;
+}
+function registerLogicalFunctions(registry) {
+  registry.set("IF", {
+    minArgs: 2,
+    maxArgs: 3,
+    evaluate(args, context, evaluator) {
+      const condition = evaluator.evaluate(args[0], context);
+      if (condition instanceof FormulaError) return condition;
+      if (condition) {
+        return evaluator.evaluate(args[1], context);
+      } else {
+        if (args.length >= 3) {
+          return evaluator.evaluate(args[2], context);
+        }
+        return false;
+      }
+    }
+  });
+  registry.set("AND", {
+    minArgs: 1,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      const values = flattenArgs2(args, context, evaluator);
+      for (const val of values) {
+        if (val instanceof FormulaError) return val;
+        if (!val) return false;
+      }
+      return true;
+    }
+  });
+  registry.set("OR", {
+    minArgs: 1,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      const values = flattenArgs2(args, context, evaluator);
+      for (const val of values) {
+        if (val instanceof FormulaError) return val;
+        if (val) return true;
+      }
+      return false;
+    }
+  });
+  registry.set("NOT", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      if (val instanceof FormulaError) return val;
+      return !val;
+    }
+  });
+  registry.set("IFERROR", {
+    minArgs: 2,
+    maxArgs: 2,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      if (val instanceof FormulaError) {
+        return evaluator.evaluate(args[1], context);
+      }
+      return val;
+    }
+  });
+  registry.set("IFNA", {
+    minArgs: 2,
+    maxArgs: 2,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      if (val instanceof FormulaError && val.type === "#N/A") {
+        return evaluator.evaluate(args[1], context);
+      }
+      return val;
+    }
+  });
+  registry.set("IFS", {
+    minArgs: 2,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      if (args.length % 2 !== 0) {
+        return new FormulaError("#VALUE!", "IFS requires pairs of condition, value");
+      }
+      for (let i = 0; i < args.length; i += 2) {
+        const condition = evaluator.evaluate(args[i], context);
+        if (condition instanceof FormulaError) return condition;
+        if (condition) {
+          return evaluator.evaluate(args[i + 1], context);
+        }
+      }
+      return new FormulaError("#N/A", "IFS no condition was TRUE");
+    }
+  });
+  registry.set("SWITCH", {
+    minArgs: 3,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      const expr = evaluator.evaluate(args[0], context);
+      if (expr instanceof FormulaError) return expr;
+      const hasDefault = (args.length - 1) % 2 !== 0;
+      const pairCount = hasDefault ? (args.length - 2) / 2 : (args.length - 1) / 2;
+      for (let i = 0; i < pairCount; i++) {
+        const caseVal = evaluator.evaluate(args[1 + i * 2], context);
+        if (caseVal instanceof FormulaError) return caseVal;
+        if (expr === caseVal) {
+          return evaluator.evaluate(args[2 + i * 2], context);
+        }
+      }
+      if (hasDefault) {
+        return evaluator.evaluate(args[args.length - 1], context);
+      }
+      return new FormulaError("#N/A", "SWITCH no match found");
+    }
+  });
+  registry.set("CHOOSE", {
+    minArgs: 2,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      const rawIdx = evaluator.evaluate(args[0], context);
+      if (rawIdx instanceof FormulaError) return rawIdx;
+      if (typeof rawIdx !== "number") return new FormulaError("#VALUE!", "CHOOSE index must be a number");
+      const idx = Math.trunc(rawIdx);
+      if (idx < 1 || idx >= args.length) {
+        return new FormulaError("#VALUE!", "CHOOSE index out of range");
+      }
+      return evaluator.evaluate(args[idx], context);
+    }
+  });
+  registry.set("XOR", {
+    minArgs: 1,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      const values = flattenArgs2(args, context, evaluator);
+      let trueCount = 0;
+      for (const val of values) {
+        if (val instanceof FormulaError) return val;
+        if (val) trueCount++;
+      }
+      return trueCount % 2 === 1;
+    }
+  });
+}
+
+// src/formula/functions/lookup.ts
+function registerLookupFunctions(registry) {
+  registry.set("VLOOKUP", {
+    minArgs: 3,
+    maxArgs: 4,
+    evaluate(args, context, evaluator) {
+      const lookupValue = evaluator.evaluate(args[0], context);
+      if (lookupValue instanceof FormulaError) return lookupValue;
+      if (args[1].kind !== "range") {
+        return new FormulaError("#VALUE!", "VLOOKUP table_array must be a range");
+      }
+      const tableData = context.getRangeValues({ start: args[1].start, end: args[1].end });
+      const rawColIndex = evaluator.evaluate(args[2], context);
+      if (rawColIndex instanceof FormulaError) return rawColIndex;
+      const colIndex = toNumber(rawColIndex);
+      if (colIndex instanceof FormulaError) return colIndex;
+      if (colIndex < 1) return new FormulaError("#VALUE!", "VLOOKUP col_index must be >= 1");
+      if (tableData.length > 0 && colIndex > tableData[0].length) {
+        return new FormulaError("#REF!", "VLOOKUP col_index exceeds table columns");
+      }
+      let rangeLookup = true;
+      if (args.length >= 4) {
+        const rawRL = evaluator.evaluate(args[3], context);
+        if (rawRL instanceof FormulaError) return rawRL;
+        rangeLookup = !!rawRL;
+      }
+      const col = Math.trunc(colIndex) - 1;
+      const lookupLower = typeof lookupValue === "string" ? lookupValue.toLowerCase() : null;
+      if (rangeLookup) {
+        let bestRow = -1;
+        for (let r = 0; r < tableData.length; r++) {
+          const cellVal = tableData[r][0];
+          if (cellVal === null || cellVal === void 0) continue;
+          if (typeof lookupValue === "number" && typeof cellVal === "number") {
+            if (cellVal <= lookupValue) bestRow = r;
+            else break;
+          } else if (lookupLower !== null && typeof cellVal === "string") {
+            if (cellVal.toLowerCase() <= lookupLower) bestRow = r;
+            else break;
+          }
+        }
+        if (bestRow === -1) return new FormulaError("#N/A", "VLOOKUP no match found");
+        return tableData[bestRow][col] ?? null;
+      } else {
+        for (let r = 0; r < tableData.length; r++) {
+          const cellVal = tableData[r][0];
+          if (lookupLower !== null && typeof cellVal === "string") {
+            if (cellVal.toLowerCase() === lookupLower) {
+              return tableData[r][col] ?? null;
+            }
+          } else if (cellVal === lookupValue) {
+            return tableData[r][col] ?? null;
+          }
+        }
+        return new FormulaError("#N/A", "VLOOKUP no exact match found");
+      }
+    }
+  });
+  registry.set("INDEX", {
+    minArgs: 2,
+    maxArgs: 3,
+    evaluate(args, context, evaluator) {
+      if (args[0].kind !== "range") {
+        return new FormulaError("#VALUE!", "INDEX first argument must be a range");
+      }
+      const rangeData = context.getRangeValues({ start: args[0].start, end: args[0].end });
+      const rawRow = evaluator.evaluate(args[1], context);
+      if (rawRow instanceof FormulaError) return rawRow;
+      const rowNum = toNumber(rawRow);
+      if (rowNum instanceof FormulaError) return rowNum;
+      let colNum = 1;
+      if (args.length >= 3) {
+        const rawCol = evaluator.evaluate(args[2], context);
+        if (rawCol instanceof FormulaError) return rawCol;
+        const c2 = toNumber(rawCol);
+        if (c2 instanceof FormulaError) return c2;
+        colNum = c2;
+      }
+      const r = Math.trunc(rowNum) - 1;
+      const c = Math.trunc(colNum) - 1;
+      if (r < 0 || r >= rangeData.length) {
+        return new FormulaError("#REF!", "INDEX row out of bounds");
+      }
+      if (c < 0 || rangeData.length > 0 && c >= rangeData[0].length) {
+        return new FormulaError("#REF!", "INDEX column out of bounds");
+      }
+      return rangeData[r][c] ?? null;
+    }
+  });
+  registry.set("HLOOKUP", {
+    minArgs: 3,
+    maxArgs: 4,
+    evaluate(args, context, evaluator) {
+      const lookupValue = evaluator.evaluate(args[0], context);
+      if (lookupValue instanceof FormulaError) return lookupValue;
+      if (args[1].kind !== "range") {
+        return new FormulaError("#VALUE!", "HLOOKUP table_array must be a range");
+      }
+      const tableData = context.getRangeValues({ start: args[1].start, end: args[1].end });
+      const rawRowIndex = evaluator.evaluate(args[2], context);
+      if (rawRowIndex instanceof FormulaError) return rawRowIndex;
+      const rowIndex = toNumber(rawRowIndex);
+      if (rowIndex instanceof FormulaError) return rowIndex;
+      if (rowIndex < 1) return new FormulaError("#VALUE!", "HLOOKUP row_index must be >= 1");
+      if (rowIndex > tableData.length) {
+        return new FormulaError("#REF!", "HLOOKUP row_index exceeds table rows");
+      }
+      let rangeLookup = true;
+      if (args.length >= 4) {
+        const rawRL = evaluator.evaluate(args[3], context);
+        if (rawRL instanceof FormulaError) return rawRL;
+        rangeLookup = !!rawRL;
+      }
+      const row = Math.trunc(rowIndex) - 1;
+      const firstRow = tableData[0] || [];
+      const lookupLower = typeof lookupValue === "string" ? lookupValue.toLowerCase() : null;
+      if (rangeLookup) {
+        let bestCol = -1;
+        for (let c = 0; c < firstRow.length; c++) {
+          const cellVal = firstRow[c];
+          if (cellVal === null || cellVal === void 0) continue;
+          if (typeof lookupValue === "number" && typeof cellVal === "number") {
+            if (cellVal <= lookupValue) bestCol = c;
+            else break;
+          } else if (lookupLower !== null && typeof cellVal === "string") {
+            if (cellVal.toLowerCase() <= lookupLower) bestCol = c;
+            else break;
+          }
+        }
+        if (bestCol === -1) return new FormulaError("#N/A", "HLOOKUP no match found");
+        return tableData[row][bestCol] ?? null;
+      } else {
+        for (let c = 0; c < firstRow.length; c++) {
+          const cellVal = firstRow[c];
+          if (lookupLower !== null && typeof cellVal === "string") {
+            if (cellVal.toLowerCase() === lookupLower) return tableData[row][c] ?? null;
+          } else if (cellVal === lookupValue) {
+            return tableData[row][c] ?? null;
+          }
+        }
+        return new FormulaError("#N/A", "HLOOKUP no exact match found");
+      }
+    }
+  });
+  registry.set("XLOOKUP", {
+    minArgs: 3,
+    maxArgs: 6,
+    evaluate(args, context, evaluator) {
+      const lookupValue = evaluator.evaluate(args[0], context);
+      if (lookupValue instanceof FormulaError) return lookupValue;
+      if (args[1].kind !== "range") {
+        return new FormulaError("#VALUE!", "XLOOKUP lookup_array must be a range");
+      }
+      const lookupArray = context.getRangeValues({ start: args[1].start, end: args[1].end });
+      if (args[2].kind !== "range") {
+        return new FormulaError("#VALUE!", "XLOOKUP return_array must be a range");
+      }
+      const returnArray = context.getRangeValues({ start: args[2].start, end: args[2].end });
+      let ifNotFound = new FormulaError("#N/A", "XLOOKUP no match found");
+      if (args.length >= 4) {
+        ifNotFound = evaluator.evaluate(args[3], context);
+      }
+      let matchMode = 0;
+      if (args.length >= 5) {
+        const rawMM = evaluator.evaluate(args[4], context);
+        if (rawMM instanceof FormulaError) return rawMM;
+        const mm = toNumber(rawMM);
+        if (mm instanceof FormulaError) return mm;
+        matchMode = Math.trunc(mm);
+      }
+      let searchMode = 1;
+      if (args.length >= 6) {
+        const rawSM = evaluator.evaluate(args[5], context);
+        if (rawSM instanceof FormulaError) return rawSM;
+        const sm = toNumber(rawSM);
+        if (sm instanceof FormulaError) return sm;
+        searchMode = Math.trunc(sm);
+      }
+      const isRow = lookupArray.length === 1;
+      const len = isRow ? lookupArray[0].length : lookupArray.length;
+      const getVal = isRow ? (i) => lookupArray[0][i] : (i) => lookupArray[i][0];
+      const lookupLower = typeof lookupValue === "string" ? lookupValue.toLowerCase() : null;
+      const eq = (a, b) => {
+        if (lookupLower !== null && typeof a === "string") return a.toLowerCase() === lookupLower;
+        return a === b;
+      };
+      let foundIdx = -1;
+      if (matchMode === 0) {
+        const start = searchMode >= 0 ? 0 : len - 1;
+        const end = searchMode >= 0 ? len : -1;
+        const step = searchMode >= 0 ? 1 : -1;
+        for (let i = start; i !== end; i += step) {
+          if (eq(getVal(i), lookupValue)) {
+            foundIdx = i;
+            break;
+          }
+        }
+      } else if (matchMode === -1) {
+        let best = -1;
+        for (let i = 0; i < len; i++) {
+          const v = getVal(i);
+          if (eq(v, lookupValue)) {
+            foundIdx = i;
+            break;
+          }
+          if (typeof lookupValue === "number" && typeof v === "number" && v < lookupValue) {
+            if (best === -1 || v > getVal(best)) best = i;
+          }
+        }
+        if (foundIdx === -1) foundIdx = best;
+      } else if (matchMode === 1) {
+        let best = -1;
+        for (let i = 0; i < len; i++) {
+          const v = getVal(i);
+          if (eq(v, lookupValue)) {
+            foundIdx = i;
+            break;
+          }
+          if (typeof lookupValue === "number" && typeof v === "number" && v > lookupValue) {
+            if (best === -1 || v < getVal(best)) best = i;
+          }
+        }
+        if (foundIdx === -1) foundIdx = best;
+      }
+      if (foundIdx === -1) return ifNotFound;
+      const isReturnRow = returnArray.length === 1;
+      if (isReturnRow) return returnArray[0][foundIdx] ?? null;
+      return returnArray[foundIdx]?.[0] ?? null;
+    }
+  });
+  registry.set("MATCH", {
+    minArgs: 2,
+    maxArgs: 3,
+    evaluate(args, context, evaluator) {
+      const lookupValue = evaluator.evaluate(args[0], context);
+      if (lookupValue instanceof FormulaError) return lookupValue;
+      if (args[1].kind !== "range") {
+        return new FormulaError("#VALUE!", "MATCH lookup_array must be a range");
+      }
+      const rangeData = context.getRangeValues({ start: args[1].start, end: args[1].end });
+      const isSingleRow = rangeData.length === 1;
+      const values = isSingleRow ? rangeData[0] : rangeData;
+      const getValue = isSingleRow ? (i) => values[i] : (i) => values[i][0];
+      const valuesLength = isSingleRow ? values.length : values.length;
+      let matchType = 1;
+      if (args.length >= 3) {
+        const rawMT = evaluator.evaluate(args[2], context);
+        if (rawMT instanceof FormulaError) return rawMT;
+        const mt = toNumber(rawMT);
+        if (mt instanceof FormulaError) return mt;
+        matchType = mt;
+      }
+      const lookupLower = typeof lookupValue === "string" ? lookupValue.toLowerCase() : null;
+      if (matchType === 0) {
+        for (let i = 0; i < valuesLength; i++) {
+          const cellVal = getValue(i);
+          if (lookupLower !== null && typeof cellVal === "string") {
+            if (cellVal.toLowerCase() === lookupLower) return i + 1;
+          } else if (cellVal === lookupValue) {
+            return i + 1;
+          }
+        }
+        return new FormulaError("#N/A", "MATCH no exact match found");
+      } else if (matchType === 1) {
+        let bestIndex = -1;
+        for (let i = 0; i < valuesLength; i++) {
+          const cellVal = getValue(i);
+          if (cellVal === null || cellVal === void 0) continue;
+          if (typeof lookupValue === "number" && typeof cellVal === "number") {
+            if (cellVal <= lookupValue) bestIndex = i;
+            else break;
+          } else if (lookupLower !== null && typeof cellVal === "string") {
+            if (cellVal.toLowerCase() <= lookupLower) bestIndex = i;
+            else break;
+          }
+        }
+        if (bestIndex === -1) return new FormulaError("#N/A", "MATCH no match found");
+        return bestIndex + 1;
+      } else {
+        let bestIndex = -1;
+        for (let i = 0; i < valuesLength; i++) {
+          const cellVal = getValue(i);
+          if (cellVal === null || cellVal === void 0) continue;
+          if (typeof lookupValue === "number" && typeof cellVal === "number") {
+            if (cellVal >= lookupValue) bestIndex = i;
+            else break;
+          } else if (lookupLower !== null && typeof cellVal === "string") {
+            if (cellVal.toLowerCase() >= lookupLower) bestIndex = i;
+            else break;
+          }
+        }
+        if (bestIndex === -1) return new FormulaError("#N/A", "MATCH no match found");
+        return bestIndex + 1;
+      }
+    }
+  });
+}
+
+// src/formula/functions/text.ts
+function registerTextFunctions(registry) {
+  registry.set("CONCATENATE", {
+    minArgs: 1,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      const values = flattenArgs(args, context, evaluator);
+      const parts = [];
+      for (const val of values) {
+        if (val instanceof FormulaError) return val;
+        parts.push(toString(val));
+      }
+      return parts.join("");
+    }
+  });
+  registry.set("CONCAT", {
+    minArgs: 1,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      const values = flattenArgs(args, context, evaluator);
+      const parts = [];
+      for (const val of values) {
+        if (val instanceof FormulaError) return val;
+        parts.push(toString(val));
+      }
+      return parts.join("");
+    }
+  });
+  registry.set("UPPER", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      if (val instanceof FormulaError) return val;
+      return toString(val).toUpperCase();
+    }
+  });
+  registry.set("LOWER", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      if (val instanceof FormulaError) return val;
+      return toString(val).toLowerCase();
+    }
+  });
+  registry.set("TRIM", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      if (val instanceof FormulaError) return val;
+      return toString(val).trim();
+    }
+  });
+  registry.set("LEFT", {
+    minArgs: 1,
+    maxArgs: 2,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      if (val instanceof FormulaError) return val;
+      const text = toString(val);
+      let numChars = 1;
+      if (args.length >= 2) {
+        const rawNum = evaluator.evaluate(args[1], context);
+        if (rawNum instanceof FormulaError) return rawNum;
+        const n = toNumber(rawNum);
+        if (n instanceof FormulaError) return n;
+        numChars = Math.trunc(n);
+      }
+      if (numChars < 0) return new FormulaError("#VALUE!", "LEFT num_chars must be >= 0");
+      return text.substring(0, numChars);
+    }
+  });
+  registry.set("RIGHT", {
+    minArgs: 1,
+    maxArgs: 2,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      if (val instanceof FormulaError) return val;
+      const text = toString(val);
+      let numChars = 1;
+      if (args.length >= 2) {
+        const rawNum = evaluator.evaluate(args[1], context);
+        if (rawNum instanceof FormulaError) return rawNum;
+        const n = toNumber(rawNum);
+        if (n instanceof FormulaError) return n;
+        numChars = Math.trunc(n);
+      }
+      if (numChars < 0) return new FormulaError("#VALUE!", "RIGHT num_chars must be >= 0");
+      return text.substring(Math.max(0, text.length - numChars));
+    }
+  });
+  registry.set("MID", {
+    minArgs: 3,
+    maxArgs: 3,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      if (val instanceof FormulaError) return val;
+      const text = toString(val);
+      const rawStart = evaluator.evaluate(args[1], context);
+      if (rawStart instanceof FormulaError) return rawStart;
+      const startPos = toNumber(rawStart);
+      if (startPos instanceof FormulaError) return startPos;
+      const rawNum = evaluator.evaluate(args[2], context);
+      if (rawNum instanceof FormulaError) return rawNum;
+      const numChars = toNumber(rawNum);
+      if (numChars instanceof FormulaError) return numChars;
+      const start = Math.trunc(startPos);
+      const count = Math.trunc(numChars);
+      if (start < 1) return new FormulaError("#VALUE!", "MID start_num must be >= 1");
+      if (count < 0) return new FormulaError("#VALUE!", "MID num_chars must be >= 0");
+      return text.substring(start - 1, start - 1 + count);
+    }
+  });
+  registry.set("LEN", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      if (val instanceof FormulaError) return val;
+      return toString(val).length;
+    }
+  });
+  registry.set("SUBSTITUTE", {
+    minArgs: 3,
+    maxArgs: 4,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      if (val instanceof FormulaError) return val;
+      const text = toString(val);
+      const rawOld = evaluator.evaluate(args[1], context);
+      if (rawOld instanceof FormulaError) return rawOld;
+      const oldText = toString(rawOld);
+      const rawNew = evaluator.evaluate(args[2], context);
+      if (rawNew instanceof FormulaError) return rawNew;
+      const newText = toString(rawNew);
+      if (args.length >= 4) {
+        const rawInstance = evaluator.evaluate(args[3], context);
+        if (rawInstance instanceof FormulaError) return rawInstance;
+        const instanceNum = toNumber(rawInstance);
+        if (instanceNum instanceof FormulaError) return instanceNum;
+        const n = Math.trunc(instanceNum);
+        if (n < 1) return new FormulaError("#VALUE!", "SUBSTITUTE instance_num must be >= 1");
+        let count = 0;
+        let result = "";
+        let searchFrom = 0;
+        while (searchFrom <= text.length) {
+          const idx = text.indexOf(oldText, searchFrom);
+          if (idx === -1) {
+            result += text.substring(searchFrom);
+            break;
+          }
+          count++;
+          if (count === n) {
+            result += text.substring(searchFrom, idx) + newText;
+            result += text.substring(idx + oldText.length);
+            break;
+          } else {
+            result += text.substring(searchFrom, idx + oldText.length);
+            searchFrom = idx + oldText.length;
+          }
+        }
+        return result;
+      } else {
+        if (oldText === "") return text;
+        return text.split(oldText).join(newText);
+      }
+    }
+  });
+  registry.set("FIND", {
+    minArgs: 2,
+    maxArgs: 3,
+    evaluate(args, context, evaluator) {
+      const rawFind = evaluator.evaluate(args[0], context);
+      if (rawFind instanceof FormulaError) return rawFind;
+      const findText = toString(rawFind);
+      const rawWithin = evaluator.evaluate(args[1], context);
+      if (rawWithin instanceof FormulaError) return rawWithin;
+      const withinText = toString(rawWithin);
+      let startNum = 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;
+        startNum = Math.trunc(s);
+      }
+      if (startNum < 1) return new FormulaError("#VALUE!", "FIND start_num must be >= 1");
+      const idx = withinText.indexOf(findText, startNum - 1);
+      if (idx === -1) return new FormulaError("#VALUE!", "FIND text not found");
+      return idx + 1;
+    }
+  });
+  registry.set("SEARCH", {
+    minArgs: 2,
+    maxArgs: 3,
+    evaluate(args, context, evaluator) {
+      const rawFind = evaluator.evaluate(args[0], context);
+      if (rawFind instanceof FormulaError) return rawFind;
+      const findText = toString(rawFind).toLowerCase();
+      const rawWithin = evaluator.evaluate(args[1], context);
+      if (rawWithin instanceof FormulaError) return rawWithin;
+      const withinText = toString(rawWithin).toLowerCase();
+      let startNum = 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;
+        startNum = Math.trunc(s);
+      }
+      if (startNum < 1) return new FormulaError("#VALUE!", "SEARCH start_num must be >= 1");
+      const idx = withinText.indexOf(findText, startNum - 1);
+      if (idx === -1) return new FormulaError("#VALUE!", "SEARCH text not found");
+      return idx + 1;
+    }
+  });
+  registry.set("REPLACE", {
+    minArgs: 4,
+    maxArgs: 4,
+    evaluate(args, context, evaluator) {
+      const rawText = evaluator.evaluate(args[0], context);
+      if (rawText instanceof FormulaError) return rawText;
+      const text = toString(rawText);
+      const rawStart = evaluator.evaluate(args[1], context);
+      if (rawStart instanceof FormulaError) return rawStart;
+      const startPos = toNumber(rawStart);
+      if (startPos instanceof FormulaError) return startPos;
+      const rawNum = evaluator.evaluate(args[2], context);
+      if (rawNum instanceof FormulaError) return rawNum;
+      const numChars = toNumber(rawNum);
+      if (numChars instanceof FormulaError) return numChars;
+      const rawNew = evaluator.evaluate(args[3], context);
+      if (rawNew instanceof FormulaError) return rawNew;
+      const newText = toString(rawNew);
+      const start = Math.trunc(startPos) - 1;
+      const count = Math.trunc(numChars);
+      return text.substring(0, start) + newText + text.substring(start + count);
+    }
+  });
+  registry.set("REPT", {
+    minArgs: 2,
+    maxArgs: 2,
+    evaluate(args, context, evaluator) {
+      const rawText = evaluator.evaluate(args[0], context);
+      if (rawText instanceof FormulaError) return rawText;
+      const text = toString(rawText);
+      const rawTimes = evaluator.evaluate(args[1], context);
+      if (rawTimes instanceof FormulaError) return rawTimes;
+      const times = toNumber(rawTimes);
+      if (times instanceof FormulaError) return times;
+      const n = Math.trunc(times);
+      if (n < 0) return new FormulaError("#VALUE!", "REPT number must be >= 0");
+      return text.repeat(n);
+    }
+  });
+  registry.set("EXACT", {
+    minArgs: 2,
+    maxArgs: 2,
+    evaluate(args, context, evaluator) {
+      const rawA = evaluator.evaluate(args[0], context);
+      if (rawA instanceof FormulaError) return rawA;
+      const rawB = evaluator.evaluate(args[1], context);
+      if (rawB instanceof FormulaError) return rawB;
+      return toString(rawA) === toString(rawB);
+    }
+  });
+  registry.set("PROPER", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      if (val instanceof FormulaError) return val;
+      return toString(val).toLowerCase().replace(/\b\w/g, (c) => c.toUpperCase());
+    }
+  });
+  registry.set("CLEAN", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      if (val instanceof FormulaError) return val;
+      return toString(val).replace(/[\x00-\x1F]/g, "");
+    }
+  });
+  registry.set("CHAR", {
+    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 < 1 || n > 65535) return new FormulaError("#VALUE!", "CHAR number must be 1-65535");
+      return String.fromCharCode(n);
+    }
+  });
+  registry.set("CODE", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      if (val instanceof FormulaError) return val;
+      const text = toString(val);
+      if (text.length === 0) return new FormulaError("#VALUE!", "CODE requires non-empty text");
+      return text.charCodeAt(0);
+    }
+  });
+  registry.set("TEXT", {
+    minArgs: 2,
+    maxArgs: 2,
+    evaluate(args, context, evaluator) {
+      const rawVal = evaluator.evaluate(args[0], context);
+      if (rawVal instanceof FormulaError) return rawVal;
+      const rawFmt = evaluator.evaluate(args[1], context);
+      if (rawFmt instanceof FormulaError) return rawFmt;
+      const fmt = toString(rawFmt);
+      const num = toNumber(rawVal);
+      if (num instanceof FormulaError) return toString(rawVal);
+      if (fmt.includes("%")) {
+        const decimals2 = (fmt.match(/0/g) || []).length - 1;
+        return (num * 100).toFixed(Math.max(0, decimals2)) + "%";
+      }
+      const decimalMatch = fmt.match(/\.(0+)/);
+      const decimals = decimalMatch ? decimalMatch[1].length : 0;
+      const useCommas = fmt.includes(",");
+      const result = num.toFixed(decimals);
+      if (useCommas) {
+        const [intPart, decPart] = result.split(".");
+        const withCommas = intPart.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+        return decPart ? withCommas + "." + decPart : withCommas;
+      }
+      return result;
+    }
+  });
+  registry.set("VALUE", {
+    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;
+      const raw = toString(val).trim();
+      const isPercent = raw.endsWith("%");
+      const text = raw.replace(/[,$%\s]/g, "");
+      const n = Number(text);
+      if (isNaN(n)) return new FormulaError("#VALUE!", "VALUE cannot convert text to number");
+      return isPercent ? n / 100 : n;
+    }
+  });
+  registry.set("TEXTJOIN", {
+    minArgs: 3,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      const rawDelim = evaluator.evaluate(args[0], context);
+      if (rawDelim instanceof FormulaError) return rawDelim;
+      const delimiter = toString(rawDelim);
+      const rawIgnore = evaluator.evaluate(args[1], context);
+      if (rawIgnore instanceof FormulaError) return rawIgnore;
+      const ignoreEmpty = !!rawIgnore;
+      const parts = [];
+      for (let i = 2; i < args.length; i++) {
+        const arg = args[i];
+        if (arg.kind === "range") {
+          const rangeData = context.getRangeValues({ start: arg.start, end: arg.end });
+          for (const row of rangeData) {
+            for (const cell of row) {
+              if (cell instanceof FormulaError) return cell;
+              const s = toString(cell);
+              if (!ignoreEmpty || s !== "") parts.push(s);
+            }
+          }
+        } else {
+          const val = evaluator.evaluate(args[i], context);
+          if (val instanceof FormulaError) return val;
+          const s = toString(val);
+          if (!ignoreEmpty || s !== "") parts.push(s);
+        }
+      }
+      return parts.join(delimiter);
+    }
+  });
+}
+
+// src/formula/functions/date.ts
+function toDate(val) {
+  if (val instanceof FormulaError) return val;
+  if (val instanceof Date) {
+    if (isNaN(val.getTime())) return new FormulaError("#VALUE!", "Invalid date");
+    return val;
+  }
+  if (typeof val === "string") {
+    const d = new Date(val);
+    if (isNaN(d.getTime())) return new FormulaError("#VALUE!", `Cannot parse "${val}" as date`);
+    return d;
+  }
+  if (typeof val === "number") {
+    const d = new Date(val);
+    if (isNaN(d.getTime())) return new FormulaError("#VALUE!", "Invalid numeric date");
+    return d;
+  }
+  return new FormulaError("#VALUE!", "Cannot convert value to date");
+}
+function registerDateFunctions(registry) {
+  registry.set("TODAY", {
+    minArgs: 0,
+    maxArgs: 0,
+    evaluate(_args, context) {
+      const now = context.now();
+      return new Date(now.getFullYear(), now.getMonth(), now.getDate());
+    }
+  });
+  registry.set("NOW", {
+    minArgs: 0,
+    maxArgs: 0,
+    evaluate(_args, context) {
+      return context.now();
+    }
+  });
+  registry.set("YEAR", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      if (val instanceof FormulaError) return val;
+      const date = toDate(val);
+      if (date instanceof FormulaError) return date;
+      return date.getFullYear();
+    }
+  });
+  registry.set("MONTH", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      if (val instanceof FormulaError) return val;
+      const date = toDate(val);
+      if (date instanceof FormulaError) return date;
+      return date.getMonth() + 1;
+    }
+  });
+  registry.set("DAY", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      if (val instanceof FormulaError) return val;
+      const date = toDate(val);
+      if (date instanceof FormulaError) return date;
+      return date.getDate();
+    }
+  });
+  registry.set("DATE", {
+    minArgs: 3,
+    maxArgs: 3,
+    evaluate(args, context, evaluator) {
+      const rawY = evaluator.evaluate(args[0], context);
+      if (rawY instanceof FormulaError) return rawY;
+      const y = toNumber(rawY);
+      if (y instanceof FormulaError) return y;
+      const rawM = evaluator.evaluate(args[1], context);
+      if (rawM instanceof FormulaError) return rawM;
+      const m = toNumber(rawM);
+      if (m instanceof FormulaError) return m;
+      const rawD = evaluator.evaluate(args[2], context);
+      if (rawD instanceof FormulaError) return rawD;
+      const d = toNumber(rawD);
+      if (d instanceof FormulaError) return d;
+      return new Date(Math.trunc(y), Math.trunc(m) - 1, Math.trunc(d));
+    }
+  });
+  registry.set("DATEDIF", {
+    minArgs: 3,
+    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;
+      const rawUnit = evaluator.evaluate(args[2], context);
+      if (rawUnit instanceof FormulaError) return rawUnit;
+      const unit = String(rawUnit).toUpperCase();
+      if (startDate > endDate) return new FormulaError("#NUM!", "DATEDIF start date must be <= end date");
+      switch (unit) {
+        case "Y": {
+          let years = endDate.getFullYear() - startDate.getFullYear();
+          if (endDate.getMonth() < startDate.getMonth() || endDate.getMonth() === startDate.getMonth() && endDate.getDate() < startDate.getDate()) {
+            years--;
+          }
+          return years;
+        }
+        case "M": {
+          let months = (endDate.getFullYear() - startDate.getFullYear()) * 12 + endDate.getMonth() - startDate.getMonth();
+          if (endDate.getDate() < startDate.getDate()) months--;
+          return months;
+        }
+        case "D":
+          return Math.floor((endDate.getTime() - startDate.getTime()) / 864e5);
+        default:
+          return new FormulaError("#VALUE!", "DATEDIF unit must be Y, M, or D");
+      }
+    }
+  });
+  registry.set("EDATE", {
+    minArgs: 2,
+    maxArgs: 2,
+    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 rawMonths = evaluator.evaluate(args[1], context);
+      if (rawMonths instanceof FormulaError) return rawMonths;
+      const months = toNumber(rawMonths);
+      if (months instanceof FormulaError) return months;
+      const result = new Date(date);
+      result.setMonth(result.getMonth() + Math.trunc(months));
+      return result;
+    }
+  });
+  registry.set("EOMONTH", {
+    minArgs: 2,
+    maxArgs: 2,
+    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 rawMonths = evaluator.evaluate(args[1], context);
+      if (rawMonths instanceof FormulaError) return rawMonths;
+      const months = toNumber(rawMonths);
+      if (months instanceof FormulaError) return months;
+      const result = new Date(date.getFullYear(), date.getMonth() + Math.trunc(months) + 1, 0);
+      return result;
+    }
+  });
+  registry.set("WEEKDAY", {
+    minArgs: 1,
+    maxArgs: 2,
+    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;
+      let returnType = 1;
+      if (args.length >= 2) {
+        const rawRT = evaluator.evaluate(args[1], context);
+        if (rawRT instanceof FormulaError) return rawRT;
+        const rt = toNumber(rawRT);
+        if (rt instanceof FormulaError) return rt;
+        returnType = Math.trunc(rt);
+      }
+      const day = date.getDay();
+      switch (returnType) {
+        case 1:
+          return day + 1;
+        // 1=Sun, 7=Sat
+        case 2:
+          return day === 0 ? 7 : day;
+        // 1=Mon, 7=Sun
+        case 3:
+          return day === 0 ? 6 : day - 1;
+        // 0=Mon, 6=Sun
+        default:
+          return new FormulaError("#VALUE!", "WEEKDAY return_type must be 1, 2, or 3");
+      }
+    }
+  });
+  registry.set("HOUR", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      if (val instanceof FormulaError) return val;
+      const date = toDate(val);
+      if (date instanceof FormulaError) return date;
+      return date.getHours();
+    }
+  });
+  registry.set("MINUTE", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      if (val instanceof FormulaError) return val;
+      const date = toDate(val);
+      if (date instanceof FormulaError) return date;
+      return date.getMinutes();
+    }
+  });
+  registry.set("SECOND", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      if (val instanceof FormulaError) return val;
+      const date = toDate(val);
+      if (date instanceof FormulaError) return date;
+      return date.getSeconds();
+    }
+  });
+  registry.set("NETWORKDAYS", {
+    minArgs: 2,
+    maxArgs: 2,
+    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;
+      const start = new Date(startDate.getFullYear(), startDate.getMonth(), startDate.getDate());
+      const end = new Date(endDate.getFullYear(), endDate.getMonth(), endDate.getDate());
+      const sign = end >= start ? 1 : -1;
+      const [from, to] = sign === 1 ? [start, end] : [end, start];
+      let count = 0;
+      const current = new Date(from);
+      while (current <= to) {
+        const day = current.getDay();
+        if (day !== 0 && day !== 6) count++;
+        current.setDate(current.getDate() + 1);
+      }
+      return count * sign;
+    }
+  });
+}
+
+// src/formula/functions/stats.ts
+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;
+      case "<>":
+        return comparableCell !== value;
+      case ">":
+        return comparableCell > value;
+      case "<":
+        return comparableCell < value;
+      case ">=":
+        return comparableCell >= value;
+      case "<=":
+        return comparableCell <= value;
+    }
+  }
+  if (op === "=") return comparableCell === value;
+  if (op === "<>") return comparableCell !== value;
+  return false;
+}
+function registerStatsFunctions(registry) {
+  registry.set("SUMIF", {
+    minArgs: 2,
+    maxArgs: 3,
+    evaluate(args, context, evaluator) {
+      if (args[0].kind !== "range") {
+        return new FormulaError("#VALUE!", "SUMIF range must be a cell range");
+      }
+      const criteriaRange = context.getRangeValues({ start: args[0].start, end: args[0].end });
+      const rawCriteria = evaluator.evaluate(args[1], context);
+      if (rawCriteria instanceof FormulaError) return rawCriteria;
+      const criteria = parseCriteria(rawCriteria);
+      let sumRange;
+      if (args.length >= 3) {
+        if (args[2].kind !== "range") {
+          return new FormulaError("#VALUE!", "SUMIF sum_range must be a cell range");
+        }
+        sumRange = context.getRangeValues({ start: args[2].start, end: args[2].end });
+      } else {
+        sumRange = criteriaRange;
+      }
+      let sum = 0;
+      for (let r = 0; r < criteriaRange.length; r++) {
+        for (let c = 0; c < criteriaRange[r].length; c++) {
+          if (matchesCriteria(criteriaRange[r][c], criteria)) {
+            const sumVal = sumRange[r] && sumRange[r][c] !== void 0 ? sumRange[r][c] : null;
+            const n = toNumber(sumVal);
+            if (typeof n === "number") {
+              sum += n;
+            }
+          }
+        }
+      }
+      return sum;
+    }
+  });
+  registry.set("COUNTIF", {
+    minArgs: 2,
+    maxArgs: 2,
+    evaluate(args, context, evaluator) {
+      if (args[0].kind !== "range") {
+        return new FormulaError("#VALUE!", "COUNTIF range must be a cell range");
+      }
+      const rangeData = context.getRangeValues({ start: args[0].start, end: args[0].end });
+      const rawCriteria = evaluator.evaluate(args[1], context);
+      if (rawCriteria instanceof FormulaError) return rawCriteria;
+      const criteria = parseCriteria(rawCriteria);
+      let count = 0;
+      for (let r = 0; r < rangeData.length; r++) {
+        for (let c = 0; c < rangeData[r].length; c++) {
+          if (matchesCriteria(rangeData[r][c], criteria)) {
+            count++;
+          }
+        }
+      }
+      return count;
+    }
+  });
+  registry.set("AVERAGEIF", {
+    minArgs: 2,
+    maxArgs: 3,
+    evaluate(args, context, evaluator) {
+      if (args[0].kind !== "range") {
+        return new FormulaError("#VALUE!", "AVERAGEIF range must be a cell range");
+      }
+      const criteriaRange = context.getRangeValues({ start: args[0].start, end: args[0].end });
+      const rawCriteria = evaluator.evaluate(args[1], context);
+      if (rawCriteria instanceof FormulaError) return rawCriteria;
+      const criteria = parseCriteria(rawCriteria);
+      let avgRange;
+      if (args.length >= 3) {
+        if (args[2].kind !== "range") {
+          return new FormulaError("#VALUE!", "AVERAGEIF avg_range must be a cell range");
+        }
+        avgRange = context.getRangeValues({ start: args[2].start, end: args[2].end });
+      } else {
+        avgRange = criteriaRange;
+      }
+      let sum = 0;
+      let count = 0;
+      for (let r = 0; r < criteriaRange.length; r++) {
+        for (let c = 0; c < criteriaRange[r].length; c++) {
+          if (matchesCriteria(criteriaRange[r][c], criteria)) {
+            const avgVal = avgRange[r] && avgRange[r][c] !== void 0 ? avgRange[r][c] : null;
+            const n = toNumber(avgVal);
+            if (typeof n === "number") {
+              sum += n;
+              count++;
+            }
+          }
+        }
+      }
+      if (count === 0) return new FormulaError("#DIV/0!", "No matching values for AVERAGEIF");
+      return sum / count;
+    }
+  });
+  registry.set("SUMIFS", {
+    minArgs: 3,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      if ((args.length - 1) % 2 !== 0) {
+        return new FormulaError("#VALUE!", "SUMIFS requires sum_range + pairs of criteria_range, criteria");
+      }
+      if (args[0].kind !== "range") {
+        return new FormulaError("#VALUE!", "SUMIFS sum_range must be a cell range");
+      }
+      const sumRange = context.getRangeValues({ start: args[0].start, end: args[0].end });
+      const pairs = [];
+      for (let i = 1; i < args.length; i += 2) {
+        const rangeArg = args[i];
+        if (rangeArg.kind !== "range") {
+          return new FormulaError("#VALUE!", "SUMIFS criteria_range must be a cell range");
+        }
+        const range = context.getRangeValues({ start: rangeArg.start, end: rangeArg.end });
+        const rawCriteria = evaluator.evaluate(args[i + 1], context);
+        if (rawCriteria instanceof FormulaError) return rawCriteria;
+        pairs.push({ range, criteria: parseCriteria(rawCriteria) });
+      }
+      let sum = 0;
+      for (let r = 0; r < sumRange.length; r++) {
+        for (let c = 0; c < sumRange[r].length; c++) {
+          let allMatch = true;
+          for (const pair of pairs) {
+            const cellVal = pair.range[r]?.[c];
+            if (!matchesCriteria(cellVal, pair.criteria)) {
+              allMatch = false;
+              break;
+            }
+          }
+          if (allMatch) {
+            const n = toNumber(sumRange[r][c]);
+            if (typeof n === "number") sum += n;
+          }
+        }
+      }
+      return sum;
+    }
+  });
+  registry.set("COUNTIFS", {
+    minArgs: 2,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      if (args.length % 2 !== 0) {
+        return new FormulaError("#VALUE!", "COUNTIFS requires pairs of criteria_range, criteria");
+      }
+      const pairs = [];
+      for (let i = 0; i < args.length; i += 2) {
+        const rangeArg = args[i];
+        if (rangeArg.kind !== "range") {
+          return new FormulaError("#VALUE!", "COUNTIFS criteria_range must be a cell range");
+        }
+        const range = context.getRangeValues({ start: rangeArg.start, end: rangeArg.end });
+        const rawCriteria = evaluator.evaluate(args[i + 1], context);
+        if (rawCriteria instanceof FormulaError) return rawCriteria;
+        pairs.push({ range, criteria: parseCriteria(rawCriteria) });
+      }
+      const firstRange = pairs[0].range;
+      let count = 0;
+      for (let r = 0; r < firstRange.length; r++) {
+        for (let c = 0; c < firstRange[r].length; c++) {
+          let allMatch = true;
+          for (const pair of pairs) {
+            const cellVal = pair.range[r]?.[c];
+            if (!matchesCriteria(cellVal, pair.criteria)) {
+              allMatch = false;
+              break;
+            }
+          }
+          if (allMatch) count++;
+        }
+      }
+      return count;
+    }
+  });
+  registry.set("AVERAGEIFS", {
+    minArgs: 3,
+    maxArgs: -1,
+    evaluate(args, context, evaluator) {
+      if ((args.length - 1) % 2 !== 0) {
+        return new FormulaError("#VALUE!", "AVERAGEIFS requires avg_range + pairs of criteria_range, criteria");
+      }
+      if (args[0].kind !== "range") {
+        return new FormulaError("#VALUE!", "AVERAGEIFS avg_range must be a cell range");
+      }
+      const avgRange = context.getRangeValues({ start: args[0].start, end: args[0].end });
+      const pairs = [];
+      for (let i = 1; i < args.length; i += 2) {
+        const rangeArg = args[i];
+        if (rangeArg.kind !== "range") {
+          return new FormulaError("#VALUE!", "AVERAGEIFS criteria_range must be a cell range");
+        }
+        const range = context.getRangeValues({ start: rangeArg.start, end: rangeArg.end });
+        const rawCriteria = evaluator.evaluate(args[i + 1], context);
+        if (rawCriteria instanceof FormulaError) return rawCriteria;
+        pairs.push({ range, criteria: parseCriteria(rawCriteria) });
+      }
+      let sum = 0;
+      let count = 0;
+      for (let r = 0; r < avgRange.length; r++) {
+        for (let c = 0; c < avgRange[r].length; c++) {
+          let allMatch = true;
+          for (const pair of pairs) {
+            const cellVal = pair.range[r]?.[c];
+            if (!matchesCriteria(cellVal, pair.criteria)) {
+              allMatch = false;
+              break;
+            }
+          }
+          if (allMatch) {
+            const n = toNumber(avgRange[r][c]);
+            if (typeof n === "number") {
+              sum += n;
+              count++;
+            }
+          }
+        }
+      }
+      if (count === 0) return new FormulaError("#DIV/0!", "No matching values for AVERAGEIFS");
+      return sum / count;
+    }
+  });
+}
+
+// src/formula/functions/info.ts
+function registerInfoFunctions(registry) {
+  registry.set("ISBLANK", {
+    minArgs: 1,
+    maxArgs: 1,
+    evaluate(args, context, evaluator) {
+      const val = evaluator.evaluate(args[0], context);
+      return val === null || val === void 0 || val === "";
+    }
+  });
+  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;
+    }
+  });
+}
+
+// src/formula/functions/index.ts
+function createBuiltInFunctions() {
+  const registry = /* @__PURE__ */ new Map();
+  registerMathFunctions(registry);
+  registerLogicalFunctions(registry);
+  registerLookupFunctions(registry);
+  registerTextFunctions(registry);
+  registerDateFunctions(registry);
+  registerStatsFunctions(registry);
+  registerInfoFunctions(registry);
+  return registry;
+}
+
+// src/formula/formulaEngine.ts
+function extractDependencies(node) {
+  const deps = /* @__PURE__ */ new Set();
+  function walk(n) {
+    switch (n.kind) {
+      case "cellRef":
+        deps.add(toCellKey(n.address.col, n.address.row, n.address.sheet));
+        break;
+      case "range": {
+        const sheet = n.start.sheet;
+        const minRow = Math.min(n.start.row, n.end.row);
+        const maxRow = Math.max(n.start.row, n.end.row);
+        const minCol = Math.min(n.start.col, n.end.col);
+        const maxCol = Math.max(n.start.col, n.end.col);
+        for (let r = minRow; r <= maxRow; r++) {
+          for (let c = minCol; c <= maxCol; c++) {
+            deps.add(toCellKey(c, r, sheet));
+          }
+        }
+        break;
+      }
+      case "functionCall":
+        for (const arg of n.args) walk(arg);
+        break;
+      case "binaryOp":
+        walk(n.left);
+        walk(n.right);
+        break;
+      case "unaryOp":
+        walk(n.operand);
+        break;
+    }
+  }
+  walk(node);
+  return deps;
+}
+var FormulaEngine = class {
+  constructor(config) {
+    this.formulas = /* @__PURE__ */ new Map();
+    this.parsedFormulas = /* @__PURE__ */ new Map();
+    this.values = /* @__PURE__ */ new Map();
+    this.depGraph = new DependencyGraph();
+    this.namedRanges = /* @__PURE__ */ new Map();
+    this.sheetAccessors = /* @__PURE__ */ new Map();
+    const builtIns = createBuiltInFunctions();
+    if (config?.customFunctions) {
+      for (const [name, fn] of Object.entries(config.customFunctions)) {
+        builtIns.set(name.toUpperCase(), fn);
+      }
+    }
+    if (config?.namedRanges) {
+      for (const [name, ref] of Object.entries(config.namedRanges)) {
+        this.namedRanges.set(name.toUpperCase(), ref);
+      }
+    }
+    this.evaluator = new FormulaEvaluator(builtIns);
+    this.maxChainLength = config?.maxChainLength ?? 1e3;
+  }
+  /**
+   * Set or clear a formula for a cell.
+   */
+  setFormula(col, row, formula, accessor) {
+    const key = toCellKey(col, row);
+    if (formula === null || formula === "") {
+      const oldValue2 = this.values.get(key);
+      this.formulas.delete(key);
+      this.parsedFormulas.delete(key);
+      this.values.delete(key);
+      this.depGraph.removeDependencies(key);
+      return {
+        updatedCells: oldValue2 !== void 0 ? [{ cellKey: key, col, row, oldValue: oldValue2, newValue: void 0 }] : []
+      };
+    }
+    const expression = formula.startsWith("=") ? formula.slice(1) : formula;
+    let ast;
+    try {
+      const tokens = tokenize(expression);
+      ast = parse(tokens, this.namedRanges);
+    } catch (err) {
+      const error = err instanceof FormulaError ? err : new FormulaError("#ERROR!", String(err));
+      ast = { kind: "error", error };
+    }
+    const deps = extractDependencies(ast);
+    if (deps.has(key) || this.depGraph.wouldCreateCycle(key, deps)) {
+      const oldValue2 = this.values.get(key);
+      const circError = new FormulaError("#CIRC!", "Circular reference detected");
+      this.formulas.set(key, formula);
+      this.parsedFormulas.set(key, ast);
+      this.values.set(key, circError);
+      this.depGraph.setDependencies(key, deps);
+      return {
+        updatedCells: [{ cellKey: key, col, row, oldValue: oldValue2, newValue: circError }]
+      };
+    }
+    this.depGraph.setDependencies(key, deps);
+    this.formulas.set(key, formula);
+    this.parsedFormulas.set(key, ast);
+    const oldValue = this.values.get(key);
+    const context = this.createContext(accessor);
+    const newValue = this.evaluator.evaluate(ast, context);
+    this.values.set(key, newValue);
+    const updatedCells = [
+      { cellKey: key, col, row, oldValue, newValue }
+    ];
+    const recalcOrder = this.depGraph.getRecalcOrder(key);
+    this.recalcCells(recalcOrder, accessor, updatedCells);
+    return { updatedCells };
+  }
+  /**
+   * Notify the engine that a non-formula cell's value changed.
+   */
+  onCellChanged(col, row, accessor) {
+    const key = toCellKey(col, row);
+    const recalcOrder = this.depGraph.getRecalcOrder(key);
+    if (recalcOrder.length === 0) return { updatedCells: [] };
+    const updatedCells = [];
+    this.recalcCells(recalcOrder, accessor, updatedCells);
+    return { updatedCells };
+  }
+  /**
+   * Batch notify: multiple cells changed.
+   */
+  onCellsChanged(cells, accessor) {
+    const keys = cells.map((c) => toCellKey(c.col, c.row));
+    const recalcOrder = this.depGraph.getRecalcOrderBatch(keys);
+    if (recalcOrder.length === 0) return { updatedCells: [] };
+    const updatedCells = [];
+    this.recalcCells(recalcOrder, accessor, updatedCells);
+    return { updatedCells };
+  }
+  /**
+   * Get the current computed value for a cell.
+   */
+  getValue(col, row) {
+    return this.values.get(toCellKey(col, row));
+  }
+  /**
+   * Get the formula string for a cell.
+   */
+  getFormula(col, row) {
+    return this.formulas.get(toCellKey(col, row));
+  }
+  /**
+   * Check if a cell has a formula.
+   */
+  hasFormula(col, row) {
+    return this.formulas.has(toCellKey(col, row));
+  }
+  /**
+   * Register a custom function at runtime.
+   */
+  registerFunction(name, fn) {
+    this.evaluator.registerFunction(name, fn);
+  }
+  /**
+   * Full recalculation of all formulas.
+   */
+  recalcAll(accessor) {
+    const updatedCells = [];
+    const context = this.createContext(accessor);
+    if (this.formulas.size === 0) return { updatedCells };
+    const allFormulaKeys = [];
+    for (const key of this.formulas.keys()) allFormulaKeys.push(key);
+    const recalcOrder = this.depGraph.getRecalcOrderBatch(allFormulaKeys);
+    const ordered = new Set(recalcOrder);
+    for (const key of allFormulaKeys) {
+      if (!ordered.has(key)) {
+        const { col, row } = fromCellKey(key);
+        const ast = this.parsedFormulas.get(key);
+        if (!ast) continue;
+        const oldValue = this.values.get(key);
+        const newValue = this.evaluator.evaluate(ast, context);
+        this.values.set(key, newValue);
+        updatedCells.push({ cellKey: key, col, row, oldValue, newValue });
+      }
+    }
+    this.recalcCells(recalcOrder, accessor, updatedCells);
+    return { updatedCells };
+  }
+  /**
+   * Clear all formulas and cached values.
+   */
+  clear() {
+    this.formulas.clear();
+    this.parsedFormulas.clear();
+    this.values.clear();
+    this.depGraph.clear();
+  }
+  /**
+   * Get all formula entries for serialization.
+   */
+  getAllFormulas() {
+    const result = [];
+    for (const [key, formula] of this.formulas) {
+      const { col, row } = fromCellKey(key);
+      result.push({ col, row, formula });
+    }
+    return result;
+  }
+  /**
+   * Bulk-load formulas. Recalculates everything.
+   */
+  loadFormulas(formulas, accessor) {
+    this.clear();
+    for (const { col, row, formula } of formulas) {
+      const key = toCellKey(col, row);
+      const expression = formula.startsWith("=") ? formula.slice(1) : formula;
+      let ast;
+      try {
+        const tokens = tokenize(expression);
+        ast = parse(tokens, this.namedRanges);
+      } catch (err) {
+        const error = err instanceof FormulaError ? err : new FormulaError("#ERROR!", String(err));
+        ast = { kind: "error", error };
+      }
+      this.formulas.set(key, formula);
+      this.parsedFormulas.set(key, ast);
+      const deps = extractDependencies(ast);
+      this.depGraph.setDependencies(key, deps);
+    }
+    return this.recalcAll(accessor);
+  }
+  // --- Named Ranges ---
+  /**
+   * Define a named range (e.g. "Revenue" → "A1:A10").
+   */
+  defineNamedRange(name, ref) {
+    this.namedRanges.set(name.toUpperCase(), ref);
+  }
+  /**
+   * Remove a named range by name.
+   */
+  removeNamedRange(name) {
+    this.namedRanges.delete(name.toUpperCase());
+  }
+  /**
+   * Get all named ranges as a Map (name → ref).
+   */
+  getNamedRanges() {
+    return this.namedRanges;
+  }
+  // --- Sheet Accessors ---
+  /**
+   * Register a data accessor for a named sheet (for cross-sheet references).
+   */
+  registerSheet(name, accessor) {
+    this.sheetAccessors.set(name, accessor);
+  }
+  /**
+   * Unregister a sheet accessor.
+   */
+  unregisterSheet(name) {
+    this.sheetAccessors.delete(name);
+  }
+  // --- Formula Auditing ---
+  /**
+   * Get all cells that a cell depends on (deep, transitive precedents).
+   */
+  getPrecedents(col, row) {
+    const key = toCellKey(col, row);
+    const result = [];
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [];
+    const directDeps = this.depGraph.getDependencies(key);
+    for (const dep of directDeps) {
+      if (!visited.has(dep)) {
+        visited.add(dep);
+        queue.push(dep);
+      }
+    }
+    let head = 0;
+    while (head < queue.length) {
+      const current = queue[head++];
+      const parsed = fromCellKey(current);
+      result.push({
+        cellKey: current,
+        col: parsed.col,
+        row: parsed.row,
+        formula: this.formulas.get(current),
+        value: this.values.has(current) ? this.values.get(current) : void 0
+      });
+      const deps = this.depGraph.getDependencies(current);
+      for (const dep of deps) {
+        if (!visited.has(dep)) {
+          visited.add(dep);
+          queue.push(dep);
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Get all cells that depend on this cell (deep, transitive dependents).
+   */
+  getDependents(col, row) {
+    const key = toCellKey(col, row);
+    const result = [];
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [];
+    const directDeps = this.depGraph.getDependents(key);
+    for (const dep of directDeps) {
+      if (!visited.has(dep)) {
+        visited.add(dep);
+        queue.push(dep);
+      }
+    }
+    let head = 0;
+    while (head < queue.length) {
+      const current = queue[head++];
+      const parsed = fromCellKey(current);
+      result.push({
+        cellKey: current,
+        col: parsed.col,
+        row: parsed.row,
+        formula: this.formulas.get(current),
+        value: this.values.has(current) ? this.values.get(current) : void 0
+      });
+      const deps = this.depGraph.getDependents(current);
+      for (const dep of deps) {
+        if (!visited.has(dep)) {
+          visited.add(dep);
+          queue.push(dep);
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Get a full audit trail for a cell: target + precedents + dependents.
+   */
+  getAuditTrail(col, row) {
+    const key = toCellKey(col, row);
+    const target = {
+      cellKey: key,
+      col,
+      row,
+      formula: this.formulas.get(key),
+      value: this.values.has(key) ? this.values.get(key) : void 0
+    };
+    return {
+      target,
+      precedents: this.getPrecedents(col, row),
+      dependents: this.getDependents(col, row)
+    };
+  }
+  // --- Private methods ---
+  createContext(accessor) {
+    const contextNow = /* @__PURE__ */ new Date();
+    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 (addr.sheet) {
+          const sheetAccessor = this.sheetAccessors.get(addr.sheet);
+          if (!sheetAccessor) return new FormulaError("#REF!", `Unknown sheet: ${addr.sheet}`);
+          return sheetAccessor.getCellValue(addr.col, addr.row);
+        }
+        return accessor.getCellValue(addr.col, addr.row);
+      },
+      getRangeValues: (range) => {
+        const result = [];
+        const sheet = range.start.sheet;
+        const rangeAccessor = sheet ? this.sheetAccessors.get(sheet) : accessor;
+        if (sheet && !rangeAccessor) {
+          return [[new FormulaError("#REF!", `Unknown sheet: ${sheet}`)]];
+        }
+        const minRow = Math.min(range.start.row, range.end.row);
+        const maxRow = Math.max(range.start.row, range.end.row);
+        const minCol = Math.min(range.start.col, range.end.col);
+        const maxCol = Math.max(range.start.col, range.end.col);
+        for (let r = minRow; r <= maxRow; r++) {
+          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);
+            } else {
+              row.push(rangeAccessor.getCellValue(c, r));
+            }
+          }
+          result.push(row);
+        }
+        return result;
+      },
+      now: () => contextNow
+    };
+  }
+  recalcCells(order, accessor, updatedCells) {
+    const context = this.createContext(accessor);
+    let count = 0;
+    for (const key of order) {
+      if (count++ > this.maxChainLength) {
+        const { col: col2, row: row2 } = fromCellKey(key);
+        const oldValue2 = this.values.get(key);
+        const circError = new FormulaError("#CIRC!", "Dependency chain too long");
+        this.values.set(key, circError);
+        updatedCells.push({ cellKey: key, col: col2, row: row2, oldValue: oldValue2, newValue: circError });
+        continue;
+      }
+      const ast = this.parsedFormulas.get(key);
+      if (!ast) continue;
+      const { col, row } = fromCellKey(key);
+      const oldValue = this.values.get(key);
+      const newValue = this.evaluator.evaluate(ast, context);
+      this.values.set(key, newValue);
+      updatedCells.push({ cellKey: key, col, row, oldValue, newValue });
+    }
+  }
+};
+
+export { AUTOSIZE_EXTRA_PX, AUTOSIZE_MAX_PX, CELL_PADDING, CHECKBOX_COLUMN_WIDTH, CIRC_ERROR, COLUMN_HEADER_MENU_ITEMS, CellDescriptorCache, DEFAULT_DEBOUNCE_MS, DEFAULT_MIN_COLUMN_WIDTH, DIV_ZERO_ERROR, DependencyGraph, FormulaEngine, FormulaError, FormulaEvaluator, GENERAL_ERROR, GRID_BORDER_RADIUS, GRID_CONTEXT_MENU_ITEMS, MAX_PAGE_BUTTONS, NAME_ERROR, NA_ERROR, PAGE_SIZE_OPTIONS, PEOPLE_SEARCH_DEBOUNCE_MS, REF_ERROR, ROW_NUMBER_COLUMN_WIDTH, SIDEBAR_TRANSITION_MS, UndoRedoStack, VALUE_ERROR, Z_INDEX, adjustFormulaReferences, applyCellDeletion, applyCutClear, applyFillValues, applyPastedValues, applyRangeRowSelection, areGridRowPropsEqual, booleanParser, buildCellIndex, buildCsvHeader, buildCsvRows, buildHeaderRows, buildInlineEditorProps, buildPopoverEditorProps, calculateDropTarget, clampSelectionToBounds, columnLetterToIndex, computeAggregations, computeArrowNavigation, computeAutoScrollSpeed, computeNextSortState, computeRowSelectionState, computeTabNavigation, computeTotalHeight, computeVisibleColumnRange, computeVisibleRange, createBuiltInFunctions, createSortFilterWorker, currencyParser, dateParser, debounce, deriveFilterOptionsFromData, emailParser, escapeCsvValue, exportToCsv, extractValueMatrix, findCtrlArrowTarget, flattenArgs, flattenColumns, formatAddress, formatCellReference, formatCellValueForTsv, formatSelectionAsTsv, formatShortcut, toString as formulaToString, fromCellKey, getCellRenderDescriptor, getCellValue, getColumnHeaderMenuItems, getContextMenuHandlers, getDataGridStatusBarConfig, getFilterField, getHeaderFilterConfig, getMultiSelectFilterFields, getPaginationViewModel, getPinStateForColumn, getScrollTopForRow, getStatusBarParts, indexToColumnLetter, injectGlobalStyles, isColumnEditable, isFilterConfig, isFormulaError, isInSelectionRange, isRowInRange, measureColumnContentWidth, measureRange, mergeFilter, normalizeSelectionRange, numberParser, parse, parseCellRef, parseRange, parseTsvClipboard, parseValue, partitionColumnsForVirtualization, processClientSideData, processClientSideDataAsync, rangesEqual, reorderColumnArray, resolveCellDisplayContent, resolveCellStyle, terminateSortFilterWorker, toBoolean, toCellKey, toNumber, toUserLike, tokenize, triggerCsvDownload, validateColumns, validateRowIds, validateVirtualScrollConfig };