@pixerate/editor 0.23.0 → 0.25.0

package/dist/chunk-XDMXXC4Z.cjs

@@ -1,3100 +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; } function _optionalChainDelete(ops) { const result = _optionalChain(ops); return result == null ? true : result; } var _class; var _class2; var _class3;
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-var _chunkRIKBJLS2cjs = require('./chunk-RIKBJLS2.cjs');
-
-// 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 === "SpillRef") {
-      deps.push({ col: curr.col, row: curr.row });
-    } else if (curr.type === "Range" && curr.endRow >= _chunkRIKBJLS2cjs.WHOLE_COLUMN_END_ROW) {
-      const startC = _chunkRIKBJLS2cjs.colNameToIndex.call(void 0, curr.startCol);
-      const endC = _chunkRIKBJLS2cjs.colNameToIndex.call(void 0, curr.endCol);
-      for (let c = Math.min(startC, endC); c <= Math.max(startC, endC); c++) {
-        deps.push({ col: _chunkRIKBJLS2cjs.indexToColName.call(void 0, c), row: 0 });
-      }
-    } else if (curr.type === "Range") {
-      const startC = _chunkRIKBJLS2cjs.colNameToIndex.call(void 0, curr.startCol);
-      const endC = _chunkRIKBJLS2cjs.colNameToIndex.call(void 0, 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: _chunkRIKBJLS2cjs.indexToColName.call(void 0, 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 = (_class = class {constructor() { _class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this); }
-  // Map of cellKey (e.g. "B2") -> Set of cellKeys that this cell depends ON
-  __init() {this.dependencies = /* @__PURE__ */ new Map()}
-  // Map of cellKey (e.g. "A1") -> Set of cellKeys that depend ON this cell (dependents)
-  __init2() {this.dependents = /* @__PURE__ */ new Map()}
-  // Dynamic-array edges, set by the controller after evaluating an anchor:
-  // spilled cells depend on their anchor, and a blocked (#SPILL!) anchor
-  // depends on the cells blocking it. Kept apart from formula dependencies,
-  // so re-entering a formula doesn't drop them.
-  __init3() {this.spillDependencies = /* @__PURE__ */ new Map()}
-  __init4() {this.spillDependents = /* @__PURE__ */ new Map()}
-  // anchor -> the edges it registered (so they can be replaced).
-  __init5() {this.spillEdges = /* @__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 = _chunkRIKBJLS2cjs.parseFormula.call(void 0, 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();
-    this.spillDependencies.clear();
-    this.spillDependents.clear();
-    this.spillEdges.clear();
-  }
-  /**
-   * Records the dynamic-array edges of the anchor `anchorKey`, replacing its
-   * previous ones: every key in `spilledKeys` (cells holding its spilled
-   * values) depends on the anchor, and the anchor depends on every key in
-   * `blockingKeys` (cells that stop it spilling). Pass empty lists to remove
-   * the anchor's edges.
-   */
-  setSpillEdges(anchorKey, spilledKeys, blockingKeys = []) {
-    const anchor = anchorKey.toUpperCase();
-    for (const [from, to] of _nullishCoalesce(this.spillEdges.get(anchor), () => ( []))) {
-      _optionalChain([this, 'access', _7 => _7.spillDependencies, 'access', _8 => _8.get, 'call', _9 => _9(from), 'optionalAccess', _10 => _10.delete, 'call', _11 => _11(to)]);
-      _optionalChain([this, 'access', _12 => _12.spillDependents, 'access', _13 => _13.get, 'call', _14 => _14(to), 'optionalAccess', _15 => _15.delete, 'call', _16 => _16(from)]);
-    }
-    const edges = [];
-    for (const key of spilledKeys) edges.push([key.toUpperCase(), anchor]);
-    for (const key of blockingKeys) edges.push([anchor, key.toUpperCase()]);
-    for (const [from, to] of edges) {
-      if (!this.spillDependencies.has(from)) this.spillDependencies.set(from, /* @__PURE__ */ new Set());
-      this.spillDependencies.get(from).add(to);
-      if (!this.spillDependents.has(to)) this.spillDependents.set(to, /* @__PURE__ */ new Set());
-      this.spillDependents.get(to).add(from);
-    }
-    if (edges.length > 0) this.spillEdges.set(anchor, edges);
-    else this.spillEdges.delete(anchor);
-  }
-  /** The spilled cells registered for `anchorKey` by `setSpillEdges`. */
-  getSpilledKeys(anchorKey) {
-    const anchor = anchorKey.toUpperCase();
-    return (_nullishCoalesce(this.spillEdges.get(anchor), () => ( []))).filter(([, to]) => to === anchor).map(([from]) => from);
-  }
-  /** Formula dependencies plus dynamic-array (spill) dependencies of a cell. */
-  getDependencies(cellKey) {
-    const key = cellKey.toUpperCase();
-    return unionOf(this.dependencies.get(key), this.spillDependencies.get(key));
-  }
-  /** Cells depending on `cellKey`, through formulas or spills. */
-  getDependents(cellKey) {
-    const key = cellKey.toUpperCase();
-    return unionOf(this.dependents.get(key), this.spillDependents.get(key));
-  }
-  /**
-   * 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.getDependencies(node);
-      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.spillDependents.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 this.getDependencies(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 };
-  }
-}, _class);
-function unionOf(a, b) {
-  if (!b || b.size === 0) return Array.from(_nullishCoalesce(a, () => ( [])));
-  if (!a || a.size === 0) return Array.from(b);
-  return Array.from(/* @__PURE__ */ new Set([...a, ...b]));
-}
-
-// 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: _chunkRIKBJLS2cjs.colNameToIndex.call(void 0, cell[2]),
-      rowAbs: cell[3],
-      row: parseInt(cell[4], 10) - 1
-    };
-  }
-  const column = COLUMN_PART.exec(text);
-  if (column) {
-    return { colAbs: column[1], col: _chunkRIKBJLS2cjs.colNameToIndex.call(void 0, column[2]), rowAbs: "", row: null };
-  }
-  return null;
-}
-function formatPart(part) {
-  const col = `${part.colAbs}${_chunkRIKBJLS2cjs.indexToColName.call(void 0, 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) {
-  return mapFormulaReferences(formula, (text) => rewriteReference(text, change));
-}
-function mapFormulaReferences(formula, rewrite) {
-  if (!formula.startsWith("=")) return formula;
-  let tokens;
-  try {
-    tokens = _chunkRIKBJLS2cjs.tokenizeFormula.call(void 0, 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" && token.type !== "SPILL_REF") continue;
-    if (_optionalChain([tokens, 'access', _17 => _17[i + 1], 'optionalAccess', _18 => _18.type]) === "LPAREN") continue;
-    let end = token.position;
-    while (end < formula.length && REF_CHAR.test(formula[end])) end++;
-    const original = formula.slice(token.position, end);
-    if (token.type === "SPILL_REF") {
-      const rewritten = rewrite(original);
-      result += formula.slice(cursor, token.position) + (rewritten === "#REF!" ? rewritten : `${rewritten}#`);
-      cursor = end + 1;
-      continue;
-    }
-    result += formula.slice(cursor, token.position) + rewrite(original);
-    cursor = end;
-  }
-  return result + formula.slice(cursor);
-}
-function offsetFormulaReferences(formula, rowOffset, colOffset) {
-  if (rowOffset === 0 && colOffset === 0) return formula;
-  return mapFormulaReferences(formula, (text) => {
-    const parts = text.split(":").map(parsePart);
-    if (parts.some((p) => p === null)) return text;
-    const moved = [];
-    for (const part of parts) {
-      const col = part.colAbs ? part.col : part.col + colOffset;
-      const row = part.row === null || part.rowAbs ? part.row : part.row + rowOffset;
-      if (col < 0 || row !== null && row < 0) return "#REF!";
-      moved.push({ ...part, col, row });
-    }
-    return moved.map(formatPart).join(":");
-  });
-}
-var MAX_REMAP_RANGE_CELLS = 1e5;
-function remapFormulaReferences(formula, moveCell) {
-  return mapFormulaReferences(formula, (text) => {
-    const parts = text.split(":").map(parsePart);
-    if (parts.some((p) => p === null)) return text;
-    const [start, end] = parts;
-    if (start.row === null || end && end.row === null) return text;
-    if (!end) {
-      const target = moveCell({ row: start.row, col: start.col });
-      return target ? formatPart({ ...start, row: target.row, col: target.col }) : text;
-    }
-    const lo = { row: Math.min(start.row, end.row), col: Math.min(start.col, end.col) };
-    const hi = { row: Math.max(start.row, end.row), col: Math.max(start.col, end.col) };
-    const area = (hi.row - lo.row + 1) * (hi.col - lo.col + 1);
-    if (area > MAX_REMAP_RANGE_CELLS) return text;
-    let minR = Infinity;
-    let maxR = -Infinity;
-    let minC = Infinity;
-    let maxC = -Infinity;
-    let movedAny = false;
-    const targets = /* @__PURE__ */ new Set();
-    for (let r = lo.row; r <= hi.row; r++) {
-      for (let c = lo.col; c <= hi.col; c++) {
-        const moved = moveCell({ row: r, col: c });
-        if (moved) movedAny = true;
-        const t = _nullishCoalesce(moved, () => ( { row: r, col: c }));
-        targets.add(`${t.row}:${t.col}`);
-        minR = Math.min(minR, t.row);
-        maxR = Math.max(maxR, t.row);
-        minC = Math.min(minC, t.col);
-        maxC = Math.max(maxC, t.col);
-      }
-    }
-    if (!movedAny || targets.size !== area || (maxR - minR + 1) * (maxC - minC + 1) !== area) {
-      return text;
-    }
-    return `${formatPart({ ...start, row: minR, col: minC })}:${formatPart({ ...end, row: maxR, col: maxC })}`;
-  });
-}
-
-// src/spreadsheet/formula/caret.ts
-var EMPTY = { prefix: null, call: null };
-function getFormulaCaretContext(input, caret = input.length) {
-  const leading = input.length - input.trimStart().length;
-  if (input[leading] !== "=") return EMPTY;
-  const end = Math.max(0, Math.min(caret, input.length));
-  if (end <= leading) return EMPTY;
-  const stack = [];
-  let quote2 = null;
-  let inProperty = false;
-  for (let i = leading + 1; i < end; i++) {
-    const char = input[i];
-    if (quote2) {
-      if (char === "\\") i++;
-      else if (char === quote2) quote2 = null;
-      continue;
-    }
-    if (inProperty) {
-      if (char === "]") inProperty = false;
-      continue;
-    }
-    if (char === '"' || char === "'") {
-      quote2 = char;
-    } else if (char === "[") {
-      inProperty = true;
-    } else if (char === "(") {
-      const name = /([A-Za-z_][A-Za-z0-9_.]*)\s*$/.exec(input.slice(leading + 1, i));
-      const isFunction = name && !/^\$?[A-Za-z]+\$?\d+$/.test(name[1]) && !/[:$]$/.test(input.slice(0, i - name[0].length));
-      stack.push({ name: isFunction ? name[1].toUpperCase() : null, argIndex: 0, openParen: i });
-    } else if (char === ")") {
-      stack.pop();
-    } else if (char === "," && stack.length > 0) {
-      stack[stack.length - 1].argIndex++;
-    }
-  }
-  if (quote2 || inProperty) {
-    return { prefix: null, call: innermostCall(stack) };
-  }
-  let prefix = null;
-  const before = input.slice(leading + 1, end);
-  const word = /[A-Za-z_][A-Za-z0-9_.]*$/.exec(before);
-  if (word) {
-    const start = leading + 1 + word.index;
-    const preceding = _nullishCoalesce(input[start - 1], () => ( ""));
-    if (!/[:$0-9.]/.test(preceding)) {
-      prefix = { text: word[0], start, end };
-    }
-  }
-  return { prefix, call: innermostCall(stack) };
-}
-function innermostCall(stack) {
-  for (let i = stack.length - 1; i >= 0; i--) {
-    const frame = stack[i];
-    if (frame.name) return { name: frame.name, argIndex: frame.argIndex, openParen: frame.openParen };
-  }
-  return null;
-}
-var toSuggestion = (def) => ({
-  name: def.name,
-  signature: _chunkRIKBJLS2cjs.getFormulaSignature.call(void 0, def),
-  description: def.description,
-  category: def.category
-});
-function getFormulaHints(input, caret = input.length, options = {}) {
-  const context = getFormulaCaretContext(input, caret);
-  let suggestions = [];
-  if (context.prefix) {
-    const query = context.prefix.text.toUpperCase();
-    suggestions = _chunkRIKBJLS2cjs.searchFormulaFunctions.call(void 0, query, { limit: void 0 }).filter((def) => def.name.startsWith(query)).slice(0, _nullishCoalesce(options.limit, () => ( 8))).map(toSuggestion);
-    const followedByParen = input.slice(context.prefix.end).trimStart().startsWith("(");
-    if (followedByParen || suggestions.length === 1 && suggestions[0].name === query) suggestions = [];
-  }
-  let activeCall = null;
-  if (context.call) {
-    const def = _chunkRIKBJLS2cjs.getFormulaFunction.call(void 0, context.call.name);
-    if (def) {
-      const specIndex = _chunkRIKBJLS2cjs.getFormulaArgumentSpecIndex.call(void 0, def, context.call.argIndex);
-      activeCall = {
-        name: def.name,
-        signature: _chunkRIKBJLS2cjs.getFormulaSignature.call(void 0, def),
-        description: def.description,
-        parts: _chunkRIKBJLS2cjs.getFormulaSignatureParts.call(void 0, def, context.call.argIndex),
-        argIndex: context.call.argIndex,
-        argument: specIndex >= 0 ? def.args[specIndex] : null
-      };
-    }
-  }
-  return { context, suggestions, activeCall };
-}
-function applyFormulaSuggestion(input, caret, name) {
-  const context = getFormulaCaretContext(input, caret);
-  const start = _nullishCoalesce(_optionalChain([context, 'access', _19 => _19.prefix, 'optionalAccess', _20 => _20.start]), () => ( caret));
-  const end = _nullishCoalesce(_optionalChain([context, 'access', _21 => _21.prefix, 'optionalAccess', _22 => _22.end]), () => ( caret));
-  const hasParen = input[end] === "(";
-  const insert = hasParen ? name.toUpperCase() : `${name.toUpperCase()}(`;
-  const value = input.slice(0, start) + insert + input.slice(end);
-  return { value, caret: start + insert.length + (hasParen ? 1 : 0) };
-}
-
-// src/spreadsheet/datasource/index.ts
-var DataSourceBinder = (_class2 = class {constructor() { _class2.prototype.__init6.call(this); }
-  __init6() {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({
-        ..._optionalChain([existing, 'optionalAccess', _23 => _23.hidden]) ? { hidden: true } : {},
-        id: _optionalChain([existing, 'optionalAccess', _24 => _24.id]) || `row_${record.id}`,
-        index: rowIndex++,
-        height: _optionalChain([existing, 'optionalAccess', _25 => _25.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);
-  }
-}, _class2);
-
-// src/spreadsheet/table.ts
-function normalizeRange(range) {
-  return {
-    startRow: Math.min(range.startRow, range.endRow),
-    startCol: Math.min(range.startCol, range.endCol),
-    endRow: Math.max(range.startRow, range.endRow),
-    endCol: Math.max(range.startCol, range.endCol)
-  };
-}
-function rangeContains(range, row, col) {
-  const r = normalizeRange(range);
-  return row >= r.startRow && row <= r.endRow && col >= r.startCol && col <= r.endCol;
-}
-function rangesIntersect(a, b) {
-  const x = normalizeRange(a);
-  const y = normalizeRange(b);
-  return x.startRow <= y.endRow && y.startRow <= x.endRow && x.startCol <= y.endCol && y.startCol <= x.endCol;
-}
-function rangeContainsRange(outer, inner) {
-  const o = normalizeRange(outer);
-  const i = normalizeRange(inner);
-  return i.startRow >= o.startRow && i.endRow <= o.endRow && i.startCol >= o.startCol && i.endCol <= o.endCol;
-}
-function isSingleCellRange(range) {
-  const r = normalizeRange(range);
-  return r.startRow === r.endRow && r.startCol === r.endCol;
-}
-var NUMBER_PATTERN = /^[-+]?(\d+\.?\d*|\.\d+)(e[-+]?\d+)?$/i;
-var ISO_DATE_PATTERN = /^(\d{4})-(\d{2})-(\d{2})$/;
-function isBlankValue(value) {
-  return value === null || value === void 0 || typeof value === "string" && value.trim() === "";
-}
-function toNumber(value) {
-  if (typeof value === "number") return Number.isFinite(value) ? value : null;
-  if (typeof value === "string") {
-    const trimmed = value.trim();
-    if (NUMBER_PATTERN.test(trimmed)) return parseFloat(trimmed);
-  }
-  return null;
-}
-var collator = typeof Intl !== "undefined" ? new Intl.Collator(void 0, { numeric: true, sensitivity: "base" }) : null;
-function compareText(a, b) {
-  return collator ? collator.compare(a, b) : a < b ? -1 : a > b ? 1 : 0;
-}
-function compareCellValues(a, b, direction = "asc") {
-  const aBlank = isBlankValue(a);
-  const bBlank = isBlankValue(b);
-  if (aBlank || bBlank) return aBlank === bBlank ? 0 : aBlank ? 1 : -1;
-  let result;
-  if (isPlainText(a) && isPlainText(b) && !(_chunkRIKBJLS2cjs.parseIsoDate.call(void 0, a) && _chunkRIKBJLS2cjs.parseIsoDate.call(void 0, b))) {
-    result = compareText(a, b);
-  } else {
-    result = _chunkRIKBJLS2cjs.sortCompareValues.call(void 0, a, b);
-  }
-  if (result === 0) return 0;
-  return direction === "desc" ? -Math.sign(result) : Math.sign(result);
-}
-var isPlainText = (value) => typeof value === "string" && !_chunkRIKBJLS2cjs.isFormulaError.call(void 0, value);
-function filterValue(value) {
-  if (isBlankValue(value) || _chunkRIKBJLS2cjs.isFormulaError.call(void 0, value)) return null;
-  if (typeof value === "number") return Number.isFinite(value) ? { value, kind: "number" } : null;
-  if (typeof value === "boolean") return { value, kind: "boolean" };
-  const num = _chunkRIKBJLS2cjs.numericValue.call(void 0, value);
-  if (num !== null) return { value: num, kind: "number" };
-  const text = String(value);
-  return { value: text, kind: _chunkRIKBJLS2cjs.parseIsoDate.call(void 0, text) ? "number" : "text" };
-}
-function filterOperand(operand) {
-  if (typeof operand !== "string") return filterValue(operand);
-  if (operand.trim() === "") return null;
-  const parsed = _chunkRIKBJLS2cjs.parseCellInput.call(void 0, operand.trim());
-  if (parsed.type === "number" || parsed.type === "date" || parsed.type === "boolean") return filterValue(parsed.value);
-  return { value: operand, kind: "text" };
-}
-function compareForFilter(value, operand) {
-  const a = filterValue(value);
-  const b = filterOperand(operand);
-  if (!a || !b || a.kind !== b.kind) return null;
-  return _chunkRIKBJLS2cjs.compareValues.call(void 0, a.value, b.value);
-}
-function looselyEquals(value, operand) {
-  const c = compareForFilter(value, operand);
-  if (c !== null) return c === 0;
-  return String(_nullishCoalesce(value, () => ( ""))).trim().toLowerCase() === String(_nullishCoalesce(operand, () => ( ""))).trim().toLowerCase();
-}
-function matchesFilterRule(value, rule) {
-  const text = String(_nullishCoalesce(value, () => ( ""))).toLowerCase();
-  switch (rule.operator) {
-    case "equals":
-      return looselyEquals(value, rule.value);
-    case "notEquals":
-      return !looselyEquals(value, rule.value);
-    case "contains":
-      return text.includes(String(_nullishCoalesce(rule.value, () => ( ""))).toLowerCase());
-    case "notContains":
-      return !text.includes(String(_nullishCoalesce(rule.value, () => ( ""))).toLowerCase());
-    case "greaterThan": {
-      const c = compareForFilter(value, rule.value);
-      return c !== null && c > 0;
-    }
-    case "greaterThanOrEqual": {
-      const c = compareForFilter(value, rule.value);
-      return c !== null && c >= 0;
-    }
-    case "lessThan": {
-      const c = compareForFilter(value, rule.value);
-      return c !== null && c < 0;
-    }
-    case "lessThanOrEqual": {
-      const c = compareForFilter(value, rule.value);
-      return c !== null && c <= 0;
-    }
-    case "between": {
-      const lo = compareForFilter(value, rule.value);
-      const hi = compareForFilter(value, rule.value2);
-      return lo !== null && hi !== null && lo >= 0 && hi <= 0;
-    }
-    case "isBlank":
-      return isBlankValue(value);
-    case "isNotBlank":
-      return !isBlankValue(value);
-    case "oneOf":
-      return (_nullishCoalesce(rule.values, () => ( []))).some((candidate) => String(candidate) === String(_nullishCoalesce(value, () => ( ""))));
-    default:
-      return true;
-  }
-}
-function aggregateValues(values, aggregate) {
-  if (aggregate === "count") return values.filter((v) => !isBlankValue(v)).length;
-  const numbers = [];
-  for (const v of values) {
-    const n = toNumber(v);
-    if (n !== null) numbers.push(n);
-  }
-  if (numbers.length === 0) return aggregate === "sum" ? 0 : null;
-  switch (aggregate) {
-    case "sum":
-      return roundFloat(numbers.reduce((s, n) => s + n, 0));
-    case "average":
-      return roundFloat(numbers.reduce((s, n) => s + n, 0) / numbers.length);
-    case "min":
-      return numbers.reduce((m, n) => n < m ? n : m, numbers[0]);
-    case "max":
-      return numbers.reduce((m, n) => n > m ? n : m, numbers[0]);
-    default:
-      return null;
-  }
-}
-function roundFloat(value) {
-  return Number.isInteger(value) ? value : parseFloat(value.toPrecision(12));
-}
-var DAY_MS = 864e5;
-var TRAILING_NUMBER = /^(.*?)(\d+)(\D*)$/;
-function classifyFillValue(raw) {
-  if (raw.trim() === "") return { kind: "blank" };
-  const num = toNumber(raw);
-  if (num !== null) return { kind: "number", value: num };
-  const typed = _chunkRIKBJLS2cjs.parseCellInput.call(void 0, raw);
-  const date = ISO_DATE_PATTERN.exec(typed.type === "date" ? String(typed.value) : raw.trim());
-  if (date) {
-    const [year, month, day] = [Number(date[1]), Number(date[2]), Number(date[3])];
-    const time = Date.UTC(year, month - 1, day);
-    const check = new Date(time);
-    if (check.getUTCMonth() === month - 1 && check.getUTCDate() === day) {
-      return { kind: "date", time, year, month, day };
-    }
-  }
-  const textNumber = TRAILING_NUMBER.exec(raw);
-  if (textNumber && textNumber[1] !== "") {
-    return {
-      kind: "textNumber",
-      prefix: textNumber[1],
-      value: parseInt(textNumber[2], 10),
-      width: textNumber[2].length,
-      suffix: textNumber[3]
-    };
-  }
-  return { kind: "text", text: raw };
-}
-var pad = (n, width) => String(Math.abs(n)).padStart(width, "0");
-function formatDate(time) {
-  const d = new Date(time);
-  return `${d.getUTCFullYear()}-${pad(d.getUTCMonth() + 1, 2)}-${pad(d.getUTCDate(), 2)}`;
-}
-function constantStep(values) {
-  const step = values[1] - values[0];
-  for (let i = 2; i < values.length; i++) {
-    if (Math.abs(values[i] - values[i - 1] - step) > 1e-9) return null;
-  }
-  return step;
-}
-function linearTrend(values, x) {
-  const n = values.length;
-  const meanX = (n - 1) / 2;
-  const meanY = values.reduce((s, v) => s + v, 0) / n;
-  let num = 0;
-  let den = 0;
-  values.forEach((v, i) => {
-    num += (i - meanX) * (v - meanY);
-    den += (i - meanX) ** 2;
-  });
-  const slope = den === 0 ? 0 : num / den;
-  return meanY + slope * (x - meanX);
-}
-function fillSeries(source, count) {
-  if (count <= 0) return [];
-  if (source.length === 0) return Array(count).fill("");
-  const repeat = () => Array.from({ length: count }, (_, i) => source[i % source.length]);
-  const parsed = source.map(classifyFillValue);
-  const kind = parsed[0].kind;
-  if (!parsed.every((p) => p.kind === kind)) return repeat();
-  const n = source.length;
-  if (kind === "number") {
-    if (n === 1) return repeat();
-    const values = parsed.map((p) => p.value);
-    return Array.from({ length: count }, (_, i) => String(roundFloat(linearTrend(values, n + i))));
-  }
-  if (kind === "date") {
-    const dates = parsed;
-    if (n === 1) {
-      return Array.from({ length: count }, (_, i) => formatDate(dates[0].time + (i + 1) * DAY_MS));
-    }
-    const monthIndex = dates.map((d) => d.year * 12 + (d.month - 1));
-    const monthStep = constantStep(monthIndex);
-    if (monthStep !== null && monthStep !== 0 && dates.every((d) => d.day === dates[0].day)) {
-      const last = monthIndex[n - 1];
-      return Array.from({ length: count }, (_, i) => {
-        const m = last + monthStep * (i + 1);
-        const year = Math.floor(m / 12);
-        const month = m - year * 12;
-        const daysInMonth = new Date(Date.UTC(year, month + 1, 0)).getUTCDate();
-        return formatDate(Date.UTC(year, month, Math.min(dates[0].day, daysInMonth)));
-      });
-    }
-    const dayStep = constantStep(dates.map((d) => Math.round(d.time / DAY_MS)));
-    if (dayStep === null) return repeat();
-    const lastTime = dates[n - 1].time;
-    return Array.from({ length: count }, (_, i) => formatDate(lastTime + dayStep * (i + 1) * DAY_MS));
-  }
-  if (kind === "textNumber") {
-    const items = parsed;
-    const { prefix, suffix } = items[0];
-    if (!items.every((t) => t.prefix === prefix && t.suffix === suffix)) return repeat();
-    const step = n === 1 ? 1 : constantStep(items.map((t) => t.value));
-    if (step === null) return repeat();
-    const last = items[n - 1];
-    return Array.from({ length: count }, (_, i) => {
-      const value = last.value + step * (i + 1);
-      const digits = value < 0 ? `-${pad(value, last.width)}` : pad(value, last.width);
-      return `${prefix}${digits}${suffix}`;
-    });
-  }
-  return repeat();
-}
-function computeFillTarget(source, pointer) {
-  const s = normalizeRange(source);
-  const rowOverflow = pointer.row > s.endRow ? pointer.row - s.endRow : pointer.row < s.startRow ? s.startRow - pointer.row : 0;
-  const colOverflow = pointer.col > s.endCol ? pointer.col - s.endCol : pointer.col < s.startCol ? s.startCol - pointer.col : 0;
-  if (rowOverflow === 0 && colOverflow === 0) return null;
-  if (rowOverflow >= colOverflow) {
-    return pointer.row > s.endRow ? { ...s, endRow: pointer.row } : { ...s, startRow: pointer.row };
-  }
-  return pointer.col > s.endCol ? { ...s, endCol: pointer.col } : { ...s, startCol: pointer.col };
-}
-function getFillDirection(source, target) {
-  const s = normalizeRange(source);
-  const t = normalizeRange(target);
-  const sameCols = s.startCol === t.startCol && s.endCol === t.endCol;
-  const sameRows = s.startRow === t.startRow && s.endRow === t.endRow;
-  if (sameCols && t.startRow === s.startRow && t.endRow > s.endRow) return "down";
-  if (sameCols && t.endRow === s.endRow && t.startRow < s.startRow) return "up";
-  if (sameRows && t.startCol === s.startCol && t.endCol > s.endCol) return "right";
-  if (sameRows && t.endCol === s.endCol && t.startCol < s.startCol) return "left";
-  return null;
-}
-
-// src/spreadsheet/csv.ts
-var BOM = "\uFEFF";
-function parseCsv(text, options = {}) {
-  const delimiter = _nullishCoalesce(options.delimiter, () => ( ","));
-  if (delimiter.length !== 1 || delimiter === '"' || delimiter === "\n" || delimiter === "\r") {
-    throw new Error(`Invalid CSV delimiter: ${JSON.stringify(delimiter)}`);
-  }
-  const input = text.startsWith(BOM) ? text.slice(1) : text;
-  const records = [];
-  let record = [];
-  let field = "";
-  let i = 0;
-  let recordStarted = false;
-  const endField = () => {
-    record.push(field);
-    field = "";
-  };
-  const endRecord = () => {
-    endField();
-    records.push(record);
-    record = [];
-    recordStarted = false;
-  };
-  let atFieldStart = true;
-  while (i < input.length) {
-    const char = input[i];
-    if (char === '"' && atFieldStart) {
-      const quoted = readQuoted(input, i, delimiter);
-      if (quoted.wellFormed || !options.requireWellFormedQuotes) {
-        recordStarted = true;
-        atFieldStart = false;
-        field += quoted.value;
-        i = quoted.end;
-        continue;
-      }
-    }
-    if (char === delimiter) {
-      recordStarted = true;
-      endField();
-      atFieldStart = true;
-      i++;
-      continue;
-    }
-    if (char === "\r" || char === "\n") {
-      endRecord();
-      atFieldStart = true;
-      i += char === "\r" && input[i + 1] === "\n" ? 2 : 1;
-      continue;
-    }
-    recordStarted = true;
-    atFieldStart = false;
-    field += char;
-    i++;
-  }
-  if (recordStarted || field !== "" || record.length > 0) endRecord();
-  return records;
-}
-function readQuoted(input, start, delimiter) {
-  let value = "";
-  let i = start + 1;
-  while (i < input.length) {
-    if (input[i] === '"') {
-      if (input[i + 1] === '"') {
-        value += '"';
-        i += 2;
-        continue;
-      }
-      const next = input[i + 1];
-      const wellFormed = next === void 0 || next === delimiter || next === "\r" || next === "\n";
-      return { value, end: i + 1, wellFormed };
-    }
-    value += input[i];
-    i++;
-  }
-  return { value, end: i, wellFormed: false };
-}
-function escapeCsvField(value, delimiter = ",", quoteAll = false) {
-  if (quoteAll || value.includes(delimiter) || /["\r\n]/.test(value)) {
-    return `"${value.replace(/"/g, '""')}"`;
-  }
-  return value;
-}
-function serializeCsv(rows, options = {}) {
-  const delimiter = _nullishCoalesce(options.delimiter, () => ( ","));
-  const lineEnding = _nullishCoalesce(options.lineEnding, () => ( "\r\n"));
-  const body = rows.map(
-    (row) => row.map((value) => escapeCsvField(value == null ? "" : String(value), delimiter, options.quoteAll)).join(delimiter)
-  ).join(lineEnding);
-  return options.bom ? BOM + body : body;
-}
-function parseTsv(text) {
-  const normalized = text.startsWith(BOM) ? text.slice(1) : text;
-  if (!normalized.includes('"')) {
-    const body = normalized.replace(/\r\n?/g, "\n").replace(/\n$/, "");
-    return body === "" ? [] : body.split("\n").map((line) => line.split("	"));
-  }
-  return parseCsv(normalized, { delimiter: "	", requireWellFormedQuotes: true });
-}
-function serializeTsv(rows) {
-  return rows.map(
-    (row) => row.map((value) => {
-      const text = value == null ? "" : String(value);
-      return /[\t\r\n]/.test(text) || text.startsWith('"') ? `"${text.replace(/"/g, '""')}"` : text;
-    }).join("	")
-  ).join("\n");
-}
-
-// src/spreadsheet/clipboard.ts
-var SPREADSHEET_CLIPBOARD_MIME = "application/x.pixerate.spreadsheet+json";
-var displayText = (value) => value === null || value === void 0 ? "" : String(value);
-function escapeHtml(text) {
-  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-}
-function serializeHtmlTable(values) {
-  const body = values.map(
-    (row) => `<tr>${row.map((v) => `<td>${escapeHtml(displayText(v)).replace(/\r?\n/g, "<br>")}</td>`).join("")}</tr>`
-  ).join("");
-  return `<table><tbody>${body}</tbody></table>`;
-}
-var NAMED_ENTITIES = {
-  amp: "&",
-  lt: "<",
-  gt: ">",
-  quot: '"',
-  apos: "'",
-  nbsp: " "
-};
-function decodeEntities(text) {
-  return text.replace(/&(#x[0-9a-f]+|#\d+|[a-z]+);/gi, (match, entity) => {
-    if (entity[0] === "#") {
-      const code = entity[1] === "x" || entity[1] === "X" ? parseInt(entity.slice(2), 16) : parseInt(entity.slice(1), 10);
-      return Number.isFinite(code) ? String.fromCodePoint(code) : match;
-    }
-    return _nullishCoalesce(NAMED_ENTITIES[entity.toLowerCase()], () => ( match));
-  });
-}
-var LINE_BREAK = "\uE000";
-function cellHtmlToText(html) {
-  const text = html.replace(/<!--[\s\S]*?-->/g, "").replace(/<(style|script)[\s\S]*?<\/\1\s*>/gi, "").replace(/<br\s*\/?>/gi, LINE_BREAK).replace(/<\/(p|div)\s*>/gi, LINE_BREAK).replace(/<[^>]*>/g, "").replace(/\s+/g, " ");
-  return decodeEntities(text).replace(/ /g, " ").split(LINE_BREAK).map((line) => line.trim()).join("\n").replace(/^\n+|\n+$/g, "");
-}
-function parseHtmlTable(html) {
-  const tableMatch = /<table[\s>][\s\S]*?<\/table\s*>/i.exec(html);
-  if (!tableMatch) return null;
-  const table = tableMatch[0];
-  const rows = [];
-  const occupied = /* @__PURE__ */ new Map();
-  const rowPattern = /<tr[\s>]([\s\S]*?)<\/tr\s*>/gi;
-  const cellPattern = /<(td|th)(\s[^>]*)?>([\s\S]*?)<\/\1\s*>/gi;
-  let rowMatch;
-  let rowIndex = 0;
-  while (rowMatch = rowPattern.exec(table)) {
-    const row = [];
-    const taken = _nullishCoalesce(occupied.get(rowIndex), () => ( /* @__PURE__ */ new Set()));
-    let col = 0;
-    let cellMatch;
-    cellPattern.lastIndex = 0;
-    while (cellMatch = cellPattern.exec(rowMatch[1])) {
-      while (taken.has(col)) row[col++] = "";
-      const attrs = _nullishCoalesce(cellMatch[2], () => ( ""));
-      const colspan = Math.max(1, parseInt(_nullishCoalesce(_optionalChain([/colspan\s*=\s*["']?(\d+)/i, 'access', _26 => _26.exec, 'call', _27 => _27(attrs), 'optionalAccess', _28 => _28[1]]), () => ( "1")), 10));
-      const rowspan = Math.max(1, parseInt(_nullishCoalesce(_optionalChain([/rowspan\s*=\s*["']?(\d+)/i, 'access', _29 => _29.exec, 'call', _30 => _30(attrs), 'optionalAccess', _31 => _31[1]]), () => ( "1")), 10));
-      row[col] = cellHtmlToText(cellMatch[3]);
-      for (let c = col; c < col + colspan; c++) {
-        if (c > col) row[c] = "";
-        for (let r = rowIndex + 1; r < rowIndex + rowspan; r++) {
-          if (!occupied.has(r)) occupied.set(r, /* @__PURE__ */ new Set());
-          occupied.get(r).add(c);
-        }
-      }
-      col += colspan;
-    }
-    while (taken.has(col)) row[col++] = "";
-    rows.push(Array.from(row, (v) => _nullishCoalesce(v, () => ( ""))));
-    rowIndex++;
-  }
-  return rows.length > 0 ? rows : null;
-}
-function createSpreadsheetClipboardData(cells, origin) {
-  const texts = cells.map((row) => row.map((cell) => _nullishCoalesce(cell.text, () => ( displayText(cell.value)))));
-  const payload = {
-    type: "pixerate-spreadsheet",
-    version: 1,
-    origin,
-    cells: cells.map((row) => row.map(({ raw, value }) => ({ raw, value })))
-  };
-  return {
-    "text/plain": serializeTsv(texts),
-    "text/html": serializeHtmlTable(texts),
-    [SPREADSHEET_CLIPBOARD_MIME]: JSON.stringify(payload)
-  };
-}
-function readFormat(source, format) {
-  try {
-    if (typeof source.getData === "function") {
-      return _nullishCoalesce(source.getData(format), () => ( ""));
-    }
-    return _nullishCoalesce(source[format], () => ( ""));
-  } catch (e3) {
-    return "";
-  }
-}
-function parsePayload(json) {
-  try {
-    const payload = JSON.parse(json);
-    if (_optionalChain([payload, 'optionalAccess', _32 => _32.type]) !== "pixerate-spreadsheet" || !Array.isArray(payload.cells) || !payload.cells.every((row) => Array.isArray(row)) || typeof _optionalChain([payload, 'access', _33 => _33.origin, 'optionalAccess', _34 => _34.row]) !== "number" || typeof _optionalChain([payload, 'access', _35 => _35.origin, 'optionalAccess', _36 => _36.col]) !== "number") {
-      return null;
-    }
-    return payload;
-  } catch (e4) {
-    return null;
-  }
-}
-function readSpreadsheetClipboard(source) {
-  const payload = parsePayload(readFormat(source, SPREADSHEET_CLIPBOARD_MIME));
-  if (payload) {
-    return {
-      format: "internal",
-      origin: payload.origin,
-      rows: payload.cells.map((row) => row.map((cell) => typeof _optionalChain([cell, 'optionalAccess', _37 => _37.raw]) === "string" ? cell.raw : displayText(_optionalChain([cell, 'optionalAccess', _38 => _38.value]))))
-    };
-  }
-  const html = readFormat(source, "text/html");
-  if (html) {
-    const rows = parseHtmlTable(html);
-    if (rows) return { format: "html", rows };
-  }
-  const text = readFormat(source, "text/plain");
-  if (text) {
-    const rows = parseTsv(text);
-    if (rows.length > 0) return { format: "text", rows };
-  }
-  return null;
-}
-function rebaseClipboardRows(rows, origin, target) {
-  const rowOffset = target.row - origin.row;
-  const colOffset = target.col - origin.col;
-  return rows.map(
-    (row) => row.map((raw) => raw.startsWith("=") ? offsetFormulaReferences(raw, rowOffset, colOffset) : raw)
-  );
-}
-
-// src/spreadsheet/view.ts
-var DEFAULT_ROW_HEIGHT = 32;
-var DEFAULT_COLUMN_WIDTH = 130;
-var clampCount = (value, max) => Math.max(0, Math.min(Math.floor(_nullishCoalesce(value, () => ( 0))), max));
-function getTableSections(doc) {
-  const total = doc.rows.length;
-  const headerRows = clampCount(_optionalChain([doc, 'access', _39 => _39.table, 'optionalAccess', _40 => _40.headerRowCount]), total);
-  const footerRows = clampCount(_optionalChain([doc, 'access', _41 => _41.table, 'optionalAccess', _42 => _42.footerRowCount]), total - headerRows);
-  return { headerRows, footerRows };
-}
-function getRowSection(doc, rowIndex) {
-  const { headerRows, footerRows } = getTableSections(doc);
-  if (rowIndex < headerRows) return "header";
-  if (rowIndex >= doc.rows.length - footerRows) return "footer";
-  return "body";
-}
-function rowPassesFilters(doc, rowIndex, getValue) {
-  const filter = _optionalChain([doc, 'access', _43 => _43.table, 'optionalAccess', _44 => _44.filter]);
-  if (!_optionalChain([filter, 'optionalAccess', _45 => _45.enabled]) || filter.rules.length === 0) return true;
-  if (getRowSection(doc, rowIndex) !== "body") return true;
-  return filter.rules.every((rule) => {
-    const colIndex = doc.columns.findIndex((c) => c.id === rule.colId);
-    if (colIndex === -1) return true;
-    return matchesFilterRule(getValue(rowIndex, colIndex), rule);
-  });
-}
-function computeRowGroups(doc, getValue) {
-  const grouping = _optionalChain([doc, 'access', _46 => _46.table, 'optionalAccess', _47 => _47.grouping]);
-  if (!grouping) return [];
-  const groupCol = doc.columns.findIndex((c) => c.id === grouping.colId);
-  if (groupCol === -1) return [];
-  const { headerRows, footerRows } = getTableSections(doc);
-  const byKey = /* @__PURE__ */ new Map();
-  for (let r = headerRows; r < doc.rows.length - footerRows; r++) {
-    if (doc.rows[r].hidden || !rowPassesFilters(doc, r, getValue)) continue;
-    const value = getValue(r, groupCol);
-    const key = isBlankValue(value) ? "" : String(value).trim();
-    if (!byKey.has(key)) byKey.set(key, []);
-    byKey.get(key).push(r);
-  }
-  const collapsed = new Set(grouping.collapsed);
-  return Array.from(byKey.keys()).sort((a, b) => compareCellValues(a, b)).map((key) => {
-    const rowIndices = byKey.get(key);
-    const summaries = {};
-    for (const summary of grouping.summaries) {
-      const colIndex = doc.columns.findIndex((c) => c.id === summary.colId);
-      if (colIndex === -1) continue;
-      summaries[summary.colId] = aggregateValues(
-        rowIndices.map((r) => getValue(r, colIndex)),
-        summary.aggregate
-      );
-    }
-    return { key, label: key === "" ? "(blank)" : key, rowIndices, collapsed: collapsed.has(key), summaries };
-  });
-}
-function buildSpreadsheetView(doc, getValue) {
-  const { headerRows, footerRows } = getTableSections(doc);
-  const frozenRows = clampCount(_optionalChain([doc, 'access', _48 => _48.table, 'optionalAccess', _49 => _49.frozenRowCount]), doc.rows.length);
-  const frozenCols = clampCount(_optionalChain([doc, 'access', _50 => _50.table, 'optionalAccess', _51 => _51.frozenColumnCount]), doc.columns.length);
-  const headerCols = clampCount(_optionalChain([doc, 'access', _52 => _52.table, 'optionalAccess', _53 => _53.headerColumnCount]), doc.columns.length);
-  const columns = [];
-  let left = 0;
-  let hiddenColumnCount = 0;
-  doc.columns.forEach((column, index) => {
-    if (column.hidden) {
-      hiddenColumnCount++;
-      return;
-    }
-    const frozen = index < frozenCols;
-    columns.push({ column, index, header: index < headerCols, frozen, stickyLeft: frozen ? left : 0 });
-    if (frozen) left += column.width || DEFAULT_COLUMN_WIDTH;
-  });
-  const rows = [];
-  let hiddenRowCount = 0;
-  let filteredOutCount = 0;
-  const pushRow = (index, section, groupKey) => {
-    const row = doc.rows[index];
-    rows.push({ kind: "row", row, index, section, frozen: false, stickyTop: 0, groupKey });
-  };
-  for (let r = 0; r < headerRows; r++) {
-    if (doc.rows[r].hidden) hiddenRowCount++;
-    else pushRow(r, "header");
-  }
-  const bodyEnd = doc.rows.length - footerRows;
-  const groups = computeRowGroups(doc, getValue);
-  for (let r = headerRows; r < bodyEnd; r++) {
-    if (doc.rows[r].hidden) hiddenRowCount++;
-    else if (!rowPassesFilters(doc, r, getValue)) filteredOutCount++;
-  }
-  const grouping = _optionalChain([doc, 'access', _54 => _54.table, 'optionalAccess', _55 => _55.grouping]);
-  if (grouping && doc.columns.some((c) => c.id === grouping.colId)) {
-    for (const group of groups) {
-      rows.push({ kind: "group", group });
-      if (!group.collapsed) group.rowIndices.forEach((r) => pushRow(r, "body", group.key));
-    }
-  } else {
-    for (let r = headerRows; r < bodyEnd; r++) {
-      if (!doc.rows[r].hidden && rowPassesFilters(doc, r, getValue)) pushRow(r, "body");
-    }
-  }
-  for (let r = bodyEnd; r < doc.rows.length; r++) {
-    if (doc.rows[r].hidden) hiddenRowCount++;
-    else pushRow(r, "footer");
-  }
-  let top = 0;
-  for (const viewRow of rows) {
-    if (viewRow.kind !== "row" || viewRow.index >= frozenRows) break;
-    viewRow.frozen = true;
-    viewRow.stickyTop = top;
-    top += viewRow.row.height || DEFAULT_ROW_HEIGHT;
-  }
-  const rowOrder = rows.flatMap((r) => r.kind === "row" ? [r.index] : []);
-  const columnOrder = columns.map((c) => c.index);
-  const rowPos = new Map(rowOrder.map((index, pos) => [index, pos]));
-  const colPos = new Map(columnOrder.map((index, pos) => [index, pos]));
-  const spans = /* @__PURE__ */ new Map();
-  const contiguousRun = (indices, positions) => {
-    const visible = indices.filter((i) => positions.has(i)).sort((a, b) => positions.get(a) - positions.get(b));
-    if (visible.length === 0) return null;
-    let run = 1;
-    while (run < visible.length && positions.get(visible[run]) === positions.get(visible[0]) + run) run++;
-    return { first: visible[0], run };
-  };
-  for (const raw of _nullishCoalesce(_optionalChain([doc, 'access', _56 => _56.table, 'optionalAccess', _57 => _57.merges]), () => ( []))) {
-    const merge = normalizeRange(raw);
-    const rowIdx = [];
-    const colIdx = [];
-    for (let r = merge.startRow; r <= merge.endRow; r++) rowIdx.push(r);
-    for (let c = merge.startCol; c <= merge.endCol; c++) colIdx.push(c);
-    const rowRun = contiguousRun(rowIdx, rowPos);
-    const colRun = contiguousRun(colIdx, colPos);
-    for (const r of rowIdx) for (const c of colIdx) spans.set(`${r}:${c}`, null);
-    if (rowRun && colRun) {
-      spans.set(`${rowRun.first}:${colRun.first}`, {
-        rowSpan: rowRun.run,
-        colSpan: colRun.run,
-        source: { row: merge.startRow, col: merge.startCol },
-        merge
-      });
-    }
-  }
-  return {
-    rows,
-    columns,
-    groups,
-    rowOrder,
-    columnOrder,
-    filteredOutCount,
-    hiddenRowCount,
-    hiddenColumnCount,
-    getCellSpan(row, col) {
-      const span = spans.get(`${row}:${col}`);
-      if (span === void 0) return { rowSpan: 1, colSpan: 1, source: { row, col } };
-      return span;
-    }
-  };
-}
-
-// src/spreadsheet/controller.ts
-var nextIdSequence = 0;
-var DEFAULT_MAX_HISTORY_BYTES = 64 * 1024 * 1024;
-var MAX_SPILL_PASSES = 25;
-var spillCellId = (rowId, colId) => `${rowId}\0${colId}`;
-var SpreadsheetController = (_class3 = class {
-  
-  __init7() {this.activeCell = null}
-  __init8() {this.selectedRange = null}
-  __init9() {this.editingCell = null}
-  __init10() {this.draftValue = ""}
-  __init11() {this.binder = new DataSourceBinder()}
-  __init12() {this.depGraph = new DependencyGraph()}
-  
-  
-  
-  
-  
-  // History stack for undo/redo
-  __init13() {this.undoStack = []}
-  __init14() {this.redoStack = []}
-  __init15() {this.isApplyingHistory = false}
-  
-  // Set while importing TSV: history and recalculation are done once at the end.
-  __init16() {this.batching = false}
-  __init17() {this.pendingCommits = []}
-  // Row being evaluated, so [property] references resolve per row.
-  __init18() {this.evaluatingRowIndex = null}
-  // Cell being evaluated, for implicit intersection (`=@A:A`).
-  __init19() {this.evaluatingCell = null}
-  // Dynamic arrays. Spilled values are derived state: they live here, not in
-  // the document, and every recalculation rebuilds them.
-  __init20() {this.spills = /* @__PURE__ */ new Map()}
-  // anchor key -> spill
-  __init21() {this.spilledBy = /* @__PURE__ */ new Map()}
-  // spilled cell key -> anchor key
-  __init22() {this.spillCells = /* @__PURE__ */ new Map()}
-  // spillCellId -> displayed cell
-  // Cells whose spill ownership changed during the current pass.
-  __init23() {this.spillChanges = null}
-  constructor(options = {}) {;_class3.prototype.__init7.call(this);_class3.prototype.__init8.call(this);_class3.prototype.__init9.call(this);_class3.prototype.__init10.call(this);_class3.prototype.__init11.call(this);_class3.prototype.__init12.call(this);_class3.prototype.__init13.call(this);_class3.prototype.__init14.call(this);_class3.prototype.__init15.call(this);_class3.prototype.__init16.call(this);_class3.prototype.__init17.call(this);_class3.prototype.__init18.call(this);_class3.prototype.__init19.call(this);_class3.prototype.__init20.call(this);_class3.prototype.__init21.call(this);_class3.prototype.__init22.call(this);_class3.prototype.__init23.call(this);_class3.prototype.__init24.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', _58 => _58.document, 'optionalAccess', _59 => _59.id]) || `sheet_${Date.now()}`,
-      name: _optionalChain([options, 'access', _60 => _60.document, 'optionalAccess', _61 => _61.name]) || "Sheet 1",
-      columns: _optionalChain([options, 'access', _62 => _62.document, 'optionalAccess', _63 => _63.columns]) || defaultCols,
-      rows: _optionalChain([options, 'access', _64 => _64.document, 'optionalAccess', _65 => _65.rows]) || defaultRows,
-      cells: _optionalChain([options, 'access', _66 => _66.document, 'optionalAccess', _67 => _67.cells]) || {},
-      createdAt: _optionalChain([options, 'access', _68 => _68.document, 'optionalAccess', _69 => _69.createdAt]) || Date.now(),
-      updatedAt: _optionalChain([options, 'access', _70 => _70.document, 'optionalAccess', _71 => _71.updatedAt]) || Date.now(),
-      ..._optionalChain([options, 'access', _72 => _72.document, 'optionalAccess', _73 => _73.table]) ? { table: options.document.table } : {}
-    };
-    this.primaryDataSourceId = options.primaryDataSourceId;
-    this.maxHistoryBytes = Math.max(0, _nullishCoalesce(options.maxHistoryBytes, () => ( DEFAULT_MAX_HISTORY_BYTES)));
-    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 (0, _chunkRIKBJLS2cjs.FormulaEvaluator)({
-      resolveCell: (colStr, rowNum) => this.resolveCellByCoord(colStr, rowNum),
-      resolveRange: (sCol, sRow, eCol, eRow) => this.resolveRangeByCoords(sCol, sRow, eCol, eRow),
-      resolveProperty: (prop) => this.resolveCurrentRowProperty(prop),
-      resolveSpill: (colStr, rowNum) => this.resolveSpillByCoord(colStr, rowNum),
-      getFormulaCell: () => this.evaluatingCell
-    });
-    this.syncWithDataSource();
-    this.rederiveTypedValues();
-    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.rederiveTypedValues();
-    this.recalculateAll();
-    this.notifyChange();
-  }
-  /**
-   * Re-parses the value of every stored typed (non-formula) cell from its
-   * `raw` input, so documents saved before typed input was parsed (whose
-   * values are text such as `"120"`) compare and sort as numbers. Cells of
-   * bound columns in record rows keep their value: it belongs to the data
-   * source.
-   */
-  rederiveTypedValues() {
-    for (const row of this.document.rows) {
-      const cells = this.document.cells[row.id];
-      if (!cells) continue;
-      for (const col of this.document.columns) {
-        const cell = cells[col.id];
-        if (!cell || typeof cell.raw !== "string" || cell.raw.startsWith("=")) continue;
-        if (col.type === "bound" && col.binding && row.recordId) continue;
-        const typed = this.typedCell(cell.raw, cell.format);
-        cell.value = typed.value;
-        if (typed.numberFormat) cell.numberFormat = typed.numberFormat;
-        else delete cell.numberFormat;
-        if (typed.format) cell.format = typed.format;
-      }
-    }
-  }
-  /**
-   * Value of typed (non-formula) input: a number, boolean, ISO date, error
-   * or text (see `parseCellInput`), its automatic number format, and the
-   * `CellFormat` to use: the automatic one (currency, percentage, date,
-   * number) when `format` is unset or `text` (the default of new columns).
-   */
-  typedCell(raw, format) {
-    const parsed = _chunkRIKBJLS2cjs.parseCellInput.call(void 0, raw);
-    return {
-      value: parsed.value,
-      ...parsed.numberFormat ? { numberFormat: parsed.numberFormat } : {},
-      format: parsed.cellFormat && (!format || format === "text") ? parsed.cellFormat : format
-    };
-  }
-  /**
-   * Typed input for a bound field, coerced by the field's declared type:
-   * number, boolean and date fields get a number, boolean or ISO date when
-   * the input parses as one; string and enum fields (and unknown fields)
-   * keep the text exactly as typed.
-   */
-  boundInputValue(dataSourceId, field, raw) {
-    if (raw.startsWith("=")) return raw;
-    const type = _optionalChain([this, 'access', _74 => _74.binder, 'access', _75 => _75.getDataSource, 'call', _76 => _76(dataSourceId), 'optionalAccess', _77 => _77.getFields, 'call', _78 => _78(), 'access', _79 => _79.find, 'call', _80 => _80((f) => f.key === field), 'optionalAccess', _81 => _81.type]);
-    if (type !== "number" && type !== "boolean" && type !== "date") return raw;
-    const parsed = _chunkRIKBJLS2cjs.parseCellInput.call(void 0, raw);
-    if (type === "number" && parsed.type === "number") return parsed.value;
-    if (type === "boolean" && parsed.type === "boolean") return parsed.value;
-    if (type === "date" && parsed.type === "date") return parsed.value;
-    return raw;
-  }
-  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 = _chunkRIKBJLS2cjs.indexToColName.call(void 0, 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', _82 => _82.document, 'access', _83 => _83.cells, 'access', _84 => _84[rowId], 'optionalAccess', _85 => _85[colId]]);
-    if (existing && existing.raw !== "") return existing;
-    if (this.spillCells.size > 0) {
-      const spilled = this.spillCells.get(spillCellId(rowId, colId));
-      if (spilled) return spilled;
-    }
-    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', _86 => _86.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);
-    const isFormula = raw.startsWith("=");
-    let cell;
-    if (_optionalChain([col, 'optionalAccess', _87 => _87.type]) === "bound" && col.binding && _optionalChain([row, 'optionalAccess', _88 => _88.recordId])) {
-      const value = this.boundInputValue(col.binding.dataSource, col.binding.field, raw);
-      this.binder.commitBoundValue(col.binding.dataSource, row.recordId, col.binding.field, value);
-      cell = { raw, value, format: col.format };
-    } else if (isFormula) {
-      cell = { raw, value: raw, format: _optionalChain([col, 'optionalAccess', _89 => _89.format]) };
-    } else {
-      cell = { raw, ...this.typedCell(raw, _optionalChain([col, 'optionalAccess', _90 => _90.format])) };
-    }
-    const cellKey = this.getCellKey(rowId, colId);
-    this.depGraph.setCellFormula(cellKey, isFormula ? raw : null);
-    this.document.cells[rowId][colId] = cell;
-    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', _91 => _91.document, 'access', _92 => _92.cells, 'access', _93 => _93[rowId], 'access', _94 => _94[colId], 'optionalAccess', _95 => _95.value]);
-    _optionalChain([this, 'access', _96 => _96.onCellCommit, 'optionalCall', _97 => _97(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);
-    const anchor = this.spilledBy.get(cellKey);
-    this.recalculateKeys(anchor ? [cellKey, anchor] : [cellKey], true);
-  }
-  /**
-   * Recalculates `keys` (and, with `includeDependents`, their dependents) in
-   * dependency order. Spill ranges are only known after evaluating their
-   * anchors, so when a pass changes which cells hold spilled values (and so
-   * the dependency graph), the dependents of those cells are recalculated in
-   * another pass, until nothing changes.
-   */
-  recalculateKeys(keys, includeDependents) {
-    let pending = Array.from(keys);
-    let withDependents = includeDependents;
-    for (let pass = 0; pass < MAX_SPILL_PASSES && pending.length > 0; pass++) {
-      const changed = /* @__PURE__ */ new Set();
-      this.spillChanges = changed;
-      try {
-        this.runEvaluationPlan(this.depGraph.getEvaluationPlan(pending, { includeDependents: withDependents }));
-      } finally {
-        this.spillChanges = null;
-      }
-      pending = Array.from(changed);
-      withDependents = true;
-    }
-  }
-  /**
-   * Rebuilds the dependency graph from scratch and recalculates every formula
-   * in dependency order.
-   */
-  recalculateAll() {
-    this.depGraph.clear();
-    this.spills.clear();
-    this.spilledBy.clear();
-    this.spillCells.clear();
-    const formulaKeys = [];
-    for (const row of this.document.rows) {
-      for (const col of this.document.columns) {
-        const cell = _nullishCoalesce(_optionalChain([this, 'access', _98 => _98.document, 'access', _99 => _99.cells, 'access', _100 => _100[row.id], 'optionalAccess', _101 => _101[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.recalculateKeys(formulaKeys, false);
-  }
-  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] = {};
-    const deps = this.depGraph.getDependencies(cellKey);
-    const selfReference = deps.includes(cellKey) || deps.includes(`${col.key.toUpperCase()}:`);
-    const spilledKeys = this.depGraph.getSpilledKeys(cellKey);
-    const ownSpill = deps.find((dep) => spilledKeys.includes(dep));
-    const errorMessage = selfReference ? "This formula can't reference its own cell." : ownSpill ? `This formula refers to ${ownSpill}, which holds its own spilled results (a circular reference).` : "This formula is part of a circular reference: it depends on its own result through other cells.";
-    this.clearSpill(cellKey.toUpperCase(), true);
-    this.document.cells[row.id][col.id] = { ...cell, value: "#CYCLE!", error: "#CYCLE!", errorMessage };
-  }
-  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;
-        cell.errorMessage = void 0;
-      }
-      this.clearSpill(`${colName}${rowNum}`);
-      return;
-    }
-    try {
-      this.evaluatingRowIndex = rowNum - 1;
-      this.evaluatingCell = { col: colName, row: rowNum };
-      const result = this.evaluator.evaluateWithDiagnostics(cell.raw);
-      if (!this.document.cells[row.id]) {
-        this.document.cells[row.id] = {};
-      }
-      let { value, error, message } = result;
-      if (result.array) {
-        const blocked = this.placeSpill(`${colName}${rowNum}`, rowNum - 1, this.document.columns.indexOf(col), result.array);
-        if (blocked) {
-          value = "#SPILL!";
-          error = "#SPILL!";
-          message = blocked;
-        }
-      } else {
-        this.clearSpill(`${colName}${rowNum}`);
-      }
-      this.document.cells[row.id][col.id] = {
-        ...cell,
-        value,
-        // `#ERROR!` (malformed formula, wrong argument count) keeps its
-        // message in `error`, as before; other errors store their code.
-        error: error === "#ERROR!" ? message : error,
-        errorMessage: message
-      };
-    } finally {
-      this.evaluatingRowIndex = null;
-      this.evaluatingCell = null;
-    }
-  }
-  // --- Dynamic arrays (spilling) ---
-  /**
-   * Spills `array` from the anchor at (row, col) into the cells below and to
-   * the right. Returns why it can't (the anchor then shows `#SPILL!`), or
-   * null once placed. The grid never grows to fit an array, as in Excel.
-   */
-  placeSpill(anchor, row, col, array) {
-    const { rows, cols } = array;
-    const area = { startRow: row, startCol: col, endRow: row + rows - 1, endCol: col + cols - 1 };
-    const label = `${_chunkRIKBJLS2cjs.indexToColName.call(void 0, area.startCol)}${area.startRow + 1}:${_chunkRIKBJLS2cjs.indexToColName.call(void 0, area.endCol)}${area.endRow + 1}`;
-    let reason = null;
-    const blockers = [];
-    if (area.endRow >= this.document.rows.length || area.endCol >= this.document.columns.length) {
-      reason = `The ${rows}\xD7${cols} result needs ${label}, which extends past the edge of the sheet.`;
-    } else if (this.getMerges().some((m) => rangesIntersect(m, area))) {
-      reason = `The result can't spill into merged cells (it needs ${label}).`;
-    } else {
-      for (let c = area.startCol; c <= area.endCol; c++) {
-        const column = this.document.columns[c];
-        for (let r = area.startRow; r <= area.endRow; r++) {
-          if (r === row && c === col) continue;
-          const rowObj = this.document.rows[r];
-          const key = `${column.key}${r + 1}`.toUpperCase();
-          const stored = _optionalChain([this, 'access', _102 => _102.document, 'access', _103 => _103.cells, 'access', _104 => _104[rowObj.id], 'optionalAccess', _105 => _105[column.id]]);
-          const raw = stored ? stored.raw : this.getDerivedCell(rowObj, column).raw;
-          const owner = this.spilledBy.get(key);
-          if (raw !== "") {
-            blockers.push(key);
-            reason ??= `The result needs ${label}, but ${key} isn't empty.`;
-          } else if (owner && owner !== anchor) {
-            blockers.push(key);
-            reason ??= `The result needs ${label}, but ${key} already holds values spilled from ${owner}.`;
-          }
-        }
-      }
-    }
-    if (reason) {
-      this.clearSpill(anchor);
-      this.depGraph.setSpillEdges(anchor, [], blockers);
-      return reason;
-    }
-    const previous = this.spills.get(anchor);
-    const cells = [];
-    for (let c = 0; c < cols; c++) {
-      const column = this.document.columns[col + c];
-      for (let r = 0; r < rows; r++) {
-        if (r === 0 && c === 0) continue;
-        const rowObj = this.document.rows[row + r];
-        const key = `${column.key}${row + r + 1}`.toUpperCase();
-        const value = _nullishCoalesce(array.values[c * rows + r], () => ( ""));
-        const display = { raw: "", value, format: column.format, spillAnchor: anchor };
-        if (_chunkRIKBJLS2cjs.isFormulaError.call(void 0, value)) {
-          display.error = value;
-          display.errorMessage = _chunkRIKBJLS2cjs.describeFormulaError.call(void 0, value);
-        }
-        this.spillCells.set(spillCellId(rowObj.id, column.id), display);
-        if (this.spilledBy.get(key) !== anchor) {
-          this.spilledBy.set(key, anchor);
-          _optionalChain([this, 'access', _106 => _106.spillChanges, 'optionalAccess', _107 => _107.add, 'call', _108 => _108(key)]);
-        }
-        cells.push({ key, rowId: rowObj.id, colId: column.id });
-      }
-    }
-    if (previous) {
-      const kept = new Set(cells.map((cell) => cell.key));
-      for (const old of previous.cells) {
-        if (kept.has(old.key)) continue;
-        this.forgetSpilledCell(anchor, old);
-      }
-    }
-    this.spills.set(anchor, { anchor, row, col, rows, cols, values: array.values, cells });
-    this.depGraph.setSpillEdges(anchor, cells.map((cell) => cell.key));
-    return null;
-  }
-  /** Removes the array spilled from `anchor`. With `keepEdges`, its dependency edges stay. */
-  clearSpill(anchor, keepEdges = false) {
-    const record = this.spills.get(anchor);
-    if (record) {
-      for (const cell of record.cells) this.forgetSpilledCell(anchor, cell);
-      this.spills.delete(anchor);
-    }
-    if (!keepEdges) this.depGraph.setSpillEdges(anchor, []);
-  }
-  forgetSpilledCell(anchor, cell) {
-    if (this.spilledBy.get(cell.key) !== anchor) return;
-    this.spilledBy.delete(cell.key);
-    this.spillCells.delete(spillCellId(cell.rowId, cell.colId));
-    _optionalChain([this, 'access', _109 => _109.spillChanges, 'optionalAccess', _110 => _110.add, 'call', _111 => _111(cell.key)]);
-  }
-  resolveSpillByCoord(colStr, rowNum) {
-    const record = this.spills.get(`${colStr}${rowNum}`.toUpperCase());
-    if (record) return { rows: record.rows, cols: record.cols, values: record.values };
-    const value = this.resolveCellByCoord(colStr, rowNum);
-    return _chunkRIKBJLS2cjs.isFormulaError.call(void 0, value) ? value : "#REF!";
-  }
-  toSpill(record) {
-    const row = this.document.rows[record.row];
-    const col = this.document.columns[record.col];
-    return {
-      key: record.anchor,
-      anchor: { row: record.row, col: record.col },
-      range: {
-        startRow: record.row,
-        startCol: record.col,
-        endRow: record.row + record.rows - 1,
-        endCol: record.col + record.cols - 1
-      },
-      formula: row && col ? this.getCell(row.id, col.id).raw : ""
-    };
-  }
-  /**
-   * The dynamic array covering (row, col), whether it is the anchor (the cell
-   * holding the formula) or a spilled cell; null when there is none.
-   */
-  getSpillAt(row, col) {
-    if (this.spills.size === 0) return null;
-    const key = `${_chunkRIKBJLS2cjs.indexToColName.call(void 0, col)}${row + 1}`;
-    const record = _nullishCoalesce(this.spills.get(key), () => ( this.spills.get(_nullishCoalesce(this.spilledBy.get(key), () => ( "")))));
-    return record ? this.toSpill(record) : null;
-  }
-  /** Every dynamic array currently spilled. */
-  getSpills() {
-    return Array.from(this.spills.values(), (record) => this.toSpill(record));
-  }
-  /** Whether `range` overlaps a spilled array (its anchor or spilled cells). */
-  intersectsSpill(range) {
-    for (const record of this.spills.values()) {
-      const area = {
-        startRow: record.row,
-        startCol: record.col,
-        endRow: record.row + record.rows - 1,
-        endCol: record.col + record.cols - 1
-      };
-      if (rangesIntersect(area, range)) return true;
-    }
-    return false;
-  }
-  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 = _chunkRIKBJLS2cjs.colNameToIndex.call(void 0, sCol);
-    const endC = _chunkRIKBJLS2cjs.colNameToIndex.call(void 0, 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), _chunkRIKBJLS2cjs.WHOLE_COLUMN_END_ROW, this.document.rows.length);
-    const results = [];
-    for (let c = minC; c <= maxC; c++) {
-      const colName = _chunkRIKBJLS2cjs.indexToColName.call(void 0, 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', _112 => _112.activeCell, 'optionalAccess', _113 => _113.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 merge = extendSelection ? null : this.getMergeAt(clampedRow, clampedCol);
-    const activeRow = merge ? merge.startRow : clampedRow;
-    const activeCol = merge ? merge.startCol : clampedCol;
-    const rowObj = this.document.rows[activeRow];
-    const colObj = this.document.columns[activeCol];
-    this.activeCell = {
-      row: activeRow,
-      col: activeCol,
-      rowId: _optionalChain([rowObj, 'optionalAccess', _114 => _114.id]),
-      colId: _optionalChain([colObj, 'optionalAccess', _115 => _115.id])
-    };
-    if (extendSelection && this.selectedRange) {
-      this.selectedRange = this.expandRangeToMerges({
-        startRow: this.selectedRange.startRow,
-        startCol: this.selectedRange.startCol,
-        endRow: clampedRow,
-        endCol: clampedCol
-      });
-    } else if (merge) {
-      this.selectedRange = { ...merge };
-    } else {
-      this.selectedRange = {
-        startRow: clampedRow,
-        startCol: clampedCol,
-        endRow: clampedRow,
-        endCol: clampedCol
-      };
-    }
-    _optionalChain([this, 'access', _116 => _116.onSelectionChange, 'optionalCall', _117 => _117(this.activeCell, this.selectedRange)]);
-  }
-  selectRange(range) {
-    this.selectedRange = range;
-    _optionalChain([this, 'access', _118 => _118.onSelectionChange, 'optionalCall', _119 => _119(this.activeCell, this.selectedRange)]);
-  }
-  startEditing(row, col, initialValue) {
-    this.selectCell(_nullishCoalesce(_nullishCoalesce(row, () => ( _optionalChain([this, 'access', _120 => _120.activeCell, 'optionalAccess', _121 => _121.row]))), () => ( 0)), _nullishCoalesce(_nullishCoalesce(col, () => ( _optionalChain([this, 'access', _122 => _122.activeCell, 'optionalAccess', _123 => _123.col]))), () => ( 0)));
-    const targetRow = _nullishCoalesce(_optionalChain([this, 'access', _124 => _124.activeCell, 'optionalAccess', _125 => _125.row]), () => ( 0));
-    const targetCol = _nullishCoalesce(_optionalChain([this, 'access', _126 => _126.activeCell, 'optionalAccess', _127 => _127.col]), () => ( 0));
-    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;
-    }
-    const { rowOrder, columnOrder } = this.getViewModel();
-    let nextRow = this.activeCell.row;
-    let nextCol = this.activeCell.col;
-    const merge = extendSelection ? null : this.getMergeAt(nextRow, nextCol);
-    switch (direction) {
-      case "up":
-        nextRow = stepInOrder(rowOrder, merge ? merge.startRow : nextRow, -1);
-        break;
-      case "down":
-        nextRow = stepInOrder(rowOrder, merge ? merge.endRow : nextRow, 1);
-        break;
-      case "left":
-        nextCol = stepInOrder(columnOrder, merge ? merge.startCol : nextCol, -1);
-        break;
-      case "right":
-        nextCol = stepInOrder(columnOrder, merge ? merge.endCol : nextCol, 1);
-        break;
-    }
-    this.selectCell(nextRow, nextCol, extendSelection);
-  }
-  // --- Grid Structure Mutations ---
-  insertColumn(index, config) {
-    this.recordSnapshot();
-    const newId = _optionalChain([config, 'optionalAccess', _128 => _128.id]) || this.generateId("col");
-    const newCol = {
-      id: newId,
-      key: _chunkRIKBJLS2cjs.indexToColName.call(void 0, index),
-      title: _optionalChain([config, 'optionalAccess', _129 => _129.title]) || _chunkRIKBJLS2cjs.indexToColName.call(void 0, index),
-      width: _optionalChain([config, 'optionalAccess', _130 => _130.width]) || 130,
-      type: _optionalChain([config, 'optionalAccess', _131 => _131.type]) || "freeform",
-      binding: _optionalChain([config, 'optionalAccess', _132 => _132.binding]),
-      formula: _optionalChain([config, 'optionalAccess', _133 => _133.formula]),
-      format: _optionalChain([config, 'optionalAccess', _134 => _134.format]) || "text",
-      readOnly: _optionalChain([config, 'optionalAccess', _135 => _135.readOnly])
-    };
-    this.shiftReferences({ axis: "col", index, type: "insert" });
-    this.adjustTableForStructuralChange({ 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.adjustTableForStructuralChange({ 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', _136 => _136.id]) || this.generateId("row");
-    const newRow = {
-      id: newId,
-      index,
-      height: _optionalChain([config, 'optionalAccess', _137 => _137.height]) || 32,
-      recordId: _optionalChain([config, 'optionalAccess', _138 => _138.recordId]),
-      type: _optionalChain([config, 'optionalAccess', _139 => _139.type]) || "freeform"
-    };
-    this.shiftReferences({ axis: "row", index, type: "insert" });
-    this.adjustTableForStructuralChange({ 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.adjustTableForStructuralChange({ 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()}_${(nextIdSequence++).toString(36)}_${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', _140 => _140.raw, 'optionalAccess', _141 => _141.startsWith, 'call', _142 => _142("=")])) {
-          cell.raw = shiftFormulaReferences(cell.raw, change);
-        }
-      }
-    }
-    if (change.axis === "col") {
-      for (const col of this.document.columns) {
-        if (_optionalChain([col, 'access', _143 => _143.formula, 'optionalAccess', _144 => _144.startsWith, 'call', _145 => _145("=")])) {
-          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 = _chunkRIKBJLS2cjs.formatCellDisplay.call(void 0, cell);
-      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) => {
-        return _chunkRIKBJLS2cjs.formatCellDisplay.call(void 0, this.getCell(row.id, col.id)).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.writeMatrix(normalized.split("\n").map((line) => line.split("	")), startRow, startCol);
-  }
-  /** Adds rows/columns at the end until (rowIndex, colIndex) exists. */
-  growGrid(rowIndex, colIndex) {
-    while (rowIndex >= this.document.rows.length) {
-      const index = this.document.rows.length;
-      this.document.rows.push({ id: this.generateId("row"), index, height: 32, type: "freeform" });
-    }
-    while (colIndex >= this.document.columns.length) {
-      const key = _chunkRIKBJLS2cjs.indexToColName.call(void 0, this.document.columns.length);
-      this.document.columns.push({
-        id: this.generateId("col"),
-        key,
-        title: key,
-        width: 130,
-        type: "freeform",
-        format: "text"
-      });
-    }
-  }
-  /**
-   * Writes raw inputs starting at (startRow, startCol), growing the grid as
-   * needed, as a single undo step with one recalculation.
-   */
-  writeMatrix(matrix, startRow, startCol) {
-    if (matrix.length === 0) return;
-    this.runBatch(() => {
-      matrix.forEach((line, rIdx) => {
-        line.forEach((val, cIdx) => {
-          this.growGrid(startRow + rIdx, startCol + cIdx);
-          const row = this.document.rows[startRow + rIdx];
-          this.setCellValue(row.id, this.document.columns[startCol + cIdx].id, val);
-        });
-      });
-    });
-  }
-  /**
-   * Runs `fn` as one undo step: cell writes inside it are batched and
-   * recalculated once, then listeners are notified.
-   */
-  runBatch(fn) {
-    this.recordSnapshot();
-    this.batching = true;
-    this.pendingCommits = [];
-    try {
-      fn();
-    } finally {
-      this.batching = false;
-    }
-    this.recomputeRowIndices();
-    this.recalculateAll();
-    this.document.updatedAt = Date.now();
-    this.notifyChange();
-    const commits = this.pendingCommits;
-    this.pendingCommits = [];
-    for (const [rowId, colId, raw] of commits) {
-      _optionalChain([this, 'access', _146 => _146.onCellCommit, 'optionalCall', _147 => _147(rowId, colId, raw, _optionalChain([this, 'access', _148 => _148.document, 'access', _149 => _149.cells, 'access', _150 => _150[rowId], 'optionalAccess', _151 => _151[colId], 'optionalAccess', _152 => _152.value]))]);
-    }
-  }
-  // --- CSV ---
-  /**
-   * Exports the sheet (or `range`) as RFC 4180 CSV. Values are exported as
-   * displayed unless `formulas` is set.
-   */
-  exportToCsv(options = {}) {
-    const matrix = this.readMatrix(_nullishCoalesce(options.range, () => ( null))).map(
-      (row) => row.map((cell) => options.formulas ? cell.raw : _chunkRIKBJLS2cjs.formatCellDisplay.call(void 0, cell))
-    );
-    return serializeCsv(matrix, {
-      delimiter: options.delimiter,
-      lineEnding: options.lineEnding,
-      bom: options.bom
-    });
-  }
-  /**
-   * Imports CSV text at (startRow, startCol) (default A1), growing the grid
-   * as needed. The whole import is a single undo step.
-   */
-  importFromCsv(csv, options = {}) {
-    const matrix = parseCsv(csv, { delimiter: options.delimiter });
-    this.writeMatrix(matrix, _nullishCoalesce(options.startRow, () => ( 0)), _nullishCoalesce(options.startCol, () => ( 0)));
-  }
-  /**
-   * Writes already-parsed rows of raw inputs (e.g. from an import adapter)
-   * starting at (startRow, startCol), as a single undo step.
-   */
-  importRows(rows, options = {}) {
-    this.writeMatrix(rows, _nullishCoalesce(options.startRow, () => ( 0)), _nullishCoalesce(options.startCol, () => ( 0)));
-  }
-  /** The cells of `range` (or the whole sheet), row by row. */
-  readMatrix(range) {
-    const r = range ? normalizeRange(range) : null;
-    const rows = r ? this.document.rows.slice(r.startRow, r.endRow + 1) : this.document.rows;
-    const columns = r ? this.document.columns.slice(r.startCol, r.endCol + 1) : this.document.columns;
-    return rows.map((row) => columns.map((col) => this.getCell(row.id, col.id)));
-  }
-  // --- Spreadsheet clipboard ---
-  /**
-   * Builds clipboard data for `range` (default: the selection) as TSV,
-   * an HTML table and the lossless internal JSON format. Write every entry
-   * with `clipboardData.setData(type, data)` in a `copy` event.
-   */
-  copyToClipboardData(range = this.selectedRange) {
-    const r = range ? normalizeRange(range) : { startRow: 0, startCol: 0, endRow: this.document.rows.length - 1, endCol: this.document.columns.length - 1 };
-    const cells = this.readMatrix(r).map(
-      (row) => row.map((cell) => {
-        const value = cell.error || cell.value;
-        const text = _chunkRIKBJLS2cjs.formatCellDisplay.call(void 0, cell);
-        if (cell.spillAnchor && !this.spillAnchorInRange(cell.spillAnchor, r)) {
-          return { raw: text, value, text };
-        }
-        return { raw: cell.raw, value, text };
-      })
-    );
-    return createSpreadsheetClipboardData(cells, { row: r.startRow, col: r.startCol });
-  }
-  /**
-   * Pastes clipboard data at `target` (default: the selection's top-left).
-   * Prefers the internal format (formulas re-based to the target), then an
-   * HTML table, then TSV. Returns false when there was nothing to paste.
-   */
-  pasteClipboardData(source, target) {
-    const parsed = readSpreadsheetClipboard(source);
-    if (!parsed) return false;
-    const at = _nullishCoalesce(target, () => ( this.getSelectionTopLeft()));
-    const rows = parsed.origin ? rebaseClipboardRows(parsed.rows, parsed.origin, at) : parsed.rows;
-    this.writeMatrix(rows, at.row, at.col);
-    const r = normalizeRange({
-      startRow: at.row,
-      startCol: at.col,
-      endRow: at.row + rows.length - 1,
-      endCol: at.col + rows.reduce((max, row) => Math.max(max, row.length), 1) - 1
-    });
-    this.selectRange(r);
-    return true;
-  }
-  spillAnchorInRange(anchor, range) {
-    const record = this.spills.get(anchor);
-    return !!record && rangeContains(range, record.row, record.col);
-  }
-  getSelectionTopLeft() {
-    if (this.selectedRange) {
-      const r = normalizeRange(this.selectedRange);
-      return { row: r.startRow, col: r.startCol };
-    }
-    return { row: _nullishCoalesce(_optionalChain([this, 'access', _153 => _153.activeCell, 'optionalAccess', _154 => _154.row]), () => ( 0)), col: _nullishCoalesce(_optionalChain([this, 'access', _155 => _155.activeCell, 'optionalAccess', _156 => _156.col]), () => ( 0)) };
-  }
-  // --- Table operations: shared helpers ---
-  /** The table settings object, created on first use. */
-  get table() {
-    if (!this.document.table) this.document.table = {};
-    return this.document.table;
-  }
-  /** Records an undo step, applies `fn`, then notifies listeners. */
-  applyTableChange(fn, options = {}) {
-    this.recordSnapshot();
-    fn();
-    if (options.recalculate) {
-      this.recomputeRowIndices();
-      this.recalculateAll();
-    }
-    this.document.updatedAt = Date.now();
-    this.notifyChange();
-  }
-  /** First and last (inclusive) body row: rows between header and footer rows. */
-  getBodyRowBounds() {
-    const { headerRows, footerRows } = getTableSections(this.document);
-    return { start: headerRows, end: this.document.rows.length - footerRows - 1 };
-  }
-  __init24() {this.getCellValueAt = (rowIndex, colIndex) => {
-    const row = this.document.rows[rowIndex];
-    const col = this.document.columns[colIndex];
-    if (!row || !col) return "";
-    return this.getCell(row.id, col.id).value;
-  }}
-  /** Rewrites every formula so references follow cells that moved. */
-  remapAllFormulas(moveCell) {
-    for (const rowCells of Object.values(this.document.cells)) {
-      for (const cell of Object.values(rowCells)) {
-        if (_optionalChain([cell, 'access', _157 => _157.raw, 'optionalAccess', _158 => _158.startsWith, 'call', _159 => _159("=")])) {
-          cell.raw = remapFormulaReferences(cell.raw, moveCell);
-        }
-      }
-    }
-  }
-  /**
-   * Keeps merges in place when rows/columns are inserted or deleted:
-   * merges after the change shift, merges across it grow or shrink, and
-   * merges reduced to a single cell are dropped.
-   */
-  adjustTableForStructuralChange(change) {
-    const merges = _optionalChain([this, 'access', _160 => _160.document, 'access', _161 => _161.table, 'optionalAccess', _162 => _162.merges]);
-    if (!_optionalChain([merges, 'optionalAccess', _163 => _163.length])) return;
-    const startKey = change.axis === "row" ? "startRow" : "startCol";
-    const endKey = change.axis === "row" ? "endRow" : "endCol";
-    const next = [];
-    for (const merge of merges) {
-      const m = { ...merge };
-      if (change.type === "insert") {
-        if (m[startKey] >= change.index) m[startKey]++;
-        if (m[endKey] >= change.index) m[endKey]++;
-      } else {
-        if (m[startKey] === change.index && m[endKey] === change.index) continue;
-        if (m[startKey] > change.index) m[startKey]--;
-        if (m[endKey] >= change.index) m[endKey]--;
-      }
-      if (!isSingleCellRange(m)) next.push(m);
-    }
-    this.document.table.merges = next;
-  }
-  // --- Sort ---
-  /**
-   * Sorts rows by one or more columns (stable; numbers before text, blanks
-   * last). Without a range (or with a range spanning every column) whole rows
-   * move; with a range only the cells inside it move. Header and footer rows
-   * never move. References follow the moved cells. Returns false when the
-   * sort is rejected (no valid keys, a key outside the range, or merged
-   * cells in the sorted area).
-   */
-  sortRows(keys, options = {}) {
-    const colCount = this.document.columns.length;
-    const body = this.getBodyRowBounds();
-    const range = options.range ? normalizeRange(options.range) : null;
-    const startRow = Math.max(_nullishCoalesce(_optionalChain([range, 'optionalAccess', _164 => _164.startRow]), () => ( body.start)), body.start);
-    const endRow = Math.min(_nullishCoalesce(_optionalChain([range, 'optionalAccess', _165 => _165.endRow]), () => ( body.end)), body.end);
-    const startCol = range ? Math.max(0, range.startCol) : 0;
-    const endCol = range ? Math.min(colCount - 1, range.endCol) : colCount - 1;
-    if (endRow - startRow < 1 || startCol > endCol) return false;
-    const keyCols = keys.map((key) => ({
-      index: this.document.columns.findIndex((c) => c.id === key.colId),
-      direction: _nullishCoalesce(key.direction, () => ( "asc"))
-    }));
-    if (keyCols.length === 0 || keyCols.some((k) => k.index < startCol || k.index > endCol)) return false;
-    const area = { startRow, startCol, endRow, endCol };
-    if ((_nullishCoalesce(_optionalChain([this, 'access', _166 => _166.document, 'access', _167 => _167.table, 'optionalAccess', _168 => _168.merges]), () => ( []))).some((m) => rangesIntersect(m, area))) return false;
-    if (this.intersectsSpill(area)) return false;
-    const sourceRows = [];
-    for (let r = startRow; r <= endRow; r++) sourceRows.push(r);
-    const sorted = sourceRows.map((r) => ({ r, values: keyCols.map((k) => this.getCellValueAt(r, k.index)) })).sort((a, b) => {
-      for (let i = 0; i < keyCols.length; i++) {
-        const result = compareCellValues(a.values[i], b.values[i], keyCols[i].direction);
-        if (result !== 0) return result;
-      }
-      return a.r - b.r;
-    }).map((entry) => entry.r);
-    if (sorted.every((r, i) => r === sourceRows[i])) return true;
-    const newIndexOf = /* @__PURE__ */ new Map();
-    sorted.forEach((oldRow, i) => newIndexOf.set(oldRow, startRow + i));
-    const wholeRows = startCol === 0 && endCol === colCount - 1;
-    this.applyTableChange(() => {
-      this.remapAllFormulas(({ row, col }) => {
-        const target = newIndexOf.get(row);
-        if (target === void 0 || col < startCol || col > endCol) return null;
-        return { row: target, col };
-      });
-      if (wholeRows) {
-        const moved = sorted.map((r) => this.document.rows[r]);
-        this.document.rows.splice(startRow, moved.length, ...moved);
-      } else {
-        const colIds = this.document.columns.slice(startCol, endCol + 1).map((c) => c.id);
-        const snapshot = sorted.map((oldRow) => {
-          const rowId = this.document.rows[oldRow].id;
-          return colIds.map((colId) => _optionalChain([this, 'access', _169 => _169.document, 'access', _170 => _170.cells, 'access', _171 => _171[rowId], 'optionalAccess', _172 => _172[colId]]));
-        });
-        snapshot.forEach((cells, i) => {
-          const rowId = this.document.rows[startRow + i].id;
-          if (!this.document.cells[rowId]) this.document.cells[rowId] = {};
-          colIds.forEach((colId, c) => {
-            if (cells[c]) this.document.cells[rowId][colId] = cells[c];
-            else delete this.document.cells[rowId][colId];
-          });
-        });
-      }
-    }, { recalculate: true });
-    return true;
-  }
-  // --- Filters ---
-  getFilterState() {
-    return _nullishCoalesce(_optionalChain([this, 'access', _173 => _173.document, 'access', _174 => _174.table, 'optionalAccess', _175 => _175.filter]), () => ( { enabled: false, rules: [] }));
-  }
-  /** Replaces all filter rules (and turns filters on when there are any). */
-  setFilterRules(rules) {
-    this.applyTableChange(() => {
-      this.table.filter = {
-        enabled: rules.length > 0,
-        rules: rules.map((rule) => ({ ...rule, id: _nullishCoalesce(rule.id, () => ( this.generateFilterId())) }))
-      };
-    });
-  }
-  /** Adds a filter rule (AND-combined with the others) and turns filters on. Returns its id. */
-  addFilterRule(rule) {
-    const id = _nullishCoalesce(rule.id, () => ( this.generateFilterId()));
-    this.applyTableChange(() => {
-      const current = this.getFilterState();
-      this.table.filter = { enabled: true, rules: [...current.rules, { ...rule, id }] };
-    });
-    return id;
-  }
-  updateFilterRule(ruleId, changes) {
-    const current = this.getFilterState();
-    if (!current.rules.some((r) => r.id === ruleId)) return;
-    this.applyTableChange(() => {
-      this.table.filter = {
-        ...current,
-        rules: current.rules.map((r) => r.id === ruleId ? { ...r, ...changes } : r)
-      };
-    });
-  }
-  removeFilterRule(ruleId) {
-    const current = this.getFilterState();
-    if (!current.rules.some((r) => r.id === ruleId)) return;
-    this.applyTableChange(() => {
-      this.table.filter = { ...current, rules: current.rules.filter((r) => r.id !== ruleId) };
-    });
-  }
-  clearFilters() {
-    if (this.getFilterState().rules.length === 0) return;
-    this.applyTableChange(() => {
-      this.table.filter = { enabled: false, rules: [] };
-    });
-  }
-  /** Turns filtering on or off, keeping the rules. */
-  setFiltersEnabled(enabled) {
-    const current = this.getFilterState();
-    if (current.enabled === enabled) return;
-    this.applyTableChange(() => {
-      this.table.filter = { ...current, enabled };
-    });
-  }
-  toggleFilters() {
-    this.setFiltersEnabled(!this.getFilterState().enabled);
-  }
-  generateFilterId() {
-    return `filter_${Date.now()}_${(nextIdSequence++).toString(36)}_${Math.random().toString(36).slice(2, 6)}`;
-  }
-  // --- Header, footer and frozen rows/columns ---
-  setHeaderRowCount(count) {
-    this.setTableCount("headerRowCount", count, this.document.rows.length);
-  }
-  setFooterRowCount(count) {
-    this.setTableCount("footerRowCount", count, this.document.rows.length);
-  }
-  setHeaderColumnCount(count) {
-    this.setTableCount("headerColumnCount", count, this.document.columns.length);
-  }
-  /** Keeps the first `count` rows visible while scrolling. 0 unfreezes. */
-  setFrozenRowCount(count) {
-    this.setTableCount("frozenRowCount", count, this.document.rows.length);
-  }
-  /** Keeps the first `count` columns visible while scrolling. 0 unfreezes. */
-  setFrozenColumnCount(count) {
-    this.setTableCount("frozenColumnCount", count, this.document.columns.length);
-  }
-  setTableCount(key, count, max) {
-    const value = Math.max(0, Math.min(Math.floor(count), max));
-    if ((_nullishCoalesce(_optionalChain([this, 'access', _176 => _176.document, 'access', _177 => _177.table, 'optionalAccess', _178 => _178[key]]), () => ( 0))) === value) return;
-    this.applyTableChange(() => {
-      this.table[key] = value;
-    });
-  }
-  // --- Hide / unhide ---
-  hideRows(indices) {
-    this.setHidden("row", indices, true);
-  }
-  unhideRows(indices) {
-    this.setHidden("row", indices, false);
-  }
-  hideColumns(indices) {
-    this.setHidden("col", indices, true);
-  }
-  unhideColumns(indices) {
-    this.setHidden("col", indices, false);
-  }
-  /** Unhides every hidden row and column (filters are unaffected). */
-  unhideAll() {
-    const rows = this.document.rows.flatMap((r, i) => r.hidden ? [i] : []);
-    const cols = this.document.columns.flatMap((c, i) => c.hidden ? [i] : []);
-    if (rows.length === 0 && cols.length === 0) return;
-    this.applyTableChange(() => {
-      rows.forEach((i) => delete this.document.rows[i].hidden);
-      cols.forEach((i) => delete this.document.columns[i].hidden);
-    });
-  }
-  setHidden(axis, indices, hidden) {
-    const items = axis === "row" ? this.document.rows : this.document.columns;
-    const targets = indices.filter((i) => items[i] && !!items[i].hidden !== hidden);
-    if (targets.length === 0) return;
-    this.applyTableChange(() => {
-      for (const i of targets) {
-        if (hidden) items[i].hidden = true;
-        else delete items[i].hidden;
-      }
-    });
-  }
-  // --- Merged cells ---
-  getMerges() {
-    return _nullishCoalesce(_optionalChain([this, 'access', _179 => _179.document, 'access', _180 => _180.table, 'optionalAccess', _181 => _181.merges]), () => ( []));
-  }
-  /** The merge containing (row, col), or null. */
-  getMergeAt(row, col) {
-    return _nullishCoalesce(this.getMerges().find((m) => rangeContains(m, row, col)), () => ( null));
-  }
-  /** Grows `range` until no merge crosses its edge. Keeps the drag direction. */
-  expandRangeToMerges(range) {
-    let r = normalizeRange(range);
-    let changed = true;
-    while (changed) {
-      changed = false;
-      for (const m of this.getMerges()) {
-        if (rangesIntersect(m, r) && !rangeContainsRange(r, m)) {
-          r = {
-            startRow: Math.min(r.startRow, m.startRow),
-            startCol: Math.min(r.startCol, m.startCol),
-            endRow: Math.max(r.endRow, m.endRow),
-            endCol: Math.max(r.endCol, m.endCol)
-          };
-          changed = true;
-        }
-      }
-    }
-    const rowsReversed = range.startRow > range.endRow;
-    const colsReversed = range.startCol > range.endCol;
-    return {
-      startRow: rowsReversed ? r.endRow : r.startRow,
-      endRow: rowsReversed ? r.startRow : r.endRow,
-      startCol: colsReversed ? r.endCol : r.startCol,
-      endCol: colsReversed ? r.startCol : r.endCol
-    };
-  }
-  /**
-   * Merges `range` (default: the selection) into one cell anchored on its
-   * top-left cell; the other cells are cleared. Merges fully inside the range
-   * are absorbed. Returns false for single cells and for ranges that
-   * partially overlap an existing merge.
-   */
-  mergeCells(range = this.selectedRange) {
-    if (!range) return false;
-    const r = normalizeRange(range);
-    if (isSingleCellRange(r) || r.startRow < 0 || r.startCol < 0 || r.endRow >= this.document.rows.length || r.endCol >= this.document.columns.length) {
-      return false;
-    }
-    const merges = this.getMerges();
-    if (merges.some((m) => rangesIntersect(m, r) && !rangeContainsRange(r, m))) return false;
-    if (this.intersectsSpill(r)) return false;
-    this.applyTableChange(() => {
-      for (let row = r.startRow; row <= r.endRow; row++) {
-        const rowId = this.document.rows[row].id;
-        for (let col = r.startCol; col <= r.endCol; col++) {
-          if (row === r.startRow && col === r.startCol) continue;
-           _optionalChainDelete([this, 'access', _182 => _182.document, 'access', _183 => _183.cells, 'access', _184 => _184[rowId], 'optionalAccess', _185 => _185[this.document.columns[col].id]]);
-        }
-      }
-      this.table.merges = [...merges.filter((m) => !rangeContainsRange(r, m)), r];
-    }, { recalculate: true });
-    this.selectCell(r.startRow, r.startCol);
-    return true;
-  }
-  /** Removes every merge intersecting `range` (default: the selection). */
-  unmergeCells(range = this.selectedRange) {
-    if (!range) return false;
-    const merges = this.getMerges();
-    const remaining = merges.filter((m) => !rangesIntersect(m, range));
-    if (remaining.length === merges.length) return false;
-    this.applyTableChange(() => {
-      this.table.merges = remaining;
-    }, { recalculate: true });
-    return true;
-  }
-  // --- Autofill ---
-  /**
-   * Fills `target` from `source` like dragging the fill handle. `target` is
-   * the extended range (source included) and must extend `source` down, up,
-   * right or left. Numbers and dates continue their series, text ending in a
-   * number counts up, other text repeats, and formulas are copied with
-   * their relative references shifted (`$` parts stay). Returns false when
-   * the ranges don't line up.
-   */
-  autofill(source, target) {
-    const s = normalizeRange(source);
-    const t = normalizeRange(target);
-    const direction = getFillDirection(s, t);
-    if (!direction || t.startRow < 0 || t.startCol < 0) return false;
-    if (s.endRow >= this.document.rows.length || s.endCol >= this.document.columns.length) return false;
-    const vertical = direction === "down" || direction === "up";
-    const forward = direction === "down" || direction === "right";
-    const sourceSteps = [];
-    const [sLo, sHi] = vertical ? [s.startRow, s.endRow] : [s.startCol, s.endCol];
-    for (let i = sLo; i <= sHi; i++) sourceSteps.push(i);
-    if (!forward) sourceSteps.reverse();
-    const fillSteps = [];
-    if (forward) for (let i = sHi + 1; i <= (vertical ? t.endRow : t.endCol); i++) fillSteps.push(i);
-    else for (let i = sLo - 1; i >= (vertical ? t.startRow : t.startCol); i--) fillSteps.push(i);
-    const [lLo, lHi] = vertical ? [s.startCol, s.endCol] : [s.startRow, s.endRow];
-    this.runBatch(() => {
-      this.growGrid(vertical ? Math.max(t.endRow, 0) : s.endRow, vertical ? s.endCol : Math.max(t.endCol, 0));
-      for (let line = lLo; line <= lHi; line++) {
-        const at = (step) => vertical ? { row: step, col: line } : { row: line, col: step };
-        const raws = sourceSteps.map((step) => {
-          const p = at(step);
-          return this.getCell(this.document.rows[p.row].id, this.document.columns[p.col].id).raw;
-        });
-        const hasFormula = raws.some((raw) => raw.startsWith("="));
-        const series = hasFormula ? null : fillSeries(raws, fillSteps.length);
-        fillSteps.forEach((step, i) => {
-          const p = at(step);
-          let raw;
-          if (series) {
-            raw = series[i];
-          } else {
-            const from = sourceSteps[i % sourceSteps.length];
-            raw = raws[i % raws.length];
-            if (raw.startsWith("=")) {
-              const delta = step - from;
-              raw = vertical ? offsetFormulaReferences(raw, delta, 0) : offsetFormulaReferences(raw, 0, delta);
-            }
-          }
-          this.setCellValue(this.document.rows[p.row].id, this.document.columns[p.col].id, raw);
-        });
-      }
-    });
-    this.selectRange(t);
-    return true;
-  }
-  // --- Categories (row groups) ---
-  /**
-   * Groups body rows by the value in `colId`, with optional per-group
-   * summaries (e.g. `[{ colId, aggregate: 'sum' }]`).
-   */
-  groupRowsBy(colId, summaries = []) {
-    if (!this.getColumn(colId)) return;
-    this.applyTableChange(() => {
-      this.table.grouping = { colId, summaries, collapsed: [] };
-    });
-  }
-  ungroupRows() {
-    if (!_optionalChain([this, 'access', _186 => _186.document, 'access', _187 => _187.table, 'optionalAccess', _188 => _188.grouping])) return;
-    this.applyTableChange(() => {
-      delete this.table.grouping;
-    });
-  }
-  /** Sets (or with `null`, removes) the group summary for a column. */
-  setGroupSummary(colId, aggregate) {
-    const grouping = _optionalChain([this, 'access', _189 => _189.document, 'access', _190 => _190.table, 'optionalAccess', _191 => _191.grouping]);
-    if (!grouping) return;
-    this.applyTableChange(() => {
-      const others = grouping.summaries.filter((s) => s.colId !== colId);
-      this.table.grouping = {
-        ...grouping,
-        summaries: aggregate ? [...others, { colId, aggregate }] : others
-      };
-    });
-  }
-  setGroupCollapsed(key, collapsed) {
-    const grouping = _optionalChain([this, 'access', _192 => _192.document, 'access', _193 => _193.table, 'optionalAccess', _194 => _194.grouping]);
-    if (!grouping || grouping.collapsed.includes(key) === collapsed) return;
-    this.applyTableChange(() => {
-      this.table.grouping = {
-        ...grouping,
-        collapsed: collapsed ? [...grouping.collapsed, key] : grouping.collapsed.filter((k) => k !== key)
-      };
-    });
-  }
-  toggleGroupCollapsed(key) {
-    const grouping = _optionalChain([this, 'access', _195 => _195.document, 'access', _196 => _196.table, 'optionalAccess', _197 => _197.grouping]);
-    if (!grouping) return;
-    this.setGroupCollapsed(key, !grouping.collapsed.includes(key));
-  }
-  /** The current row groups with their summaries (empty when not grouped). */
-  getGroups() {
-    return computeRowGroups(this.document, this.getCellValueAt);
-  }
-  // --- Transpose ---
-  /**
-   * Transposes `range` (default: the selection) in place around its top-left
-   * cell: rows become columns. Cells left uncovered are cleared, the grid
-   * grows if needed, and references follow the moved cells. Returns false
-   * for single cells or when merged cells are involved.
-   */
-  transposeRange(range = this.selectedRange) {
-    if (!range) return false;
-    const s = normalizeRange(range);
-    if (isSingleCellRange(s)) return false;
-    const height = s.endRow - s.startRow + 1;
-    const width = s.endCol - s.startCol + 1;
-    const t = { startRow: s.startRow, startCol: s.startCol, endRow: s.startRow + width - 1, endCol: s.startCol + height - 1 };
-    if (this.getMerges().some((m) => rangesIntersect(m, s) || rangesIntersect(m, t))) return false;
-    if (this.intersectsSpill(s) || this.intersectsSpill(t)) return false;
-    this.applyTableChange(() => {
-      this.growGrid(t.endRow, t.endCol);
-      this.remapAllFormulas(({ row, col }) => {
-        if (!rangeContains(s, row, col)) return null;
-        return { row: s.startRow + (col - s.startCol), col: s.startCol + (row - s.startRow) };
-      });
-      const rowId = (r) => this.document.rows[r].id;
-      const colId = (c) => this.document.columns[c].id;
-      const moved = [];
-      for (let r = s.startRow; r <= s.endRow; r++) {
-        for (let c = s.startCol; c <= s.endCol; c++) {
-          moved.push({
-            row: s.startRow + (c - s.startCol),
-            col: s.startCol + (r - s.startRow),
-            cell: _optionalChain([this, 'access', _198 => _198.document, 'access', _199 => _199.cells, 'access', _200 => _200[rowId(r)], 'optionalAccess', _201 => _201[colId(c)]])
-          });
-           _optionalChainDelete([this, 'access', _202 => _202.document, 'access', _203 => _203.cells, 'access', _204 => _204[rowId(r)], 'optionalAccess', _205 => _205[colId(c)]]);
-        }
-      }
-      for (const { row, col, cell } of moved) {
-        if (!cell) continue;
-        if (!this.document.cells[rowId(row)]) this.document.cells[rowId(row)] = {};
-        this.document.cells[rowId(row)][colId(col)] = cell;
-      }
-    }, { recalculate: true });
-    this.selectRange(t);
-    return true;
-  }
-  // --- View model ---
-  /**
-   * What to render: visible rows (with group headers) and columns in display
-   * order, frozen offsets and merged-cell spans. Filters, hidden rows/columns
-   * and collapsed groups only affect this view, never the document.
-   */
-  getViewModel() {
-    return buildSpreadsheetView(this.document, this.getCellValueAt);
-  }
-  // --- 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 = [];
-    this.trimHistory();
-  }
-  /** Drops the oldest snapshots beyond `maxHistoryBytes`, always keeping the newest. */
-  trimHistory() {
-    if (this.maxHistoryBytes <= 0 || this.undoStack.length <= 1) return;
-    let total = 0;
-    for (const s of this.undoStack) total += s.length * 2;
-    for (const s of this.redoStack) total += s.length * 2;
-    while (total > this.maxHistoryBytes && this.undoStack.length > 1) {
-      total -= this.undoStack.shift().length * 2;
-    }
-  }
-  /** Approximate bytes held by the undo/redo snapshots (UTF-16 size). */
-  getHistoryByteSize() {
-    let total = 0;
-    for (const s of this.undoStack) total += s.length * 2;
-    for (const s of this.redoStack) total += s.length * 2;
-    return total;
-  }
-  /** Number of undo / redo snapshots currently held. */
-  getHistoryDepth() {
-    return { undo: this.undoStack.length, redo: this.redoStack.length };
-  }
-  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', _206 => _206.onDocumentChange, 'optionalCall', _207 => _207(this.document)]);
-  }
-}, _class3);
-function stepInOrder(order, from, delta) {
-  if (order.length === 0) return from;
-  const pos = order.indexOf(from);
-  if (pos === -1) {
-    const candidates = order.filter((i) => delta > 0 ? i > from : i < from);
-    if (candidates.length === 0) return from;
-    return candidates.reduce((best, i) => delta > 0 ? Math.min(best, i) : Math.max(best, i));
-  }
-  return order[Math.max(0, Math.min(order.length - 1, pos + delta))];
-}
-
-// src/spreadsheet/menu.ts
-function clampMenuPosition(point, size, viewport, margin = 4) {
-  const place = (start, length, limit) => {
-    if (start + length <= limit - margin) return Math.max(margin, start);
-    const flipped = start - length;
-    return Math.max(margin, flipped >= margin ? flipped : limit - margin - length);
-  };
-  return {
-    x: place(point.x, size.width, viewport.width),
-    y: place(point.y, size.height, viewport.height)
-  };
-}
-var quote = (value) => {
-  const text = String(_nullishCoalesce(value, () => ( "")));
-  return text.length > 24 ? `"${text.slice(0, 23)}\u2026"` : `"${text}"`;
-};
-function getSpreadsheetMenuItems(controller, cell) {
-  const doc = controller.document;
-  const column = doc.columns[cell.col];
-  const row = doc.rows[cell.row];
-  if (!column || !row) return [];
-  const selection = controller.selectedRange && rangeContains(controller.selectedRange, cell.row, cell.col) ? normalizeRange(controller.selectedRange) : { startRow: cell.row, startCol: cell.col, endRow: cell.row, endCol: cell.col };
-  const colName = _chunkRIKBJLS2cjs.indexToColName.call(void 0, cell.col);
-  const cellData = controller.getCell(row.id, column.id);
-  const value = cellData.value;
-  const table = _nullishCoalesce(doc.table, () => ( {}));
-  const filter = controller.getFilterState();
-  const grouping = table.grouping;
-  const rows = Array.from({ length: selection.endRow - selection.startRow + 1 }, (_, i) => selection.startRow + i);
-  const cols = Array.from({ length: selection.endCol - selection.startCol + 1 }, (_, i) => selection.startCol + i);
-  const anyHidden = doc.rows.some((r) => r.hidden) || doc.columns.some((c) => c.hidden);
-  const hasMerge = controller.getMerges().some((m) => rangesIntersect(m, selection));
-  const sortRange = isSingleCellRange(selection) ? null : selection;
-  const items = [
-    {
-      id: "sort-asc",
-      label: `Sort ascending by column ${colName}`,
-      run: () => controller.sortRows([{ colId: column.id, direction: "asc" }], { range: sortRange })
-    },
-    {
-      id: "sort-desc",
-      label: `Sort descending by column ${colName}`,
-      run: () => controller.sortRows([{ colId: column.id, direction: "desc" }], { range: sortRange })
-    },
-    {
-      id: "filter-equals",
-      label: `Show only rows where ${colName} = ${quote(_chunkRIKBJLS2cjs.formatCellDisplay.call(void 0, cellData))}`,
-      separatorBefore: true,
-      run: () => controller.addFilterRule({ colId: column.id, operator: "equals", value: String(_nullishCoalesce(value, () => ( ""))) })
-    },
-    {
-      id: "filter-toggle",
-      label: filter.enabled ? "Turn filters off" : "Turn filters on",
-      disabled: filter.rules.length === 0,
-      run: () => controller.toggleFilters()
-    },
-    {
-      id: "filter-clear",
-      label: "Clear filters",
-      disabled: filter.rules.length === 0,
-      run: () => controller.clearFilters()
-    },
-    {
-      id: "freeze-rows",
-      label: `Freeze rows 1\u2013${cell.row + 1}`,
-      separatorBefore: true,
-      run: () => controller.setFrozenRowCount(cell.row + 1)
-    },
-    {
-      id: "freeze-columns",
-      label: `Freeze columns A\u2013${colName}`,
-      run: () => controller.setFrozenColumnCount(cell.col + 1)
-    },
-    {
-      id: "unfreeze",
-      label: "Unfreeze rows and columns",
-      disabled: !table.frozenRowCount && !table.frozenColumnCount,
-      run: () => {
-        controller.setFrozenRowCount(0);
-        controller.setFrozenColumnCount(0);
-      }
-    },
-    {
-      id: "header-rows",
-      label: `Use rows 1\u2013${cell.row + 1} as header rows`,
-      run: () => controller.setHeaderRowCount(cell.row + 1)
-    },
-    {
-      id: "footer-rows",
-      label: `Use rows ${cell.row + 1}\u2013${doc.rows.length} as footer rows`,
-      run: () => controller.setFooterRowCount(doc.rows.length - cell.row)
-    },
-    {
-      id: "hide-rows",
-      label: rows.length > 1 ? `Hide ${rows.length} rows` : `Hide row ${cell.row + 1}`,
-      separatorBefore: true,
-      run: () => controller.hideRows(rows)
-    },
-    {
-      id: "hide-columns",
-      label: cols.length > 1 ? `Hide ${cols.length} columns` : `Hide column ${colName}`,
-      run: () => controller.hideColumns(cols)
-    },
-    {
-      id: "unhide-all",
-      label: "Unhide all rows and columns",
-      disabled: !anyHidden,
-      run: () => controller.unhideAll()
-    },
-    {
-      id: "merge",
-      label: "Merge cells",
-      separatorBefore: true,
-      disabled: isSingleCellRange(selection),
-      run: () => {
-        controller.mergeCells(selection);
-      }
-    },
-    {
-      id: "unmerge",
-      label: "Unmerge cells",
-      disabled: !hasMerge,
-      run: () => {
-        controller.unmergeCells(selection);
-      }
-    },
-    {
-      id: "transpose",
-      label: "Transpose",
-      disabled: isSingleCellRange(selection),
-      run: () => {
-        controller.transposeRange(selection);
-      }
-    }
-  ];
-  if (grouping) {
-    items.push(
-      {
-        id: "ungroup",
-        label: "Remove categories",
-        separatorBefore: true,
-        run: () => controller.ungroupRows()
-      },
-      ...["sum", "count", "average"].map((aggregate) => ({
-        id: `summary-${aggregate}`,
-        label: `Summarize column ${colName}: ${aggregate.toUpperCase()}`,
-        run: () => controller.setGroupSummary(column.id, aggregate)
-      }))
-    );
-  } else {
-    items.push({
-      id: "group-by",
-      label: `Categorize by column ${colName}`,
-      separatorBefore: true,
-      run: () => controller.groupRowsBy(column.id)
-    });
-  }
-  return items;
-}
-
-// src/spreadsheet/actions.ts
-var SPREADSHEET_TABLE_ACTIONS = [
-  "sortRows",
-  "getFilterState",
-  "setFilterRules",
-  "addFilterRule",
-  "updateFilterRule",
-  "removeFilterRule",
-  "clearFilters",
-  "setFiltersEnabled",
-  "toggleFilters",
-  "setHeaderRowCount",
-  "setFooterRowCount",
-  "setHeaderColumnCount",
-  "setFrozenRowCount",
-  "setFrozenColumnCount",
-  "hideRows",
-  "unhideRows",
-  "hideColumns",
-  "unhideColumns",
-  "unhideAll",
-  "getMerges",
-  "getMergeAt",
-  "mergeCells",
-  "unmergeCells",
-  "autofill",
-  "groupRowsBy",
-  "ungroupRows",
-  "setGroupSummary",
-  "setGroupCollapsed",
-  "toggleGroupCollapsed",
-  "getGroups",
-  "transposeRange",
-  "exportToCsv",
-  "importFromCsv",
-  "copyToClipboardData",
-  "pasteClipboardData"
-];
-function bindSpreadsheetTableActions(controller) {
-  const actions = {};
-  for (const name of SPREADSHEET_TABLE_ACTIONS) {
-    actions[name] = controller[name].bind(controller);
-  }
-  return actions;
-}
-
-// src/spreadsheet/import.ts
-function delimitedAdapter(id, label, delimiter, mimeTypes, extensions) {
-  return {
-    id,
-    label,
-    mimeTypes,
-    extensions,
-    target: "spreadsheet",
-    async import(_input, context) {
-      return { rows: parseCsv(await context.readText(), { delimiter }), delimiter };
-    }
-  };
-}
-var csvImportAdapter = delimitedAdapter(
-  "csv",
-  "CSV",
-  ",",
-  ["text/csv", "application/csv", "text/comma-separated-values"],
-  [".csv"]
-);
-var tsvImportAdapter = delimitedAdapter(
-  "tsv",
-  "Tab-separated values",
-  "	",
-  ["text/tab-separated-values"],
-  [".tsv", ".tab"]
-);
-var SPREADSHEET_IMPORT_ADAPTERS = [
-  csvImportAdapter,
-  tsvImportAdapter
-];
-function registerSpreadsheetImportAdapters(registry) {
-  const unregisters = SPREADSHEET_IMPORT_ADAPTERS.map(
-    (adapter) => registry.register(adapter, { replace: true })
-  );
-  return () => unregisters.forEach((unregister) => unregister());
-}
-async function importFileIntoSpreadsheet(controller, input, options) {
-  const { registry, startRow, startCol, ...rest } = options;
-  const outcome = await registry.importFile(input, { ...rest, target: "spreadsheet" });
-  controller.importRows(outcome.result.rows, { startRow, startCol });
-  return outcome;
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-exports.columnDependencyKey = columnDependencyKey; exports.extractCellDependencies = extractCellDependencies; exports.DependencyGraph = DependencyGraph; exports.shiftFormulaReferences = shiftFormulaReferences; exports.mapFormulaReferences = mapFormulaReferences; exports.offsetFormulaReferences = offsetFormulaReferences; exports.remapFormulaReferences = remapFormulaReferences; exports.getFormulaCaretContext = getFormulaCaretContext; exports.getFormulaHints = getFormulaHints; exports.applyFormulaSuggestion = applyFormulaSuggestion; exports.DataSourceBinder = DataSourceBinder; exports.normalizeRange = normalizeRange; exports.rangeContains = rangeContains; exports.rangesIntersect = rangesIntersect; exports.rangeContainsRange = rangeContainsRange; exports.isSingleCellRange = isSingleCellRange; exports.isBlankValue = isBlankValue; exports.toNumber = toNumber; exports.compareCellValues = compareCellValues; exports.matchesFilterRule = matchesFilterRule; exports.aggregateValues = aggregateValues; exports.roundFloat = roundFloat; exports.fillSeries = fillSeries; exports.computeFillTarget = computeFillTarget; exports.getFillDirection = getFillDirection; exports.parseCsv = parseCsv; exports.escapeCsvField = escapeCsvField; exports.serializeCsv = serializeCsv; exports.parseTsv = parseTsv; exports.serializeTsv = serializeTsv; exports.SPREADSHEET_CLIPBOARD_MIME = SPREADSHEET_CLIPBOARD_MIME; exports.serializeHtmlTable = serializeHtmlTable; exports.parseHtmlTable = parseHtmlTable; exports.createSpreadsheetClipboardData = createSpreadsheetClipboardData; exports.readSpreadsheetClipboard = readSpreadsheetClipboard; exports.rebaseClipboardRows = rebaseClipboardRows; exports.DEFAULT_ROW_HEIGHT = DEFAULT_ROW_HEIGHT; exports.DEFAULT_COLUMN_WIDTH = DEFAULT_COLUMN_WIDTH; exports.getTableSections = getTableSections; exports.getRowSection = getRowSection; exports.rowPassesFilters = rowPassesFilters; exports.computeRowGroups = computeRowGroups; exports.buildSpreadsheetView = buildSpreadsheetView; exports.SpreadsheetController = SpreadsheetController; exports.clampMenuPosition = clampMenuPosition; exports.getSpreadsheetMenuItems = getSpreadsheetMenuItems; exports.SPREADSHEET_TABLE_ACTIONS = SPREADSHEET_TABLE_ACTIONS; exports.bindSpreadsheetTableActions = bindSpreadsheetTableActions; exports.csvImportAdapter = csvImportAdapter; exports.tsvImportAdapter = tsvImportAdapter; exports.SPREADSHEET_IMPORT_ADAPTERS = SPREADSHEET_IMPORT_ADAPTERS; exports.registerSpreadsheetImportAdapters = registerSpreadsheetImportAdapters; exports.importFileIntoSpreadsheet = importFileIntoSpreadsheet;
-//# sourceMappingURL=chunk-XDMXXC4Z.cjs.map