@particle-academy/fancy-sheets 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1646 @@
+'use strict';
+
+var react = require('react');
+var reactFancy = require('@particle-academy/react-fancy');
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/components/Spreadsheet/Spreadsheet.tsx
+var SpreadsheetContext = react.createContext(null);
+function useSpreadsheet() {
+  const ctx = react.useContext(SpreadsheetContext);
+  if (!ctx) {
+    throw new Error("useSpreadsheet must be used within a <Spreadsheet> component");
+  }
+  return ctx;
+}
+
+// src/types/sheet.ts
+function createEmptySheet(id, name) {
+  return {
+    id,
+    name,
+    cells: {},
+    columnWidths: {},
+    mergedRegions: [],
+    columnFilters: {},
+    frozenRows: 0,
+    frozenCols: 0
+  };
+}
+function createEmptyWorkbook() {
+  const sheet = createEmptySheet("sheet-1", "Sheet 1");
+  return {
+    sheets: [sheet],
+    activeSheetId: sheet.id
+  };
+}
+
+// src/engine/cell-utils.ts
+function columnToLetter(col) {
+  let result = "";
+  let c = col;
+  while (c >= 0) {
+    result = String.fromCharCode(c % 26 + 65) + result;
+    c = Math.floor(c / 26) - 1;
+  }
+  return result;
+}
+function letterToColumn(letters) {
+  let result = 0;
+  for (let i = 0; i < letters.length; i++) {
+    result = result * 26 + (letters.charCodeAt(i) - 64);
+  }
+  return result - 1;
+}
+function parseAddress(addr) {
+  const match = addr.match(/^([A-Z]+)(\d+)$/);
+  if (!match) return { row: 0, col: 0 };
+  return {
+    col: letterToColumn(match[1]),
+    row: parseInt(match[2], 10) - 1
+  };
+}
+function toAddress(row, col) {
+  return columnToLetter(col) + (row + 1);
+}
+function expandRange(startAddr, endAddr) {
+  const s = parseAddress(startAddr);
+  const e = parseAddress(endAddr);
+  const minRow = Math.min(s.row, e.row);
+  const maxRow = Math.max(s.row, e.row);
+  const minCol = Math.min(s.col, e.col);
+  const maxCol = Math.max(s.col, e.col);
+  const addresses = [];
+  for (let r = minRow; r <= maxRow; r++) {
+    for (let c = minCol; c <= maxCol; c++) {
+      addresses.push(toAddress(r, c));
+    }
+  }
+  return addresses;
+}
+function normalizeRange(startAddr, endAddr) {
+  const s = parseAddress(startAddr);
+  const e = parseAddress(endAddr);
+  return {
+    start: toAddress(Math.min(s.row, e.row), Math.min(s.col, e.col)),
+    end: toAddress(Math.max(s.row, e.row), Math.max(s.col, e.col))
+  };
+}
+
+// src/engine/formula/lexer.ts
+function lexFormula(input) {
+  const tokens = [];
+  const len = input.length;
+  let i = 0;
+  while (i < len) {
+    const ch = input[i];
+    if (ch === " " || ch === "	") {
+      i++;
+      continue;
+    }
+    if (ch >= "0" && ch <= "9" || ch === "." && i + 1 < len && input[i + 1] >= "0" && input[i + 1] <= "9") {
+      const pos = i;
+      while (i < len && (input[i] >= "0" && input[i] <= "9" || input[i] === ".")) i++;
+      if (i < len && (input[i] === "e" || input[i] === "E")) {
+        i++;
+        if (i < len && (input[i] === "+" || input[i] === "-")) i++;
+        while (i < len && input[i] >= "0" && input[i] <= "9") i++;
+      }
+      tokens.push({ type: "number", value: input.slice(pos, i), position: pos });
+      continue;
+    }
+    if (ch === '"') {
+      const pos = i;
+      i++;
+      while (i < len && input[i] !== '"') {
+        if (input[i] === "\\") i++;
+        i++;
+      }
+      i++;
+      tokens.push({ type: "string", value: input.slice(pos + 1, i - 1), position: pos });
+      continue;
+    }
+    if (ch >= "A" && ch <= "Z" || ch >= "a" && ch <= "z" || ch === "_") {
+      const pos = i;
+      i++;
+      while (i < len && (input[i] >= "A" && input[i] <= "Z" || input[i] >= "a" && input[i] <= "z" || input[i] >= "0" && input[i] <= "9" || input[i] === "_")) i++;
+      const word = input.slice(pos, i);
+      if (word.toUpperCase() === "TRUE" || word.toUpperCase() === "FALSE") {
+        tokens.push({ type: "boolean", value: word.toUpperCase(), position: pos });
+        continue;
+      }
+      if (i < len && input[i] === ":") {
+        const colonPos = i;
+        i++;
+        const rangeStart = i;
+        while (i < len && (input[i] >= "A" && input[i] <= "Z" || input[i] >= "a" && input[i] <= "z" || input[i] >= "0" && input[i] <= "9")) i++;
+        if (i > rangeStart) {
+          tokens.push({ type: "rangeRef", value: word + ":" + input.slice(rangeStart, i), position: pos });
+          continue;
+        }
+        i = colonPos;
+      }
+      let j = i;
+      while (j < len && input[j] === " ") j++;
+      if (j < len && input[j] === "(") {
+        tokens.push({ type: "function", value: word.toUpperCase(), position: pos });
+        continue;
+      }
+      if (/^[A-Z]+\d+$/i.test(word)) {
+        tokens.push({ type: "cellRef", value: word.toUpperCase(), position: pos });
+        continue;
+      }
+      tokens.push({ type: "cellRef", value: word.toUpperCase(), position: pos });
+      continue;
+    }
+    if (ch === "+" || ch === "-" || ch === "*" || ch === "/" || ch === "^" || ch === "&") {
+      tokens.push({ type: "operator", value: ch, position: i });
+      i++;
+      continue;
+    }
+    if (ch === "=" || ch === "<" || ch === ">") {
+      const pos = i;
+      i++;
+      if (i < len && (input[i] === "=" || input[i] === ">")) i++;
+      tokens.push({ type: "operator", value: input.slice(pos, i), position: pos });
+      continue;
+    }
+    if (ch === "(" || ch === ")") {
+      tokens.push({ type: "paren", value: ch, position: i });
+      i++;
+      continue;
+    }
+    if (ch === ",") {
+      tokens.push({ type: "comma", value: ",", position: i });
+      i++;
+      continue;
+    }
+    i++;
+  }
+  return tokens;
+}
+
+// src/engine/formula/parser.ts
+function parseFormula(tokens) {
+  let pos = 0;
+  function peek() {
+    return tokens[pos];
+  }
+  function advance() {
+    return tokens[pos++];
+  }
+  function expect(type, value) {
+    const t = advance();
+    if (!t || t.type !== type || value !== void 0 && t.value !== value) {
+      throw new Error(`Expected ${type}${value ? ` '${value}'` : ""} at position ${t?.position ?? pos}`);
+    }
+    return t;
+  }
+  function parseExpression() {
+    return parseComparison();
+  }
+  function parseComparison() {
+    let left = parseConcatenation();
+    while (peek() && peek().type === "operator" && ["=", "<>", "<", ">", "<=", ">="].includes(peek().value)) {
+      const op = advance().value;
+      const right = parseConcatenation();
+      left = { type: "binaryOp", operator: op, left, right };
+    }
+    return left;
+  }
+  function parseConcatenation() {
+    let left = parseAddition();
+    while (peek() && peek().type === "operator" && peek().value === "&") {
+      advance();
+      const right = parseAddition();
+      left = { type: "binaryOp", operator: "&", left, right };
+    }
+    return left;
+  }
+  function parseAddition() {
+    let left = parseMultiplication();
+    while (peek() && peek().type === "operator" && (peek().value === "+" || peek().value === "-")) {
+      const op = advance().value;
+      const right = parseMultiplication();
+      left = { type: "binaryOp", operator: op, left, right };
+    }
+    return left;
+  }
+  function parseMultiplication() {
+    let left = parseExponentiation();
+    while (peek() && peek().type === "operator" && (peek().value === "*" || peek().value === "/")) {
+      const op = advance().value;
+      const right = parseExponentiation();
+      left = { type: "binaryOp", operator: op, left, right };
+    }
+    return left;
+  }
+  function parseExponentiation() {
+    let left = parseUnary();
+    while (peek() && peek().type === "operator" && peek().value === "^") {
+      advance();
+      const right = parseUnary();
+      left = { type: "binaryOp", operator: "^", left, right };
+    }
+    return left;
+  }
+  function parseUnary() {
+    if (peek() && peek().type === "operator" && (peek().value === "-" || peek().value === "+")) {
+      const op = advance().value;
+      const operand = parseUnary();
+      return { type: "unaryOp", operator: op, operand };
+    }
+    return parseAtom();
+  }
+  function parseAtom() {
+    const t = peek();
+    if (!t) throw new Error("Unexpected end of formula");
+    if (t.type === "number") {
+      advance();
+      return { type: "number", value: parseFloat(t.value) };
+    }
+    if (t.type === "string") {
+      advance();
+      return { type: "string", value: t.value };
+    }
+    if (t.type === "boolean") {
+      advance();
+      return { type: "boolean", value: t.value === "TRUE" };
+    }
+    if (t.type === "rangeRef") {
+      advance();
+      const parts = t.value.split(":");
+      return { type: "rangeRef", start: parts[0], end: parts[1] };
+    }
+    if (t.type === "function") {
+      const name = advance().value;
+      expect("paren", "(");
+      const args = [];
+      if (peek() && !(peek().type === "paren" && peek().value === ")")) {
+        args.push(parseExpression());
+        while (peek() && peek().type === "comma") {
+          advance();
+          args.push(parseExpression());
+        }
+      }
+      expect("paren", ")");
+      return { type: "functionCall", name, args };
+    }
+    if (t.type === "cellRef") {
+      advance();
+      return { type: "cellRef", address: t.value };
+    }
+    if (t.type === "paren" && t.value === "(") {
+      advance();
+      const expr = parseExpression();
+      expect("paren", ")");
+      return expr;
+    }
+    throw new Error(`Unexpected token '${t.value}' at position ${t.position}`);
+  }
+  const ast = parseExpression();
+  return ast;
+}
+
+// src/engine/formula/functions/registry.ts
+var functionRegistry = /* @__PURE__ */ new Map();
+function registerFunction(name, fn) {
+  functionRegistry.set(name.toUpperCase(), { fn });
+}
+function getFunction(name) {
+  return functionRegistry.get(name.toUpperCase());
+}
+
+// src/engine/formula/functions/math.ts
+function toNumbers(args) {
+  const nums = [];
+  for (const group of args) {
+    for (const v of group) {
+      if (typeof v === "number") nums.push(v);
+      else if (typeof v === "string" && v !== "" && !isNaN(Number(v))) nums.push(Number(v));
+    }
+  }
+  return nums;
+}
+registerFunction("SUM", (args) => {
+  return toNumbers(args).reduce((a, b) => a + b, 0);
+});
+registerFunction("AVERAGE", (args) => {
+  const nums = toNumbers(args);
+  if (nums.length === 0) return 0;
+  return nums.reduce((a, b) => a + b, 0) / nums.length;
+});
+registerFunction("MIN", (args) => {
+  const nums = toNumbers(args);
+  if (nums.length === 0) return 0;
+  return Math.min(...nums);
+});
+registerFunction("MAX", (args) => {
+  const nums = toNumbers(args);
+  if (nums.length === 0) return 0;
+  return Math.max(...nums);
+});
+registerFunction("COUNT", (args) => {
+  return toNumbers(args).length;
+});
+registerFunction("ROUND", (args) => {
+  const flat = args.flat();
+  const num = typeof flat[0] === "number" ? flat[0] : Number(flat[0]);
+  const decimals = typeof flat[1] === "number" ? flat[1] : flat[1] != null ? Number(flat[1]) : 0;
+  if (isNaN(num)) return "#VALUE!";
+  return Math.round(num * Math.pow(10, decimals)) / Math.pow(10, decimals);
+});
+registerFunction("ABS", (args) => {
+  const val = args.flat()[0];
+  const num = typeof val === "number" ? val : Number(val);
+  if (isNaN(num)) return "#VALUE!";
+  return Math.abs(num);
+});
+
+// src/engine/formula/functions/text.ts
+registerFunction("UPPER", (args) => {
+  const val = args.flat()[0];
+  return val != null ? String(val).toUpperCase() : "";
+});
+registerFunction("LOWER", (args) => {
+  const val = args.flat()[0];
+  return val != null ? String(val).toLowerCase() : "";
+});
+registerFunction("LEN", (args) => {
+  const val = args.flat()[0];
+  return val != null ? String(val).length : 0;
+});
+registerFunction("TRIM", (args) => {
+  const val = args.flat()[0];
+  return val != null ? String(val).trim() : "";
+});
+registerFunction("CONCAT", (args) => {
+  return args.flat().map((v) => v != null ? String(v) : "").join("");
+});
+
+// src/engine/formula/functions/logic.ts
+function toBool(v) {
+  if (typeof v === "boolean") return v;
+  if (typeof v === "number") return v !== 0;
+  if (typeof v === "string") return v.toUpperCase() === "TRUE";
+  return false;
+}
+registerFunction("IF", (args) => {
+  const flat = args.flat();
+  const condition = toBool(flat[0]);
+  const trueVal = flat[1] ?? true;
+  const falseVal = flat[2] ?? false;
+  return condition ? trueVal : falseVal;
+});
+registerFunction("AND", (args) => {
+  return args.flat().every(toBool);
+});
+registerFunction("OR", (args) => {
+  return args.flat().some(toBool);
+});
+registerFunction("NOT", (args) => {
+  return !toBool(args.flat()[0]);
+});
+
+// src/engine/formula/evaluator.ts
+function evaluateAST(node, getCellValue, getRangeValues) {
+  switch (node.type) {
+    case "number":
+      return node.value;
+    case "string":
+      return node.value;
+    case "boolean":
+      return node.value;
+    case "cellRef":
+      return getCellValue(node.address);
+    case "rangeRef":
+      const vals = getRangeValues(node.start, node.end);
+      return vals[0] ?? null;
+    case "functionCall": {
+      const entry = getFunction(node.name);
+      if (!entry) return `#NAME?`;
+      const argValues = node.args.map((arg) => {
+        if (arg.type === "rangeRef") {
+          return getRangeValues(arg.start, arg.end);
+        }
+        const val = evaluateAST(arg, getCellValue, getRangeValues);
+        return [val];
+      });
+      try {
+        return entry.fn(argValues);
+      } catch {
+        return "#ERROR!";
+      }
+    }
+    case "binaryOp": {
+      const left = evaluateAST(node.left, getCellValue, getRangeValues);
+      const right = evaluateAST(node.right, getCellValue, getRangeValues);
+      const lNum = typeof left === "number" ? left : Number(left);
+      const rNum = typeof right === "number" ? right : Number(right);
+      switch (node.operator) {
+        case "+":
+          return isNaN(lNum) || isNaN(rNum) ? "#VALUE!" : lNum + rNum;
+        case "-":
+          return isNaN(lNum) || isNaN(rNum) ? "#VALUE!" : lNum - rNum;
+        case "*":
+          return isNaN(lNum) || isNaN(rNum) ? "#VALUE!" : lNum * rNum;
+        case "/":
+          return rNum === 0 ? "#DIV/0!" : isNaN(lNum) || isNaN(rNum) ? "#VALUE!" : lNum / rNum;
+        case "^":
+          return isNaN(lNum) || isNaN(rNum) ? "#VALUE!" : Math.pow(lNum, rNum);
+        case "&":
+          return String(left ?? "") + String(right ?? "");
+        case "=":
+          return left === right;
+        case "<>":
+          return left !== right;
+        case "<":
+          return lNum < rNum;
+        case ">":
+          return lNum > rNum;
+        case "<=":
+          return lNum <= rNum;
+        case ">=":
+          return lNum >= rNum;
+        default:
+          return "#ERROR!";
+      }
+    }
+    case "unaryOp": {
+      const operand = evaluateAST(node.operand, getCellValue, getRangeValues);
+      const num = typeof operand === "number" ? operand : Number(operand);
+      if (isNaN(num)) return "#VALUE!";
+      return node.operator === "-" ? -num : num;
+    }
+    default:
+      return "#ERROR!";
+  }
+}
+
+// src/engine/formula/references.ts
+function extractReferences(node) {
+  const refs = [];
+  function walk(n) {
+    switch (n.type) {
+      case "cellRef":
+        refs.push(n.address);
+        break;
+      case "rangeRef": {
+        const s = parseAddress(n.start);
+        const e = parseAddress(n.end);
+        const minRow = Math.min(s.row, e.row);
+        const maxRow = Math.max(s.row, e.row);
+        const minCol = Math.min(s.col, e.col);
+        const maxCol = Math.max(s.col, e.col);
+        for (let r = minRow; r <= maxRow; r++) {
+          for (let c = minCol; c <= maxCol; c++) {
+            refs.push(toAddress(r, c));
+          }
+        }
+        break;
+      }
+      case "functionCall":
+        n.args.forEach(walk);
+        break;
+      case "binaryOp":
+        walk(n.left);
+        walk(n.right);
+        break;
+      case "unaryOp":
+        walk(n.operand);
+        break;
+    }
+  }
+  walk(node);
+  return refs;
+}
+
+// src/engine/formula/dependency-graph.ts
+function buildDependencyGraph(cells) {
+  const graph = /* @__PURE__ */ new Map();
+  for (const [addr, cell] of Object.entries(cells)) {
+    if (!cell.formula) continue;
+    try {
+      const tokens = lexFormula(cell.formula);
+      const ast = parseFormula(tokens);
+      const refs = extractReferences(ast);
+      graph.set(addr, new Set(refs));
+    } catch {
+      graph.set(addr, /* @__PURE__ */ new Set());
+    }
+  }
+  return graph;
+}
+function detectCircularRefs(graph) {
+  const circular = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const inStack = /* @__PURE__ */ new Set();
+  function dfs(node) {
+    if (inStack.has(node)) return true;
+    if (visited.has(node)) return false;
+    visited.add(node);
+    inStack.add(node);
+    const deps = graph.get(node);
+    if (deps) {
+      for (const dep of deps) {
+        if (dfs(dep)) {
+          circular.add(node);
+          return true;
+        }
+      }
+    }
+    inStack.delete(node);
+    return false;
+  }
+  for (const node of graph.keys()) {
+    dfs(node);
+  }
+  return circular;
+}
+function getRecalculationOrder(graph) {
+  const visited = /* @__PURE__ */ new Set();
+  const order = [];
+  function visit(node) {
+    if (visited.has(node)) return;
+    visited.add(node);
+    const deps = graph.get(node);
+    if (deps) {
+      for (const dep of deps) {
+        visit(dep);
+      }
+    }
+    order.push(node);
+  }
+  for (const node of graph.keys()) {
+    visit(node);
+  }
+  return order;
+}
+
+// src/hooks/use-spreadsheet-store.ts
+function createInitialState(data) {
+  return {
+    workbook: data ?? createEmptyWorkbook(),
+    selection: { activeCell: "A1", ranges: [{ start: "A1", end: "A1" }] },
+    editingCell: null,
+    editValue: "",
+    undoStack: [],
+    redoStack: []
+  };
+}
+function getActiveSheet(state) {
+  return state.workbook.sheets.find((s) => s.id === state.workbook.activeSheetId);
+}
+function updateActiveSheet(state, updater) {
+  return {
+    ...state.workbook,
+    sheets: state.workbook.sheets.map(
+      (s) => s.id === state.workbook.activeSheetId ? updater(s) : s
+    )
+  };
+}
+function pushUndo(state) {
+  const stack = [...state.undoStack, state.workbook];
+  if (stack.length > 50) stack.shift();
+  return { undoStack: stack, redoStack: [] };
+}
+function recalculateSheet(sheet) {
+  const graph = buildDependencyGraph(sheet.cells);
+  if (graph.size === 0) return sheet;
+  const circular = detectCircularRefs(graph);
+  const order = getRecalculationOrder(graph);
+  const cells = { ...sheet.cells };
+  const getCellValue = (addr) => {
+    const c = cells[addr];
+    if (!c) return null;
+    if (c.formula && c.computedValue !== void 0) return c.computedValue;
+    return c.value;
+  };
+  const getRangeValues = (startAddr, endAddr) => {
+    const addresses = expandRange(startAddr, endAddr);
+    return addresses.map(getCellValue);
+  };
+  for (const addr of order) {
+    const cell = cells[addr];
+    if (!cell?.formula) continue;
+    if (circular.has(addr)) {
+      cells[addr] = { ...cell, computedValue: "#CIRC!" };
+      continue;
+    }
+    try {
+      const tokens = lexFormula(cell.formula);
+      const ast = parseFormula(tokens);
+      const result = evaluateAST(ast, getCellValue, getRangeValues);
+      cells[addr] = { ...cell, computedValue: result };
+    } catch {
+      cells[addr] = { ...cell, computedValue: "#ERROR!" };
+    }
+  }
+  return { ...sheet, cells };
+}
+function getCellDisplayValue(cell) {
+  if (!cell) return "";
+  if (cell.computedValue !== void 0) return String(cell.computedValue);
+  if (cell.value === null) return "";
+  return String(cell.value);
+}
+function reducer(state, action) {
+  switch (action.type) {
+    case "SET_CELL_VALUE": {
+      const history = pushUndo(state);
+      const isFormula = action.value.startsWith("=");
+      const cellData = isFormula ? { value: action.value, formula: action.value.slice(1), computedValue: null } : { value: isNaN(Number(action.value)) || action.value === "" ? action.value : Number(action.value) };
+      const sheet = getActiveSheet(state);
+      const existing = sheet.cells[action.address];
+      if (existing?.format) cellData.format = existing.format;
+      const workbook = updateActiveSheet(state, (s) => {
+        const updated = { ...s, cells: { ...s.cells, [action.address]: cellData } };
+        return recalculateSheet(updated);
+      });
+      return { ...state, workbook, ...history };
+    }
+    case "SET_CELL_FORMAT": {
+      const history = pushUndo(state);
+      const workbook = updateActiveSheet(state, (s) => {
+        const cells = { ...s.cells };
+        for (const addr of action.addresses) {
+          const existing = cells[addr] ?? { value: null };
+          cells[addr] = { ...existing, format: { ...existing.format, ...action.format } };
+        }
+        return { ...s, cells };
+      });
+      return { ...state, workbook, ...history };
+    }
+    case "SET_SELECTION":
+      return {
+        ...state,
+        selection: {
+          activeCell: action.cell,
+          ranges: [{ start: action.cell, end: action.cell }]
+        },
+        editingCell: null
+      };
+    case "EXTEND_SELECTION":
+      return {
+        ...state,
+        selection: {
+          ...state.selection,
+          ranges: [
+            { start: state.selection.activeCell, end: action.cell },
+            ...state.selection.ranges.slice(1)
+          ]
+        }
+      };
+    case "ADD_SELECTION":
+      return {
+        ...state,
+        selection: {
+          activeCell: action.cell,
+          ranges: [...state.selection.ranges, { start: action.cell, end: action.cell }]
+        }
+      };
+    case "SELECT_RANGE":
+      return {
+        ...state,
+        selection: {
+          activeCell: action.start,
+          ranges: [{ start: action.start, end: action.end }]
+        }
+      };
+    case "NAVIGATE": {
+      const { row, col } = parseAddress(state.selection.activeCell);
+      let newRow = row;
+      let newCol = col;
+      switch (action.direction) {
+        case "up":
+          newRow = Math.max(0, row - 1);
+          break;
+        case "down":
+          newRow = row + 1;
+          break;
+        case "left":
+          newCol = Math.max(0, col - 1);
+          break;
+        case "right":
+          newCol = col + 1;
+          break;
+      }
+      const newAddr = toAddress(newRow, newCol);
+      if (action.extend) {
+        return {
+          ...state,
+          selection: {
+            ...state.selection,
+            ranges: [
+              { start: state.selection.activeCell, end: newAddr },
+              ...state.selection.ranges.slice(1)
+            ]
+          }
+        };
+      }
+      return {
+        ...state,
+        selection: { activeCell: newAddr, ranges: [{ start: newAddr, end: newAddr }] },
+        editingCell: null
+      };
+    }
+    case "START_EDIT": {
+      const sheet = getActiveSheet(state);
+      const cell = sheet.cells[state.selection.activeCell];
+      const initialValue = action.value ?? (cell?.formula ? "=" + cell.formula : getCellDisplayValue(cell));
+      return { ...state, editingCell: state.selection.activeCell, editValue: initialValue };
+    }
+    case "UPDATE_EDIT":
+      return { ...state, editValue: action.value };
+    case "CONFIRM_EDIT": {
+      if (!state.editingCell) return state;
+      const newState = reducer(state, { type: "SET_CELL_VALUE", address: state.editingCell, value: state.editValue });
+      const { row, col } = parseAddress(state.editingCell);
+      const nextAddr = toAddress(row + 1, col);
+      return {
+        ...newState,
+        editingCell: null,
+        editValue: "",
+        selection: { activeCell: nextAddr, ranges: [{ start: nextAddr, end: nextAddr }] }
+      };
+    }
+    case "CANCEL_EDIT":
+      return { ...state, editingCell: null, editValue: "" };
+    case "RESIZE_COLUMN": {
+      const workbook = updateActiveSheet(state, (s) => ({
+        ...s,
+        columnWidths: { ...s.columnWidths, [action.col]: Math.max(30, action.width) }
+      }));
+      return { ...state, workbook };
+    }
+    case "ADD_SHEET": {
+      const id = `sheet-${Date.now()}`;
+      const num = state.workbook.sheets.length + 1;
+      const sheet = createEmptySheet(id, `Sheet ${num}`);
+      return {
+        ...state,
+        workbook: {
+          sheets: [...state.workbook.sheets, sheet],
+          activeSheetId: id
+        }
+      };
+    }
+    case "RENAME_SHEET":
+      return {
+        ...state,
+        workbook: {
+          ...state.workbook,
+          sheets: state.workbook.sheets.map(
+            (s) => s.id === action.sheetId ? { ...s, name: action.name } : s
+          )
+        }
+      };
+    case "DELETE_SHEET": {
+      if (state.workbook.sheets.length <= 1) return state;
+      const remaining = state.workbook.sheets.filter((s) => s.id !== action.sheetId);
+      const activeId = state.workbook.activeSheetId === action.sheetId ? remaining[0].id : state.workbook.activeSheetId;
+      return {
+        ...state,
+        workbook: { sheets: remaining, activeSheetId: activeId }
+      };
+    }
+    case "SET_ACTIVE_SHEET":
+      return {
+        ...state,
+        workbook: { ...state.workbook, activeSheetId: action.sheetId },
+        selection: { activeCell: "A1", ranges: [{ start: "A1", end: "A1" }] },
+        editingCell: null
+      };
+    case "UNDO": {
+      if (state.undoStack.length === 0) return state;
+      const prev = state.undoStack[state.undoStack.length - 1];
+      return {
+        ...state,
+        workbook: prev,
+        undoStack: state.undoStack.slice(0, -1),
+        redoStack: [...state.redoStack, state.workbook]
+      };
+    }
+    case "REDO": {
+      if (state.redoStack.length === 0) return state;
+      const next = state.redoStack[state.redoStack.length - 1];
+      return {
+        ...state,
+        workbook: next,
+        undoStack: [...state.undoStack, state.workbook],
+        redoStack: state.redoStack.slice(0, -1)
+      };
+    }
+    case "SET_WORKBOOK":
+      return { ...state, workbook: action.workbook };
+    default:
+      return state;
+  }
+}
+function useSpreadsheetStore(initialData) {
+  const [state, dispatch] = react.useReducer(reducer, initialData, (data) => createInitialState(data));
+  const actions = react.useMemo(() => ({
+    setCellValue: (address, value) => dispatch({ type: "SET_CELL_VALUE", address, value }),
+    setCellFormat: (addresses, format) => dispatch({ type: "SET_CELL_FORMAT", addresses, format }),
+    setSelection: (cell) => dispatch({ type: "SET_SELECTION", cell }),
+    extendSelection: (cell) => dispatch({ type: "EXTEND_SELECTION", cell }),
+    addSelection: (cell) => dispatch({ type: "ADD_SELECTION", cell }),
+    selectRange: (start, end) => dispatch({ type: "SELECT_RANGE", start, end }),
+    navigate: (direction, extend) => dispatch({ type: "NAVIGATE", direction, extend }),
+    startEdit: (value) => dispatch({ type: "START_EDIT", value }),
+    updateEdit: (value) => dispatch({ type: "UPDATE_EDIT", value }),
+    confirmEdit: () => dispatch({ type: "CONFIRM_EDIT" }),
+    cancelEdit: () => dispatch({ type: "CANCEL_EDIT" }),
+    resizeColumn: (col, width) => dispatch({ type: "RESIZE_COLUMN", col, width }),
+    addSheet: () => dispatch({ type: "ADD_SHEET" }),
+    renameSheet: (sheetId, name) => dispatch({ type: "RENAME_SHEET", sheetId, name }),
+    deleteSheet: (sheetId) => dispatch({ type: "DELETE_SHEET", sheetId }),
+    setActiveSheet: (sheetId) => dispatch({ type: "SET_ACTIVE_SHEET", sheetId }),
+    undo: () => dispatch({ type: "UNDO" }),
+    redo: () => dispatch({ type: "REDO" }),
+    setWorkbook: (workbook) => dispatch({ type: "SET_WORKBOOK", workbook })
+  }), []);
+  return { state, actions };
+}
+function ColumnResizeHandle({ colIndex }) {
+  const { resizeColumn, getColumnWidth } = useSpreadsheet();
+  const startX = react.useRef(0);
+  const startWidth = react.useRef(0);
+  const handlePointerDown = react.useCallback(
+    (e) => {
+      e.preventDefault();
+      e.stopPropagation();
+      startX.current = e.clientX;
+      startWidth.current = getColumnWidth(colIndex);
+      const target = e.currentTarget;
+      target.setPointerCapture(e.pointerId);
+      const handlePointerMove = (ev) => {
+        const delta = ev.clientX - startX.current;
+        resizeColumn(colIndex, startWidth.current + delta);
+      };
+      const handlePointerUp = () => {
+        target.removeEventListener("pointermove", handlePointerMove);
+        target.removeEventListener("pointerup", handlePointerUp);
+      };
+      target.addEventListener("pointermove", handlePointerMove);
+      target.addEventListener("pointerup", handlePointerUp);
+    },
+    [colIndex, getColumnWidth, resizeColumn]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      "data-fancy-sheets-resize-handle": "",
+      className: "absolute right-0 top-0 h-full w-1 cursor-col-resize hover:bg-blue-500/50",
+      onPointerDown: handlePointerDown
+    }
+  );
+}
+ColumnResizeHandle.displayName = "ColumnResizeHandle";
+function ColumnHeaders() {
+  const { columnCount, rowHeight, getColumnWidth } = useSpreadsheet();
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      "data-fancy-sheets-column-headers": "",
+      className: "flex border-b border-zinc-300 bg-zinc-100 dark:border-zinc-600 dark:bg-zinc-800",
+      style: { height: rowHeight },
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            className: "flex shrink-0 items-center justify-center border-r border-zinc-300 bg-zinc-100 text-[11px] font-medium text-zinc-400 dark:border-zinc-600 dark:bg-zinc-800",
+            style: { width: 48, minWidth: 48 }
+          }
+        ),
+        Array.from({ length: columnCount }, (_, i) => /* @__PURE__ */ jsxRuntime.jsxs(
+          "div",
+          {
+            className: "relative flex shrink-0 items-center justify-center border-r border-zinc-300 text-[11px] font-medium text-zinc-500 select-none dark:border-zinc-600 dark:text-zinc-400",
+            style: { width: getColumnWidth(i), minWidth: getColumnWidth(i) },
+            children: [
+              columnToLetter(i),
+              /* @__PURE__ */ jsxRuntime.jsx(ColumnResizeHandle, { colIndex: i })
+            ]
+          },
+          i
+        ))
+      ]
+    }
+  );
+}
+ColumnHeaders.displayName = "ColumnHeaders";
+function RowHeader({ rowIndex }) {
+  const { rowHeight } = useSpreadsheet();
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      "data-fancy-sheets-row-header": "",
+      className: "flex shrink-0 items-center justify-center border-r border-b border-zinc-300 bg-zinc-100 text-[11px] font-medium text-zinc-500 select-none dark:border-zinc-600 dark:bg-zinc-800 dark:text-zinc-400",
+      style: { width: 48, minWidth: 48, height: rowHeight },
+      children: rowIndex + 1
+    }
+  );
+}
+RowHeader.displayName = "RowHeader";
+function getCellDisplayValue2(cell) {
+  if (!cell) return "";
+  if (cell.formula && cell.computedValue !== void 0) return String(cell.computedValue ?? "");
+  if (cell.value === null) return "";
+  return String(cell.value);
+}
+var Cell = react.memo(function Cell2({ address, row, col }) {
+  const {
+    activeSheet,
+    selection,
+    editingCell,
+    readOnly,
+    setSelection,
+    extendSelection,
+    addSelection,
+    startEdit,
+    rowHeight,
+    getColumnWidth,
+    isCellSelected,
+    isCellActive
+  } = useSpreadsheet();
+  const cell = activeSheet.cells[address];
+  const isActive = isCellActive(address);
+  const isSelected = isCellSelected(address);
+  const isEditing = editingCell === address;
+  const displayValue = getCellDisplayValue2(cell);
+  const width = getColumnWidth(col);
+  const handleMouseDown = react.useCallback(
+    (e) => {
+      if (e.shiftKey) {
+        extendSelection(address);
+      } else if (e.ctrlKey || e.metaKey) {
+        addSelection(address);
+      } else {
+        setSelection(address);
+      }
+    },
+    [address, setSelection, extendSelection, addSelection]
+  );
+  const handleDoubleClick = react.useCallback(() => {
+    if (readOnly) return;
+    startEdit();
+  }, [readOnly, startEdit]);
+  const formatStyle = {};
+  if (cell?.format?.bold) formatStyle.fontWeight = "bold";
+  if (cell?.format?.italic) formatStyle.fontStyle = "italic";
+  if (cell?.format?.textAlign) formatStyle.textAlign = cell.format.textAlign;
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      "data-fancy-sheets-cell": "",
+      "data-selected": isSelected || void 0,
+      "data-active": isActive || void 0,
+      role: "gridcell",
+      className: reactFancy.cn(
+        "relative flex items-center truncate border-r border-b border-zinc-200 px-1.5 text-[13px] dark:border-zinc-700",
+        isActive && "ring-2 ring-inset ring-blue-500",
+        isSelected && !isActive && "bg-blue-500/10"
+      ),
+      style: { width, minWidth: width, height: rowHeight, ...formatStyle },
+      onMouseDown: handleMouseDown,
+      onDoubleClick: handleDoubleClick,
+      children: !isEditing && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "truncate", children: displayValue })
+    }
+  );
+});
+Cell.displayName = "Cell";
+function CellEditor() {
+  const {
+    editingCell,
+    editValue,
+    updateEdit,
+    confirmEdit,
+    cancelEdit,
+    getColumnWidth,
+    rowHeight,
+    activeSheet
+  } = useSpreadsheet();
+  const inputRef = react.useRef(null);
+  react.useEffect(() => {
+    if (editingCell && inputRef.current) {
+      inputRef.current.focus();
+      inputRef.current.select();
+    }
+  }, [editingCell]);
+  if (!editingCell) return null;
+  const { row, col } = parseAddress(editingCell);
+  const width = getColumnWidth(col);
+  const handleKeyDown = (e) => {
+    if (e.key === "Enter") {
+      e.preventDefault();
+      confirmEdit();
+    } else if (e.key === "Escape") {
+      e.preventDefault();
+      cancelEdit();
+    } else if (e.key === "Tab") {
+      e.preventDefault();
+      confirmEdit();
+    }
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "input",
+    {
+      ref: inputRef,
+      "data-fancy-sheets-cell-editor": "",
+      className: "absolute z-20 border-2 border-blue-500 bg-white px-1 text-[13px] outline-none dark:bg-zinc-800 dark:text-zinc-100",
+      style: { width: Math.max(width, 60), height: rowHeight },
+      value: editValue,
+      onChange: (e) => updateEdit(e.target.value),
+      onKeyDown: handleKeyDown,
+      onBlur: confirmEdit
+    }
+  );
+}
+CellEditor.displayName = "CellEditor";
+function SelectionOverlay() {
+  const { selection, getColumnWidth, rowHeight } = useSpreadsheet();
+  const rects = react.useMemo(() => {
+    return selection.ranges.map((range, i) => {
+      const norm = normalizeRange(range.start, range.end);
+      const s = parseAddress(norm.start);
+      const e = parseAddress(norm.end);
+      let left = 48;
+      for (let c = 0; c < s.col; c++) left += getColumnWidth(c);
+      let width = 0;
+      for (let c = s.col; c <= e.col; c++) width += getColumnWidth(c);
+      const top = rowHeight + s.row * rowHeight;
+      const height = (e.row - s.row + 1) * rowHeight;
+      return { left, top, width, height, isPrimary: i === 0 };
+    });
+  }, [selection.ranges, getColumnWidth, rowHeight]);
+  return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: rects.map((rect, i) => /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      "data-fancy-sheets-selection": "",
+      className: "pointer-events-none absolute border-2 border-blue-500",
+      style: {
+        left: rect.left,
+        top: rect.top,
+        width: rect.width,
+        height: rect.height,
+        backgroundColor: rect.isPrimary ? "rgba(59, 130, 246, 0.08)" : "rgba(59, 130, 246, 0.05)"
+      }
+    },
+    i
+  )) });
+}
+SelectionOverlay.displayName = "SelectionOverlay";
+
+// src/engine/clipboard.ts
+function cellsToTSV(cells, range) {
+  const norm = normalizeRange(range.start, range.end);
+  const s = parseAddress(norm.start);
+  const e = parseAddress(norm.end);
+  const rows = [];
+  for (let r = s.row; r <= e.row; r++) {
+    const cols = [];
+    for (let c = s.col; c <= e.col; c++) {
+      const addr = toAddress(r, c);
+      const cell = cells[addr];
+      if (!cell) {
+        cols.push("");
+      } else if (cell.computedValue !== void 0 && cell.computedValue !== null) {
+        cols.push(String(cell.computedValue));
+      } else if (cell.value !== null) {
+        cols.push(String(cell.value));
+      } else {
+        cols.push("");
+      }
+    }
+    rows.push(cols.join("	"));
+  }
+  return rows.join("\n");
+}
+function tsvToCells(tsv) {
+  const lines = tsv.split("\n");
+  const values = lines.map((line) => line.split("	"));
+  const rows = values.length;
+  const cols = Math.max(...values.map((v) => v.length));
+  return { values, rows, cols };
+}
+function SpreadsheetGrid({ className }) {
+  const {
+    columnCount,
+    rowCount,
+    rowHeight,
+    getColumnWidth,
+    selection,
+    editingCell,
+    readOnly,
+    activeSheet,
+    navigate,
+    startEdit,
+    confirmEdit,
+    cancelEdit,
+    setCellValue,
+    undo,
+    redo
+  } = useSpreadsheet();
+  const containerRef = react.useRef(null);
+  const handleKeyDown = react.useCallback(
+    (e) => {
+      if (editingCell) return;
+      if (e.key === "ArrowUp") {
+        e.preventDefault();
+        navigate("up", e.shiftKey);
+        return;
+      }
+      if (e.key === "ArrowDown") {
+        e.preventDefault();
+        navigate("down", e.shiftKey);
+        return;
+      }
+      if (e.key === "ArrowLeft") {
+        e.preventDefault();
+        navigate("left", e.shiftKey);
+        return;
+      }
+      if (e.key === "ArrowRight") {
+        e.preventDefault();
+        navigate("right", e.shiftKey);
+        return;
+      }
+      if (e.key === "Tab") {
+        e.preventDefault();
+        navigate(e.shiftKey ? "left" : "right");
+        return;
+      }
+      if (e.key === "Enter") {
+        e.preventDefault();
+        if (!readOnly) startEdit();
+        return;
+      }
+      if ((e.ctrlKey || e.metaKey) && e.key === "c") {
+        e.preventDefault();
+        const range = selection.ranges[0];
+        if (range) {
+          const tsv = cellsToTSV(activeSheet.cells, range);
+          navigator.clipboard.writeText(tsv);
+        }
+        return;
+      }
+      if ((e.ctrlKey || e.metaKey) && e.key === "v") {
+        e.preventDefault();
+        navigator.clipboard.readText().then((text) => {
+          if (!text) return;
+          const { values } = tsvToCells(text);
+          const { row: startRow, col: startCol } = parseAddress(selection.activeCell);
+          for (let r = 0; r < values.length; r++) {
+            for (let c = 0; c < values[r].length; c++) {
+              const addr = toAddress(startRow + r, startCol + c);
+              setCellValue(addr, values[r][c]);
+            }
+          }
+        });
+        return;
+      }
+      if ((e.ctrlKey || e.metaKey) && e.key === "z") {
+        e.preventDefault();
+        undo();
+        return;
+      }
+      if ((e.ctrlKey || e.metaKey) && e.key === "y") {
+        e.preventDefault();
+        redo();
+        return;
+      }
+      if (!readOnly && !e.ctrlKey && !e.metaKey && !e.altKey && e.key.length === 1) {
+        startEdit(e.key);
+      }
+      if (!readOnly && (e.key === "Delete" || e.key === "Backspace")) {
+        e.preventDefault();
+        startEdit("");
+        setTimeout(() => confirmEdit(), 0);
+      }
+    },
+    [editingCell, readOnly, navigate, startEdit, confirmEdit, undo, redo]
+  );
+  const editorPosition = editingCell ? (() => {
+    const { row, col } = parseAddress(editingCell);
+    let left = 48;
+    for (let c = 0; c < col; c++) left += getColumnWidth(c);
+    const top = rowHeight + row * rowHeight;
+    return { left, top };
+  })() : null;
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      ref: containerRef,
+      "data-fancy-sheets-grid": "",
+      className: reactFancy.cn("relative flex-1 overflow-auto bg-white focus:outline-none dark:bg-zinc-900", className),
+      tabIndex: 0,
+      onKeyDown: handleKeyDown,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "sticky top-0 z-10", children: /* @__PURE__ */ jsxRuntime.jsx(ColumnHeaders, {}) }),
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "relative", children: [
+          Array.from({ length: rowCount }, (_, rowIdx) => /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex", children: [
+            /* @__PURE__ */ jsxRuntime.jsx("div", { className: "sticky left-0 z-[5]", children: /* @__PURE__ */ jsxRuntime.jsx(RowHeader, { rowIndex: rowIdx }) }),
+            Array.from({ length: columnCount }, (_2, colIdx) => {
+              const addr = toAddress(rowIdx, colIdx);
+              return /* @__PURE__ */ jsxRuntime.jsx(Cell, { address: addr, row: rowIdx, col: colIdx }, addr);
+            })
+          ] }, rowIdx)),
+          /* @__PURE__ */ jsxRuntime.jsx(SelectionOverlay, {}),
+          editorPosition && /* @__PURE__ */ jsxRuntime.jsx(
+            "div",
+            {
+              className: "absolute z-20",
+              style: { left: editorPosition.left, top: editorPosition.top },
+              children: /* @__PURE__ */ jsxRuntime.jsx(CellEditor, {})
+            }
+          )
+        ] })
+      ]
+    }
+  );
+}
+SpreadsheetGrid.displayName = "SpreadsheetGrid";
+var btnClass = "inline-flex items-center justify-center rounded px-2 py-1 text-[12px] font-medium text-zinc-600 transition-colors hover:bg-zinc-100 disabled:opacity-40 dark:text-zinc-300 dark:hover:bg-zinc-800";
+var activeBtnClass = "bg-zinc-200 dark:bg-zinc-700";
+function DefaultToolbar() {
+  const {
+    selection,
+    activeSheet,
+    editingCell,
+    editValue,
+    updateEdit,
+    confirmEdit,
+    startEdit,
+    setCellFormat,
+    undo,
+    redo,
+    canUndo,
+    canRedo,
+    readOnly
+  } = useSpreadsheet();
+  const cell = activeSheet.cells[selection.activeCell];
+  const isBold = cell?.format?.bold ?? false;
+  const isItalic = cell?.format?.italic ?? false;
+  const textAlign = cell?.format?.textAlign ?? "left";
+  const selectedAddresses = [selection.activeCell];
+  const handleFormulaBarChange = (e) => {
+    if (editingCell) {
+      updateEdit(e.target.value);
+    } else {
+      startEdit(e.target.value);
+    }
+  };
+  const handleFormulaBarKeyDown = (e) => {
+    if (e.key === "Enter") {
+      e.preventDefault();
+      confirmEdit();
+    }
+  };
+  const formulaBarValue = editingCell ? editValue : cell?.formula ? "=" + cell.formula : cell?.value != null ? String(cell.value) : "";
+  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-0.5 border-b border-zinc-200 px-1.5 py-1 dark:border-zinc-700", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("button", { className: btnClass, onClick: undo, disabled: !canUndo || readOnly, title: "Undo (Ctrl+Z)", children: /* @__PURE__ */ jsxRuntime.jsxs("svg", { width: "14", height: "14", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("polyline", { points: "1 4 1 10 7 10" }),
+        /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M3.51 15a9 9 0 1 0 2.13-9.36L1 10" })
+      ] }) }),
+      /* @__PURE__ */ jsxRuntime.jsx("button", { className: btnClass, onClick: redo, disabled: !canRedo || readOnly, title: "Redo (Ctrl+Y)", children: /* @__PURE__ */ jsxRuntime.jsxs("svg", { width: "14", height: "14", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("polyline", { points: "23 4 23 10 17 10" }),
+        /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M20.49 15a9 9 0 1 1-2.12-9.36L23 10" })
+      ] }) }),
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "mx-1 h-4 w-px bg-zinc-200 dark:bg-zinc-700" }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          className: reactFancy.cn(btnClass, isBold && activeBtnClass),
+          onClick: () => setCellFormat(selectedAddresses, { bold: !isBold }),
+          disabled: readOnly,
+          title: "Bold",
+          children: /* @__PURE__ */ jsxRuntime.jsx("span", { className: "font-bold", children: "B" })
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          className: reactFancy.cn(btnClass, isItalic && activeBtnClass),
+          onClick: () => setCellFormat(selectedAddresses, { italic: !isItalic }),
+          disabled: readOnly,
+          title: "Italic",
+          children: /* @__PURE__ */ jsxRuntime.jsx("span", { className: "italic", children: "I" })
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "mx-1 h-4 w-px bg-zinc-200 dark:bg-zinc-700" }),
+      ["left", "center", "right"].map((align) => /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          className: reactFancy.cn(btnClass, textAlign === align && activeBtnClass),
+          onClick: () => setCellFormat(selectedAddresses, { textAlign: align }),
+          disabled: readOnly,
+          title: `Align ${align}`,
+          children: /* @__PURE__ */ jsxRuntime.jsxs("svg", { width: "14", height: "14", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", children: [
+            /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "3", y1: "6", x2: "21", y2: "6" }),
+            /* @__PURE__ */ jsxRuntime.jsx("line", { x1: align === "left" ? "3" : align === "center" ? "6" : "9", y1: "12", x2: align === "left" ? "15" : align === "center" ? "18" : "21", y2: "12" }),
+            /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "3", y1: "18", x2: "21", y2: "18" })
+          ] })
+        },
+        align
+      ))
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { "data-fancy-sheets-formula-bar": "", className: "flex items-center gap-2 border-b border-zinc-200 px-2 py-1 dark:border-zinc-700", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: "w-12 shrink-0 text-center text-[11px] font-medium text-zinc-500 dark:text-zinc-400", children: selection.activeCell }),
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "h-4 w-px bg-zinc-200 dark:bg-zinc-700" }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "input",
+        {
+          className: "flex-1 bg-transparent text-[13px] outline-none dark:text-zinc-100",
+          value: formulaBarValue,
+          onChange: handleFormulaBarChange,
+          onKeyDown: handleFormulaBarKeyDown,
+          readOnly,
+          placeholder: "Enter value or formula (=SUM(A1:A5))"
+        }
+      )
+    ] })
+  ] });
+}
+function SpreadsheetToolbar({ children, className }) {
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { "data-fancy-sheets-toolbar": "", className: reactFancy.cn("", className), children: children ?? /* @__PURE__ */ jsxRuntime.jsx(DefaultToolbar, {}) });
+}
+SpreadsheetToolbar.displayName = "SpreadsheetToolbar";
+function SpreadsheetSheetTabs({ className }) {
+  const { workbook, setActiveSheet, addSheet, renameSheet, deleteSheet, readOnly } = useSpreadsheet();
+  const [renamingId, setRenamingId] = react.useState(null);
+  const [renameValue, setRenameValue] = react.useState("");
+  const handleDoubleClick = react.useCallback(
+    (sheetId, name) => {
+      if (readOnly) return;
+      setRenamingId(sheetId);
+      setRenameValue(name);
+    },
+    [readOnly]
+  );
+  const handleRenameConfirm = react.useCallback(() => {
+    if (renamingId && renameValue.trim()) {
+      renameSheet(renamingId, renameValue.trim());
+    }
+    setRenamingId(null);
+  }, [renamingId, renameValue, renameSheet]);
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      "data-fancy-sheets-tabs": "",
+      className: reactFancy.cn(
+        "flex items-center gap-0.5 border-t border-zinc-200 bg-zinc-50 px-2 py-1 dark:border-zinc-700 dark:bg-zinc-900/50",
+        className
+      ),
+      children: [
+        workbook.sheets.map((sheet) => {
+          const isActive = sheet.id === workbook.activeSheetId;
+          const isRenaming = renamingId === sheet.id;
+          return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "relative flex items-center", children: [
+            isRenaming ? /* @__PURE__ */ jsxRuntime.jsx(
+              "input",
+              {
+                className: "rounded border border-blue-500 bg-white px-2 py-0.5 text-[12px] outline-none dark:bg-zinc-800 dark:text-zinc-100",
+                value: renameValue,
+                onChange: (e) => setRenameValue(e.target.value),
+                onBlur: handleRenameConfirm,
+                onKeyDown: (e) => {
+                  if (e.key === "Enter") handleRenameConfirm();
+                  if (e.key === "Escape") setRenamingId(null);
+                },
+                autoFocus: true
+              }
+            ) : /* @__PURE__ */ jsxRuntime.jsx(
+              "button",
+              {
+                className: reactFancy.cn(
+                  "rounded px-3 py-1 text-[12px] font-medium transition-colors",
+                  isActive ? "bg-white text-zinc-900 shadow-sm dark:bg-zinc-800 dark:text-zinc-100" : "text-zinc-500 hover:bg-zinc-100 dark:text-zinc-400 dark:hover:bg-zinc-800"
+                ),
+                onClick: () => setActiveSheet(sheet.id),
+                onDoubleClick: () => handleDoubleClick(sheet.id, sheet.name),
+                children: sheet.name
+              }
+            ),
+            !readOnly && workbook.sheets.length > 1 && isActive && !isRenaming && /* @__PURE__ */ jsxRuntime.jsx(
+              "button",
+              {
+                className: "ml-0.5 rounded p-0.5 text-zinc-400 hover:bg-zinc-200 hover:text-zinc-600 dark:hover:bg-zinc-700 dark:hover:text-zinc-300",
+                onClick: () => deleteSheet(sheet.id),
+                title: "Delete sheet",
+                children: /* @__PURE__ */ jsxRuntime.jsxs("svg", { width: "10", height: "10", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2.5", strokeLinecap: "round", children: [
+                  /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "18", y1: "6", x2: "6", y2: "18" }),
+                  /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "6", y1: "6", x2: "18", y2: "18" })
+                ] })
+              }
+            )
+          ] }, sheet.id);
+        }),
+        !readOnly && /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            className: "rounded px-2 py-1 text-[12px] font-medium text-zinc-400 transition-colors hover:bg-zinc-100 hover:text-zinc-600 dark:hover:bg-zinc-800 dark:hover:text-zinc-300",
+            onClick: addSheet,
+            title: "Add sheet",
+            children: "+"
+          }
+        )
+      ]
+    }
+  );
+}
+SpreadsheetSheetTabs.displayName = "SpreadsheetSheetTabs";
+function SpreadsheetRoot({
+  children,
+  className,
+  data,
+  defaultData,
+  onChange,
+  columnCount = 26,
+  rowCount = 100,
+  defaultColumnWidth = 100,
+  rowHeight = 28,
+  readOnly = false
+}) {
+  const { state, actions } = useSpreadsheetStore(data ?? defaultData);
+  react.useEffect(() => {
+    if (data && data !== state.workbook) {
+      actions.setWorkbook(data);
+    }
+  }, [data]);
+  react.useEffect(() => {
+    onChange?.(state.workbook);
+  }, [state.workbook]);
+  const activeSheet = react.useMemo(
+    () => state.workbook.sheets.find((s) => s.id === state.workbook.activeSheetId),
+    [state.workbook]
+  );
+  const getColumnWidth = react.useCallback(
+    (col) => activeSheet.columnWidths[col] ?? defaultColumnWidth,
+    [activeSheet.columnWidths, defaultColumnWidth]
+  );
+  const isCellSelected = react.useCallback(
+    (address) => {
+      const target = parseAddress(address);
+      return state.selection.ranges.some((range) => {
+        const norm = normalizeRange(range.start, range.end);
+        const s = parseAddress(norm.start);
+        const e = parseAddress(norm.end);
+        return target.row >= s.row && target.row <= e.row && target.col >= s.col && target.col <= e.col;
+      });
+    },
+    [state.selection.ranges]
+  );
+  const isCellActive = react.useCallback(
+    (address) => state.selection.activeCell === address,
+    [state.selection.activeCell]
+  );
+  const ctx = react.useMemo(
+    () => ({
+      workbook: state.workbook,
+      activeSheet,
+      columnCount,
+      rowCount,
+      defaultColumnWidth,
+      rowHeight,
+      readOnly,
+      selection: state.selection,
+      editingCell: state.editingCell,
+      editValue: state.editValue,
+      ...actions,
+      canUndo: state.undoStack.length > 0,
+      canRedo: state.redoStack.length > 0,
+      getColumnWidth,
+      isCellSelected,
+      isCellActive
+    }),
+    [state, activeSheet, columnCount, rowCount, defaultColumnWidth, rowHeight, readOnly, actions, getColumnWidth, isCellSelected, isCellActive]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(SpreadsheetContext.Provider, { value: ctx, children: /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      "data-fancy-sheets": "",
+      className: reactFancy.cn("flex flex-col overflow-hidden", className),
+      children
+    }
+  ) });
+}
+SpreadsheetRoot.displayName = "Spreadsheet";
+var Spreadsheet = Object.assign(SpreadsheetRoot, {
+  Toolbar: SpreadsheetToolbar,
+  Grid: SpreadsheetGrid,
+  SheetTabs: SpreadsheetSheetTabs
+});
+
+// src/engine/csv.ts
+function parseCSV(text) {
+  const rows = [];
+  let current = "";
+  let inQuotes = false;
+  let row = [];
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (inQuotes) {
+      if (ch === '"' && text[i + 1] === '"') {
+        current += '"';
+        i++;
+      } else if (ch === '"') {
+        inQuotes = false;
+      } else {
+        current += ch;
+      }
+    } else {
+      if (ch === '"') {
+        inQuotes = true;
+      } else if (ch === ",") {
+        row.push(current);
+        current = "";
+      } else if (ch === "\n" || ch === "\r" && text[i + 1] === "\n") {
+        row.push(current);
+        current = "";
+        rows.push(row);
+        row = [];
+        if (ch === "\r") i++;
+      } else {
+        current += ch;
+      }
+    }
+  }
+  row.push(current);
+  if (row.some((c) => c !== "")) rows.push(row);
+  return rows;
+}
+function stringifyCSV(data) {
+  return data.map(
+    (row) => row.map((cell) => {
+      if (cell.includes(",") || cell.includes('"') || cell.includes("\n")) {
+        return '"' + cell.replace(/"/g, '""') + '"';
+      }
+      return cell;
+    }).join(",")
+  ).join("\n");
+}
+function csvToWorkbook(csv, sheetName = "Sheet 1") {
+  const data = parseCSV(csv);
+  const sheet = createEmptySheet("sheet-1", sheetName);
+  for (let r = 0; r < data.length; r++) {
+    for (let c = 0; c < data[r].length; c++) {
+      const val = data[r][c];
+      if (val === "") continue;
+      const addr = toAddress(r, c);
+      const numVal = Number(val);
+      sheet.cells[addr] = { value: isNaN(numVal) || val === "" ? val : numVal };
+    }
+  }
+  return { sheets: [sheet], activeSheetId: sheet.id };
+}
+function workbookToCSV(workbook, sheetId) {
+  const sheet = sheetId ? workbook.sheets.find((s) => s.id === sheetId) : workbook.sheets.find((s) => s.id === workbook.activeSheetId);
+  if (!sheet) return "";
+  let maxRow = 0;
+  let maxCol = 0;
+  for (const addr of Object.keys(sheet.cells)) {
+    const match = addr.match(/^([A-Z]+)(\d+)$/);
+    if (!match) continue;
+    const col = match[1].split("").reduce((acc, ch) => acc * 26 + ch.charCodeAt(0) - 64, 0) - 1;
+    const row = parseInt(match[2], 10) - 1;
+    maxRow = Math.max(maxRow, row);
+    maxCol = Math.max(maxCol, col);
+  }
+  const data = [];
+  for (let r = 0; r <= maxRow; r++) {
+    const row = [];
+    for (let c = 0; c <= maxCol; c++) {
+      const addr = toAddress(r, c);
+      const cell = sheet.cells[addr];
+      if (!cell) {
+        row.push("");
+      } else if (cell.computedValue !== void 0 && cell.computedValue !== null) {
+        row.push(String(cell.computedValue));
+      } else if (cell.value !== null) {
+        row.push(String(cell.value));
+      } else {
+        row.push("");
+      }
+    }
+    data.push(row);
+  }
+  return stringifyCSV(data);
+}
+
+exports.Spreadsheet = Spreadsheet;
+exports.columnToLetter = columnToLetter;
+exports.createEmptySheet = createEmptySheet;
+exports.createEmptyWorkbook = createEmptyWorkbook;
+exports.csvToWorkbook = csvToWorkbook;
+exports.letterToColumn = letterToColumn;
+exports.parseAddress = parseAddress;
+exports.parseCSV = parseCSV;
+exports.registerFunction = registerFunction;
+exports.stringifyCSV = stringifyCSV;
+exports.toAddress = toAddress;
+exports.useSpreadsheet = useSpreadsheet;
+exports.workbookToCSV = workbookToCSV;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map