@pixerate/editor 0.19.0 → 0.20.0

package/dist/chunk-YQCI4CCN.cjs

@@ -1,1715 +0,0 @@
-"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; var _class3; var _class4;// 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 quote = char;
-      const start = i;
-      i++;
-      let str = "";
-      while (i < input.length && input[i] !== quote) {
-        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/evaluator.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 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;
-}
-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 FormulaEvaluator = class {
-  
-  constructor(context = {}) {
-    this.context = context;
-  }
-  evaluate(astOrFormula) {
-    const ast = typeof astOrFormula === "string" ? parseFormula(astOrFormula) : astOrFormula;
-    return this.evaluateNode(ast);
-  }
-  evaluateNode(node) {
-    switch (node.type) {
-      case "Literal":
-        return node.value;
-      case "CellRef": {
-        if (!this.context.resolveCell) {
-          throw new Error(`Cannot resolve cell reference ${node.ref}: no cell resolver provided`);
-        }
-        return this.context.resolveCell(node.col, node.row);
-      }
-      case "Range": {
-        if (!this.context.resolveRange) {
-          throw new Error(`Cannot resolve range ${node.raw}: no range resolver provided`);
-        }
-        return this.context.resolveRange(node.startCol, node.startRow, node.endCol, node.endRow);
-      }
-      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 val = toNumber(this.evaluateNode(node.argument));
-        if (isFormulaError(val)) return val;
-        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 a;
-          const b = toNumber(right);
-          if (isFormulaError(b)) return b;
-          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 "#DIV/0!";
-              result = x / y;
-              break;
-            default:
-              result = Math.pow(x, y);
-          }
-          return Number.isFinite(result) ? result : "#NUM!";
-        }
-        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.name, node.args);
-      }
-      default:
-        throw new Error(`Unknown AST node: ${node.type}`);
-    }
-  }
-  callFunction(name, args) {
-    const fnName = name.toUpperCase();
-    const evaluateAndFlatten = () => {
-      const items = [];
-      for (const arg of args) {
-        const val = this.evaluateNode(arg);
-        if (Array.isArray(val)) {
-          for (const item of val) items.push(item);
-        } else {
-          items.push(val);
-        }
-      }
-      return items;
-    };
-    const numericArgs = () => {
-      const nums = [];
-      for (const item of evaluateAndFlatten()) {
-        if (isFormulaError(item)) return item;
-        if (isBlank(item) || typeof item === "boolean") continue;
-        const num = typeof item === "number" ? item : Number(String(item).trim());
-        if (String(item).trim() !== "" && !isNaN(num)) nums.push(num);
-      }
-      return nums;
-    };
-    const evaluateArg = (index) => this.evaluateNode(args[index]);
-    switch (fnName) {
-      case "SUM": {
-        const nums = numericArgs();
-        if (typeof nums === "string") return nums;
-        let total = 0;
-        for (const num of nums) total += num;
-        return total;
-      }
-      case "AVERAGE": {
-        const items = evaluateAndFlatten();
-        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) && item !== "" && item !== null && item !== void 0) {
-            total += num;
-            count++;
-          }
-        }
-        return count === 0 ? 0 : total / count;
-      }
-      case "COUNT": {
-        const items = evaluateAndFlatten();
-        let count = 0;
-        for (const item of items) {
-          const num = Number(item);
-          if (!isNaN(num) && item !== "" && item !== null && item !== void 0) {
-            count++;
-          }
-        }
-        return count;
-      }
-      case "COUNTA": {
-        const items = evaluateAndFlatten();
-        let count = 0;
-        for (const item of items) {
-          if (item !== "" && item !== null && item !== void 0) {
-            count++;
-          }
-        }
-        return count;
-      }
-      case "MIN":
-      case "MAX": {
-        const nums = numericArgs();
-        if (typeof nums === "string") return nums;
-        if (nums.length === 0) return 0;
-        let result = nums[0];
-        for (const num of nums) {
-          result = fnName === "MIN" ? Math.min(result, num) : Math.max(result, num);
-        }
-        return result;
-      }
-      case "IF": {
-        if (args.length < 2) throw new Error("IF requires at least 2 arguments");
-        const condition = toBoolean(evaluateArg(0));
-        if (isFormulaError(condition)) return condition;
-        if (condition) {
-          return this.evaluateNode(args[1]);
-        } else {
-          return args.length > 2 ? this.evaluateNode(args[2]) : false;
-        }
-      }
-      case "CONCAT": {
-        const items = evaluateAndFlatten();
-        const error = items.find(isFormulaError);
-        if (error) return error;
-        return items.map(toText).join("");
-      }
-      case "UPPER": {
-        if (args.length !== 1) throw new Error("UPPER requires 1 argument");
-        const val = evaluateArg(0);
-        if (isFormulaError(val)) return val;
-        return toText(val).toUpperCase();
-      }
-      case "LOWER": {
-        if (args.length !== 1) throw new Error("LOWER requires 1 argument");
-        const val = evaluateArg(0);
-        if (isFormulaError(val)) return val;
-        return toText(val).toLowerCase();
-      }
-      case "TRIM": {
-        if (args.length !== 1) throw new Error("TRIM requires 1 argument");
-        const val = evaluateArg(0);
-        if (isFormulaError(val)) return val;
-        return toText(val).trim();
-      }
-      case "LEN": {
-        if (args.length !== 1) throw new Error("LEN requires 1 argument");
-        const val = evaluateArg(0);
-        if (isFormulaError(val)) return val;
-        return toText(val).length;
-      }
-      case "ROUND": {
-        if (args.length < 1) throw new Error("ROUND requires at least 1 argument");
-        const num = toNumber(evaluateArg(0));
-        if (isFormulaError(num)) return num;
-        const decimals = args.length > 1 ? toNumber(evaluateArg(1)) : 0;
-        if (isFormulaError(decimals)) return decimals;
-        return roundHalfAwayFromZero(num, Math.trunc(decimals));
-      }
-      case "ABS": {
-        if (args.length !== 1) throw new Error("ABS requires 1 argument");
-        const num = toNumber(evaluateArg(0));
-        return isFormulaError(num) ? num : Math.abs(num);
-      }
-      case "TODAY": {
-        const now = /* @__PURE__ */ new Date();
-        const pad = (n) => String(n).padStart(2, "0");
-        return `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}`;
-      }
-      case "DAYS": {
-        if (args.length !== 2) throw new Error("DAYS requires 2 arguments (end_date, start_date)");
-        const d1 = new Date(this.evaluateNode(args[0]));
-        const d2 = new Date(this.evaluateNode(args[1]));
-        const diffTime = d1.getTime() - d2.getTime();
-        return Math.round(diffTime / (1e3 * 60 * 60 * 24));
-      }
-      default:
-        return "#NAME?";
-    }
-  }
-};
-
-// src/spreadsheet/formula/dependency-graph.ts
-var columnDependencyKey = (col) => `${col.toUpperCase()}:`;
-function extractCellDependencies(node) {
-  const deps = [];
-  const visit = (curr) => {
-    if (curr.type === "CellRef") {
-      deps.push({ col: curr.col, row: curr.row });
-    } else if (curr.type === "Range" && curr.endRow >= WHOLE_COLUMN_END_ROW) {
-      const startC = colNameToIndex(curr.startCol);
-      const endC = colNameToIndex(curr.endCol);
-      for (let c = Math.min(startC, endC); c <= Math.max(startC, endC); c++) {
-        deps.push({ col: indexToColName(c), row: 0 });
-      }
-    } else if (curr.type === "Range") {
-      const startC = colNameToIndex(curr.startCol);
-      const endC = colNameToIndex(curr.endCol);
-      const minC = Math.min(startC, endC);
-      const maxC = Math.max(startC, endC);
-      const minR = Math.min(curr.startRow, curr.endRow);
-      const maxR = Math.max(curr.startRow, curr.endRow);
-      for (let c = minC; c <= maxC; c++) {
-        for (let r = minR; r <= maxR; r++) {
-          deps.push({ col: indexToColName(c), row: r });
-        }
-      }
-    } else if (curr.type === "BinaryOp") {
-      visit(curr.left);
-      visit(curr.right);
-    } else if (curr.type === "UnaryOp") {
-      visit(curr.argument);
-    } else if (curr.type === "FunctionCall") {
-      curr.args.forEach(visit);
-    }
-  };
-  visit(node);
-  return deps;
-}
-var DependencyGraph = (_class2 = class {constructor() { _class2.prototype.__init3.call(this);_class2.prototype.__init4.call(this); }
-  // Map of cellKey (e.g. "B2") -> Set of cellKeys that this cell depends ON
-  __init3() {this.dependencies = /* @__PURE__ */ new Map()}
-  // Map of cellKey (e.g. "A1") -> Set of cellKeys that depend ON this cell (dependents)
-  __init4() {this.dependents = /* @__PURE__ */ new Map()}
-  setCellFormula(cellKey, formulaStr) {
-    const key = cellKey.toUpperCase();
-    const oldDeps = this.dependencies.get(key) || /* @__PURE__ */ new Set();
-    for (const dep of oldDeps) {
-      _optionalChain([this, 'access', _2 => _2.dependents, 'access', _3 => _3.get, 'call', _4 => _4(dep), 'optionalAccess', _5 => _5.delete, 'call', _6 => _6(key)]);
-    }
-    this.dependencies.delete(key);
-    if (!formulaStr || !formulaStr.startsWith("=")) {
-      return;
-    }
-    try {
-      const ast = parseFormula(formulaStr);
-      const deps = extractCellDependencies(ast);
-      const newDeps = /* @__PURE__ */ new Set();
-      for (const d of deps) {
-        const depKey = d.row === 0 ? columnDependencyKey(d.col) : `${d.col}${d.row}`.toUpperCase();
-        newDeps.add(depKey);
-        if (!this.dependents.has(depKey)) {
-          this.dependents.set(depKey, /* @__PURE__ */ new Set());
-        }
-        this.dependents.get(depKey).add(key);
-      }
-      this.dependencies.set(key, newDeps);
-    } catch (e) {
-    }
-  }
-  /** Removes every registered formula and dependency. */
-  clear() {
-    this.dependencies.clear();
-    this.dependents.clear();
-  }
-  getDependencies(cellKey) {
-    return Array.from(this.dependencies.get(cellKey.toUpperCase()) || []);
-  }
-  getDependents(cellKey) {
-    return Array.from(this.dependents.get(cellKey.toUpperCase()) || []);
-  }
-  /**
-   * Detects if there is a cycle containing cellKey.
-   */
-  hasCycle(cellKey) {
-    const key = cellKey.toUpperCase();
-    const visited = /* @__PURE__ */ new Set();
-    const recStack = /* @__PURE__ */ new Set();
-    const dfs = (node) => {
-      visited.add(node);
-      recStack.add(node);
-      const deps = this.dependencies.get(node) || /* @__PURE__ */ new Set();
-      for (const neighbor of deps) {
-        if (!visited.has(neighbor)) {
-          if (dfs(neighbor)) return true;
-        } else if (recStack.has(neighbor)) {
-          return true;
-        }
-      }
-      recStack.delete(node);
-      return false;
-    };
-    return dfs(key);
-  }
-  /**
-   * Returns cells affected by updating cellKey in topological order.
-   */
-  getEvaluationOrder(startCellKey) {
-    const start = startCellKey.toUpperCase();
-    const visited = /* @__PURE__ */ new Set();
-    const recStack = /* @__PURE__ */ new Set();
-    const order = [];
-    let cycleDetected = false;
-    const affected = /* @__PURE__ */ new Set();
-    const collectAffected = (node) => {
-      affected.add(node);
-      const directDependents = this.dependents.get(node) || /* @__PURE__ */ new Set();
-      for (const dep of directDependents) {
-        if (!affected.has(dep)) {
-          collectAffected(dep);
-        }
-      }
-    };
-    collectAffected(start);
-    const visit = (node) => {
-      if (recStack.has(node)) {
-        cycleDetected = true;
-        return;
-      }
-      if (visited.has(node)) return;
-      recStack.add(node);
-      visited.add(node);
-      const deps = this.dependencies.get(node) || /* @__PURE__ */ new Set();
-      for (const neighbor of deps) {
-        if (affected.has(neighbor)) {
-          visit(neighbor);
-        }
-      }
-      recStack.delete(node);
-      order.push(node);
-    };
-    for (const node of affected) {
-      if (!visited.has(node)) {
-        visit(node);
-      }
-    }
-    return { order, hasCycle: cycleDetected };
-  }
-  /**
-   * Plans a recalculation over `cellKeys` (and, with `includeDependents`, every
-   * cell that transitively depends on them). Returns the keys in evaluation
-   * order (dependencies first) and the set of keys that are part of a cycle,
-   * which must be marked `#CYCLE!` instead of evaluated. Every member of a
-   * cycle is reported, not just the cell that closed it.
-   */
-  getEvaluationPlan(cellKeys, options = {}) {
-    const nodes = /* @__PURE__ */ new Set();
-    const queue = [];
-    for (const key of cellKeys) {
-      const upper = key.toUpperCase();
-      if (!nodes.has(upper)) {
-        nodes.add(upper);
-        queue.push(upper);
-      }
-    }
-    if (options.includeDependents) {
-      while (queue.length > 0) {
-        const node = queue.pop();
-        const direct = [
-          ..._nullishCoalesce(this.dependents.get(node), () => ( [])),
-          ..._nullishCoalesce(this.dependents.get(columnDependencyKey(node.replace(/\d+$/, ""))), () => ( []))
-        ];
-        for (const dep of direct) {
-          if (!nodes.has(dep)) {
-            nodes.add(dep);
-            queue.push(dep);
-          }
-        }
-      }
-    }
-    const neighbors = (node) => {
-      const result = [];
-      for (const dep of _nullishCoalesce(this.dependencies.get(node), () => ( []))) {
-        if (dep.endsWith(":")) {
-          const col = dep.slice(0, -1);
-          for (const candidate of nodes) {
-            if (candidate.replace(/\d+$/, "") === col) result.push(candidate);
-          }
-        } else if (nodes.has(dep)) {
-          result.push(dep);
-        }
-      }
-      return result;
-    };
-    const order = [];
-    const cyclic = /* @__PURE__ */ new Set();
-    const index = /* @__PURE__ */ new Map();
-    const low = /* @__PURE__ */ new Map();
-    const stack = [];
-    const onStack = /* @__PURE__ */ new Set();
-    let counter = 0;
-    for (const root of nodes) {
-      if (index.has(root)) continue;
-      const work = [];
-      const enter = (node) => {
-        index.set(node, counter);
-        low.set(node, counter);
-        counter++;
-        stack.push(node);
-        onStack.add(node);
-        work.push({ node, edges: neighbors(node), next: 0 });
-      };
-      enter(root);
-      while (work.length > 0) {
-        const frame = work[work.length - 1];
-        if (frame.next < frame.edges.length) {
-          const target = frame.edges[frame.next++];
-          if (!index.has(target)) {
-            enter(target);
-          } else if (onStack.has(target)) {
-            low.set(frame.node, Math.min(low.get(frame.node), index.get(target)));
-          }
-          continue;
-        }
-        work.pop();
-        if (work.length > 0) {
-          const parent = work[work.length - 1].node;
-          low.set(parent, Math.min(low.get(parent), low.get(frame.node)));
-        }
-        if (low.get(frame.node) === index.get(frame.node)) {
-          const component = [];
-          let member;
-          do {
-            member = stack.pop();
-            onStack.delete(member);
-            component.push(member);
-          } while (member !== frame.node);
-          const isCycle = component.length > 1 || frame.edges.includes(frame.node);
-          for (const key of component) {
-            order.push(key);
-            if (isCycle) cyclic.add(key);
-          }
-        }
-      }
-    }
-    return { order, cyclic };
-  }
-}, _class2);
-
-// src/spreadsheet/formula/references.ts
-var CELL_PART = /^(\$?)([A-Za-z]+)(\$?)(\d+)$/;
-var COLUMN_PART = /^(\$?)([A-Za-z]+)$/;
-var REF_CHAR = /[A-Za-z0-9_$.:]/;
-function parsePart(text) {
-  const cell = CELL_PART.exec(text);
-  if (cell) {
-    return {
-      colAbs: cell[1],
-      col: colNameToIndex(cell[2]),
-      rowAbs: cell[3],
-      row: parseInt(cell[4], 10) - 1
-    };
-  }
-  const column = COLUMN_PART.exec(text);
-  if (column) {
-    return { colAbs: column[1], col: colNameToIndex(column[2]), rowAbs: "", row: null };
-  }
-  return null;
-}
-function formatPart(part) {
-  const col = `${part.colAbs}${indexToColName(part.col)}`;
-  return part.row === null ? col : `${col}${part.rowAbs}${part.row + 1}`;
-}
-function shiftCoordinate(value, change) {
-  if (change.type === "insert") {
-    return value >= change.index ? value + 1 : value;
-  }
-  if (value === change.index) return null;
-  return value > change.index ? value - 1 : value;
-}
-function shiftSpan(lo, hi, change) {
-  if (change.type === "insert") {
-    return [lo >= change.index ? lo + 1 : lo, hi >= change.index ? hi + 1 : hi];
-  }
-  if (lo === change.index && hi === change.index) return null;
-  return [lo > change.index ? lo - 1 : lo, hi >= change.index ? hi - 1 : hi];
-}
-function rewriteReference(text, change) {
-  const [startText, endText] = text.split(":");
-  const start = parsePart(startText);
-  if (!start) return text;
-  const key = change.axis === "row" ? "row" : "col";
-  if (endText === void 0) {
-    if (start[key] === null) return text;
-    const shifted = shiftCoordinate(start[key], change);
-    if (shifted === null) return "#REF!";
-    return formatPart({ ...start, [key]: shifted });
-  }
-  const end = parsePart(endText);
-  if (!end) return text;
-  if (start[key] === null || end[key] === null) return text;
-  const startValue = start[key];
-  const endValue = end[key];
-  const span = shiftSpan(Math.min(startValue, endValue), Math.max(startValue, endValue), change);
-  if (span === null) return "#REF!";
-  const [lo, hi] = span;
-  const newStart = { ...start, [key]: startValue <= endValue ? lo : hi };
-  const newEnd = { ...end, [key]: startValue <= endValue ? hi : lo };
-  return `${formatPart(newStart)}:${formatPart(newEnd)}`;
-}
-function shiftFormulaReferences(formula, change) {
-  if (!formula.startsWith("=")) return formula;
-  let tokens;
-  try {
-    tokens = tokenizeFormula(formula);
-  } catch (e2) {
-    return formula;
-  }
-  let result = "";
-  let cursor = 0;
-  for (let i = 0; i < tokens.length; i++) {
-    const token = tokens[i];
-    if (token.type !== "CELL_REF" && token.type !== "RANGE") continue;
-    if (_optionalChain([tokens, 'access', _7 => _7[i + 1], 'optionalAccess', _8 => _8.type]) === "LPAREN") continue;
-    let end = token.position;
-    while (end < formula.length && REF_CHAR.test(formula[end])) end++;
-    const original = formula.slice(token.position, end);
-    result += formula.slice(cursor, token.position) + rewriteReference(original, change);
-    cursor = end;
-  }
-  return result + formula.slice(cursor);
-}
-
-// src/spreadsheet/datasource/index.ts
-var DataSourceBinder = (_class3 = class {constructor() { _class3.prototype.__init5.call(this); }
-  __init5() {this.dataSources = /* @__PURE__ */ new Map()}
-  register(dataSource) {
-    this.dataSources.set(dataSource.id, dataSource);
-  }
-  unregister(dataSourceId) {
-    this.dataSources.delete(dataSourceId);
-  }
-  getDataSource(id) {
-    return this.dataSources.get(id);
-  }
-  /**
-   * Generates or reconciles spreadsheet rows from a primary data source.
-   */
-  syncRows(currentRows, dataSourceId) {
-    const ds = this.dataSources.get(dataSourceId);
-    if (!ds) return currentRows;
-    const records = ds.getRecords();
-    const existingRecordRowMap = /* @__PURE__ */ new Map();
-    const freeformRows = [];
-    for (const row of currentRows) {
-      if (row.type === "record" && row.recordId) {
-        existingRecordRowMap.set(row.recordId, row);
-      } else {
-        freeformRows.push(row);
-      }
-    }
-    const nextRows = [];
-    let rowIndex = 0;
-    for (const record of records) {
-      const existing = existingRecordRowMap.get(record.id);
-      nextRows.push({
-        id: _optionalChain([existing, 'optionalAccess', _9 => _9.id]) || `row_${record.id}`,
-        index: rowIndex++,
-        height: _optionalChain([existing, 'optionalAccess', _10 => _10.height]) || 32,
-        recordId: record.id,
-        type: "record"
-      });
-      existingRecordRowMap.delete(record.id);
-    }
-    for (const freeform of freeformRows) {
-      nextRows.push({
-        ...freeform,
-        index: rowIndex++
-      });
-    }
-    return nextRows;
-  }
-  /**
-   * Resolves a record's bound field value.
-   */
-  resolveBoundValue(dataSourceId, recordId, field) {
-    const ds = this.dataSources.get(dataSourceId);
-    if (!ds) return void 0;
-    const records = ds.getRecords();
-    const record = records.find((r) => r.id === recordId);
-    return record ? record[field] : void 0;
-  }
-  /**
-   * Dispatches an update to the underlying data source.
-   */
-  async commitBoundValue(dataSourceId, recordId, field, value) {
-    const ds = this.dataSources.get(dataSourceId);
-    if (!ds) return;
-    await ds.updateRecord(recordId, field, value);
-  }
-}, _class3);
-
-// src/spreadsheet/controller.ts
-var SpreadsheetController = (_class4 = class {
-  
-  __init6() {this.activeCell = null}
-  __init7() {this.selectedRange = null}
-  __init8() {this.editingCell = null}
-  __init9() {this.draftValue = ""}
-  __init10() {this.binder = new DataSourceBinder()}
-  __init11() {this.depGraph = new DependencyGraph()}
-  
-  
-  
-  
-  
-  // History stack for undo/redo
-  __init12() {this.undoStack = []}
-  __init13() {this.redoStack = []}
-  __init14() {this.isApplyingHistory = false}
-  // Set while importing TSV: history and recalculation are done once at the end.
-  __init15() {this.batching = false}
-  __init16() {this.pendingCommits = []}
-  // Row being evaluated, so [property] references resolve per row.
-  __init17() {this.evaluatingRowIndex = null}
-  constructor(options = {}) {;_class4.prototype.__init6.call(this);_class4.prototype.__init7.call(this);_class4.prototype.__init8.call(this);_class4.prototype.__init9.call(this);_class4.prototype.__init10.call(this);_class4.prototype.__init11.call(this);_class4.prototype.__init12.call(this);_class4.prototype.__init13.call(this);_class4.prototype.__init14.call(this);_class4.prototype.__init15.call(this);_class4.prototype.__init16.call(this);_class4.prototype.__init17.call(this);
-    const defaultCols = [
-      { id: "col_a", key: "A", title: "A", width: 120, type: "freeform" },
-      { id: "col_b", key: "B", title: "B", width: 120, type: "freeform" },
-      { id: "col_c", key: "C", title: "C", width: 120, type: "freeform" },
-      { id: "col_d", key: "D", title: "D", width: 120, type: "freeform" }
-    ];
-    const defaultRows = options.primaryDataSourceId ? [] : Array.from({ length: 10 }, (_, i) => ({
-      id: `row_${i + 1}`,
-      index: i,
-      height: 32,
-      type: "freeform"
-    }));
-    this.document = {
-      id: _optionalChain([options, 'access', _11 => _11.document, 'optionalAccess', _12 => _12.id]) || `sheet_${Date.now()}`,
-      name: _optionalChain([options, 'access', _13 => _13.document, 'optionalAccess', _14 => _14.name]) || "Sheet 1",
-      columns: _optionalChain([options, 'access', _15 => _15.document, 'optionalAccess', _16 => _16.columns]) || defaultCols,
-      rows: _optionalChain([options, 'access', _17 => _17.document, 'optionalAccess', _18 => _18.rows]) || defaultRows,
-      cells: _optionalChain([options, 'access', _19 => _19.document, 'optionalAccess', _20 => _20.cells]) || {},
-      createdAt: _optionalChain([options, 'access', _21 => _21.document, 'optionalAccess', _22 => _22.createdAt]) || Date.now(),
-      updatedAt: _optionalChain([options, 'access', _23 => _23.document, 'optionalAccess', _24 => _24.updatedAt]) || Date.now()
-    };
-    this.primaryDataSourceId = options.primaryDataSourceId;
-    this.onDocumentChange = options.onDocumentChange;
-    this.onSelectionChange = options.onSelectionChange;
-    this.onCellCommit = options.onCellCommit;
-    if (options.dataSources) {
-      options.dataSources.forEach((ds) => this.binder.register(ds));
-    }
-    this.evaluator = new FormulaEvaluator({
-      resolveCell: (colStr, rowNum) => this.resolveCellByCoord(colStr, rowNum),
-      resolveRange: (sCol, sRow, eCol, eRow) => this.resolveRangeByCoords(sCol, sRow, eCol, eRow),
-      resolveProperty: (prop) => this.resolveCurrentRowProperty(prop)
-    });
-    this.syncWithDataSource();
-    this.recalculateAll();
-  }
-  loadDocument(document) {
-    this.document = JSON.parse(JSON.stringify(document));
-    this.activeCell = null;
-    this.selectedRange = null;
-    this.editingCell = null;
-    this.draftValue = "";
-    this.undoStack = [];
-    this.redoStack = [];
-    this.syncWithDataSource();
-    this.recalculateAll();
-    this.notifyChange();
-  }
-  registerDataSource(ds) {
-    this.binder.register(ds);
-    this.syncWithDataSource();
-    this.recalculateAll();
-  }
-  setPrimaryDataSource(dataSourceId) {
-    this.primaryDataSourceId = dataSourceId;
-    this.syncWithDataSource();
-    this.recalculateAll();
-  }
-  syncWithDataSource() {
-    if (!this.primaryDataSourceId) return;
-    this.document.rows = this.binder.syncRows(this.document.rows, this.primaryDataSourceId);
-    this.recomputeRowIndices();
-  }
-  recomputeRowIndices() {
-    this.document.rows.forEach((r, idx) => {
-      r.index = idx;
-    });
-    this.document.columns.forEach((c, idx) => {
-      c.key = indexToColName(idx);
-    });
-  }
-  getColumn(colIdOrKey) {
-    return this.document.columns.find(
-      (c) => c.id === colIdOrKey || c.key.toUpperCase() === colIdOrKey.toUpperCase()
-    );
-  }
-  getRow(rowIdOrIndex) {
-    if (typeof rowIdOrIndex === "number") {
-      return this.document.rows[rowIdOrIndex];
-    }
-    return this.document.rows.find((r) => r.id === rowIdOrIndex);
-  }
-  getCell(rowId, colId) {
-    const existing = _optionalChain([this, 'access', _25 => _25.document, 'access', _26 => _26.cells, 'access', _27 => _27[rowId], 'optionalAccess', _28 => _28[colId]]);
-    if (existing) return existing;
-    const col = this.document.columns.find((c) => c.id === colId);
-    const row = this.document.rows.find((r) => r.id === rowId);
-    return this.getDerivedCell(row, col);
-  }
-  /** Value of a cell with no stored data: bound record value, column formula, or blank. */
-  getDerivedCell(row, col) {
-    if (col && row && col.type === "bound" && col.binding && row.recordId) {
-      const boundVal = this.binder.resolveBoundValue(
-        col.binding.dataSource,
-        row.recordId,
-        col.binding.field
-      );
-      return {
-        raw: boundVal !== void 0 ? String(boundVal) : "",
-        value: _nullishCoalesce(boundVal, () => ( "")),
-        format: col.format
-      };
-    }
-    if (col && col.type === "formula" && col.formula) {
-      return {
-        raw: col.formula,
-        value: "",
-        format: col.format
-      };
-    }
-    return { raw: "", value: "", format: _optionalChain([col, 'optionalAccess', _29 => _29.format]) };
-  }
-  setCellValue(rowId, colId, raw) {
-    this.recordSnapshot();
-    if (!this.document.cells[rowId]) {
-      this.document.cells[rowId] = {};
-    }
-    const col = this.document.columns.find((c) => c.id === colId);
-    const row = this.document.rows.find((r) => r.id === rowId);
-    if (_optionalChain([col, 'optionalAccess', _30 => _30.type]) === "bound" && col.binding && _optionalChain([row, 'optionalAccess', _31 => _31.recordId])) {
-      this.binder.commitBoundValue(
-        col.binding.dataSource,
-        row.recordId,
-        col.binding.field,
-        raw
-      );
-    }
-    const cellKey = this.getCellKey(rowId, colId);
-    this.depGraph.setCellFormula(cellKey, raw.startsWith("=") ? raw : null);
-    this.document.cells[rowId][colId] = {
-      raw,
-      value: raw,
-      format: _optionalChain([col, 'optionalAccess', _32 => _32.format])
-    };
-    this.document.updatedAt = Date.now();
-    if (this.batching) {
-      this.pendingCommits.push([rowId, colId, raw]);
-      return;
-    }
-    this.recalculateCell(rowId, colId);
-    this.notifyChange();
-    const evaluatedVal = _optionalChain([this, 'access', _33 => _33.document, 'access', _34 => _34.cells, 'access', _35 => _35[rowId], 'access', _36 => _36[colId], 'optionalAccess', _37 => _37.value]);
-    _optionalChain([this, 'access', _38 => _38.onCellCommit, 'optionalCall', _39 => _39(rowId, colId, raw, evaluatedVal)]);
-  }
-  getCellKey(rowId, colId) {
-    const row = this.document.rows.find((r) => r.id === rowId);
-    const col = this.document.columns.find((c) => c.id === colId);
-    if (!row || !col) return `${colId}_${rowId}`;
-    return `${col.key}${row.index + 1}`.toUpperCase();
-  }
-  /**
-   * Recalculates a cell and everything that depends on it, in dependency
-   * order. Every cell in a reference cycle is marked `#CYCLE!`.
-   */
-  recalculateCell(rowId, colId) {
-    const cellKey = this.getCellKey(rowId, colId);
-    this.runEvaluationPlan(this.depGraph.getEvaluationPlan([cellKey], { includeDependents: true }));
-  }
-  /**
-   * Rebuilds the dependency graph from scratch and recalculates every formula
-   * in dependency order.
-   */
-  recalculateAll() {
-    this.depGraph.clear();
-    const formulaKeys = [];
-    for (const row of this.document.rows) {
-      for (const col of this.document.columns) {
-        const cell = _nullishCoalesce(_optionalChain([this, 'access', _40 => _40.document, 'access', _41 => _41.cells, 'access', _42 => _42[row.id], 'optionalAccess', _43 => _43[col.id]]), () => ( this.getDerivedCell(row, col)));
-        if (cell.raw.startsWith("=")) {
-          const cellKey = `${col.key}${row.index + 1}`.toUpperCase();
-          this.depGraph.setCellFormula(cellKey, cell.raw);
-          formulaKeys.push(cellKey);
-        }
-      }
-    }
-    this.runEvaluationPlan(this.depGraph.getEvaluationPlan(formulaKeys));
-  }
-  runEvaluationPlan(plan) {
-    for (const key of plan.order) {
-      if (plan.cyclic.has(key)) {
-        this.markCycle(key);
-      } else {
-        this.evalSingleCellByKey(key);
-      }
-    }
-  }
-  locateCellKey(cellKey) {
-    const match = cellKey.match(/^([A-Za-z]+)(\d+)$/);
-    if (!match) return null;
-    const col = this.document.columns.find((c) => c.key.toUpperCase() === match[1].toUpperCase());
-    const row = this.document.rows[parseInt(match[2], 10) - 1];
-    return col && row ? { row, col } : null;
-  }
-  markCycle(cellKey) {
-    const located = this.locateCellKey(cellKey);
-    if (!located) return;
-    const { row, col } = located;
-    const cell = this.getCell(row.id, col.id);
-    if (!cell.raw.startsWith("=")) return;
-    if (!this.document.cells[row.id]) this.document.cells[row.id] = {};
-    this.document.cells[row.id][col.id] = { ...cell, value: "#CYCLE!", error: "#CYCLE!" };
-  }
-  evalSingleCellByKey(cellKey) {
-    const match = cellKey.match(/^([A-Za-z]+)(\d+)$/);
-    if (!match) return;
-    const colName = match[1].toUpperCase();
-    const rowNum = parseInt(match[2], 10);
-    const col = this.document.columns.find((c) => c.key.toUpperCase() === colName);
-    const row = this.document.rows[rowNum - 1];
-    if (!col || !row) return;
-    const cell = this.getCell(row.id, col.id);
-    if (!cell.raw.startsWith("=")) {
-      if (cell.error === "#CYCLE!") {
-        cell.error = void 0;
-      }
-      return;
-    }
-    try {
-      this.evaluatingRowIndex = rowNum - 1;
-      const computed = this.evaluator.evaluate(cell.raw);
-      if (!this.document.cells[row.id]) {
-        this.document.cells[row.id] = {};
-      }
-      this.document.cells[row.id][col.id] = {
-        ...cell,
-        value: computed,
-        error: void 0
-      };
-    } catch (err) {
-      if (!this.document.cells[row.id]) {
-        this.document.cells[row.id] = {};
-      }
-      this.document.cells[row.id][col.id] = {
-        ...cell,
-        value: "#ERROR!",
-        error: _optionalChain([err, 'optionalAccess', _44 => _44.message]) || "Formula error"
-      };
-    } finally {
-      this.evaluatingRowIndex = null;
-    }
-  }
-  resolveCellByCoord(colStr, rowNum) {
-    const col = this.document.columns.find((c) => c.key.toUpperCase() === colStr.toUpperCase());
-    const row = this.document.rows[rowNum - 1];
-    if (!col || !row) return 0;
-    return _nullishCoalesce(this.getCell(row.id, col.id).value, () => ( ""));
-  }
-  resolveRangeByCoords(sCol, sRow, eCol, eRow) {
-    const startC = colNameToIndex(sCol);
-    const endC = colNameToIndex(eCol);
-    const minC = Math.min(startC, endC);
-    const maxC = Math.max(startC, endC);
-    const minR = Math.min(sRow, eRow);
-    const maxR = Math.min(Math.max(sRow, eRow), WHOLE_COLUMN_END_ROW, this.document.rows.length);
-    const results = [];
-    for (let c = minC; c <= maxC; c++) {
-      const colName = indexToColName(c);
-      const col = this.document.columns.find((colDef) => colDef.key.toUpperCase() === colName);
-      if (!col) continue;
-      for (let r = minR; r <= maxR; r++) {
-        const row = this.document.rows[r - 1];
-        if (!row) continue;
-        results.push(_nullishCoalesce(this.getCell(row.id, col.id).value, () => ( "")));
-      }
-    }
-    return results;
-  }
-  resolveCurrentRowProperty(prop) {
-    const rowIndex = _nullishCoalesce(this.evaluatingRowIndex, () => ( _optionalChain([this, 'access', _45 => _45.activeCell, 'optionalAccess', _46 => _46.row])));
-    if (rowIndex === void 0 || rowIndex === null) return 0;
-    const row = this.document.rows[rowIndex];
-    if (!row || !row.recordId || !this.primaryDataSourceId) return 0;
-    return _nullishCoalesce(this.binder.resolveBoundValue(this.primaryDataSourceId, row.recordId, prop), () => ( 0));
-  }
-  // --- Selection and Navigation ---
-  selectCell(row, col, extendSelection = false) {
-    const clampedRow = Math.max(0, Math.min(row, this.document.rows.length - 1));
-    const clampedCol = Math.max(0, Math.min(col, this.document.columns.length - 1));
-    const rowObj = this.document.rows[clampedRow];
-    const colObj = this.document.columns[clampedCol];
-    this.activeCell = {
-      row: clampedRow,
-      col: clampedCol,
-      rowId: _optionalChain([rowObj, 'optionalAccess', _47 => _47.id]),
-      colId: _optionalChain([colObj, 'optionalAccess', _48 => _48.id])
-    };
-    if (extendSelection && this.selectedRange) {
-      this.selectedRange = {
-        startRow: this.selectedRange.startRow,
-        startCol: this.selectedRange.startCol,
-        endRow: clampedRow,
-        endCol: clampedCol
-      };
-    } else {
-      this.selectedRange = {
-        startRow: clampedRow,
-        startCol: clampedCol,
-        endRow: clampedRow,
-        endCol: clampedCol
-      };
-    }
-    _optionalChain([this, 'access', _49 => _49.onSelectionChange, 'optionalCall', _50 => _50(this.activeCell, this.selectedRange)]);
-  }
-  selectRange(range) {
-    this.selectedRange = range;
-    _optionalChain([this, 'access', _51 => _51.onSelectionChange, 'optionalCall', _52 => _52(this.activeCell, this.selectedRange)]);
-  }
-  startEditing(row, col, initialValue) {
-    const targetRow = _nullishCoalesce(_nullishCoalesce(row, () => ( _optionalChain([this, 'access', _53 => _53.activeCell, 'optionalAccess', _54 => _54.row]))), () => ( 0));
-    const targetCol = _nullishCoalesce(_nullishCoalesce(col, () => ( _optionalChain([this, 'access', _55 => _55.activeCell, 'optionalAccess', _56 => _56.col]))), () => ( 0));
-    this.selectCell(targetRow, targetCol);
-    const rowObj = this.document.rows[targetRow];
-    const colObj = this.document.columns[targetCol];
-    if (!rowObj || !colObj) return;
-    this.editingCell = {
-      row: targetRow,
-      col: targetCol,
-      rowId: rowObj.id,
-      colId: colObj.id
-    };
-    const cell = this.getCell(rowObj.id, colObj.id);
-    this.draftValue = initialValue !== void 0 ? initialValue : cell.raw;
-  }
-  commitEditing(valueToCommit) {
-    if (!this.editingCell) return;
-    const val = valueToCommit !== void 0 ? valueToCommit : this.draftValue;
-    if (this.editingCell.rowId && this.editingCell.colId) {
-      this.setCellValue(this.editingCell.rowId, this.editingCell.colId, val);
-    }
-    this.editingCell = null;
-    this.draftValue = "";
-  }
-  cancelEditing() {
-    this.editingCell = null;
-    this.draftValue = "";
-  }
-  moveCursor(direction, extendSelection = false) {
-    if (!this.activeCell) {
-      this.selectCell(0, 0);
-      return;
-    }
-    let nextRow = this.activeCell.row;
-    let nextCol = this.activeCell.col;
-    switch (direction) {
-      case "up":
-        nextRow = Math.max(0, nextRow - 1);
-        break;
-      case "down":
-        nextRow = Math.min(this.document.rows.length - 1, nextRow + 1);
-        break;
-      case "left":
-        nextCol = Math.max(0, nextCol - 1);
-        break;
-      case "right":
-        nextCol = Math.min(this.document.columns.length - 1, nextCol + 1);
-        break;
-    }
-    this.selectCell(nextRow, nextCol, extendSelection);
-  }
-  // --- Grid Structure Mutations ---
-  insertColumn(index, config) {
-    this.recordSnapshot();
-    const newId = _optionalChain([config, 'optionalAccess', _57 => _57.id]) || this.generateId("col");
-    const newCol = {
-      id: newId,
-      key: indexToColName(index),
-      title: _optionalChain([config, 'optionalAccess', _58 => _58.title]) || indexToColName(index),
-      width: _optionalChain([config, 'optionalAccess', _59 => _59.width]) || 130,
-      type: _optionalChain([config, 'optionalAccess', _60 => _60.type]) || "freeform",
-      binding: _optionalChain([config, 'optionalAccess', _61 => _61.binding]),
-      formula: _optionalChain([config, 'optionalAccess', _62 => _62.formula]),
-      format: _optionalChain([config, 'optionalAccess', _63 => _63.format]) || "text",
-      readOnly: _optionalChain([config, 'optionalAccess', _64 => _64.readOnly])
-    };
-    this.shiftReferences({ axis: "col", index, type: "insert" });
-    this.document.columns.splice(index, 0, newCol);
-    this.recomputeRowIndices();
-    this.recalculateAll();
-    this.notifyChange();
-  }
-  deleteColumn(colId) {
-    this.recordSnapshot();
-    const colIndex = this.document.columns.findIndex((c) => c.id === colId);
-    if (colIndex === -1) return;
-    this.shiftReferences({ axis: "col", index: colIndex, type: "delete" });
-    this.document.columns = this.document.columns.filter((c) => c.id !== colId);
-    for (const rowId of Object.keys(this.document.cells)) {
-      delete this.document.cells[rowId][colId];
-    }
-    this.recomputeRowIndices();
-    this.recalculateAll();
-    this.notifyChange();
-  }
-  insertRow(index, config) {
-    this.recordSnapshot();
-    const newId = _optionalChain([config, 'optionalAccess', _65 => _65.id]) || this.generateId("row");
-    const newRow = {
-      id: newId,
-      index,
-      height: _optionalChain([config, 'optionalAccess', _66 => _66.height]) || 32,
-      recordId: _optionalChain([config, 'optionalAccess', _67 => _67.recordId]),
-      type: _optionalChain([config, 'optionalAccess', _68 => _68.type]) || "freeform"
-    };
-    this.shiftReferences({ axis: "row", index, type: "insert" });
-    this.document.rows.splice(index, 0, newRow);
-    this.recomputeRowIndices();
-    this.recalculateAll();
-    this.notifyChange();
-  }
-  deleteRow(rowId) {
-    this.recordSnapshot();
-    const rowIndex = this.document.rows.findIndex((r) => r.id === rowId);
-    if (rowIndex === -1) return;
-    this.shiftReferences({ axis: "row", index: rowIndex, type: "delete" });
-    this.document.rows = this.document.rows.filter((r) => r.id !== rowId);
-    delete this.document.cells[rowId];
-    this.recomputeRowIndices();
-    this.recalculateAll();
-    this.notifyChange();
-  }
-  generateId(prefix) {
-    return `${prefix}_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
-  }
-  /**
-   * Rewrites references in every cell formula (and, for column changes, every
-   * column formula) so they keep pointing at the same cells.
-   */
-  shiftReferences(change) {
-    for (const rowCells of Object.values(this.document.cells)) {
-      for (const cell of Object.values(rowCells)) {
-        if (_optionalChain([cell, 'access', _69 => _69.raw, 'optionalAccess', _70 => _70.startsWith, 'call', _71 => _71("=")])) {
-          cell.raw = shiftFormulaReferences(cell.raw, change);
-        }
-      }
-    }
-    if (change.axis === "col") {
-      for (const col of this.document.columns) {
-        if (_optionalChain([col, 'access', _72 => _72.formula, 'optionalAccess', _73 => _73.startsWith, 'call', _74 => _74("=")])) {
-          col.formula = shiftFormulaReferences(col.formula, change);
-        }
-      }
-    }
-  }
-  setColumnWidth(colId, width) {
-    const col = this.document.columns.find((c) => c.id === colId);
-    if (col) {
-      col.width = Math.max(30, width);
-      this.notifyChange();
-    }
-  }
-  autoFitColumnWidth(colId, customWidth) {
-    if (customWidth !== void 0) {
-      this.setColumnWidth(colId, customWidth);
-      return;
-    }
-    const col = this.document.columns.find((c) => c.id === colId);
-    if (!col) return;
-    let maxLen = (col.title || "").length + (col.key ? col.key.length + 3 : 0);
-    for (const row of this.document.rows) {
-      const cell = this.getCell(row.id, col.id);
-      const valStr = cell.value != null ? String(cell.value) : "";
-      if (valStr.length > maxLen) {
-        maxLen = valStr.length;
-      }
-    }
-    const estimatedWidth = Math.min(600, Math.max(50, Math.ceil(maxLen * 8.5 + 32)));
-    this.setColumnWidth(colId, estimatedWidth);
-  }
-  // --- Clipboard TSV/CSV ---
-  /**
-   * Exports cell values as TSV: the whole sheet, or only `range` (e.g. the
-   * current selection) when given.
-   */
-  exportToTsv(range) {
-    const rows = range ? this.document.rows.slice(
-      Math.min(range.startRow, range.endRow),
-      Math.max(range.startRow, range.endRow) + 1
-    ) : this.document.rows;
-    const columns = range ? this.document.columns.slice(
-      Math.min(range.startCol, range.endCol),
-      Math.max(range.startCol, range.endCol) + 1
-    ) : this.document.columns;
-    return rows.map(
-      (row) => columns.map((col) => {
-        const cell = this.getCell(row.id, col.id);
-        return String(_nullishCoalesce(cell.value, () => ( ""))).replace(/\t/g, " ");
-      }).join("	")
-    ).join("\n");
-  }
-  /**
-   * Pastes tab-separated values starting at (startRow, startCol), adding rows
-   * and columns as needed. The whole paste is a single undo step.
-   */
-  importFromTsv(tsvData, startRow = 0, startCol = 0) {
-    const normalized = tsvData.replace(/\r\n?/g, "\n").replace(/\n$/, "");
-    if (normalized === "") return;
-    this.recordSnapshot();
-    this.batching = true;
-    this.pendingCommits = [];
-    try {
-      normalized.split("\n").forEach((line, rIdx) => {
-        const targetR = startRow + rIdx;
-        while (targetR >= this.document.rows.length) {
-          const index = this.document.rows.length;
-          this.document.rows.push({ id: this.generateId("row"), index, height: 32, type: "freeform" });
-        }
-        const row = this.document.rows[targetR];
-        line.split("	").forEach((val, cIdx) => {
-          const targetC = startCol + cIdx;
-          while (targetC >= this.document.columns.length) {
-            const key = indexToColName(this.document.columns.length);
-            this.document.columns.push({
-              id: this.generateId("col"),
-              key,
-              title: key,
-              width: 130,
-              type: "freeform",
-              format: "text"
-            });
-          }
-          this.setCellValue(row.id, this.document.columns[targetC].id, val);
-        });
-      });
-    } finally {
-      this.batching = false;
-    }
-    this.recalculateAll();
-    this.notifyChange();
-    const commits = this.pendingCommits;
-    this.pendingCommits = [];
-    for (const [rowId, colId, raw] of commits) {
-      _optionalChain([this, 'access', _75 => _75.onCellCommit, 'optionalCall', _76 => _76(rowId, colId, raw, _optionalChain([this, 'access', _77 => _77.document, 'access', _78 => _78.cells, 'access', _79 => _79[rowId], 'optionalAccess', _80 => _80[colId], 'optionalAccess', _81 => _81.value]))]);
-    }
-  }
-  // --- Undo/Redo Snapshots ---
-  recordSnapshot() {
-    if (this.isApplyingHistory || this.batching) return;
-    this.undoStack.push(JSON.stringify(this.document));
-    if (this.undoStack.length > 50) this.undoStack.shift();
-    this.redoStack = [];
-  }
-  undo() {
-    if (this.undoStack.length === 0) return;
-    this.isApplyingHistory = true;
-    try {
-      this.redoStack.push(JSON.stringify(this.document));
-      this.document = JSON.parse(this.undoStack.pop());
-      this.recalculateAll();
-      this.notifyChange();
-    } finally {
-      this.isApplyingHistory = false;
-    }
-  }
-  redo() {
-    if (this.redoStack.length === 0) return;
-    this.isApplyingHistory = true;
-    try {
-      this.undoStack.push(JSON.stringify(this.document));
-      this.document = JSON.parse(this.redoStack.pop());
-      this.recalculateAll();
-      this.notifyChange();
-    } finally {
-      this.isApplyingHistory = false;
-    }
-  }
-  notifyChange() {
-    _optionalChain([this, 'access', _82 => _82.onDocumentChange, 'optionalCall', _83 => _83(this.document)]);
-  }
-}, _class4);
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-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.FormulaEvaluator = FormulaEvaluator; exports.columnDependencyKey = columnDependencyKey; exports.extractCellDependencies = extractCellDependencies; exports.DependencyGraph = DependencyGraph; exports.shiftFormulaReferences = shiftFormulaReferences; exports.DataSourceBinder = DataSourceBinder; exports.SpreadsheetController = SpreadsheetController;
-//# sourceMappingURL=chunk-YQCI4CCN.cjs.map