@pixerate/editor 0.16.1 → 0.17.0

package/dist/{chunk-CYKQLDYH.cjs → chunk-YQCI4CCN.cjs}

@@ -41,9 +41,10 @@ function tokenizeFormula(formula) {
         str += input[i];
         i++;
       }
-      if (i < input.length && input[i] === quote) {
-        i++;
+      if (i >= input.length) {
+        throw new Error(`Unterminated string starting at position ${start + offset}`);
       }
+      i++;
       tokens.push({
         type: "STRING",
         value: str,
@@ -51,6 +52,15 @@ function tokenizeFormula(formula) {
       });
       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++;
@@ -148,13 +158,14 @@ function tokenizeFormula(formula) {
       });
       continue;
     }
-    i++;
+    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) {
@@ -166,12 +177,23 @@ function parseCellReference(ref) {
   };
 }
 function parseRange(rangeStr) {
-  const [start, end] = rangeStr.split(":");
+  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: rangeStr.toUpperCase(),
+    raw,
     startCol: startRef.col,
     startRow: startRef.row,
     endCol: endRef.col,
@@ -264,6 +286,10 @@ var FormulaParser = (_class = class {
       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);
@@ -303,7 +329,7 @@ var FormulaParser = (_class = class {
           args
         };
       }
-      return { type: "Literal", value: name };
+      return { type: "Literal", value: "#NAME?" };
     }
     if (this.match("LPAREN")) {
       const expr = this.expression();
@@ -357,6 +383,57 @@ function parseFormula(formula) {
 }
 
 // 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();
@@ -407,42 +484,59 @@ var FormulaEvaluator = class {
         return this.context.resolveProperty(node.property);
       }
       case "UnaryOp": {
-        const val = this.evaluateNode(node.argument);
-        if (node.op === "-") return -Number(val);
-        if (node.op === "+") return +Number(val);
+        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);
-        switch (node.op) {
-          case "+":
-            return Number(left) + Number(right);
-          case "-":
-            return Number(left) - Number(right);
-          case "*":
-            return Number(left) * Number(right);
-          case "/": {
-            const denom = Number(right);
-            if (denom === 0) return "#DIV/0!";
-            return Number(left) / denom;
+        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);
           }
-          case "^":
-            return Math.pow(Number(left), Number(right));
+          return Number.isFinite(result) ? result : "#NUM!";
+        }
+        switch (node.op) {
           case "&":
-            return `${_nullishCoalesce(left, () => ( ""))}${_nullishCoalesce(right, () => ( ""))}`;
+            return toText(left) + toText(right);
           case "=":
-            return String(left).toLowerCase() === String(right).toLowerCase();
+            return compareValues(left, right) === 0;
           case "<>":
-            return String(left).toLowerCase() !== String(right).toLowerCase();
+            return compareValues(left, right) !== 0;
           case "<":
-            return Number(left) < Number(right);
+            return compareValues(left, right) < 0;
           case "<=":
-            return Number(left) <= Number(right);
+            return compareValues(left, right) <= 0;
           case ">":
-            return Number(left) > Number(right);
+            return compareValues(left, right) > 0;
           case ">=":
-            return Number(left) >= Number(right);
+            return compareValues(left, right) >= 0;
           default:
             throw new Error(`Unsupported binary operator: ${node.op}`);
         }
@@ -461,25 +555,36 @@ var FormulaEvaluator = class {
       for (const arg of args) {
         const val = this.evaluateNode(arg);
         if (Array.isArray(val)) {
-          items.push(...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 items = evaluateAndFlatten();
+        const nums = numericArgs();
+        if (typeof nums === "string") return nums;
         let total = 0;
-        for (const item of items) {
-          const num = Number(item);
-          if (!isNaN(num)) total += num;
-        }
+        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) {
@@ -512,17 +617,21 @@ var FormulaEvaluator = class {
         }
         return count;
       }
-      case "MIN": {
-        const items = evaluateAndFlatten().map(Number).filter((n) => !isNaN(n));
-        return items.length === 0 ? 0 : Math.min(...items);
-      }
+      case "MIN":
       case "MAX": {
-        const items = evaluateAndFlatten().map(Number).filter((n) => !isNaN(n));
-        return items.length === 0 ? 0 : Math.max(...items);
+        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 = Boolean(this.evaluateNode(args[0]));
+        const condition = toBoolean(evaluateArg(0));
+        if (isFormulaError(condition)) return condition;
         if (condition) {
           return this.evaluateNode(args[1]);
         } else {
@@ -531,41 +640,51 @@ var FormulaEvaluator = class {
       }
       case "CONCAT": {
         const items = evaluateAndFlatten();
-        return items.map((i) => i === null || i === void 0 ? "" : String(i)).join("");
+        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 = this.evaluateNode(args[0]);
-        return String(_nullishCoalesce(val, () => ( ""))).toUpperCase();
+        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 = this.evaluateNode(args[0]);
-        return String(_nullishCoalesce(val, () => ( ""))).toLowerCase();
+        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 = this.evaluateNode(args[0]);
-        return String(_nullishCoalesce(val, () => ( ""))).trim();
+        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 = this.evaluateNode(args[0]);
-        return String(_nullishCoalesce(val, () => ( ""))).length;
+        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 = Number(this.evaluateNode(args[0]));
-        const decimals = args.length > 1 ? Number(this.evaluateNode(args[1])) : 0;
-        const factor = Math.pow(10, decimals);
-        return Math.round(num * factor) / factor;
+        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");
-        return Math.abs(Number(this.evaluateNode(args[0])));
+        const num = toNumber(evaluateArg(0));
+        return isFormulaError(num) ? num : Math.abs(num);
       }
       case "TODAY": {
-        return (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+        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)");
@@ -575,17 +694,24 @@ var FormulaEvaluator = class {
         return Math.round(diffTime / (1e3 * 60 * 60 * 24));
       }
       default:
-        throw new Error(`Unknown function: ${fnName}`);
+        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);
@@ -630,7 +756,7 @@ var DependencyGraph = (_class2 = class {constructor() { _class2.prototype.__init
       const deps = extractCellDependencies(ast);
       const newDeps = /* @__PURE__ */ new Set();
       for (const d of deps) {
-        const depKey = `${d.col}${d.row}`.toUpperCase();
+        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());
@@ -641,6 +767,11 @@ var DependencyGraph = (_class2 = class {constructor() { _class2.prototype.__init
     } 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()) || []);
   }
@@ -714,8 +845,191 @@ var DependencyGraph = (_class2 = class {constructor() { _class2.prototype.__init
     }
     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()}
@@ -749,9 +1063,9 @@ var DataSourceBinder = (_class3 = class {constructor() { _class3.prototype.__ini
     for (const record of records) {
       const existing = existingRecordRowMap.get(record.id);
       nextRows.push({
-        id: _optionalChain([existing, 'optionalAccess', _7 => _7.id]) || `row_${record.id}`,
+        id: _optionalChain([existing, 'optionalAccess', _9 => _9.id]) || `row_${record.id}`,
         index: rowIndex++,
-        height: _optionalChain([existing, 'optionalAccess', _8 => _8.height]) || 32,
+        height: _optionalChain([existing, 'optionalAccess', _10 => _10.height]) || 32,
         recordId: record.id,
         type: "record"
       });
@@ -803,7 +1117,12 @@ var SpreadsheetController = (_class4 = class {
   __init12() {this.undoStack = []}
   __init13() {this.redoStack = []}
   __init14() {this.isApplyingHistory = false}
-  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);
+  // 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" },
@@ -817,13 +1136,13 @@ var SpreadsheetController = (_class4 = class {
       type: "freeform"
     }));
     this.document = {
-      id: _optionalChain([options, 'access', _9 => _9.document, 'optionalAccess', _10 => _10.id]) || `sheet_${Date.now()}`,
-      name: _optionalChain([options, 'access', _11 => _11.document, 'optionalAccess', _12 => _12.name]) || "Sheet 1",
-      columns: _optionalChain([options, 'access', _13 => _13.document, 'optionalAccess', _14 => _14.columns]) || defaultCols,
-      rows: _optionalChain([options, 'access', _15 => _15.document, 'optionalAccess', _16 => _16.rows]) || defaultRows,
-      cells: _optionalChain([options, 'access', _17 => _17.document, 'optionalAccess', _18 => _18.cells]) || {},
-      createdAt: _optionalChain([options, 'access', _19 => _19.document, 'optionalAccess', _20 => _20.createdAt]) || Date.now(),
-      updatedAt: _optionalChain([options, 'access', _21 => _21.document, 'optionalAccess', _22 => _22.updatedAt]) || Date.now()
+      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;
@@ -887,10 +1206,14 @@ var SpreadsheetController = (_class4 = class {
     return this.document.rows.find((r) => r.id === rowIdOrIndex);
   }
   getCell(rowId, colId) {
-    const existing = _optionalChain([this, 'access', _23 => _23.document, 'access', _24 => _24.cells, 'access', _25 => _25[rowId], 'optionalAccess', _26 => _26[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,
@@ -910,7 +1233,7 @@ var SpreadsheetController = (_class4 = class {
         format: col.format
       };
     }
-    return { raw: "", value: "", format: _optionalChain([col, 'optionalAccess', _27 => _27.format]) };
+    return { raw: "", value: "", format: _optionalChain([col, 'optionalAccess', _29 => _29.format]) };
   }
   setCellValue(rowId, colId, raw) {
     this.recordSnapshot();
@@ -919,7 +1242,7 @@ var SpreadsheetController = (_class4 = class {
     }
     const col = this.document.columns.find((c) => c.id === colId);
     const row = this.document.rows.find((r) => r.id === rowId);
-    if (_optionalChain([col, 'optionalAccess', _28 => _28.type]) === "bound" && col.binding && _optionalChain([row, 'optionalAccess', _29 => _29.recordId])) {
+    if (_optionalChain([col, 'optionalAccess', _30 => _30.type]) === "bound" && col.binding && _optionalChain([row, 'optionalAccess', _31 => _31.recordId])) {
       this.binder.commitBoundValue(
         col.binding.dataSource,
         row.recordId,
@@ -932,13 +1255,17 @@ var SpreadsheetController = (_class4 = class {
     this.document.cells[rowId][colId] = {
       raw,
       value: raw,
-      format: _optionalChain([col, 'optionalAccess', _30 => _30.format])
+      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', _31 => _31.document, 'access', _32 => _32.cells, 'access', _33 => _33[rowId], 'access', _34 => _34[colId], 'optionalAccess', _35 => _35.value]);
-    _optionalChain([this, 'access', _36 => _36.onCellCommit, 'optionalCall', _37 => _37(rowId, colId, raw, evaluatedVal)]);
+    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);
@@ -946,37 +1273,58 @@ var SpreadsheetController = (_class4 = class {
     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);
-    const { order, hasCycle } = this.depGraph.getEvaluationOrder(cellKey);
-    if (hasCycle) {
-      if (_optionalChain([this, 'access', _38 => _38.document, 'access', _39 => _39.cells, 'access', _40 => _40[rowId], 'optionalAccess', _41 => _41[colId]])) {
-        this.document.cells[rowId][colId].error = "#CYCLE!";
-        this.document.cells[rowId][colId].value = "#CYCLE!";
-      }
-      return;
-    }
-    for (const key of order) {
-      this.evalSingleCellByKey(key);
-    }
+    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 = this.getCell(row.id, col.id);
-        const cellKey = `${col.key}${row.index + 1}`.toUpperCase();
+        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);
         }
       }
     }
-    for (const row of this.document.rows) {
-      for (const col of this.document.columns) {
-        const cellKey = `${col.key}${row.index + 1}`.toUpperCase();
-        this.evalSingleCellByKey(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;
@@ -993,6 +1341,7 @@ var SpreadsheetController = (_class4 = class {
       return;
     }
     try {
+      this.evaluatingRowIndex = rowNum - 1;
       const computed = this.evaluator.evaluate(cell.raw);
       if (!this.document.cells[row.id]) {
         this.document.cells[row.id] = {};
@@ -1009,16 +1358,17 @@ var SpreadsheetController = (_class4 = class {
       this.document.cells[row.id][col.id] = {
         ...cell,
         value: "#ERROR!",
-        error: _optionalChain([err, 'optionalAccess', _42 => _42.message]) || "Formula 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;
-    const cell = this.getCell(row.id, col.id);
-    return cell.value !== void 0 && cell.value !== "" ? cell.value : 0;
+    return _nullishCoalesce(this.getCell(row.id, col.id).value, () => ( ""));
   }
   resolveRangeByCoords(sCol, sRow, eCol, eRow) {
     const startC = colNameToIndex(sCol);
@@ -1026,7 +1376,7 @@ var SpreadsheetController = (_class4 = class {
     const minC = Math.min(startC, endC);
     const maxC = Math.max(startC, endC);
     const minR = Math.min(sRow, eRow);
-    const maxR = Math.max(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);
@@ -1035,15 +1385,15 @@ var SpreadsheetController = (_class4 = class {
       for (let r = minR; r <= maxR; r++) {
         const row = this.document.rows[r - 1];
         if (!row) continue;
-        const cell = this.getCell(row.id, col.id);
-        results.push(cell.value !== void 0 && cell.value !== "" ? cell.value : 0);
+        results.push(_nullishCoalesce(this.getCell(row.id, col.id).value, () => ( "")));
       }
     }
     return results;
   }
   resolveCurrentRowProperty(prop) {
-    if (!this.activeCell) return 0;
-    const row = this.document.rows[this.activeCell.row];
+    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));
   }
@@ -1056,8 +1406,8 @@ var SpreadsheetController = (_class4 = class {
     this.activeCell = {
       row: clampedRow,
       col: clampedCol,
-      rowId: _optionalChain([rowObj, 'optionalAccess', _43 => _43.id]),
-      colId: _optionalChain([colObj, 'optionalAccess', _44 => _44.id])
+      rowId: _optionalChain([rowObj, 'optionalAccess', _47 => _47.id]),
+      colId: _optionalChain([colObj, 'optionalAccess', _48 => _48.id])
     };
     if (extendSelection && this.selectedRange) {
       this.selectedRange = {
@@ -1074,15 +1424,15 @@ var SpreadsheetController = (_class4 = class {
         endCol: clampedCol
       };
     }
-    _optionalChain([this, 'access', _45 => _45.onSelectionChange, 'optionalCall', _46 => _46(this.activeCell, this.selectedRange)]);
+    _optionalChain([this, 'access', _49 => _49.onSelectionChange, 'optionalCall', _50 => _50(this.activeCell, this.selectedRange)]);
   }
   selectRange(range) {
     this.selectedRange = range;
-    _optionalChain([this, 'access', _47 => _47.onSelectionChange, 'optionalCall', _48 => _48(this.activeCell, this.selectedRange)]);
+    _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', _49 => _49.activeCell, 'optionalAccess', _50 => _50.row]))), () => ( 0));
-    const targetCol = _nullishCoalesce(_nullishCoalesce(col, () => ( _optionalChain([this, 'access', _51 => _51.activeCell, 'optionalAccess', _52 => _52.col]))), () => ( 0));
+    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];
@@ -1135,18 +1485,19 @@ var SpreadsheetController = (_class4 = class {
   // --- Grid Structure Mutations ---
   insertColumn(index, config) {
     this.recordSnapshot();
-    const newId = _optionalChain([config, 'optionalAccess', _53 => _53.id]) || `col_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
+    const newId = _optionalChain([config, 'optionalAccess', _57 => _57.id]) || this.generateId("col");
     const newCol = {
       id: newId,
       key: indexToColName(index),
-      title: _optionalChain([config, 'optionalAccess', _54 => _54.title]) || indexToColName(index),
-      width: _optionalChain([config, 'optionalAccess', _55 => _55.width]) || 130,
-      type: _optionalChain([config, 'optionalAccess', _56 => _56.type]) || "freeform",
-      binding: _optionalChain([config, 'optionalAccess', _57 => _57.binding]),
-      formula: _optionalChain([config, 'optionalAccess', _58 => _58.formula]),
-      format: _optionalChain([config, 'optionalAccess', _59 => _59.format]) || "text",
-      readOnly: _optionalChain([config, 'optionalAccess', _60 => _60.readOnly])
+      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();
@@ -1154,6 +1505,9 @@ var SpreadsheetController = (_class4 = class {
   }
   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];
@@ -1164,14 +1518,15 @@ var SpreadsheetController = (_class4 = class {
   }
   insertRow(index, config) {
     this.recordSnapshot();
-    const newId = _optionalChain([config, 'optionalAccess', _61 => _61.id]) || `row_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
+    const newId = _optionalChain([config, 'optionalAccess', _65 => _65.id]) || this.generateId("row");
     const newRow = {
       id: newId,
       index,
-      height: _optionalChain([config, 'optionalAccess', _62 => _62.height]) || 32,
-      recordId: _optionalChain([config, 'optionalAccess', _63 => _63.recordId]),
-      type: _optionalChain([config, 'optionalAccess', _64 => _64.type]) || "freeform"
+      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();
@@ -1179,12 +1534,38 @@ var SpreadsheetController = (_class4 = class {
   }
   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) {
@@ -1211,39 +1592,74 @@ var SpreadsheetController = (_class4 = class {
     this.setColumnWidth(colId, estimatedWidth);
   }
   // --- Clipboard TSV/CSV ---
-  exportToTsv() {
-    return this.document.rows.map(
-      (row) => this.document.columns.map((col) => {
+  /**
+   * 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();
-    const lines = tsvData.trim().split("\n");
-    lines.forEach((line, rIdx) => {
-      const cells = line.split("	");
-      const targetR = startRow + rIdx;
-      while (targetR >= this.document.rows.length) {
-        this.insertRow(this.document.rows.length);
-      }
-      const row = this.document.rows[targetR];
-      cells.forEach((val, cIdx) => {
-        const targetC = startCol + cIdx;
-        while (targetC >= this.document.columns.length) {
-          this.insertColumn(this.document.columns.length);
+    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 col = this.document.columns[targetC];
-        this.setCellValue(row.id, col.id, val);
+        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) return;
+    if (this.isApplyingHistory || this.batching) return;
     this.undoStack.push(JSON.stringify(this.document));
     if (this.undoStack.length > 50) this.undoStack.shift();
     this.redoStack = [];
@@ -1251,25 +1667,29 @@ var SpreadsheetController = (_class4 = class {
   undo() {
     if (this.undoStack.length === 0) return;
     this.isApplyingHistory = true;
-    this.redoStack.push(JSON.stringify(this.document));
-    const previous = JSON.parse(this.undoStack.pop());
-    this.document = previous;
-    this.recalculateAll();
-    this.notifyChange();
-    this.isApplyingHistory = false;
+    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;
-    this.undoStack.push(JSON.stringify(this.document));
-    const next = JSON.parse(this.redoStack.pop());
-    this.document = next;
-    this.recalculateAll();
-    this.notifyChange();
-    this.isApplyingHistory = false;
+    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', _65 => _65.onDocumentChange, 'optionalCall', _66 => _66(this.document)]);
+    _optionalChain([this, 'access', _82 => _82.onDocumentChange, 'optionalCall', _83 => _83(this.document)]);
   }
 }, _class4);
 
@@ -1286,5 +1706,10 @@ var SpreadsheetController = (_class4 = class {
 
 
 
-exports.tokenizeFormula = tokenizeFormula; exports.parseCellReference = parseCellReference; exports.parseRange = parseRange; exports.FormulaParser = FormulaParser; exports.parseFormula = parseFormula; exports.colNameToIndex = colNameToIndex; exports.indexToColName = indexToColName; exports.FormulaEvaluator = FormulaEvaluator; exports.extractCellDependencies = extractCellDependencies; exports.DependencyGraph = DependencyGraph; exports.DataSourceBinder = DataSourceBinder; exports.SpreadsheetController = SpreadsheetController;
-//# sourceMappingURL=chunk-CYKQLDYH.cjs.map
+
+
+
+
+
+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