@pixerate/editor 0.18.0 → 0.20.0

package/dist/chunk-JYRIOFEN.cjs

@@ -0,0 +1,2657 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2;// src/spreadsheet/formula/lexer.ts
+function tokenizeFormula(formula) {
+  const tokens = [];
+  let input = formula.trim();
+  let offset = 0;
+  if (input.startsWith("=")) {
+    input = input.slice(1);
+    offset = 1;
+  }
+  let i = 0;
+  while (i < input.length) {
+    const char = input[i];
+    if (/\s/.test(char)) {
+      i++;
+      continue;
+    }
+    if (/\d/.test(char) || char === "." && i + 1 < input.length && /\d/.test(input[i + 1])) {
+      const start = i;
+      let hasDot = char === ".";
+      i++;
+      while (i < input.length && (/\d/.test(input[i]) || input[i] === "." && !hasDot)) {
+        if (input[i] === ".") hasDot = true;
+        i++;
+      }
+      tokens.push({
+        type: "NUMBER",
+        value: input.slice(start, i),
+        position: start + offset
+      });
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      const quote2 = char;
+      const start = i;
+      i++;
+      let str = "";
+      while (i < input.length && input[i] !== quote2) {
+        if (input[i] === "\\" && i + 1 < input.length) {
+          i++;
+        }
+        str += input[i];
+        i++;
+      }
+      if (i >= input.length) {
+        throw new Error(`Unterminated string starting at position ${start + offset}`);
+      }
+      i++;
+      tokens.push({
+        type: "STRING",
+        value: str,
+        position: start + offset
+      });
+      continue;
+    }
+    if (char === "#") {
+      const match = /^#(?:REF!|DIV\/0!|VALUE!|NAME\?|N\/A|NUM!|CYCLE!|ERROR!)/.exec(input.slice(i));
+      if (!match) {
+        throw new Error(`Unexpected character '#' at position ${i + offset}`);
+      }
+      tokens.push({ type: "ERROR", value: match[0], position: i + offset });
+      i += match[0].length;
+      continue;
+    }
+    if (char === "[") {
+      const start = i;
+      i++;
+      let prop = "";
+      while (i < input.length && input[i] !== "]") {
+        prop += input[i];
+        i++;
+      }
+      if (i < input.length && input[i] === "]") {
+        i++;
+      }
+      tokens.push({
+        type: "PROPERTY_REF",
+        value: prop.trim(),
+        position: start + offset
+      });
+      continue;
+    }
+    if (char === "(") {
+      tokens.push({ type: "LPAREN", value: "(", position: i + offset });
+      i++;
+      continue;
+    }
+    if (char === ")") {
+      tokens.push({ type: "RPAREN", value: ")", position: i + offset });
+      i++;
+      continue;
+    }
+    if (char === ",") {
+      tokens.push({ type: "COMMA", value: ",", position: i + offset });
+      i++;
+      continue;
+    }
+    const twoChars = input.slice(i, i + 2);
+    if (["<=", ">=", "<>", "!="].includes(twoChars)) {
+      tokens.push({
+        type: "OPERATOR",
+        value: twoChars === "!=" ? "<>" : twoChars,
+        position: i + offset
+      });
+      i += 2;
+      continue;
+    }
+    if (["+", "-", "*", "/", "^", "&", "=", "<", ">"].includes(char)) {
+      tokens.push({ type: "OPERATOR", value: char, position: i + offset });
+      i++;
+      continue;
+    }
+    if (/[a-zA-Z_$]/.test(char)) {
+      const start = i;
+      while (i < input.length && /[a-zA-Z0-9_$.]/.test(input[i])) {
+        i++;
+      }
+      const rawWord = input.slice(start, i);
+      if (i < input.length && input[i] === ":") {
+        const colonPos = i;
+        i++;
+        const secondStart = i;
+        while (i < input.length && /[a-zA-Z0-9_$.]/.test(input[i])) {
+          i++;
+        }
+        const secondWord = input.slice(secondStart, i);
+        if (secondWord.length > 0) {
+          tokens.push({
+            type: "RANGE",
+            value: `${rawWord}:${secondWord}`.toUpperCase(),
+            position: start + offset
+          });
+          continue;
+        } else {
+          i = colonPos;
+        }
+      }
+      const upper = rawWord.toUpperCase();
+      if (upper === "TRUE" || upper === "FALSE") {
+        tokens.push({
+          type: "BOOLEAN",
+          value: upper,
+          position: start + offset
+        });
+        continue;
+      }
+      if (/^\$?[A-Za-z]+\$?[0-9]+$/.test(rawWord)) {
+        tokens.push({
+          type: "CELL_REF",
+          value: upper.replace(/\$/g, ""),
+          position: start + offset
+        });
+        continue;
+      }
+      tokens.push({
+        type: "IDENTIFIER",
+        value: upper,
+        position: start + offset
+      });
+      continue;
+    }
+    throw new Error(`Unexpected character '${char}' at position ${i + offset}`);
+  }
+  tokens.push({ type: "EOF", value: "", position: input.length + offset });
+  return tokens;
+}
+
+// src/spreadsheet/formula/parser.ts
+var WHOLE_COLUMN_END_ROW = 1048576;
+function parseCellReference(ref) {
+  const match = ref.match(/^([A-Za-z]+)(\d+)$/);
+  if (!match) {
+    throw new Error(`Invalid cell reference: ${ref}`);
+  }
+  return {
+    col: match[1].toUpperCase(),
+    row: parseInt(match[2], 10)
+  };
+}
+function parseRange(rangeStr) {
+  const [start, end] = rangeStr.replace(/\$/g, "").split(":");
+  const raw = rangeStr.toUpperCase();
+  if (/^[A-Za-z]+$/.test(start) && /^[A-Za-z]+$/.test(end)) {
+    return {
+      type: "Range",
+      raw,
+      startCol: start.toUpperCase(),
+      startRow: 1,
+      endCol: end.toUpperCase(),
+      endRow: WHOLE_COLUMN_END_ROW
+    };
+  }
+  const startRef = parseCellReference(start);
+  const endRef = parseCellReference(end);
+  return {
+    type: "Range",
+    raw,
+    startCol: startRef.col,
+    startRow: startRef.row,
+    endCol: endRef.col,
+    endRow: endRef.row
+  };
+}
+var FormulaParser = (_class = class {
+  __init() {this.tokens = []}
+  __init2() {this.current = 0}
+  constructor(tokens) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);
+    this.tokens = tokens;
+  }
+  parse() {
+    if (this.peek().type === "EOF") {
+      return { type: "Literal", value: "" };
+    }
+    const expr = this.expression();
+    if (this.peek().type !== "EOF") {
+      throw new Error(`Unexpected token at position ${this.peek().position}: ${this.peek().value}`);
+    }
+    return expr;
+  }
+  expression() {
+    return this.comparison();
+  }
+  comparison() {
+    let expr = this.concatenation();
+    while (this.matchOperator("=", "<>", "<", ">", "<=", ">=")) {
+      const op = this.previous().value;
+      const right = this.concatenation();
+      expr = { type: "BinaryOp", op, left: expr, right };
+    }
+    return expr;
+  }
+  concatenation() {
+    let expr = this.addition();
+    while (this.matchOperator("&")) {
+      const op = this.previous().value;
+      const right = this.addition();
+      expr = { type: "BinaryOp", op, left: expr, right };
+    }
+    return expr;
+  }
+  addition() {
+    let expr = this.multiplication();
+    while (this.matchOperator("+", "-")) {
+      const op = this.previous().value;
+      const right = this.multiplication();
+      expr = { type: "BinaryOp", op, left: expr, right };
+    }
+    return expr;
+  }
+  multiplication() {
+    let expr = this.exponentiation();
+    while (this.matchOperator("*", "/")) {
+      const op = this.previous().value;
+      const right = this.exponentiation();
+      expr = { type: "BinaryOp", op, left: expr, right };
+    }
+    return expr;
+  }
+  exponentiation() {
+    let expr = this.unary();
+    while (this.matchOperator("^")) {
+      const op = this.previous().value;
+      const right = this.unary();
+      expr = { type: "BinaryOp", op, left: expr, right };
+    }
+    return expr;
+  }
+  unary() {
+    if (this.matchOperator("-", "+")) {
+      const op = this.previous().value;
+      const argument = this.unary();
+      return { type: "UnaryOp", op, argument };
+    }
+    return this.primary();
+  }
+  primary() {
+    const token = this.peek();
+    if (token.type === "NUMBER") {
+      this.advance();
+      return { type: "Literal", value: parseFloat(token.value) };
+    }
+    if (token.type === "STRING") {
+      this.advance();
+      return { type: "Literal", value: token.value };
+    }
+    if (token.type === "BOOLEAN") {
+      this.advance();
+      return { type: "Literal", value: token.value === "TRUE" };
+    }
+    if (token.type === "ERROR") {
+      this.advance();
+      return { type: "Literal", value: token.value };
+    }
+    if (token.type === "CELL_REF") {
+      this.advance();
+      const parsed = parseCellReference(token.value);
+      return {
+        type: "CellRef",
+        ref: token.value,
+        col: parsed.col,
+        row: parsed.row
+      };
+    }
+    if (token.type === "RANGE") {
+      this.advance();
+      return parseRange(token.value);
+    }
+    if (token.type === "PROPERTY_REF") {
+      this.advance();
+      return {
+        type: "PropertyRef",
+        property: token.value
+      };
+    }
+    if (token.type === "IDENTIFIER") {
+      const name = token.value;
+      this.advance();
+      if (this.check("LPAREN")) {
+        this.consume("LPAREN", `Expected '(' after function ${name}`);
+        const args = [];
+        if (!this.check("RPAREN")) {
+          do {
+            args.push(this.expression());
+          } while (this.match("COMMA"));
+        }
+        this.consume("RPAREN", `Expected ')' after function arguments`);
+        return {
+          type: "FunctionCall",
+          name,
+          args
+        };
+      }
+      return { type: "Literal", value: "#NAME?" };
+    }
+    if (this.match("LPAREN")) {
+      const expr = this.expression();
+      this.consume("RPAREN", `Expected ')' after expression`);
+      return expr;
+    }
+    throw new Error(`Unexpected token at position ${token.position}: ${token.value || token.type}`);
+  }
+  match(...types) {
+    for (const type of types) {
+      if (this.check(type)) {
+        this.advance();
+        return true;
+      }
+    }
+    return false;
+  }
+  matchOperator(...ops) {
+    if (this.check("OPERATOR") && ops.includes(this.peek().value)) {
+      this.advance();
+      return true;
+    }
+    return false;
+  }
+  check(type) {
+    if (this.isAtEnd()) return false;
+    return this.peek().type === type;
+  }
+  advance() {
+    if (!this.isAtEnd()) this.current++;
+    return this.previous();
+  }
+  isAtEnd() {
+    return this.peek().type === "EOF";
+  }
+  peek() {
+    return this.tokens[this.current];
+  }
+  previous() {
+    return this.tokens[this.current - 1];
+  }
+  consume(type, message) {
+    if (this.check(type)) return this.advance();
+    throw new Error(message);
+  }
+}, _class);
+function parseFormula(formula) {
+  const tokens = tokenizeFormula(formula);
+  const parser = new FormulaParser(tokens);
+  return parser.parse();
+}
+
+// src/spreadsheet/formula/values.ts
+var FORMULA_ERRORS = /* @__PURE__ */ new Set([
+  "#DIV/0!",
+  "#VALUE!",
+  "#REF!",
+  "#NAME?",
+  "#N/A",
+  "#NUM!",
+  "#CYCLE!",
+  "#ERROR!"
+]);
+function isFormulaError(value) {
+  return typeof value === "string" && FORMULA_ERRORS.has(value);
+}
+var isBlank = (value) => value === "" || value === null || value === void 0;
+function toNumber(value) {
+  if (isFormulaError(value)) return value;
+  if (isBlank(value)) return 0;
+  if (typeof value === "boolean") return value ? 1 : 0;
+  if (typeof value === "number") return value;
+  const trimmed = String(value).trim();
+  const num = trimmed === "" ? NaN : Number(trimmed);
+  return isNaN(num) ? "#VALUE!" : num;
+}
+function toBoolean(value) {
+  if (isFormulaError(value)) return value;
+  if (isBlank(value)) return false;
+  if (typeof value === "boolean") return value;
+  if (typeof value === "number") return value !== 0;
+  const upper = String(value).trim().toUpperCase();
+  if (upper === "TRUE") return true;
+  if (upper === "FALSE") return false;
+  return "#VALUE!";
+}
+var toText = (value) => isBlank(value) ? "" : typeof value === "boolean" ? value ? "TRUE" : "FALSE" : String(value);
+function numericValue(value) {
+  if (typeof value === "number") return Number.isFinite(value) ? value : null;
+  if (typeof value !== "string" || FORMULA_ERRORS.has(value)) return null;
+  const trimmed = value.trim();
+  if (trimmed === "") return null;
+  const num = Number(trimmed);
+  return Number.isFinite(num) ? num : null;
+}
+function normalizeValue(value) {
+  const num = typeof value === "string" ? numericValue(value) : null;
+  return num === null ? value : num;
+}
+function compareValues(left, right) {
+  const rank = (v) => typeof v === "boolean" ? 2 : typeof v === "string" ? 1 : 0;
+  const l = isBlank(left) ? typeof right === "string" ? "" : 0 : left;
+  const r = isBlank(right) ? typeof l === "string" ? "" : 0 : right;
+  if (rank(l) !== rank(r)) return rank(l) - rank(r);
+  if (typeof l === "string") {
+    const a = l.toLowerCase();
+    const b = r.toLowerCase();
+    return a < b ? -1 : a > b ? 1 : 0;
+  }
+  return Number(l) - Number(r);
+}
+function roundHalfAwayFromZero(value, decimals) {
+  const factor = Math.pow(10, decimals);
+  const scaled = Number((Math.abs(value) * factor).toPrecision(15));
+  return Math.sign(value) * Math.round(scaled) / factor;
+}
+var cleanFloat = (value) => Number(value.toPrecision(15));
+function colNameToIndex(col) {
+  let index = 0;
+  const upper = col.toUpperCase();
+  for (let i = 0; i < upper.length; i++) {
+    index = index * 26 + (upper.charCodeAt(i) - 65 + 1);
+  }
+  return index - 1;
+}
+function indexToColName(index) {
+  let num = index + 1;
+  let name = "";
+  while (num > 0) {
+    const mod = (num - 1) % 26;
+    name = String.fromCharCode(65 + mod) + name;
+    num = Math.floor((num - mod) / 26);
+  }
+  return name;
+}
+var rangeShapes = /* @__PURE__ */ new WeakMap();
+function withRangeShape(values, rows, cols) {
+  rangeShapes.set(values, { rows, cols });
+  return values;
+}
+function toFormulaRange(values) {
+  const shape = rangeShapes.get(values);
+  if (shape && shape.rows * shape.cols === values.length) return { ...shape, values };
+  return { rows: values.length, cols: 1, values };
+}
+var rangeGet = (range, row, col) => row < range.rows && col < range.cols ? range.values[col * range.rows + row] : "";
+function sliceRange(range, rowStart, rowCount, colStart, colCount) {
+  const out = [];
+  for (let c = colStart; c < colStart + colCount; c++) {
+    for (let r = rowStart; r < rowStart + rowCount; r++) out.push(rangeGet(range, r, c));
+  }
+  return withRangeShape(out, rowCount, colCount);
+}
+var MS_PER_DAY = 24 * 60 * 60 * 1e3;
+var pad = (n, width = 2) => String(n).padStart(width, "0");
+function toDate(value) {
+  if (value instanceof Date) return isNaN(value.getTime()) ? null : value;
+  if (typeof value === "number") return serialToDate(value);
+  if (typeof value !== "string" || FORMULA_ERRORS.has(value)) return null;
+  const text = value.trim();
+  if (text === "") return null;
+  const iso = /^(\d{4})-(\d{1,2})-(\d{1,2})(?:[ T](\d{1,2}):(\d{2})(?::(\d{2}))?)?$/.exec(text);
+  if (iso) {
+    const [, y, m, d, hh = "0", mm = "0", ss = "0"] = iso;
+    const date = new Date(Number(y), Number(m) - 1, Number(d), Number(hh), Number(mm), Number(ss));
+    return date.getMonth() === Number(m) - 1 ? date : null;
+  }
+  const serial = numericValue(text);
+  if (serial !== null) return serialToDate(serial);
+  if (/[a-z/]/i.test(text)) {
+    const parsed = Date.parse(text);
+    return isNaN(parsed) ? null : new Date(parsed);
+  }
+  return null;
+}
+function dateToSerial(date) {
+  const utc = Date.UTC(
+    date.getFullYear(),
+    date.getMonth(),
+    date.getDate(),
+    date.getHours(),
+    date.getMinutes(),
+    date.getSeconds()
+  );
+  return cleanFloat((utc - Date.UTC(1899, 11, 30)) / MS_PER_DAY);
+}
+function serialToDate(serial) {
+  if (!Number.isFinite(serial)) return null;
+  const utc = new Date(Date.UTC(1899, 11, 30) + Math.round(serial * MS_PER_DAY));
+  return new Date(
+    utc.getUTCFullYear(),
+    utc.getUTCMonth(),
+    utc.getUTCDate(),
+    utc.getUTCHours(),
+    utc.getUTCMinutes(),
+    utc.getUTCSeconds()
+  );
+}
+var formatIsoDate = (date) => `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+var formatIsoDateTime = (date) => `${formatIsoDate(date)} ${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
+var daysBetween = (start, end) => Math.round(
+  (Date.UTC(end.getFullYear(), end.getMonth(), end.getDate()) - Date.UTC(start.getFullYear(), start.getMonth(), start.getDate())) / MS_PER_DAY
+);
+
+// src/spreadsheet/formula/criteria.ts
+function wildcardToRegExp(pattern) {
+  let source = "";
+  for (let i = 0; i < pattern.length; i++) {
+    const char = pattern[i];
+    if (char === "~" && i + 1 < pattern.length) {
+      source += escapeRegExp(pattern[++i]);
+    } else if (char === "*") {
+      source += "[\\s\\S]*";
+    } else if (char === "?") {
+      source += "[\\s\\S]";
+    } else {
+      source += escapeRegExp(char);
+    }
+  }
+  return new RegExp(`^${source}$`, "i");
+}
+var escapeRegExp = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var hasWildcards = (pattern) => /(^|[^~])[*?]/.test(pattern);
+function parseCriteria(criterion) {
+  if (typeof criterion === "number") {
+    return (value) => numericValue(value) === criterion;
+  }
+  if (typeof criterion === "boolean") {
+    return (value) => value === criterion;
+  }
+  if (isBlank(criterion)) return (value) => isBlank(value);
+  const text = String(criterion);
+  const match = /^(<>|<=|>=|=|<|>)?([\s\S]*)$/.exec(text);
+  const op = _nullishCoalesce(match[1], () => ( "="));
+  const operand = match[2];
+  if (operand === "") {
+    if (op === "=") return (value) => isBlank(value);
+    if (op === "<>") return (value) => !isBlank(value);
+    return () => false;
+  }
+  const operandNumber = numericValue(operand);
+  const operandUpper = operand.trim().toUpperCase();
+  const operandBoolean = operandUpper === "TRUE" ? true : operandUpper === "FALSE" ? false : null;
+  if (op === "=" || op === "<>") {
+    let equals;
+    if (operandNumber !== null) {
+      equals = (value) => numericValue(value) === operandNumber;
+    } else if (operandBoolean !== null) {
+      equals = (value) => value === operandBoolean || typeof value === "string" && value.trim().toUpperCase() === operandUpper;
+    } else if (isFormulaError(operand)) {
+      return op === "=" ? (value) => value === operand : (value) => value !== operand && !isBlank(value);
+    } else {
+      const regex = wildcardToRegExp(operand);
+      equals = (value) => typeof value === "string" && !isFormulaError(value) && regex.test(value);
+    }
+    return op === "=" ? (value) => !isFormulaError(value) && equals(value) : (value) => !isFormulaError(value) && !equals(value);
+  }
+  const test = (cmp) => op === "<" ? cmp < 0 : op === "<=" ? cmp <= 0 : op === ">" ? cmp > 0 : cmp >= 0;
+  if (operandNumber !== null) {
+    return (value) => {
+      const num = numericValue(value);
+      return num !== null && test(num - operandNumber);
+    };
+  }
+  const lower = operand.toLowerCase();
+  return (value) => {
+    if (typeof value !== "string" || value === "" || FORMULA_ERRORS.has(value) || numericValue(value) !== null) {
+      return false;
+    }
+    const v = value.toLowerCase();
+    return test(v < lower ? -1 : v > lower ? 1 : 0);
+  };
+}
+
+// src/spreadsheet/formula/format.ts
+function formatValueWithCode(value, format) {
+  if (isDateFormat(format)) {
+    const date = toDate(value);
+    return date ? formatDate(date, format) : null;
+  }
+  const num = typeof value === "boolean" ? null : numericValue(value);
+  return num === null ? toText(value) : formatNumber(num, format);
+}
+function tokenize(format) {
+  const out = [];
+  const push = (literal, text) => {
+    const last = out[out.length - 1];
+    if (last && last.literal === literal) last.text += text;
+    else out.push({ literal, text });
+  };
+  for (let i = 0; i < format.length; i++) {
+    const char = format[i];
+    if (char === '"') {
+      const end = format.indexOf('"', i + 1);
+      const stop = end === -1 ? format.length : end;
+      push(true, format.slice(i + 1, stop));
+      i = stop;
+    } else if (char === "\\" && i + 1 < format.length) {
+      push(true, format[++i]);
+    } else {
+      push(false, char);
+    }
+  }
+  return out;
+}
+var codeText = (format) => tokenize(format).filter((t) => !t.literal).map((t) => t.text).join("");
+function isDateFormat(format) {
+  const code = codeText(format);
+  if (/[0#?]/.test(code)) return false;
+  return /[ydhs]|m/i.test(code);
+}
+function formatNumber(num, format) {
+  const sections = splitSections(format);
+  let section = sections[0];
+  let value = num;
+  let sign = num < 0 ? "-" : "";
+  if (num < 0 && sections.length > 1) {
+    section = sections[1];
+    value = Math.abs(num);
+    sign = "";
+  } else if (num === 0 && sections.length > 2) {
+    section = sections[2];
+  }
+  let prefix = "";
+  let suffix = "";
+  let pattern = "";
+  for (const token of tokenize(section)) {
+    if (token.literal) {
+      if (pattern) suffix += token.text;
+      else prefix += token.text;
+      continue;
+    }
+    for (let i = 0; i < token.text.length; i++) {
+      const char = token.text[i];
+      const isExponent = /e/i.test(char) && /[+-]/.test(_nullishCoalesce(token.text[i + 1], () => ( "")));
+      const isExponentSign = /[+-]/.test(char) && /e$/i.test(pattern);
+      if (/[0#?.,]/.test(char) || pattern && (isExponent || isExponentSign)) {
+        pattern += char;
+      } else if (pattern) {
+        suffix += char;
+      } else {
+        prefix += char;
+      }
+    }
+  }
+  const percents = (prefix + suffix).split("%").length - 1;
+  value = Math.abs(value) * Math.pow(100, percents);
+  if (!pattern) return `${sign}${prefix}${suffix}`;
+  const expMatch = /^([^Ee]*)[Ee]([+-])(0+)$/.exec(pattern);
+  if (expMatch) {
+    const [, mantissa, expSign, expDigits] = expMatch;
+    const decimals = (_nullishCoalesce(mantissa.split(".")[1], () => ( ""))).length;
+    const [m, e] = value.toExponential(decimals).split("e");
+    const exponent = Number(e);
+    const expText = String(Math.abs(exponent)).padStart(expDigits.length, "0");
+    const shownSign = exponent < 0 ? "-" : expSign === "+" ? "+" : "";
+    return `${sign}${prefix}${m}E${shownSign}${expText}${suffix}`;
+  }
+  const [intPattern, decPattern = ""] = pattern.split(".");
+  const maxDecimals = (_nullishCoalesce(decPattern.match(/[0#?]/g), () => ( []))).length;
+  const minDecimals = (_nullishCoalesce(decPattern.match(/0/g), () => ( []))).length;
+  const minInt = (_nullishCoalesce(intPattern.match(/0/g), () => ( []))).length;
+  const grouping = intPattern.includes(",");
+  const rounded = roundHalfAwayFromZero(value, maxDecimals);
+  let [intPart, decPart = ""] = rounded.toFixed(maxDecimals).split(".");
+  while (decPart.length > minDecimals && decPart.endsWith("0")) decPart = decPart.slice(0, -1);
+  if (intPart === "0" && minInt === 0) intPart = "";
+  intPart = intPart.padStart(minInt, "0");
+  if (grouping) intPart = intPart.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+  const showSign = sign && /[1-9]/.test(intPart + decPart) ? sign : "";
+  return `${showSign}${prefix}${intPart}${decPart ? `.${decPart}` : ""}${suffix}`;
+}
+function splitSections(format) {
+  const sections = [""];
+  let quoted = false;
+  for (let i = 0; i < format.length; i++) {
+    const char = format[i];
+    if (char === '"') quoted = !quoted;
+    if (char === "\\" && i + 1 < format.length) {
+      sections[sections.length - 1] += char + format[++i];
+      continue;
+    }
+    if (char === ";" && !quoted) sections.push("");
+    else sections[sections.length - 1] += char;
+  }
+  return sections;
+}
+var MONTHS = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
+var DAYS = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+var pad2 = (n) => String(n).padStart(2, "0");
+function formatDate(date, format) {
+  const parts = [];
+  for (const token of tokenize(format)) {
+    if (token.literal) {
+      parts.push(token);
+      continue;
+    }
+    const re = /AM\/PM|am\/pm|A\/P|a\/p|y+|m+|d+|h+|s+|[^ymdhsaA]+|./gi;
+    for (const match of _nullishCoalesce(token.text.match(re), () => ( []))) {
+      const isCode = /^(AM\/PM|A\/P|y+|m+|d+|h+|s+)$/i.test(match);
+      parts.push({ literal: !isCode, text: match });
+    }
+  }
+  const codes = parts.map((p, i) => ({ ...p, i })).filter((p) => !p.literal);
+  const twelveHour = codes.some((p) => /^(AM\/PM|A\/P)$/i.test(p.text));
+  return parts.map((part, index) => {
+    if (part.literal) return part.text;
+    const code = part.text;
+    const lower = code.toLowerCase();
+    if (/^(am\/pm|a\/p)$/.test(lower)) {
+      const pm = date.getHours() >= 12;
+      const full = pm ? "PM" : "AM";
+      const text = lower === "a/p" ? full[0] : full;
+      return code[0] === code[0].toLowerCase() ? text.toLowerCase() : text;
+    }
+    if (lower.startsWith("y")) {
+      return lower.length <= 2 ? pad2(date.getFullYear() % 100) : String(date.getFullYear());
+    }
+    if (lower.startsWith("d")) {
+      if (lower.length >= 4) return DAYS[date.getDay()];
+      if (lower.length === 3) return DAYS[date.getDay()].slice(0, 3);
+      return lower.length === 2 ? pad2(date.getDate()) : String(date.getDate());
+    }
+    if (lower.startsWith("h")) {
+      let hours = date.getHours();
+      if (twelveHour) hours = hours % 12 || 12;
+      return lower.length >= 2 ? pad2(hours) : String(hours);
+    }
+    if (lower.startsWith("s")) {
+      return lower.length >= 2 ? pad2(date.getSeconds()) : String(date.getSeconds());
+    }
+    const position = codes.findIndex((c) => c.i === index);
+    const prev = _nullishCoalesce(_optionalChain([codes, 'access', _2 => _2[position - 1], 'optionalAccess', _3 => _3.text, 'access', _4 => _4.toLowerCase, 'call', _5 => _5()]), () => ( ""));
+    const next = _nullishCoalesce(_optionalChain([codes, 'access', _6 => _6[position + 1], 'optionalAccess', _7 => _7.text, 'access', _8 => _8.toLowerCase, 'call', _9 => _9()]), () => ( ""));
+    if (lower.length <= 2 && (prev.startsWith("h") || next.startsWith("s"))) {
+      return lower.length === 2 ? pad2(date.getMinutes()) : String(date.getMinutes());
+    }
+    if (lower.length >= 4) return MONTHS[date.getMonth()];
+    if (lower.length === 3) return MONTHS[date.getMonth()].slice(0, 3);
+    return lower.length === 2 ? pad2(date.getMonth() + 1) : String(date.getMonth() + 1);
+  }).join("");
+}
+
+// src/spreadsheet/formula/functions/helpers.ts
+var arg = (name, description, type = "any", extra = {}) => ({ name, description, type, ...extra });
+var optional = (name, description, type = "any") => arg(name, description, type, { optional: true });
+var repeating = (name, description, type = "any") => arg(name, description, type, { repeating: true });
+function failed(value) {
+  return isFormulaError(value);
+}
+function unaryMath(ctx, fn) {
+  const value = ctx.number(0);
+  if (failed(value)) return value;
+  const result = fn(value);
+  if (typeof result === "number" && !Number.isFinite(result)) {
+    return ctx.error("#NUM!", `${ctx.name} produced a number that is out of range.`);
+  }
+  return result;
+}
+
+// src/spreadsheet/formula/functions/math.ts
+var NUMBER = arg("number", "The number to use.", "number");
+var NUM_DIGITS = optional("num_digits", "Decimal places to round to; negative values round to the left of the decimal point (default 0).", "number");
+function roundWith(value, digits, mode) {
+  const factor = Math.pow(10, Math.trunc(digits));
+  const scaled = Number((Math.abs(value) * factor).toPrecision(15));
+  const rounded = mode === "up" ? Math.ceil(scaled) : Math.floor(scaled);
+  return cleanFloat(Math.sign(value) * rounded / factor);
+}
+var MATH_FUNCTIONS = [
+  {
+    name: "SUM",
+    category: "math",
+    description: "Adds numbers and the numbers in ranges. Text and blank cells are ignored.",
+    args: [repeating("value", "A number, cell or range to add.", "number")],
+    evaluate: (ctx) => {
+      const nums = ctx.numbers();
+      if (failed(nums)) return nums;
+      let total = 0;
+      for (const num of nums) total += num;
+      return total;
+    }
+  },
+  {
+    name: "PRODUCT",
+    category: "math",
+    description: "Multiplies numbers and the numbers in ranges. Text and blank cells are ignored.",
+    args: [repeating("value", "A number, cell or range to multiply.", "number")],
+    evaluate: (ctx) => {
+      const nums = ctx.numbers();
+      if (failed(nums)) return nums;
+      if (nums.length === 0) return 0;
+      let product = 1;
+      for (const num of nums) product *= num;
+      return cleanFloat(product);
+    }
+  },
+  {
+    name: "ROUND",
+    category: "math",
+    description: "Rounds a number to a number of decimal places, halves away from zero.",
+    args: [NUMBER, NUM_DIGITS],
+    evaluate: (ctx) => {
+      const num = ctx.number(0);
+      if (failed(num)) return num;
+      const decimals = ctx.number(1, 0);
+      if (failed(decimals)) return decimals;
+      return roundHalfAwayFromZero(num, Math.trunc(decimals));
+    }
+  },
+  {
+    name: "ROUNDUP",
+    category: "math",
+    description: "Rounds a number away from zero to a number of decimal places.",
+    args: [NUMBER, NUM_DIGITS],
+    evaluate: (ctx) => {
+      const num = ctx.number(0);
+      if (failed(num)) return num;
+      const digits = ctx.number(1, 0);
+      if (failed(digits)) return digits;
+      return roundWith(num, digits, "up");
+    }
+  },
+  {
+    name: "ROUNDDOWN",
+    category: "math",
+    description: "Rounds a number toward zero to a number of decimal places.",
+    args: [NUMBER, NUM_DIGITS],
+    evaluate: (ctx) => {
+      const num = ctx.number(0);
+      if (failed(num)) return num;
+      const digits = ctx.number(1, 0);
+      if (failed(digits)) return digits;
+      return roundWith(num, digits, "down");
+    }
+  },
+  {
+    name: "INT",
+    category: "math",
+    description: "Rounds a number down to the nearest integer (INT(-1.5) is -2).",
+    args: [NUMBER],
+    evaluate: (ctx) => unaryMath(ctx, Math.floor)
+  },
+  {
+    name: "ABS",
+    category: "math",
+    description: "Returns the absolute value of a number.",
+    args: [NUMBER],
+    evaluate: (ctx) => unaryMath(ctx, Math.abs)
+  },
+  {
+    name: "SIGN",
+    category: "math",
+    description: "Returns 1 for positive numbers, -1 for negative numbers and 0 for zero.",
+    args: [NUMBER],
+    evaluate: (ctx) => unaryMath(ctx, (n) => n > 0 ? 1 : n < 0 ? -1 : 0)
+  },
+  {
+    name: "SQRT",
+    category: "math",
+    description: "Returns the square root of a number.",
+    args: [NUMBER],
+    evaluate: (ctx) => unaryMath(
+      ctx,
+      (n) => n < 0 ? ctx.argError(0, "#NUM!", "can't be negative.") : Math.sqrt(n)
+    )
+  },
+  {
+    name: "POWER",
+    category: "math",
+    description: "Raises a number to a power.",
+    args: [arg("number", "The base.", "number"), arg("power", "The exponent.", "number")],
+    evaluate: (ctx) => {
+      const base = ctx.number(0);
+      if (failed(base)) return base;
+      const exponent = ctx.number(1);
+      if (failed(exponent)) return exponent;
+      if (base === 0 && exponent < 0) return ctx.error("#DIV/0!", "POWER of zero to a negative exponent divides by zero.");
+      const result = Math.pow(base, exponent);
+      return Number.isFinite(result) ? result : ctx.error("#NUM!", "POWER produced a number that is out of range.");
+    }
+  },
+  {
+    name: "MOD",
+    category: "math",
+    description: "Returns the remainder after division. The result has the sign of the divisor.",
+    args: [arg("number", "The number to divide.", "number"), arg("divisor", "The number to divide by.", "number")],
+    evaluate: (ctx) => {
+      const num = ctx.number(0);
+      if (failed(num)) return num;
+      const divisor = ctx.number(1);
+      if (failed(divisor)) return divisor;
+      if (divisor === 0) return ctx.argError(1, "#DIV/0!", "can't be zero.");
+      return cleanFloat(num - divisor * Math.floor(num / divisor));
+    }
+  },
+  {
+    name: "CEILING",
+    category: "math",
+    description: "Rounds a number up to the nearest multiple of significance.",
+    args: [NUMBER, optional("significance", "The multiple to round to (default 1).", "number")],
+    evaluate: (ctx) => roundToMultiple(ctx.name, ctx.number(0), ctx.number(1, 1), Math.ceil, ctx)
+  },
+  {
+    name: "FLOOR",
+    category: "math",
+    description: "Rounds a number down to the nearest multiple of significance.",
+    args: [NUMBER, optional("significance", "The multiple to round to (default 1).", "number")],
+    evaluate: (ctx) => roundToMultiple(ctx.name, ctx.number(0), ctx.number(1, 1), Math.floor, ctx)
+  },
+  {
+    name: "PI",
+    category: "math",
+    description: "Returns the number \u03C0 (3.14159\u2026).",
+    args: [],
+    evaluate: () => Math.PI
+  },
+  {
+    name: "RAND",
+    category: "math",
+    description: "Returns a random number between 0 (inclusive) and 1 (exclusive). Changes on every recalculation.",
+    args: [],
+    volatile: true,
+    evaluate: () => Math.random()
+  },
+  {
+    name: "RANDBETWEEN",
+    category: "math",
+    description: "Returns a random integer between bottom and top, inclusive. Changes on every recalculation.",
+    args: [arg("bottom", "The smallest integer to return.", "number"), arg("top", "The largest integer to return.", "number")],
+    volatile: true,
+    evaluate: (ctx) => {
+      const bottom = ctx.number(0);
+      if (failed(bottom)) return bottom;
+      const top = ctx.number(1);
+      if (failed(top)) return top;
+      const lo = Math.ceil(bottom);
+      const hi = Math.floor(top);
+      if (lo > hi) return ctx.error("#NUM!", "RANDBETWEEN needs bottom to be less than or equal to top.");
+      return lo + Math.floor(Math.random() * (hi - lo + 1));
+    }
+  }
+];
+function roundToMultiple(name, number, significance, round, ctx) {
+  if (failed(number)) return number;
+  if (failed(significance)) return significance;
+  if (number === 0) return 0;
+  if (significance === 0) {
+    return name === "FLOOR" ? ctx.error("#DIV/0!", "FLOOR needs a significance other than zero.") : 0;
+  }
+  if (number > 0 && significance < 0) {
+    return ctx.error("#NUM!", `${name} can't round a positive number to a negative significance.`);
+  }
+  return cleanFloat(round(cleanFloat(number / significance)) * significance);
+}
+
+// src/spreadsheet/formula/functions/statistical.ts
+var VALUES = repeating("value", "A number, cell or range.", "number");
+function kth(ctx, pick) {
+  const nums = ctx.numbers(0, 1);
+  if (failed(nums)) return nums;
+  const k = ctx.number(1);
+  if (failed(k)) return k;
+  const index = Math.ceil(k);
+  if (index < 1 || index > nums.length) {
+    return ctx.argError(1, "#NUM!", `must be between 1 and the number of values (${nums.length}).`);
+  }
+  return pick([...nums].sort((a, b) => a - b), index);
+}
+function variance(ctx) {
+  const nums = ctx.numbers();
+  if (failed(nums)) return nums;
+  if (nums.length < 2) return ctx.error("#DIV/0!", `${ctx.name} needs at least two numbers.`);
+  let mean = 0;
+  for (const num of nums) mean += num;
+  mean /= nums.length;
+  let squares = 0;
+  for (const num of nums) squares += (num - mean) ** 2;
+  return squares / (nums.length - 1);
+}
+var STATISTICAL_FUNCTIONS = [
+  {
+    name: "AVERAGE",
+    category: "statistical",
+    description: "Returns the arithmetic mean of numbers. Blank cells and text are ignored.",
+    args: [VALUES],
+    evaluate: (ctx) => {
+      const items = ctx.flatValues();
+      const error = items.find(isFormulaError);
+      if (error) return error;
+      let total = 0;
+      let count = 0;
+      for (const item of items) {
+        const num = Number(item);
+        if (!isNaN(num) && !isBlank(item)) {
+          total += num;
+          count++;
+        }
+      }
+      return count === 0 ? 0 : total / count;
+    }
+  },
+  {
+    name: "COUNT",
+    category: "statistical",
+    description: "Counts the values that are numbers.",
+    args: [repeating("value", "A value, cell or range to count.")],
+    evaluate: (ctx) => {
+      let count = 0;
+      for (const item of ctx.flatValues()) {
+        if (!isNaN(Number(item)) && !isBlank(item)) count++;
+      }
+      return count;
+    }
+  },
+  {
+    name: "COUNTA",
+    category: "statistical",
+    description: "Counts the values that are not blank.",
+    args: [repeating("value", "A value, cell or range to count.")],
+    evaluate: (ctx) => ctx.flatValues().filter((item) => !isBlank(item)).length
+  },
+  {
+    name: "COUNTBLANK",
+    category: "statistical",
+    description: "Counts the blank cells in a range.",
+    args: [arg("range", "The range to check.", "range")],
+    evaluate: (ctx) => {
+      const range = ctx.range(0);
+      if (failed(range)) return range;
+      return range.values.filter(isBlank).length;
+    }
+  },
+  {
+    name: "MIN",
+    category: "statistical",
+    description: "Returns the smallest number. Text and blank cells are ignored.",
+    args: [VALUES],
+    evaluate: (ctx) => {
+      const nums = ctx.numbers();
+      if (failed(nums)) return nums;
+      if (nums.length === 0) return 0;
+      let result = nums[0];
+      for (const num of nums) result = Math.min(result, num);
+      return result;
+    }
+  },
+  {
+    name: "MAX",
+    category: "statistical",
+    description: "Returns the largest number. Text and blank cells are ignored.",
+    args: [VALUES],
+    evaluate: (ctx) => {
+      const nums = ctx.numbers();
+      if (failed(nums)) return nums;
+      if (nums.length === 0) return 0;
+      let result = nums[0];
+      for (const num of nums) result = Math.max(result, num);
+      return result;
+    }
+  },
+  {
+    name: "MEDIAN",
+    category: "statistical",
+    description: "Returns the middle number of a set of numbers.",
+    args: [VALUES],
+    evaluate: (ctx) => {
+      const nums = ctx.numbers();
+      if (failed(nums)) return nums;
+      if (nums.length === 0) return ctx.error("#NUM!", "MEDIAN needs at least one number.");
+      const sorted = [...nums].sort((a, b) => a - b);
+      const mid = Math.floor(sorted.length / 2);
+      return sorted.length % 2 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+    }
+  },
+  {
+    name: "MODE",
+    category: "statistical",
+    description: "Returns the most frequently occurring number. Ties go to the number that appears first.",
+    args: [VALUES],
+    evaluate: (ctx) => {
+      const nums = ctx.numbers();
+      if (failed(nums)) return nums;
+      const counts = /* @__PURE__ */ new Map();
+      let best = null;
+      let bestCount = 1;
+      for (const num of nums) {
+        const count = (_nullishCoalesce(counts.get(num), () => ( 0))) + 1;
+        counts.set(num, count);
+        if (count > bestCount) {
+          best = num;
+          bestCount = count;
+        }
+      }
+      if (best !== null) {
+        for (const num of nums) {
+          if (counts.get(num) === bestCount) return num;
+        }
+      }
+      return ctx.error("#N/A", "MODE found no number that appears more than once.");
+    }
+  },
+  {
+    name: "STDEV",
+    category: "statistical",
+    description: "Estimates the standard deviation of a sample.",
+    args: [VALUES],
+    evaluate: (ctx) => {
+      const v = variance(ctx);
+      return failed(v) ? v : cleanFloat(Math.sqrt(v));
+    }
+  },
+  {
+    name: "VAR",
+    category: "statistical",
+    description: "Estimates the variance of a sample.",
+    args: [VALUES],
+    evaluate: (ctx) => {
+      const v = variance(ctx);
+      return failed(v) ? v : cleanFloat(v);
+    }
+  },
+  {
+    name: "LARGE",
+    category: "statistical",
+    description: "Returns the k-th largest number (LARGE(range, 1) is the maximum).",
+    args: [arg("array", "The numbers to look through.", "range"), arg("k", "Position from the largest (1 = largest).", "number")],
+    evaluate: (ctx) => kth(ctx, (sorted, k) => sorted[sorted.length - k])
+  },
+  {
+    name: "SMALL",
+    category: "statistical",
+    description: "Returns the k-th smallest number (SMALL(range, 1) is the minimum).",
+    args: [arg("array", "The numbers to look through.", "range"), arg("k", "Position from the smallest (1 = smallest).", "number")],
+    evaluate: (ctx) => kth(ctx, (sorted, k) => sorted[k - 1])
+  },
+  {
+    name: "RANK",
+    category: "statistical",
+    description: "Returns the rank of a number in a list. Equal numbers share a rank.",
+    args: [
+      arg("number", "The number to rank.", "number"),
+      arg("ref", "The list of numbers to rank against.", "range"),
+      optional("order", "0 or omitted ranks the largest as 1; any other value ranks the smallest as 1.", "number")
+    ],
+    evaluate: (ctx) => {
+      const num = ctx.number(0);
+      if (failed(num)) return num;
+      const nums = ctx.numbers(1, 2);
+      if (failed(nums)) return nums;
+      const order = ctx.number(2, 0);
+      if (failed(order)) return order;
+      if (!nums.includes(num)) return ctx.argError(0, "#N/A", `(${num}) must be one of the numbers in argument 2.`);
+      let rank = 1;
+      for (const other of nums) {
+        if (order === 0 ? other > num : other < num) rank++;
+      }
+      return rank;
+    }
+  }
+];
+
+// src/spreadsheet/formula/functions/conditional.ts
+var CRITERIA_DESCRIPTION = 'The condition, e.g. 5, ">5", "<>done", "a*" (wildcards * and ?), or "" for blank cells.';
+function matchMask(ctx, base, baseIndex, firstPair) {
+  const mask = new Array(base.rows * base.cols).fill(true);
+  for (let i = firstPair; i + 1 < ctx.args.length; i += 2) {
+    const range = ctx.range(i);
+    if (failed(range)) return range;
+    if (i !== baseIndex && (range.rows !== base.rows || range.cols !== base.cols)) {
+      return ctx.argError(i, "#VALUE!", `must be the same size as argument ${baseIndex + 1} (${base.rows}\xD7${base.cols}).`);
+    }
+    const criterion = ctx.scalar(i + 1);
+    if (isFormulaError(criterion)) return criterion;
+    const matches = parseCriteria(criterion);
+    for (let k = 0; k < mask.length; k++) {
+      if (mask[k] && !matches(range.values[k])) mask[k] = false;
+    }
+  }
+  return mask;
+}
+function matchedNumbers(target, base, mask) {
+  const nums = [];
+  for (let c = 0; c < base.cols; c++) {
+    for (let r = 0; r < base.rows; r++) {
+      if (!mask[c * base.rows + r]) continue;
+      const value = rangeGet(target, r, c);
+      if (isFormulaError(value)) return value;
+      const num = numericValue(value);
+      if (num !== null) nums.push(num);
+    }
+  }
+  return nums;
+}
+var sum = (nums) => {
+  let total = 0;
+  for (const num of nums) total += num;
+  return total;
+};
+var average = (nums, ctx) => nums.length === 0 ? ctx.error("#DIV/0!", `${ctx.name} found no matching numbers to average.`) : sum(nums, ctx) / nums.length;
+var max = (nums) => nums.reduce((a, b) => Math.max(a, b), nums.length ? -Infinity : 0);
+var min = (nums) => nums.reduce((a, b) => Math.min(a, b), nums.length ? Infinity : 0);
+function singleCriterion(aggregate) {
+  return (ctx) => {
+    const base = ctx.range(0);
+    if (failed(base)) return base;
+    const mask = matchMask(ctx, base, 0, 0);
+    if (failed(mask)) return mask;
+    let target = base;
+    if (ctx.has(2)) {
+      const range = ctx.range(2);
+      if (failed(range)) return range;
+      target = range;
+    }
+    const nums = matchedNumbers(target, base, mask);
+    return failed(nums) ? nums : aggregate(nums, ctx);
+  };
+}
+function multipleCriteria(aggregate) {
+  return (ctx) => {
+    const target = ctx.range(0);
+    if (failed(target)) return target;
+    const mask = matchMask(ctx, target, 0, 1);
+    if (failed(mask)) return mask;
+    const nums = matchedNumbers(target, target, mask);
+    return failed(nums) ? nums : aggregate(nums, ctx);
+  };
+}
+var criteriaPair = [
+  repeating("criteria_range", "A range to test. Must be the same size as the other ranges.", "range"),
+  repeating("criteria", CRITERIA_DESCRIPTION, "criteria")
+];
+var CONDITIONAL_FUNCTIONS = [
+  {
+    name: "SUMIF",
+    category: "math",
+    description: "Adds the cells that meet a condition.",
+    args: [
+      arg("range", "The range to test.", "range"),
+      arg("criteria", CRITERIA_DESCRIPTION, "criteria"),
+      optional("sum_range", "The cells to add (default: range itself).", "range")
+    ],
+    evaluate: singleCriterion(sum)
+  },
+  {
+    name: "SUMIFS",
+    category: "math",
+    description: "Adds the cells that meet every condition.",
+    args: [arg("sum_range", "The cells to add.", "range"), ...criteriaPair],
+    evaluate: multipleCriteria(sum)
+  },
+  {
+    name: "COUNTIF",
+    category: "statistical",
+    description: "Counts the cells that meet a condition.",
+    args: [arg("range", "The range to test.", "range"), arg("criteria", CRITERIA_DESCRIPTION, "criteria")],
+    evaluate: (ctx) => {
+      const base = ctx.range(0);
+      if (failed(base)) return base;
+      const mask = matchMask(ctx, base, 0, 0);
+      return failed(mask) ? mask : mask.filter(Boolean).length;
+    }
+  },
+  {
+    name: "COUNTIFS",
+    category: "statistical",
+    description: "Counts the cells that meet every condition.",
+    args: criteriaPair,
+    evaluate: (ctx) => {
+      const base = ctx.range(0);
+      if (failed(base)) return base;
+      const mask = matchMask(ctx, base, 0, 0);
+      return failed(mask) ? mask : mask.filter(Boolean).length;
+    }
+  },
+  {
+    name: "AVERAGEIF",
+    category: "statistical",
+    description: "Averages the cells that meet a condition.",
+    args: [
+      arg("range", "The range to test.", "range"),
+      arg("criteria", CRITERIA_DESCRIPTION, "criteria"),
+      optional("average_range", "The cells to average (default: range itself).", "range")
+    ],
+    evaluate: singleCriterion(average)
+  },
+  {
+    name: "AVERAGEIFS",
+    category: "statistical",
+    description: "Averages the cells that meet every condition.",
+    args: [arg("average_range", "The cells to average.", "range"), ...criteriaPair],
+    evaluate: multipleCriteria(average)
+  },
+  {
+    name: "MAXIFS",
+    category: "statistical",
+    description: "Returns the largest number among the cells that meet every condition (0 if none match).",
+    args: [arg("max_range", "The cells to take the maximum of.", "range"), ...criteriaPair],
+    evaluate: multipleCriteria(max)
+  },
+  {
+    name: "MINIFS",
+    category: "statistical",
+    description: "Returns the smallest number among the cells that meet every condition (0 if none match).",
+    args: [arg("min_range", "The cells to take the minimum of.", "range"), ...criteriaPair],
+    evaluate: multipleCriteria(min)
+  }
+];
+
+// src/spreadsheet/formula/functions/logical.ts
+function logicalValues(ctx) {
+  const values = [];
+  for (let i = 0; i < ctx.args.length; i++) {
+    const value = ctx.value(i);
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (isFormulaError(item)) return item;
+        if (isBlank(item)) continue;
+        if (typeof item === "boolean") values.push(item);
+        else if (typeof item === "number") values.push(item !== 0);
+        else {
+          const num = numericValue(item);
+          const bool2 = num !== null ? num !== 0 : toBoolean(item);
+          if (typeof bool2 === "boolean") values.push(bool2);
+        }
+      }
+      continue;
+    }
+    const bool = ctx.boolean(i);
+    if (failed(bool)) return bool;
+    values.push(bool);
+  }
+  if (values.length === 0) return ctx.error("#VALUE!", `${ctx.name} found no logical values to test.`);
+  return values;
+}
+var LOGICALS = repeating("logical", "A condition, logical value or range of logical values.", "logical");
+var LOGICAL_FUNCTIONS = [
+  {
+    name: "IF",
+    category: "logical",
+    description: "Returns one value if a condition is true and another if it is false.",
+    args: [
+      arg("logical_test", "The condition to test.", "logical"),
+      arg("value_if_true", "The result when the condition is TRUE."),
+      optional("value_if_false", "The result when the condition is FALSE (default FALSE).")
+    ],
+    evaluate: (ctx) => {
+      const condition = ctx.boolean(0);
+      if (failed(condition)) return condition;
+      if (condition) return ctx.value(1);
+      return ctx.has(2) ? ctx.value(2) : false;
+    }
+  },
+  {
+    name: "IFERROR",
+    category: "logical",
+    description: "Returns a value, or an alternative if the value is an error.",
+    args: [arg("value", "The value to check."), arg("value_if_error", "The result when value is an error.")],
+    evaluate: (ctx) => {
+      const value = ctx.value(0);
+      return isFormulaError(value) ? ctx.value(1) : value;
+    }
+  },
+  {
+    name: "IFNA",
+    category: "logical",
+    description: "Returns a value, or an alternative if the value is #N/A.",
+    args: [arg("value", "The value to check."), arg("value_if_na", "The result when value is #N/A.")],
+    evaluate: (ctx) => {
+      const value = ctx.value(0);
+      return value === "#N/A" ? ctx.value(1) : value;
+    }
+  },
+  {
+    name: "IFS",
+    category: "logical",
+    description: "Returns the value for the first condition that is TRUE.",
+    args: [
+      repeating("logical_test", "A condition to test.", "logical"),
+      repeating("value_if_true", "The result when this condition is the first TRUE one.")
+    ],
+    evaluate: (ctx) => {
+      for (let i = 0; i + 1 < ctx.args.length; i += 2) {
+        const condition = ctx.boolean(i);
+        if (failed(condition)) return condition;
+        if (condition) return ctx.value(i + 1);
+      }
+      return ctx.error("#N/A", "None of the conditions in IFS were TRUE.");
+    }
+  },
+  {
+    name: "SWITCH",
+    category: "logical",
+    description: "Compares an expression with a list of values and returns the result for the first match. An extra last argument is the default.",
+    args: [
+      arg("expression", "The value to compare."),
+      repeating("value", "A value to compare the expression with."),
+      repeating("result", "The result when the expression equals this value.")
+    ],
+    allowTrailingArgument: true,
+    evaluate: (ctx) => {
+      const expression = ctx.scalar(0);
+      if (isFormulaError(expression)) return expression;
+      const target = normalizeValue(expression);
+      let i = 1;
+      for (; i + 1 < ctx.args.length; i += 2) {
+        const candidate = ctx.scalar(i);
+        if (isFormulaError(candidate)) return candidate;
+        if (compareValues(target, normalizeValue(candidate)) === 0) return ctx.value(i + 1);
+      }
+      if (i < ctx.args.length) return ctx.value(i);
+      return ctx.error("#N/A", "SWITCH found no matching value and has no default.");
+    }
+  },
+  {
+    name: "AND",
+    category: "logical",
+    description: "Returns TRUE if every argument is TRUE.",
+    args: [LOGICALS],
+    evaluate: (ctx) => {
+      const values = logicalValues(ctx);
+      return failed(values) ? values : values.every(Boolean);
+    }
+  },
+  {
+    name: "OR",
+    category: "logical",
+    description: "Returns TRUE if any argument is TRUE.",
+    args: [LOGICALS],
+    evaluate: (ctx) => {
+      const values = logicalValues(ctx);
+      return failed(values) ? values : values.some(Boolean);
+    }
+  },
+  {
+    name: "XOR",
+    category: "logical",
+    description: "Returns TRUE if an odd number of arguments are TRUE.",
+    args: [LOGICALS],
+    evaluate: (ctx) => {
+      const values = logicalValues(ctx);
+      return failed(values) ? values : values.filter(Boolean).length % 2 === 1;
+    }
+  },
+  {
+    name: "NOT",
+    category: "logical",
+    description: "Reverses a logical value.",
+    args: [arg("logical", "The value to reverse.", "logical")],
+    evaluate: (ctx) => {
+      const value = ctx.boolean(0);
+      return failed(value) ? value : !value;
+    }
+  }
+];
+
+// src/spreadsheet/formula/functions/text.ts
+var TEXT = arg("text", "The text to use.", "text");
+function textAndCount(ctx, countIndex, fallback) {
+  const text = ctx.text(0);
+  if (failed(text)) return text;
+  const count = ctx.integer(countIndex, fallback);
+  if (failed(count)) return count;
+  if (count < 0) return ctx.argError(countIndex, "#VALUE!", "can't be negative.");
+  return { text, count };
+}
+function parseNumericText(text) {
+  let trimmed = text.trim();
+  if (trimmed === "") return null;
+  let scale = 1;
+  if (trimmed.endsWith("%")) {
+    trimmed = trimmed.slice(0, -1).trim();
+    scale = 0.01;
+  }
+  const negative = /^\(.*\)$/.test(trimmed);
+  if (negative) trimmed = trimmed.slice(1, -1);
+  const cleaned = trimmed.replace(/^([+-]?)[$€£¥]/, "$1").replace(/,(?=\d{3}(\D|$))/g, "");
+  if (cleaned !== "" && /^[+-]?(\d+\.?\d*|\.\d+)(e[+-]?\d+)?$/i.test(cleaned)) {
+    const num = Number(cleaned) * scale;
+    return negative ? -num : num;
+  }
+  if (scale === 1 && !negative) {
+    const date = /^\d{4}-\d{1,2}-\d{1,2}/.test(trimmed) ? toDate(trimmed) : null;
+    if (date) return dateToSerial(date);
+  }
+  return null;
+}
+function findText(ctx, caseInsensitive) {
+  const needle = ctx.text(0);
+  if (failed(needle)) return needle;
+  const haystack = ctx.text(1);
+  if (failed(haystack)) return haystack;
+  const start = ctx.integer(2, 1);
+  if (failed(start)) return start;
+  if (start < 1 || start > haystack.length + 1) {
+    return ctx.argError(2, "#VALUE!", `must be between 1 and the length of the text (${haystack.length}).`);
+  }
+  let index;
+  if (caseInsensitive) {
+    const pattern = wildcardToRegExp(needle).source.slice(1, -1);
+    const regex = new RegExp(pattern, "i");
+    const match = regex.exec(haystack.slice(start - 1));
+    index = match ? match.index + start - 1 : -1;
+  } else {
+    index = haystack.indexOf(needle, start - 1);
+  }
+  if (index === -1) return ctx.error("#VALUE!", `${ctx.name} couldn't find "${needle}" in "${haystack}".`);
+  return index + 1;
+}
+var TEXT_FUNCTIONS = [
+  {
+    name: "CONCAT",
+    category: "text",
+    description: "Joins text, numbers and the values of ranges into one piece of text.",
+    args: [repeating("text", "A value, cell or range to join.", "text")],
+    evaluate: (ctx) => {
+      const items = ctx.flatValues();
+      const error = items.find(isFormulaError);
+      if (error) return error;
+      return items.map(toText).join("");
+    }
+  },
+  {
+    name: "TEXTJOIN",
+    category: "text",
+    description: "Joins values with a delimiter, optionally skipping empty values.",
+    args: [
+      arg("delimiter", "Text to put between values.", "text"),
+      arg("ignore_empty", "TRUE to skip empty values.", "logical"),
+      repeating("text", "A value, cell or range to join.", "text")
+    ],
+    evaluate: (ctx) => {
+      const delimiter = ctx.text(0);
+      if (failed(delimiter)) return delimiter;
+      const ignoreEmpty = ctx.boolean(1);
+      if (failed(ignoreEmpty)) return ignoreEmpty;
+      const items = ctx.flatValues(2);
+      const error = items.find(isFormulaError);
+      if (error) return error;
+      return items.map(toText).filter((text) => !ignoreEmpty || text !== "").join(delimiter);
+    }
+  },
+  {
+    name: "UPPER",
+    category: "text",
+    description: "Converts text to upper case.",
+    args: [TEXT],
+    evaluate: (ctx) => {
+      const text = ctx.text(0);
+      return failed(text) ? text : text.toUpperCase();
+    }
+  },
+  {
+    name: "LOWER",
+    category: "text",
+    description: "Converts text to lower case.",
+    args: [TEXT],
+    evaluate: (ctx) => {
+      const text = ctx.text(0);
+      return failed(text) ? text : text.toLowerCase();
+    }
+  },
+  {
+    name: "PROPER",
+    category: "text",
+    description: "Capitalizes the first letter of each word and lower-cases the rest.",
+    args: [TEXT],
+    evaluate: (ctx) => {
+      const text = ctx.text(0);
+      if (failed(text)) return text;
+      return text.toLowerCase().replace(/(^|[^\p{L}])(\p{L})/gu, (_, before, letter) => before + letter.toUpperCase());
+    }
+  },
+  {
+    name: "TRIM",
+    category: "text",
+    description: "Removes leading and trailing spaces.",
+    args: [TEXT],
+    evaluate: (ctx) => {
+      const text = ctx.text(0);
+      return failed(text) ? text : text.trim();
+    }
+  },
+  {
+    name: "LEN",
+    category: "text",
+    description: "Returns the number of characters in text.",
+    args: [TEXT],
+    evaluate: (ctx) => {
+      const text = ctx.text(0);
+      return failed(text) ? text : text.length;
+    }
+  },
+  {
+    name: "LEFT",
+    category: "text",
+    description: "Returns the first characters of text.",
+    args: [TEXT, optional("num_chars", "How many characters to return (default 1).", "number")],
+    evaluate: (ctx) => {
+      const parts = textAndCount(ctx, 1, 1);
+      return typeof parts === "string" ? parts : parts.text.slice(0, parts.count);
+    }
+  },
+  {
+    name: "RIGHT",
+    category: "text",
+    description: "Returns the last characters of text.",
+    args: [TEXT, optional("num_chars", "How many characters to return (default 1).", "number")],
+    evaluate: (ctx) => {
+      const parts = textAndCount(ctx, 1, 1);
+      if (typeof parts === "string") return parts;
+      return parts.count === 0 ? "" : parts.text.slice(-parts.count);
+    }
+  },
+  {
+    name: "MID",
+    category: "text",
+    description: "Returns characters from the middle of text, starting at a position.",
+    args: [
+      TEXT,
+      arg("start_num", "Position of the first character (1 = first).", "number"),
+      arg("num_chars", "How many characters to return.", "number")
+    ],
+    evaluate: (ctx) => {
+      const parts = textAndCount(ctx, 2);
+      if (typeof parts === "string") return parts;
+      const start = ctx.integer(1);
+      if (failed(start)) return start;
+      if (start < 1) return ctx.argError(1, "#VALUE!", "must be 1 or more.");
+      return parts.text.slice(start - 1, start - 1 + parts.count);
+    }
+  },
+  {
+    name: "FIND",
+    category: "text",
+    description: "Returns the position of text within other text (case-sensitive, no wildcards).",
+    args: [
+      arg("find_text", "The text to find.", "text"),
+      arg("within_text", "The text to search.", "text"),
+      optional("start_num", "Position to start searching from (default 1).", "number")
+    ],
+    evaluate: (ctx) => findText(ctx, false)
+  },
+  {
+    name: "SEARCH",
+    category: "text",
+    description: "Returns the position of text within other text (case-insensitive, supports * and ? wildcards).",
+    args: [
+      arg("find_text", "The text to find.", "text"),
+      arg("within_text", "The text to search.", "text"),
+      optional("start_num", "Position to start searching from (default 1).", "number")
+    ],
+    evaluate: (ctx) => findText(ctx, true)
+  },
+  {
+    name: "SUBSTITUTE",
+    category: "text",
+    description: "Replaces occurrences of old text with new text (all of them, or only the given instance).",
+    args: [
+      TEXT,
+      arg("old_text", "The text to replace.", "text"),
+      arg("new_text", "The replacement text.", "text"),
+      optional("instance_num", "Which occurrence to replace (default: all).", "number")
+    ],
+    evaluate: (ctx) => {
+      const text = ctx.text(0);
+      if (failed(text)) return text;
+      const oldText = ctx.text(1);
+      if (failed(oldText)) return oldText;
+      const newText = ctx.text(2);
+      if (failed(newText)) return newText;
+      if (oldText === "") return text;
+      if (!ctx.has(3)) return text.split(oldText).join(newText);
+      const instance = ctx.integer(3);
+      if (failed(instance)) return instance;
+      if (instance < 1) return ctx.argError(3, "#VALUE!", "must be 1 or more.");
+      let index = -1;
+      for (let n = 0; n < instance; n++) {
+        index = text.indexOf(oldText, index + 1);
+        if (index === -1) return text;
+      }
+      return text.slice(0, index) + newText + text.slice(index + oldText.length);
+    }
+  },
+  {
+    name: "REPLACE",
+    category: "text",
+    description: "Replaces part of text, by position, with new text.",
+    args: [
+      arg("old_text", "The text to change.", "text"),
+      arg("start_num", "Position of the first character to replace (1 = first).", "number"),
+      arg("num_chars", "How many characters to replace.", "number"),
+      arg("new_text", "The replacement text.", "text")
+    ],
+    evaluate: (ctx) => {
+      const text = ctx.text(0);
+      if (failed(text)) return text;
+      const start = ctx.integer(1);
+      if (failed(start)) return start;
+      if (start < 1) return ctx.argError(1, "#VALUE!", "must be 1 or more.");
+      const count = ctx.integer(2);
+      if (failed(count)) return count;
+      if (count < 0) return ctx.argError(2, "#VALUE!", "can't be negative.");
+      const newText = ctx.text(3);
+      if (failed(newText)) return newText;
+      return text.slice(0, start - 1) + newText + text.slice(start - 1 + count);
+    }
+  },
+  {
+    name: "REPT",
+    category: "text",
+    description: "Repeats text a number of times.",
+    args: [TEXT, arg("number_times", "How many times to repeat the text.", "number")],
+    evaluate: (ctx) => {
+      const parts = textAndCount(ctx, 1);
+      if (typeof parts === "string") return parts;
+      if (parts.text.length * parts.count > 32767) {
+        return ctx.error("#VALUE!", "REPT would produce text longer than 32,767 characters.");
+      }
+      return parts.text.repeat(parts.count);
+    }
+  },
+  {
+    name: "EXACT",
+    category: "text",
+    description: "Returns TRUE if two pieces of text are identical, including case.",
+    args: [arg("text1", "The first text.", "text"), arg("text2", "The second text.", "text")],
+    evaluate: (ctx) => {
+      const a = ctx.text(0);
+      if (failed(a)) return a;
+      const b = ctx.text(1);
+      if (failed(b)) return b;
+      return a === b;
+    }
+  },
+  {
+    name: "VALUE",
+    category: "text",
+    description: 'Converts text that looks like a number (e.g. "1,234.5", "50%", "$12") or an ISO date to a number.',
+    args: [TEXT],
+    evaluate: (ctx) => {
+      const value = ctx.scalar(0);
+      if (isFormulaError(value)) return value;
+      if (typeof value === "number") return value;
+      if (isBlank(value)) return 0;
+      const num = parseNumericText(toText(value));
+      if (num === null) return ctx.argError(0, "#VALUE!", `("${toText(value)}") can't be converted to a number.`);
+      return num;
+    }
+  },
+  {
+    name: "TEXT",
+    category: "text",
+    description: 'Formats a number or date as text using a format code such as "0.00", "#,##0", "0%" or "yyyy-mm-dd".',
+    args: [arg("value", "The number or date to format."), arg("format_text", "The format code.", "text")],
+    evaluate: (ctx) => {
+      const value = ctx.scalar(0);
+      if (isFormulaError(value)) return value;
+      const format = ctx.text(1);
+      if (failed(format)) return format;
+      const result = formatValueWithCode(value, format);
+      return _nullishCoalesce(result, () => ( ctx.argError(0, "#VALUE!", `isn't a date, so it can't use the format "${format}".`)));
+    }
+  }
+];
+
+// src/spreadsheet/formula/functions/lookup.ts
+var sameType = (a, b) => typeof a === "number" === (typeof b === "number") && typeof a === "boolean" === (typeof b === "boolean");
+function lookupIndex(values, target, mode, reverse = false) {
+  const wanted = normalizeValue(target);
+  const order = values.map((_, i) => i);
+  if (reverse) order.reverse();
+  if (mode === "exact" || mode === "wildcard") {
+    const regex = mode === "wildcard" && typeof wanted === "string" && hasWildcards(wanted) ? wildcardToRegExp(wanted) : null;
+    for (const i of order) {
+      const value = normalizeValue(values[i]);
+      if (isFormulaError(value) || isBlank(value)) continue;
+      if (regex ? typeof value === "string" && regex.test(value) : sameType(value, wanted) && compareValues(value, wanted) === 0) {
+        return i;
+      }
+    }
+    return -1;
+  }
+  if (mode === "sorted-asc" || mode === "sorted-desc") {
+    let found = -1;
+    for (let i = 0; i < values.length; i++) {
+      const value = normalizeValue(values[i]);
+      if (isFormulaError(value) || isBlank(value) || !sameType(value, wanted)) continue;
+      const cmp = compareValues(value, wanted);
+      if (mode === "sorted-asc" ? cmp <= 0 : cmp >= 0) found = i;
+      else break;
+    }
+    return found;
+  }
+  let best = -1;
+  let bestValue;
+  for (const i of order) {
+    const value = normalizeValue(values[i]);
+    if (isFormulaError(value) || isBlank(value) || !sameType(value, wanted)) continue;
+    const cmp = compareValues(value, wanted);
+    if (cmp === 0) return i;
+    const candidate = mode === "next-smaller" ? cmp < 0 : cmp > 0;
+    const closer = best === -1 || (mode === "next-smaller" ? compareValues(value, bestValue) > 0 : compareValues(value, bestValue) < 0);
+    if (candidate && closer) {
+      best = i;
+      bestValue = value;
+    }
+  }
+  return best;
+}
+function vector(ctx, index) {
+  const range = ctx.range(index);
+  if (failed(range)) return range;
+  if (range.rows !== 1 && range.cols !== 1) {
+    return ctx.argError(index, "#N/A", "must be a single row or column.");
+  }
+  return { range, values: range.values };
+}
+var notFound = (ctx, value) => ctx.error("#N/A", `${ctx.name} couldn't find ${typeof value === "string" ? `"${value}"` : String(value)}.`);
+function tableLookup(ctx, vertical) {
+  const target = ctx.scalar(0);
+  if (isFormulaError(target)) return target;
+  const table = ctx.range(1);
+  if (failed(table)) return table;
+  const index = ctx.integer(2);
+  if (failed(index)) return index;
+  const approximate = ctx.boolean(3, true);
+  if (failed(approximate)) return approximate;
+  const span = vertical ? table.cols : table.rows;
+  if (index < 1) return ctx.argError(2, "#VALUE!", "must be 1 or more.");
+  if (index > span) {
+    return ctx.argError(2, "#REF!", `is larger than the number of ${vertical ? "columns" : "rows"} in the table (${span}).`);
+  }
+  const keys = vertical ? sliceRange(table, 0, table.rows, 0, 1) : sliceRange(table, 0, 1, 0, table.cols);
+  const position = lookupIndex(keys, target, approximate ? "sorted-asc" : "wildcard");
+  if (position === -1) return notFound(ctx, target);
+  return vertical ? rangeGet(table, position, index - 1) : rangeGet(table, index - 1, position);
+}
+var LOOKUP_FUNCTIONS = [
+  {
+    name: "VLOOKUP",
+    category: "lookup",
+    description: "Looks for a value in the first column of a table and returns the value in the same row of another column.",
+    args: [
+      arg("lookup_value", "The value to find in the first column."),
+      arg("table_array", "The table to search.", "range"),
+      arg("col_index_num", "Which column to return (1 = first column).", "number"),
+      optional("range_lookup", "FALSE for an exact match; TRUE or omitted for the closest match in a sorted first column.", "logical")
+    ],
+    evaluate: (ctx) => tableLookup(ctx, true)
+  },
+  {
+    name: "HLOOKUP",
+    category: "lookup",
+    description: "Looks for a value in the first row of a table and returns the value in the same column of another row.",
+    args: [
+      arg("lookup_value", "The value to find in the first row."),
+      arg("table_array", "The table to search.", "range"),
+      arg("row_index_num", "Which row to return (1 = first row).", "number"),
+      optional("range_lookup", "FALSE for an exact match; TRUE or omitted for the closest match in a sorted first row.", "logical")
+    ],
+    evaluate: (ctx) => tableLookup(ctx, false)
+  },
+  {
+    name: "MATCH",
+    category: "lookup",
+    description: "Returns the position of a value in a row or column.",
+    args: [
+      arg("lookup_value", "The value to find."),
+      arg("lookup_array", "A single row or column to search.", "range"),
+      optional("match_type", "0 = exact; 1 (default) = largest value <= lookup_value in ascending data; -1 = smallest value >= lookup_value in descending data.", "number")
+    ],
+    evaluate: (ctx) => {
+      const target = ctx.scalar(0);
+      if (isFormulaError(target)) return target;
+      const list = vector(ctx, 1);
+      if (failed(list)) return list;
+      const type = ctx.number(2, 1);
+      if (failed(type)) return type;
+      const mode = type === 0 ? "wildcard" : type > 0 ? "sorted-asc" : "sorted-desc";
+      const position = lookupIndex(list.values, target, mode);
+      return position === -1 ? notFound(ctx, target) : position + 1;
+    }
+  },
+  {
+    name: "INDEX",
+    category: "lookup",
+    description: "Returns the value at a row and column of a range. Row or column 0 returns the whole column or row.",
+    args: [
+      arg("array", "The range to read from.", "range"),
+      arg("row_num", "The row (1 = first row; 0 = every row).", "number"),
+      optional("column_num", "The column (1 = first column; 0 = every column).", "number")
+    ],
+    evaluate: (ctx) => {
+      const range = ctx.range(0);
+      if (failed(range)) return range;
+      let row = ctx.integer(1);
+      if (failed(row)) return row;
+      let col = ctx.integer(2, ctx.has(2) ? void 0 : 1);
+      if (failed(col)) return col;
+      if (!ctx.has(2) && range.rows === 1 && range.cols > 1) {
+        col = row;
+        row = 1;
+      }
+      if (row < 0 || row > range.rows) {
+        return ctx.argError(1, "#REF!", `is outside the range (1 to ${range.rows}).`);
+      }
+      if (col < 0 || col > range.cols) {
+        return ctx.argError(2, "#REF!", `is outside the range (1 to ${range.cols}).`);
+      }
+      if (row === 0 && col === 0) return range.values;
+      if (row === 0) return sliceRange(range, 0, range.rows, col - 1, 1);
+      if (col === 0) return sliceRange(range, row - 1, 1, 0, range.cols);
+      return rangeGet(range, row - 1, col - 1);
+    }
+  },
+  {
+    name: "XLOOKUP",
+    category: "lookup",
+    description: "Finds a value in one range and returns the value at the same position in another range.",
+    args: [
+      arg("lookup_value", "The value to find."),
+      arg("lookup_array", "A single row or column to search.", "range"),
+      arg("return_array", "The range to return a value from; same height (or width) as lookup_array.", "range"),
+      optional("if_not_found", "Returned when nothing matches (default #N/A)."),
+      optional("match_mode", "0 (default) = exact; -1 = exact or next smaller; 1 = exact or next larger; 2 = wildcard match.", "number"),
+      optional("search_mode", "1 (default) = first to last; -1 = last to first.", "number")
+    ],
+    evaluate: (ctx) => {
+      const target = ctx.scalar(0);
+      if (isFormulaError(target)) return target;
+      const list = vector(ctx, 1);
+      if (failed(list)) return list;
+      const result = ctx.range(2);
+      if (failed(result)) return result;
+      const matchMode = ctx.integer(4, 0);
+      if (failed(matchMode)) return matchMode;
+      const searchMode = ctx.integer(5, 1);
+      if (failed(searchMode)) return searchMode;
+      const vertical = list.range.cols === 1 && list.range.rows > 1;
+      const length = list.values.length;
+      if ((vertical ? result.rows : result.cols) !== length && !(length === 1 && (result.rows === 1 || result.cols === 1))) {
+        return ctx.argError(2, "#VALUE!", "must be the same height (or width) as argument 2.");
+      }
+      const modes = { 0: "exact", [-1]: "next-smaller", 1: "next-larger", 2: "wildcard" };
+      const mode = modes[matchMode];
+      if (!mode) return ctx.argError(4, "#VALUE!", "must be 0, -1, 1 or 2.");
+      if (![1, -1, 2, -2].includes(searchMode)) return ctx.argError(5, "#VALUE!", "must be 1, -1, 2 or -2.");
+      const position = lookupIndex(list.values, target, mode, searchMode < 0);
+      if (position === -1) return ctx.has(3) ? ctx.value(3) : notFound(ctx, target);
+      if (vertical) {
+        return result.cols === 1 ? rangeGet(result, position, 0) : sliceRange(result, position, 1, 0, result.cols);
+      }
+      return result.rows === 1 ? rangeGet(result, 0, position) : sliceRange(result, 0, result.rows, position, 1);
+    }
+  }
+];
+
+// src/spreadsheet/formula/functions/date.ts
+var START_DATE = arg("start_date", "The date to start from.", "date");
+var DATE = arg("date", 'A date (e.g. "2026-01-31" or a cell containing one).', "date");
+function addMonths(date, months) {
+  const target = new Date(date.getFullYear(), date.getMonth() + months, 1);
+  const lastDay = new Date(target.getFullYear(), target.getMonth() + 1, 0).getDate();
+  target.setDate(Math.min(date.getDate(), lastDay));
+  return target;
+}
+function datePart(ctx, part) {
+  const date = ctx.date(0);
+  return failed(date) ? date : part(date);
+}
+var isWorkday = (date) => date.getDay() !== 0 && date.getDay() !== 6;
+var DATE_FUNCTIONS = [
+  {
+    name: "TODAY",
+    category: "date",
+    description: "Returns today's date (YYYY-MM-DD). Changes on every recalculation.",
+    args: [],
+    volatile: true,
+    // Local calendar date (toISOString would give the UTC date).
+    evaluate: () => formatIsoDate(/* @__PURE__ */ new Date())
+  },
+  {
+    name: "NOW",
+    category: "date",
+    description: "Returns the current date and time (YYYY-MM-DD HH:MM:SS). Changes on every recalculation.",
+    args: [],
+    volatile: true,
+    evaluate: () => formatIsoDateTime(/* @__PURE__ */ new Date())
+  },
+  {
+    name: "DATE",
+    category: "date",
+    description: "Builds a date from a year, month and day. Months and days outside their range roll over.",
+    args: [
+      arg("year", "The year (0-1899 are added to 1900).", "number"),
+      arg("month", "The month (1-12).", "number"),
+      arg("day", "The day of the month.", "number")
+    ],
+    evaluate: (ctx) => {
+      let year = ctx.integer(0);
+      if (failed(year)) return year;
+      const month = ctx.integer(1);
+      if (failed(month)) return month;
+      const day = ctx.integer(2);
+      if (failed(day)) return day;
+      if (year < 0 || year > 9999) return ctx.argError(0, "#NUM!", "must be between 0 and 9999.");
+      if (year < 1900) year += 1900;
+      const date = new Date(year, month - 1, 1);
+      date.setDate(day);
+      if (date.getFullYear() < 1900 || date.getFullYear() > 9999) {
+        return ctx.error("#NUM!", "DATE produced a date outside the years 1900-9999.");
+      }
+      return formatIsoDate(date);
+    }
+  },
+  {
+    name: "YEAR",
+    category: "date",
+    description: "Returns the year of a date.",
+    args: [DATE],
+    evaluate: (ctx) => datePart(ctx, (d) => d.getFullYear())
+  },
+  {
+    name: "MONTH",
+    category: "date",
+    description: "Returns the month of a date (1-12).",
+    args: [DATE],
+    evaluate: (ctx) => datePart(ctx, (d) => d.getMonth() + 1)
+  },
+  {
+    name: "DAY",
+    category: "date",
+    description: "Returns the day of the month of a date (1-31).",
+    args: [DATE],
+    evaluate: (ctx) => datePart(ctx, (d) => d.getDate())
+  },
+  {
+    name: "WEEKDAY",
+    category: "date",
+    description: "Returns the day of the week of a date.",
+    args: [DATE, optional("return_type", "1 (default) = Sunday 1 to Saturday 7; 2 = Monday 1 to Sunday 7; 3 = Monday 0 to Sunday 6.", "number")],
+    evaluate: (ctx) => {
+      const date = ctx.date(0);
+      if (failed(date)) return date;
+      const type = ctx.integer(1, 1);
+      if (failed(type)) return type;
+      const day = date.getDay();
+      if (type === 1) return day + 1;
+      if (type === 2) return day === 0 ? 7 : day;
+      if (type === 3) return day === 0 ? 6 : day - 1;
+      return ctx.argError(1, "#NUM!", "must be 1, 2 or 3.");
+    }
+  },
+  {
+    name: "DAYS",
+    category: "date",
+    description: "Returns the number of days between two dates.",
+    args: [arg("end_date", "The later date.", "date"), START_DATE],
+    evaluate: (ctx) => {
+      const end = ctx.date(0);
+      if (failed(end)) return end;
+      const start = ctx.date(1);
+      if (failed(start)) return start;
+      return daysBetween(start, end);
+    }
+  },
+  {
+    name: "EDATE",
+    category: "date",
+    description: "Returns the date a number of months before or after a date.",
+    args: [START_DATE, arg("months", "Months to add (negative for earlier dates).", "number")],
+    evaluate: (ctx) => {
+      const start = ctx.date(0);
+      if (failed(start)) return start;
+      const months = ctx.integer(1);
+      if (failed(months)) return months;
+      return formatIsoDate(addMonths(start, months));
+    }
+  },
+  {
+    name: "EOMONTH",
+    category: "date",
+    description: "Returns the last day of the month a number of months before or after a date.",
+    args: [START_DATE, arg("months", "Months to add (0 = same month).", "number")],
+    evaluate: (ctx) => {
+      const start = ctx.date(0);
+      if (failed(start)) return start;
+      const months = ctx.integer(1);
+      if (failed(months)) return months;
+      return formatIsoDate(new Date(start.getFullYear(), start.getMonth() + months + 1, 0));
+    }
+  },
+  {
+    name: "NETWORKDAYS",
+    category: "date",
+    description: "Counts the working days (Monday to Friday) between two dates, inclusive, minus holidays.",
+    args: [START_DATE, arg("end_date", "The last date.", "date"), optional("holidays", "Dates to exclude.", "range")],
+    evaluate: (ctx) => {
+      const start = ctx.date(0);
+      if (failed(start)) return start;
+      const end = ctx.date(1);
+      if (failed(end)) return end;
+      const holidays = /* @__PURE__ */ new Set();
+      if (ctx.has(2)) {
+        const raw = ctx.value(2);
+        for (const value of Array.isArray(raw) ? raw : [raw]) {
+          if (isFormulaError(value)) return value;
+          if (isBlank(value)) continue;
+          const date = toDate(value);
+          if (!date) return ctx.argError(2, "#VALUE!", "must contain only dates.");
+          holidays.add(formatIsoDate(date));
+        }
+      }
+      const sign = daysBetween(start, end) < 0 ? -1 : 1;
+      const [from, to] = sign < 0 ? [end, start] : [start, end];
+      let count = 0;
+      const total = daysBetween(from, to);
+      for (let i = 0; i <= total; i++) {
+        const day = new Date(from.getFullYear(), from.getMonth(), from.getDate() + i);
+        if (isWorkday(day) && !holidays.has(formatIsoDate(day))) count++;
+      }
+      return sign * count;
+    }
+  },
+  {
+    name: "DATEDIF",
+    category: "date",
+    description: "Returns the difference between two dates in years, months or days.",
+    args: [
+      START_DATE,
+      arg("end_date", "The later date.", "date"),
+      arg("unit", '"Y" years, "M" months, "D" days, "MD" days ignoring months and years, "YM" months ignoring years, "YD" days ignoring years.', "text")
+    ],
+    evaluate: (ctx) => {
+      const start = ctx.date(0);
+      if (failed(start)) return start;
+      const end = ctx.date(1);
+      if (failed(end)) return end;
+      const unit = ctx.text(2);
+      if (failed(unit)) return unit;
+      if (daysBetween(start, end) < 0) return ctx.error("#NUM!", "DATEDIF needs the start date to be on or before the end date.");
+      let months = (end.getFullYear() - start.getFullYear()) * 12 + end.getMonth() - start.getMonth();
+      if (end.getDate() < start.getDate()) months--;
+      switch (unit.trim().toUpperCase()) {
+        case "Y":
+          return Math.floor(months / 12);
+        case "M":
+          return months;
+        case "D":
+          return daysBetween(start, end);
+        case "YM":
+          return months % 12;
+        case "MD": {
+          const anchor = addMonths(start, months);
+          return daysBetween(anchor, end);
+        }
+        case "YD": {
+          const anchor = addMonths(start, Math.floor(months / 12) * 12);
+          return daysBetween(anchor, end);
+        }
+        default:
+          return ctx.argError(2, "#NUM!", 'must be "Y", "M", "D", "MD", "YM" or "YD".');
+      }
+    }
+  }
+];
+
+// src/spreadsheet/formula/functions/information.ts
+var VALUE = arg("value", "The value or cell to check.");
+var check = (test) => (ctx) => test(ctx.scalar(0));
+var INFORMATION_FUNCTIONS = [
+  {
+    name: "ISBLANK",
+    category: "information",
+    description: "Returns TRUE if the value is empty.",
+    args: [VALUE],
+    evaluate: check(isBlank)
+  },
+  {
+    name: "ISNUMBER",
+    category: "information",
+    description: "Returns TRUE if the value is a number (typed cell values that look like numbers count).",
+    args: [VALUE],
+    evaluate: check((value) => numericValue(value) !== null)
+  },
+  {
+    name: "ISTEXT",
+    category: "information",
+    description: "Returns TRUE if the value is text that is not a number.",
+    args: [VALUE],
+    evaluate: check(
+      (value) => typeof value === "string" && !isBlank(value) && !isFormulaError(value) && numericValue(value) === null
+    )
+  },
+  {
+    name: "ISERROR",
+    category: "information",
+    description: "Returns TRUE if the value is any error.",
+    args: [VALUE],
+    evaluate: check(isFormulaError)
+  },
+  {
+    name: "ISNA",
+    category: "information",
+    description: "Returns TRUE if the value is the #N/A error.",
+    args: [VALUE],
+    evaluate: check((value) => value === "#N/A")
+  }
+];
+
+// src/spreadsheet/formula/functions/index.ts
+var BUILTIN_FORMULA_FUNCTIONS = [
+  ...MATH_FUNCTIONS,
+  ...STATISTICAL_FUNCTIONS,
+  ...CONDITIONAL_FUNCTIONS,
+  ...LOGICAL_FUNCTIONS,
+  ...TEXT_FUNCTIONS,
+  ...LOOKUP_FUNCTIONS,
+  ...DATE_FUNCTIONS,
+  ...INFORMATION_FUNCTIONS
+];
+
+// src/spreadsheet/formula/registry.ts
+var registry = /* @__PURE__ */ new Map();
+var builtinsLoaded = false;
+function ensureBuiltins() {
+  if (builtinsLoaded) return;
+  builtinsLoaded = true;
+  for (const def of BUILTIN_FORMULA_FUNCTIONS) {
+    if (!registry.has(def.name)) registry.set(def.name, def);
+  }
+}
+function registerFormulaFunction(definition) {
+  ensureBuiltins();
+  const name = definition.name.trim().toUpperCase();
+  if (!/^[A-Z_][A-Z0-9_.]*$/.test(name)) {
+    throw new Error(`Invalid formula function name "${definition.name}"`);
+  }
+  registry.set(name, { ...definition, name });
+}
+function unregisterFormulaFunction(name) {
+  ensureBuiltins();
+  return registry.delete(name.toUpperCase());
+}
+function getFormulaFunction(name) {
+  ensureBuiltins();
+  return registry.get(name.toUpperCase());
+}
+function listFormulaFunctions(category) {
+  ensureBuiltins();
+  return Array.from(registry.values()).filter((def) => !category || def.category === category).sort((a, b) => a.name.localeCompare(b.name));
+}
+function searchFormulaFunctions(query, options = {}) {
+  const q = query.trim().toUpperCase();
+  const all = listFormulaFunctions(options.category);
+  const prefix = all.filter((def) => def.name.startsWith(q));
+  const contains = q ? all.filter((def) => !def.name.startsWith(q) && def.name.includes(q)) : [];
+  const results = [...prefix, ...contains];
+  return options.limit !== void 0 ? results.slice(0, options.limit) : results;
+}
+function layoutOf(def) {
+  const groupStart = def.args.findIndex((arg2) => arg2.repeating);
+  if (groupStart === -1) return { fixed: def.args, group: [], groupStart: def.args.length };
+  return { fixed: def.args.slice(0, groupStart), group: def.args.slice(groupStart), groupStart };
+}
+function getFormulaArgumentSpecIndex(def, argIndex) {
+  const { fixed, group, groupStart } = layoutOf(def);
+  if (argIndex < fixed.length) return argIndex;
+  if (group.length === 0) return -1;
+  return groupStart + (argIndex - groupStart) % group.length;
+}
+function checkFormulaArgumentCount(def, count) {
+  const { fixed, group } = layoutOf(def);
+  const requiredFixed = fixed.filter((arg2) => !arg2.optional).length;
+  const groupRequired = group.length > 0 && !group[0].optional;
+  const min2 = requiredFixed + (groupRequired ? group.length : 0);
+  const max2 = group.length > 0 ? Infinity : fixed.length;
+  const given = `${count} ${count === 1 ? "was" : "were"} given`;
+  const plural = (n) => `${n} argument${n === 1 ? "" : "s"}`;
+  if (count < min2) {
+    const expected = min2 === max2 ? plural(min2) : `at least ${plural(min2)}`;
+    return `${def.name} needs ${expected}, but ${given}.`;
+  }
+  if (count > max2) {
+    const expected = min2 === max2 ? plural(max2) : `at most ${plural(max2)}`;
+    return max2 === 0 ? `${def.name} takes no arguments, but ${given}.` : `${def.name} takes ${expected}, but ${given}.`;
+  }
+  if (group.length > 1 && count > fixed.length) {
+    const extra = (count - fixed.length) % group.length;
+    if (extra !== 0 && !(def.allowTrailingArgument && extra === 1)) {
+      const names = group.map((arg2) => arg2.name).join(", ");
+      return `${def.name} expects its repeating arguments (${names}) in complete groups.`;
+    }
+  }
+  return null;
+}
+function getFormulaSignatureParts(nameOrDef, activeArgIndex) {
+  const def = typeof nameOrDef === "string" ? getFormulaFunction(nameOrDef) : nameOrDef;
+  if (!def) return [];
+  const { fixed, group, groupStart } = layoutOf(def);
+  let activeSpec = -1;
+  let activeRepeat = 0;
+  if (activeArgIndex !== void 0 && activeArgIndex !== null && activeArgIndex >= 0) {
+    activeSpec = getFormulaArgumentSpecIndex(def, activeArgIndex);
+    if (activeSpec >= groupStart && group.length > 0) {
+      activeRepeat = Math.floor((activeArgIndex - groupStart) / group.length) > 0 ? 1 : 0;
+    }
+  }
+  const parts = [{ text: `${def.name}(`, specIndex: null, active: false }];
+  const pushArg = (text, specIndex, repeat = 0) => {
+    if (parts.length > 1) parts.push({ text: ", ", specIndex: null, active: false });
+    parts.push({ text, specIndex, active: specIndex === activeSpec && repeat === activeRepeat });
+  };
+  fixed.forEach((arg2, i) => pushArg(arg2.optional ? `[${arg2.name}]` : arg2.name, i));
+  if (group.length > 0) {
+    const groupOptional = !!group[0].optional;
+    group.forEach((arg2, i) => {
+      const open = groupOptional && i === 0 ? "[" : "";
+      pushArg(`${open}${arg2.name}1`, groupStart + i, 0);
+    });
+    group.forEach((arg2, i) => {
+      const open = !groupOptional && i === 0 ? "[" : "";
+      pushArg(`${open}${arg2.name}2`, groupStart + i, 1);
+    });
+    parts.push({ text: ", ...]", specIndex: null, active: false });
+  }
+  parts.push({ text: ")", specIndex: null, active: false });
+  return parts;
+}
+function getFormulaSignature(nameOrDef) {
+  return getFormulaSignatureParts(nameOrDef).map((part) => part.text).join("");
+}
+
+// src/spreadsheet/formula/evaluator.ts
+var DEFAULT_MESSAGES = {
+  "#DIV/0!": "The formula divides by zero.",
+  "#VALUE!": "A value in the formula has the wrong type.",
+  "#REF!": "The formula refers to a cell or range that was deleted.",
+  "#NAME?": "The formula contains an unknown name.",
+  "#N/A": "A value is not available.",
+  "#NUM!": "The formula produced an invalid number.",
+  "#CYCLE!": "This formula is part of a circular reference.",
+  "#ERROR!": "The formula could not be evaluated."
+};
+function describeFormulaError(code) {
+  return _nullishCoalesce(DEFAULT_MESSAGES[code], () => ( "The formula could not be evaluated."));
+}
+var quote = (value) => typeof value === "string" ? `"${value}"` : String(value);
+var FormulaEvaluator = (_class2 = class {
+  
+  __init3() {this.diagnostics = []}
+  constructor(context = {}) {;_class2.prototype.__init3.call(this);
+    this.context = context;
+  }
+  /**
+   * Evaluates a formula. Errors in the formula are returned as error values
+   * (`#VALUE!` etc.); malformed formulas and missing resolvers throw.
+   */
+  evaluate(astOrFormula) {
+    const ast = typeof astOrFormula === "string" ? parseFormula(astOrFormula) : astOrFormula;
+    return this.evaluateNode(ast);
+  }
+  /**
+   * Evaluates a formula and explains errors. Never throws: malformed formulas
+   * return `#ERROR!` with the parser's message. A result that is a whole range
+   * (no dynamic-array spilling) is reduced to its first value.
+   */
+  evaluateWithDiagnostics(astOrFormula) {
+    const saved = this.diagnostics;
+    this.diagnostics = [];
+    try {
+      let value = this.evaluate(astOrFormula);
+      if (Array.isArray(value)) value = value.length > 0 ? value[0] : "";
+      if (isFormulaError(value)) {
+        const code = value;
+        const diagnostic = this.diagnostics.find((d) => d.code === code);
+        return { value, error: code, message: _nullishCoalesce(_optionalChain([diagnostic, 'optionalAccess', _10 => _10.message]), () => ( describeFormulaError(code))) };
+      }
+      return { value };
+    } catch (err) {
+      return { value: "#ERROR!", error: "#ERROR!", message: _optionalChain([err, 'optionalAccess', _11 => _11.message]) || "Formula error" };
+    } finally {
+      this.diagnostics = saved;
+    }
+  }
+  /** Records why an error happened and returns the error code. */
+  fail(code, message) {
+    this.diagnostics.push({ code, message });
+    return code;
+  }
+  evaluateNode(node) {
+    switch (node.type) {
+      case "Literal":
+        if (node.value === "#REF!") return this.fail("#REF!", "This formula refers to a cell or range that was deleted.");
+        if (node.value === "#NAME?") return this.fail("#NAME?", "This formula contains an unknown name.");
+        return node.value;
+      case "CellRef": {
+        if (!this.context.resolveCell) {
+          throw new Error(`Cannot resolve cell reference ${node.ref}: no cell resolver provided`);
+        }
+        const value = this.context.resolveCell(node.col, node.row);
+        if (isFormulaError(value)) {
+          this.fail(
+            value,
+            value === "#CYCLE!" ? `Cell ${node.ref} is part of a circular reference.` : `Cell ${node.ref} contains an error (${value}).`
+          );
+        }
+        return value;
+      }
+      case "Range":
+        return this.evaluateRange(node);
+      case "PropertyRef": {
+        if (!this.context.resolveProperty) {
+          throw new Error(`Cannot resolve property [${node.property}]: no property resolver provided`);
+        }
+        return this.context.resolveProperty(node.property);
+      }
+      case "UnaryOp": {
+        const raw = this.evaluateNode(node.argument);
+        const val = toNumber(raw);
+        if (isFormulaError(val)) {
+          return isFormulaError(raw) ? raw : this.fail("#VALUE!", `The ${node.op} operator can't use text (${quote(raw)}).`);
+        }
+        if (node.op === "-") return -val;
+        if (node.op === "+") return val;
+        throw new Error(`Unsupported unary operator: ${node.op}`);
+      }
+      case "BinaryOp": {
+        const left = this.evaluateNode(node.left);
+        if (isFormulaError(left)) return left;
+        const right = this.evaluateNode(node.right);
+        if (isFormulaError(right)) return right;
+        if (["+", "-", "*", "/", "^"].includes(node.op)) {
+          const a = toNumber(left);
+          if (isFormulaError(a)) return this.fail("#VALUE!", `The ${node.op} operator can't use text (${quote(left)}).`);
+          const b = toNumber(right);
+          if (isFormulaError(b)) return this.fail("#VALUE!", `The ${node.op} operator can't use text (${quote(right)}).`);
+          const x = a;
+          const y = b;
+          let result;
+          switch (node.op) {
+            case "+":
+              result = x + y;
+              break;
+            case "-":
+              result = x - y;
+              break;
+            case "*":
+              result = x * y;
+              break;
+            case "/":
+              if (y === 0) return this.fail("#DIV/0!", "The formula divides by zero.");
+              result = x / y;
+              break;
+            default:
+              result = Math.pow(x, y);
+          }
+          return Number.isFinite(result) ? result : this.fail("#NUM!", "The result is too large or not a number.");
+        }
+        switch (node.op) {
+          case "&":
+            return toText(left) + toText(right);
+          case "=":
+            return compareValues(left, right) === 0;
+          case "<>":
+            return compareValues(left, right) !== 0;
+          case "<":
+            return compareValues(left, right) < 0;
+          case "<=":
+            return compareValues(left, right) <= 0;
+          case ">":
+            return compareValues(left, right) > 0;
+          case ">=":
+            return compareValues(left, right) >= 0;
+          default:
+            throw new Error(`Unsupported binary operator: ${node.op}`);
+        }
+      }
+      case "FunctionCall":
+        return this.callFunction(node);
+      default:
+        throw new Error(`Unknown AST node: ${node.type}`);
+    }
+  }
+  evaluateRange(node) {
+    if (!this.context.resolveRange) {
+      throw new Error(`Cannot resolve range ${node.raw}: no range resolver provided`);
+    }
+    const values = this.context.resolveRange(node.startCol, node.startRow, node.endCol, node.endRow);
+    if (!Array.isArray(values)) return values;
+    const cols = Math.abs(colNameToIndex(node.endCol) - colNameToIndex(node.startCol)) + 1;
+    if (values.length % cols === 0) withRangeShape(values, values.length / cols, cols);
+    const error = values.find(isFormulaError);
+    if (error) this.fail(error, `The range ${node.raw} contains an error (${error}).`);
+    return values;
+  }
+  callFunction(node) {
+    const def = getFormulaFunction(node.name);
+    if (!def) return this.fail("#NAME?", `Unknown function "${node.name.toUpperCase()}".`);
+    const countError = checkFormulaArgumentCount(def, node.args.length);
+    if (countError) return this.fail("#ERROR!", countError);
+    const result = def.evaluate(this.createContext(def, node.args));
+    if (typeof result === "number" && !Number.isFinite(result)) {
+      return this.fail("#NUM!", `${def.name} produced an invalid number.`);
+    }
+    return result === void 0 || result === null ? "" : result;
+  }
+  createContext(def, nodes) {
+    const cache = /* @__PURE__ */ new Map();
+    const args = nodes.map((node, index) => ({
+      index,
+      node,
+      value: () => {
+        if (!cache.has(index)) cache.set(index, this.evaluateNode(node));
+        return cache.get(index);
+      }
+    }));
+    const has = (index) => index >= 0 && index < args.length;
+    const value = (index) => has(index) ? args[index].value() : "";
+    const argError = (index, code, reason) => this.fail(code, `Argument ${index + 1} of ${def.name} ${reason}`);
+    const scalar = (index) => {
+      const v = value(index);
+      if (!Array.isArray(v)) return v;
+      if (v.length <= 1) return v.length === 1 ? v[0] : "";
+      return argError(index, "#VALUE!", "must be a single value, not a range.");
+    };
+    const number = (index, fallback) => {
+      if (!has(index) && fallback !== void 0) return fallback;
+      const v = scalar(index);
+      if (isFormulaError(v)) return v;
+      const num = toNumber(v);
+      return isFormulaError(num) ? argError(index, "#VALUE!", `can't be text (${quote(v)}).`) : num;
+    };
+    const flatValues = (from = 0, to = args.length) => {
+      const items = [];
+      for (let i = from; i < Math.min(to, args.length); i++) {
+        const v = args[i].value();
+        if (Array.isArray(v)) {
+          for (const item of v) items.push(item);
+        } else {
+          items.push(v);
+        }
+      }
+      return items;
+    };
+    return {
+      name: def.name,
+      args,
+      error: (code, message) => this.fail(code, _nullishCoalesce(message, () => ( describeFormulaError(code)))),
+      argError,
+      has,
+      value,
+      scalar,
+      number,
+      integer: (index, fallback) => {
+        const num = number(index, fallback);
+        return isFormulaError(num) ? num : Math.trunc(num);
+      },
+      text: (index, fallback) => {
+        if (!has(index) && fallback !== void 0) return fallback;
+        const v = scalar(index);
+        return isFormulaError(v) ? v : toText(v);
+      },
+      boolean: (index, fallback) => {
+        if (!has(index) && fallback !== void 0) return fallback;
+        const v = scalar(index);
+        if (isFormulaError(v)) return v;
+        const bool = toBoolean(v);
+        return isFormulaError(bool) ? argError(index, "#VALUE!", `must be TRUE or FALSE, not text (${quote(v)}).`) : bool;
+      },
+      date: (index) => {
+        const v = scalar(index);
+        if (isFormulaError(v)) return v;
+        if (isBlank(v)) return argError(index, "#VALUE!", "is empty, but a date is needed.");
+        return _nullishCoalesce(toDate(v), () => ( argError(index, "#VALUE!", `(${quote(v)}) isn't a valid date.`)));
+      },
+      range: (index) => {
+        const v = value(index);
+        if (Array.isArray(v)) return toFormulaRange(v);
+        if (isFormulaError(v)) return v;
+        return argError(index, "#VALUE!", "must be a range.");
+      },
+      flatValues,
+      numbers: (from, to) => {
+        const nums = [];
+        for (const item of flatValues(from, to)) {
+          if (isFormulaError(item)) return item;
+          if (isBlank(item) || typeof item === "boolean") continue;
+          const num = typeof item === "number" ? item : numericValue(item);
+          if (num !== null) nums.push(num);
+        }
+        return nums;
+      }
+    };
+  }
+}, _class2);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.tokenizeFormula = tokenizeFormula; exports.WHOLE_COLUMN_END_ROW = WHOLE_COLUMN_END_ROW; exports.parseCellReference = parseCellReference; exports.parseRange = parseRange; exports.FormulaParser = FormulaParser; exports.parseFormula = parseFormula; exports.FORMULA_ERRORS = FORMULA_ERRORS; exports.isFormulaError = isFormulaError; exports.colNameToIndex = colNameToIndex; exports.indexToColName = indexToColName; exports.wildcardToRegExp = wildcardToRegExp; exports.parseCriteria = parseCriteria; exports.formatValueWithCode = formatValueWithCode; exports.registerFormulaFunction = registerFormulaFunction; exports.unregisterFormulaFunction = unregisterFormulaFunction; exports.getFormulaFunction = getFormulaFunction; exports.listFormulaFunctions = listFormulaFunctions; exports.searchFormulaFunctions = searchFormulaFunctions; exports.getFormulaArgumentSpecIndex = getFormulaArgumentSpecIndex; exports.checkFormulaArgumentCount = checkFormulaArgumentCount; exports.getFormulaSignatureParts = getFormulaSignatureParts; exports.getFormulaSignature = getFormulaSignature; exports.describeFormulaError = describeFormulaError; exports.FormulaEvaluator = FormulaEvaluator;
+//# sourceMappingURL=chunk-JYRIOFEN.cjs.map