@abraca/nuxt 1.8.2 → 2.0.0

package/dist/runtime/composables/useSheetsFormulas.js

@@ -0,0 +1,725 @@
+export class FormulaError {
+  constructor(type) {
+    this.type = type;
+  }
+  toString() {
+    return this.type;
+  }
+}
+const CELL_REF_RE = /^\$?([A-Z]{1,3})\$?(\d{1,5})/;
+const OPERATORS = /* @__PURE__ */ new Set(["+", "-", "*", "/", "^", ">", "<", "="]);
+const TWO_CHAR_OPS = /* @__PURE__ */ new Set([">=", "<=", "<>"]);
+function tokenize(formula) {
+  const tokens = [];
+  let i = 0;
+  const s = formula.trim();
+  while (i < s.length) {
+    const ch = s[i];
+    if (ch === " " || ch === "	") {
+      i++;
+      continue;
+    }
+    if (i + 1 < s.length && TWO_CHAR_OPS.has(s[i] + s[i + 1])) {
+      tokens.push({ type: "OPERATOR", value: s[i] + s[i + 1] });
+      i += 2;
+      continue;
+    }
+    if (OPERATORS.has(ch)) {
+      tokens.push({ type: "OPERATOR", value: ch });
+      i++;
+      continue;
+    }
+    if (ch === "(") {
+      tokens.push({ type: "LPAREN", value: "(" });
+      i++;
+      continue;
+    }
+    if (ch === ")") {
+      tokens.push({ type: "RPAREN", value: ")" });
+      i++;
+      continue;
+    }
+    if (ch === ",") {
+      tokens.push({ type: "COMMA", value: "," });
+      i++;
+      continue;
+    }
+    if (ch === ":") {
+      tokens.push({ type: "COLON", value: ":" });
+      i++;
+      continue;
+    }
+    if (ch === '"') {
+      let str = "";
+      i++;
+      while (i < s.length && s[i] !== '"') {
+        str += s[i];
+        i++;
+      }
+      i++;
+      tokens.push({ type: "STRING", value: str });
+      continue;
+    }
+    if (ch >= "0" && ch <= "9" || ch === ".") {
+      let num = "";
+      while (i < s.length && (s[i] >= "0" && s[i] <= "9" || s[i] === ".")) {
+        num += s[i];
+        i++;
+      }
+      tokens.push({ type: "NUMBER", value: num });
+      continue;
+    }
+    if (ch >= "A" && ch <= "Z" || ch >= "a" && ch <= "z" || ch === "$") {
+      const rest = s.slice(i).toUpperCase();
+      if (rest.startsWith("TRUE") && (i + 4 >= s.length || !isAlphaNum(s[i + 4]))) {
+        tokens.push({ type: "NUMBER", value: "TRUE" });
+        i += 4;
+        continue;
+      }
+      if (rest.startsWith("FALSE") && (i + 5 >= s.length || !isAlphaNum(s[i + 5]))) {
+        tokens.push({ type: "NUMBER", value: "FALSE" });
+        i += 5;
+        continue;
+      }
+      const cellMatch = rest.match(CELL_REF_RE);
+      let afterRef = i + (cellMatch ? cellMatch[0].length : 0);
+      while (afterRef < s.length && s[afterRef] === " ") afterRef++;
+      let word = "";
+      let j = i;
+      while (j < s.length && (s[j] >= "A" && s[j] <= "Z" || s[j] >= "a" && s[j] <= "z" || s[j] === "_" || s[j] === "$")) {
+        word += s[j].toUpperCase();
+        j++;
+      }
+      let wordWithDigits = word;
+      let k = j;
+      while (k < s.length && s[k] >= "0" && s[k] <= "9") {
+        wordWithDigits += s[k];
+        k++;
+      }
+      let afterWord = j;
+      while (afterWord < s.length && s[afterWord] === " ") afterWord++;
+      if (afterWord < s.length && s[afterWord] === "(" && word.length > 0 && !word.includes("$")) {
+        tokens.push({ type: "FUNCTION", value: word });
+        i = j;
+        continue;
+      }
+      if (cellMatch) {
+        tokens.push({ type: "CELL_REF", value: cellMatch[1] + cellMatch[2] });
+        i += cellMatch[0].length;
+        continue;
+      }
+      tokens.push({ type: "FUNCTION", value: word });
+      i = j;
+      continue;
+    }
+    i++;
+  }
+  return tokens;
+}
+function isAlphaNum(ch) {
+  return ch >= "A" && ch <= "Z" || ch >= "a" && ch <= "z" || ch >= "0" && ch <= "9";
+}
+class Parser {
+  constructor(tokens) {
+    this.tokens = tokens;
+  }
+  pos = 0;
+  parse() {
+    const node = this.parseExpression();
+    return node;
+  }
+  peek() {
+    return this.tokens[this.pos] ?? null;
+  }
+  consume(type) {
+    const t = this.tokens[this.pos];
+    if (!t) throw new FormulaError("#ERROR!");
+    if (type && t.type !== type) throw new FormulaError("#ERROR!");
+    this.pos++;
+    return t;
+  }
+  parseExpression() {
+    return this.parseComparison();
+  }
+  parseComparison() {
+    let left = this.parseAddSub();
+    while (this.peek()?.type === "OPERATOR" && [">", "<", ">=", "<=", "=", "<>"].includes(this.peek().value)) {
+      const op = this.consume().value;
+      const right = this.parseAddSub();
+      left = { type: "binaryOp", op, left, right };
+    }
+    return left;
+  }
+  parseAddSub() {
+    let left = this.parseMulDiv();
+    while (this.peek()?.type === "OPERATOR" && (this.peek().value === "+" || this.peek().value === "-")) {
+      const op = this.consume().value;
+      const right = this.parseMulDiv();
+      left = { type: "binaryOp", op, left, right };
+    }
+    return left;
+  }
+  parseMulDiv() {
+    let left = this.parsePower();
+    while (this.peek()?.type === "OPERATOR" && (this.peek().value === "*" || this.peek().value === "/")) {
+      const op = this.consume().value;
+      const right = this.parsePower();
+      left = { type: "binaryOp", op, left, right };
+    }
+    return left;
+  }
+  parsePower() {
+    let left = this.parseUnary();
+    while (this.peek()?.type === "OPERATOR" && this.peek().value === "^") {
+      this.consume();
+      const right = this.parseUnary();
+      left = { type: "binaryOp", op: "^", left, right };
+    }
+    return left;
+  }
+  parseUnary() {
+    if (this.peek()?.type === "OPERATOR" && this.peek().value === "-") {
+      this.consume();
+      const operand = this.parseUnary();
+      return { type: "unaryOp", op: "-", operand };
+    }
+    if (this.peek()?.type === "OPERATOR" && this.peek().value === "+") {
+      this.consume();
+      return this.parseUnary();
+    }
+    return this.parsePrimary();
+  }
+  parsePrimary() {
+    const t = this.peek();
+    if (!t) throw new FormulaError("#ERROR!");
+    if (t.type === "NUMBER") {
+      this.consume();
+      if (t.value === "TRUE") return { type: "boolean", value: true };
+      if (t.value === "FALSE") return { type: "boolean", value: false };
+      return { type: "number", value: parseFloat(t.value) };
+    }
+    if (t.type === "STRING") {
+      this.consume();
+      return { type: "string", value: t.value };
+    }
+    if (t.type === "FUNCTION") {
+      const name = this.consume().value;
+      this.consume("LPAREN");
+      const args = [];
+      if (this.peek()?.type !== "RPAREN") {
+        args.push(this.parseExpression());
+        while (this.peek()?.type === "COMMA") {
+          this.consume();
+          args.push(this.parseExpression());
+        }
+      }
+      this.consume("RPAREN");
+      return { type: "functionCall", name, args };
+    }
+    if (t.type === "CELL_REF") {
+      const ref1 = this.consume();
+      const { col: col1, row: row1 } = parseCellRefStr(ref1.value);
+      if (this.peek()?.type === "COLON") {
+        this.consume();
+        const ref2 = this.consume("CELL_REF");
+        const { col: col2, row: row2 } = parseCellRefStr(ref2.value);
+        return { type: "rangeRef", startCol: col1, startRow: row1, endCol: col2, endRow: row2 };
+      }
+      return { type: "cellRef", col: col1, row: row1 };
+    }
+    if (t.type === "LPAREN") {
+      this.consume();
+      const expr = this.parseExpression();
+      this.consume("RPAREN");
+      return expr;
+    }
+    throw new FormulaError("#ERROR!");
+  }
+}
+function parseCellRefStr(ref) {
+  const match = ref.match(/^([A-Z]+)(\d+)$/);
+  if (!match) throw new FormulaError("#REF!");
+  return { col: match[1], row: parseInt(match[2], 10) };
+}
+function evaluate(node, ctx) {
+  switch (node.type) {
+    case "number":
+      return node.value;
+    case "string":
+      return node.value;
+    case "boolean":
+      return node.value;
+    case "cellRef": {
+      const colIdx = ctx.colLetterToIndex(node.col);
+      const rowIdx = node.row - 1;
+      const key = `${colIdx}:${rowIdx}`;
+      if (ctx.evaluating.has(key)) return new FormulaError("#REF!");
+      ctx.evaluating.add(key);
+      const result = ctx.getCellValue(colIdx, rowIdx);
+      ctx.evaluating.delete(key);
+      return result;
+    }
+    case "rangeRef":
+      return new FormulaError("#VALUE!");
+    case "unaryOp": {
+      const val = evaluate(node.operand, ctx);
+      if (val instanceof FormulaError) return val;
+      if (node.op === "-") return -toNumber(val);
+      return val;
+    }
+    case "binaryOp": {
+      const left = evaluate(node.left, ctx);
+      const right = evaluate(node.right, ctx);
+      if (left instanceof FormulaError) return left;
+      if (right instanceof FormulaError) return right;
+      return evalBinaryOp(node.op, left, right);
+    }
+    case "functionCall":
+      return evalFunction(node.name, node.args, ctx);
+  }
+}
+function evalBinaryOp(op, left, right) {
+  if (left instanceof FormulaError) return left;
+  if (right instanceof FormulaError) return right;
+  const ln = toNumber(left);
+  const rn = toNumber(right);
+  switch (op) {
+    case "+":
+      return ln + rn;
+    case "-":
+      return ln - rn;
+    case "*":
+      return ln * rn;
+    case "/":
+      return rn === 0 ? new FormulaError("#DIV/0!") : ln / rn;
+    case "^":
+      return Math.pow(ln, rn);
+    case ">":
+      return ln > rn;
+    case "<":
+      return ln < rn;
+    case ">=":
+      return ln >= rn;
+    case "<=":
+      return ln <= rn;
+    case "=":
+      return left === right || ln === rn;
+    case "<>":
+      return left !== right && ln !== rn;
+    default:
+      return new FormulaError("#ERROR!");
+  }
+}
+function evalFunction(name, args, ctx) {
+  switch (name) {
+    case "SUM": {
+      const values = collectValues(args, ctx);
+      if (values instanceof FormulaError) return values;
+      return values.reduce((s, v) => s + toNumber(v), 0);
+    }
+    case "AVERAGE": {
+      const values = collectValues(args, ctx);
+      if (values instanceof FormulaError) return values;
+      if (values.length === 0) return new FormulaError("#DIV/0!");
+      return values.reduce((s, v) => s + toNumber(v), 0) / values.length;
+    }
+    case "COUNT": {
+      const values = collectValues(args, ctx);
+      if (values instanceof FormulaError) return values;
+      return values.filter((v) => typeof v === "number" || typeof v === "string" && v !== "" && !isNaN(Number(v))).length;
+    }
+    case "MIN": {
+      const values = collectValues(args, ctx);
+      if (values instanceof FormulaError) return values;
+      const nums = values.map(toNumber).filter((n) => !isNaN(n));
+      return nums.length ? Math.min(...nums) : 0;
+    }
+    case "MAX": {
+      const values = collectValues(args, ctx);
+      if (values instanceof FormulaError) return values;
+      const nums = values.map(toNumber).filter((n) => !isNaN(n));
+      return nums.length ? Math.max(...nums) : 0;
+    }
+    case "IF": {
+      if (args.length < 2) return new FormulaError("#VALUE!");
+      const cond = evaluate(args[0], ctx);
+      if (cond instanceof FormulaError) return cond;
+      const truthy = !!cond && cond !== 0 && cond !== "";
+      if (truthy) return evaluate(args[1], ctx);
+      return args[2] ? evaluate(args[2], ctx) : false;
+    }
+    case "ROUND": {
+      if (args.length < 1) return new FormulaError("#VALUE!");
+      const val = evaluate(args[0], ctx);
+      if (val instanceof FormulaError) return val;
+      const decimals = args[1] ? evaluate(args[1], ctx) : 0;
+      if (decimals instanceof FormulaError) return decimals;
+      const d = toNumber(decimals);
+      const factor = Math.pow(10, d);
+      return Math.round(toNumber(val) * factor) / factor;
+    }
+    case "ABS": {
+      if (args.length < 1) return new FormulaError("#VALUE!");
+      const val = evaluate(args[0], ctx);
+      if (val instanceof FormulaError) return val;
+      return Math.abs(toNumber(val));
+    }
+    case "CONCAT": {
+      const parts = [];
+      for (const arg of args) {
+        const val = evaluate(arg, ctx);
+        if (val instanceof FormulaError) return val;
+        parts.push(String(val));
+      }
+      return parts.join("");
+    }
+    // ── Math functions ──────────────────────────────────────────────────────
+    case "SQRT": {
+      if (args.length < 1) return new FormulaError("#VALUE!");
+      const val = evaluate(args[0], ctx);
+      if (val instanceof FormulaError) return val;
+      const n = toNumber(val);
+      return n < 0 ? new FormulaError("#VALUE!") : Math.sqrt(n);
+    }
+    case "POWER": {
+      if (args.length < 2) return new FormulaError("#VALUE!");
+      const base = evaluate(args[0], ctx);
+      const exp = evaluate(args[1], ctx);
+      if (base instanceof FormulaError) return base;
+      if (exp instanceof FormulaError) return exp;
+      return Math.pow(toNumber(base), toNumber(exp));
+    }
+    case "LOG": {
+      if (args.length < 1) return new FormulaError("#VALUE!");
+      const val = evaluate(args[0], ctx);
+      if (val instanceof FormulaError) return val;
+      const n = toNumber(val);
+      if (n <= 0) return new FormulaError("#VALUE!");
+      const base = args[1] ? evaluate(args[1], ctx) : 10;
+      if (base instanceof FormulaError) return base;
+      const b = toNumber(base);
+      return b === 1 ? new FormulaError("#DIV/0!") : Math.log(n) / Math.log(b);
+    }
+    case "FLOOR": {
+      if (args.length < 1) return new FormulaError("#VALUE!");
+      const val = evaluate(args[0], ctx);
+      if (val instanceof FormulaError) return val;
+      return Math.floor(toNumber(val));
+    }
+    case "CEIL":
+    case "CEILING": {
+      if (args.length < 1) return new FormulaError("#VALUE!");
+      const val = evaluate(args[0], ctx);
+      if (val instanceof FormulaError) return val;
+      return Math.ceil(toNumber(val));
+    }
+    case "MOD": {
+      if (args.length < 2) return new FormulaError("#VALUE!");
+      const val = evaluate(args[0], ctx);
+      const div = evaluate(args[1], ctx);
+      if (val instanceof FormulaError) return val;
+      if (div instanceof FormulaError) return div;
+      const d = toNumber(div);
+      return d === 0 ? new FormulaError("#DIV/0!") : toNumber(val) % d;
+    }
+    case "RAND": {
+      return Math.random();
+    }
+    // ── Text functions ──────────────────────────────────────────────────────
+    case "LEN": {
+      if (args.length < 1) return new FormulaError("#VALUE!");
+      const val = evaluate(args[0], ctx);
+      if (val instanceof FormulaError) return val;
+      return String(val).length;
+    }
+    case "LEFT": {
+      if (args.length < 1) return new FormulaError("#VALUE!");
+      const val = evaluate(args[0], ctx);
+      if (val instanceof FormulaError) return val;
+      const n = args[1] ? evaluate(args[1], ctx) : 1;
+      if (n instanceof FormulaError) return n;
+      return String(val).slice(0, toNumber(n));
+    }
+    case "RIGHT": {
+      if (args.length < 1) return new FormulaError("#VALUE!");
+      const val = evaluate(args[0], ctx);
+      if (val instanceof FormulaError) return val;
+      const n = args[1] ? evaluate(args[1], ctx) : 1;
+      if (n instanceof FormulaError) return n;
+      const s = String(val);
+      return s.slice(Math.max(0, s.length - toNumber(n)));
+    }
+    case "MID": {
+      if (args.length < 3) return new FormulaError("#VALUE!");
+      const val = evaluate(args[0], ctx);
+      const start = evaluate(args[1], ctx);
+      const len = evaluate(args[2], ctx);
+      if (val instanceof FormulaError) return val;
+      if (start instanceof FormulaError) return start;
+      if (len instanceof FormulaError) return len;
+      return String(val).substr(toNumber(start) - 1, toNumber(len));
+    }
+    case "UPPER": {
+      if (args.length < 1) return new FormulaError("#VALUE!");
+      const val = evaluate(args[0], ctx);
+      if (val instanceof FormulaError) return val;
+      return String(val).toUpperCase();
+    }
+    case "LOWER": {
+      if (args.length < 1) return new FormulaError("#VALUE!");
+      const val = evaluate(args[0], ctx);
+      if (val instanceof FormulaError) return val;
+      return String(val).toLowerCase();
+    }
+    case "TRIM": {
+      if (args.length < 1) return new FormulaError("#VALUE!");
+      const val = evaluate(args[0], ctx);
+      if (val instanceof FormulaError) return val;
+      return String(val).trim();
+    }
+    case "SUBSTITUTE": {
+      if (args.length < 3) return new FormulaError("#VALUE!");
+      const text = evaluate(args[0], ctx);
+      const old = evaluate(args[1], ctx);
+      const rep = evaluate(args[2], ctx);
+      if (text instanceof FormulaError) return text;
+      if (old instanceof FormulaError) return old;
+      if (rep instanceof FormulaError) return rep;
+      return String(text).split(String(old)).join(String(rep));
+    }
+    // ── Logic functions ─────────────────────────────────────────────────────
+    case "AND": {
+      for (const arg of args) {
+        const val = evaluate(arg, ctx);
+        if (val instanceof FormulaError) return val;
+        if (!val || val === 0 || val === "") return false;
+      }
+      return true;
+    }
+    case "OR": {
+      for (const arg of args) {
+        const val = evaluate(arg, ctx);
+        if (val instanceof FormulaError) return val;
+        if (val && val !== 0 && val !== "") return true;
+      }
+      return false;
+    }
+    case "NOT": {
+      if (args.length < 1) return new FormulaError("#VALUE!");
+      const val = evaluate(args[0], ctx);
+      if (val instanceof FormulaError) return val;
+      return !val || val === 0 || val === "";
+    }
+    case "IFERROR": {
+      if (args.length < 2) return new FormulaError("#VALUE!");
+      const val = evaluate(args[0], ctx);
+      if (val instanceof FormulaError) return evaluate(args[1], ctx);
+      return val;
+    }
+    // ── Conditional aggregation ─────────────────────────────────────────────
+    case "SUMIF": {
+      if (args.length < 2) return new FormulaError("#VALUE!");
+      const rangeVals = collectValues([args[0]], ctx);
+      if (rangeVals instanceof FormulaError) return rangeVals;
+      const criteria = evaluate(args[1], ctx);
+      if (criteria instanceof FormulaError) return criteria;
+      const sumVals = args[2] ? collectValues([args[2]], ctx) : rangeVals;
+      if (sumVals instanceof FormulaError) return sumVals;
+      let sum = 0;
+      for (let i = 0; i < rangeVals.length; i++) {
+        if (matchesCriteria(rangeVals[i], criteria)) {
+          sum += toNumber(sumVals[i] ?? 0);
+        }
+      }
+      return sum;
+    }
+    case "COUNTIF": {
+      if (args.length < 2) return new FormulaError("#VALUE!");
+      const rangeVals = collectValues([args[0]], ctx);
+      if (rangeVals instanceof FormulaError) return rangeVals;
+      const criteria = evaluate(args[1], ctx);
+      if (criteria instanceof FormulaError) return criteria;
+      let count = 0;
+      for (const v of rangeVals) {
+        if (matchesCriteria(v, criteria)) count++;
+      }
+      return count;
+    }
+    // ── Lookup ──────────────────────────────────────────────────────────────
+    case "VLOOKUP": {
+      if (args.length < 3) return new FormulaError("#VALUE!");
+      const lookupVal = evaluate(args[0], ctx);
+      if (lookupVal instanceof FormulaError) return lookupVal;
+      const rangeArg = args[1];
+      if (rangeArg.type !== "rangeRef") return new FormulaError("#VALUE!");
+      const colIndex = evaluate(args[2], ctx);
+      if (colIndex instanceof FormulaError) return colIndex;
+      const ci = toNumber(colIndex);
+      if (ci < 1) return new FormulaError("#VALUE!");
+      const startColIdx = ctx.colLetterToIndex(rangeArg.startCol);
+      const endColIdx = ctx.colLetterToIndex(rangeArg.endCol);
+      const startRow = rangeArg.startRow - 1;
+      const endRow = rangeArg.endRow - 1;
+      if (ci > endColIdx - startColIdx + 1) return new FormulaError("#REF!");
+      for (let r = startRow; r <= endRow; r++) {
+        const cellVal = ctx.getCellValue(startColIdx, r);
+        if (cellVal instanceof FormulaError) continue;
+        if (cellVal === lookupVal || toNumber(cellVal) === toNumber(lookupVal)) {
+          return ctx.getCellValue(startColIdx + ci - 1, r);
+        }
+      }
+      return new FormulaError("#VALUE!");
+    }
+    default:
+      return new FormulaError("#NAME?");
+  }
+}
+function collectValues(args, ctx) {
+  const values = [];
+  for (const arg of args) {
+    if (arg.type === "rangeRef") {
+      const startColIdx = ctx.colLetterToIndex(arg.startCol);
+      const endColIdx = ctx.colLetterToIndex(arg.endCol);
+      const startRow = arg.startRow - 1;
+      const endRow = arg.endRow - 1;
+      const minCol = Math.min(startColIdx, endColIdx);
+      const maxCol = Math.max(startColIdx, endColIdx);
+      const minRow = Math.min(startRow, endRow);
+      const maxRow = Math.max(startRow, endRow);
+      for (let c = minCol; c <= maxCol; c++) {
+        for (let r = minRow; r <= maxRow; r++) {
+          const key = `${c}:${r}`;
+          if (ctx.evaluating.has(key)) return new FormulaError("#REF!");
+          ctx.evaluating.add(key);
+          const v = ctx.getCellValue(c, r);
+          ctx.evaluating.delete(key);
+          if (v instanceof FormulaError) return v;
+          values.push(v);
+        }
+      }
+    } else {
+      const v = evaluate(arg, ctx);
+      if (v instanceof FormulaError) return v;
+      values.push(v);
+    }
+  }
+  return values;
+}
+function matchesCriteria(cellVal, criteria) {
+  if (cellVal instanceof FormulaError) return false;
+  if (criteria instanceof FormulaError) return false;
+  if (typeof criteria === "string") {
+    const opMatch = criteria.match(/^(<>|>=|<=|>|<|=)(.+)$/);
+    if (opMatch) {
+      const op = opMatch[1];
+      const cmpVal = opMatch[2];
+      const cn = Number(cmpVal);
+      const cv = typeof cellVal === "number" ? cellVal : cellVal !== "" && !isNaN(Number(cellVal)) ? Number(cellVal) : NaN;
+      if (!isNaN(cn) && !isNaN(cv)) {
+        switch (op) {
+          case ">":
+            return cv > cn;
+          case "<":
+            return cv < cn;
+          case ">=":
+            return cv >= cn;
+          case "<=":
+            return cv <= cn;
+          case "<>":
+            return cv !== cn;
+          case "=":
+            return cv === cn;
+        }
+      }
+      switch (op) {
+        case "<>":
+          return String(cellVal) !== cmpVal;
+        case "=":
+          return String(cellVal) === cmpVal;
+        default:
+          return false;
+      }
+    }
+  }
+  if (typeof criteria === "number") return toNumber(cellVal) === criteria;
+  return String(cellVal) === String(criteria);
+}
+function toNumber(val) {
+  if (typeof val === "number") return val;
+  if (typeof val === "boolean") return val ? 1 : 0;
+  if (typeof val === "string") {
+    if (val === "") return 0;
+    const n = Number(val);
+    return isNaN(n) ? 0 : n;
+  }
+  return 0;
+}
+export function evaluateFormula(formula, ctx) {
+  try {
+    const tokens = tokenize(formula);
+    const parser = new Parser(tokens);
+    const ast = parser.parse();
+    return evaluate(ast, ctx);
+  } catch (e) {
+    if (e instanceof FormulaError) return e;
+    return new FormulaError("#ERROR!");
+  }
+}
+export function formatFormulaResult(result) {
+  if (result instanceof FormulaError) return result.type;
+  if (typeof result === "boolean") return result ? "TRUE" : "FALSE";
+  if (typeof result === "number") {
+    return String(Math.round(result * 1e10) / 1e10);
+  }
+  return String(result);
+}
+export function extractCellRefs(formula) {
+  const results = [];
+  const refRe = /\$?([A-Z]{1,3})\$?(\d{1,5})(?::(\$?[A-Z]{1,3})\$?(\d{1,5}))?/g;
+  let match;
+  while ((match = refRe.exec(formula)) !== null) {
+    const col1 = match[1];
+    const row1 = parseInt(match[2], 10);
+    if (match[3] && match[4]) {
+      const col2 = match[3].replace(/\$/g, "");
+      const row2 = parseInt(match[4], 10);
+      results.push({
+        range: match[0],
+        startCol: colLetterToIndexStatic(col1),
+        startRow: row1 - 1,
+        endCol: colLetterToIndexStatic(col2),
+        endRow: row2 - 1
+      });
+    } else {
+      results.push({
+        ref: match[0],
+        colIdx: colLetterToIndexStatic(col1),
+        rowIdx: row1 - 1
+      });
+    }
+  }
+  return results;
+}
+function colLetterToIndexStatic(s) {
+  let result = 0;
+  for (let i = 0; i < s.length; i++) {
+    result = result * 26 + (s.charCodeAt(i) - 64);
+  }
+  return result - 1;
+}
+function indexToColLetterStatic(n) {
+  let result = "";
+  let idx = n;
+  while (idx >= 0) {
+    result = String.fromCharCode(65 + idx % 26) + result;
+    idx = Math.floor(idx / 26) - 1;
+  }
+  return result;
+}
+export function adjustFormulaRefs(formula, dCol, dRow) {
+  return formula.replace(/(\$?)([A-Z]{1,3})(\$?)(\d{1,5})/g, (_match, absDollarCol, col, absDollarRow, row) => {
+    const newCol = absDollarCol ? col : indexToColLetterStatic(colLetterToIndexStatic(col) + dCol);
+    const newRow = absDollarRow ? row : String(parseInt(row, 10) + dRow);
+    return `${absDollarCol}${newCol}${absDollarRow}${newRow}`;
+  });
+}