@coco-vexel/coco-office-editor 0.0.0-stage → 1.0.1

package/dist/spreadsheet.js

@@ -0,0 +1,4213 @@
+import { parseCellAddress, parseRangeAddress, formatCellAddress, formatRangeAddress, shiftFormulaReferences, ExcelWorkbook, SpreadsheetFormulaEngine, diffExcelWorkbookModels, rewriteFormulaForRowSort, columnIndexToName } from '@coco-vexel/coco-office/excel';
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/spreadsheet/types.ts
+function rowColumnKey(row, column) {
+  return `${row}:${column}`;
+}
+__name(rowColumnKey, "rowColumnKey");
+function buildSpreadsheetSheetRenderModel(sheet, styles, options = {}) {
+  var _a, _b, _c;
+  const cellsByAddress = /* @__PURE__ */ new Map();
+  const cellsByRowColumn = /* @__PURE__ */ new Map();
+  const rowMetaByIndex = /* @__PURE__ */ new Map();
+  const columnMetaByIndex = /* @__PURE__ */ new Map();
+  const mergeMasterByAddress = /* @__PURE__ */ new Map();
+  const mergeFollowerByAddress = /* @__PURE__ */ new Map();
+  let maxRow = (_a = options.minimumRows) != null ? _a : 100;
+  let maxColumn = (_b = options.minimumColumns) != null ? _b : 26;
+  for (const row of sheet.rows) {
+    rowMetaByIndex.set(row.index, row);
+    maxRow = Math.max(maxRow, row.index);
+  }
+  for (const column of sheet.columns) {
+    for (let index = column.min; index <= column.max; index++) {
+      columnMetaByIndex.set(index, column);
+    }
+    maxColumn = Math.max(maxColumn, column.max);
+  }
+  for (const cell of sheet.cells) {
+    const renderCell = toRenderCell(cell, styles, options.formulaResults);
+    cellsByAddress.set(cell.address, renderCell);
+    cellsByRowColumn.set(rowColumnKey(cell.row, cell.column), renderCell);
+    maxRow = Math.max(maxRow, cell.row);
+    maxColumn = Math.max(maxColumn, cell.column);
+  }
+  for (const [address, result] of (_c = options.formulaResults) != null ? _c : []) {
+    if (cellsByAddress.has(address) || result.error) continue;
+    const parsed = parseCellAddress(address);
+    const virtualCell = {
+      address,
+      row: parsed.row,
+      column: parsed.column,
+      kind: "formula",
+      value: null
+    };
+    const renderCell = toRenderCell(virtualCell, styles, options.formulaResults);
+    cellsByAddress.set(address, renderCell);
+    cellsByRowColumn.set(rowColumnKey(parsed.row, parsed.column), renderCell);
+    maxRow = Math.max(maxRow, parsed.row);
+    maxColumn = Math.max(maxColumn, parsed.column);
+  }
+  for (const merge of sheet.mergedRanges) {
+    const range = parseRangeAddress(merge.address);
+    const endRow = range.startRow + range.rowCount - 1;
+    const endColumn = range.startColumn + range.columnCount - 1;
+    const renderRange = {
+      startRow: range.startRow,
+      startColumn: range.startColumn,
+      endRow,
+      endColumn
+    };
+    const masterAddress = formatCellAddress(range.startRow, range.startColumn);
+    const info = {
+      address: merge.address,
+      range: renderRange,
+      masterAddress,
+      source: merge
+    };
+    mergeMasterByAddress.set(masterAddress, info);
+    maxRow = Math.max(maxRow, endRow);
+    maxColumn = Math.max(maxColumn, endColumn);
+    for (let row = range.startRow; row <= endRow; row++) {
+      for (let column = range.startColumn; column <= endColumn; column++) {
+        const address = formatCellAddress(row, column);
+        if (address !== masterAddress) mergeFollowerByAddress.set(address, masterAddress);
+      }
+    }
+  }
+  return {
+    sheetId: sheet.id,
+    sheetName: sheet.name,
+    source: sheet,
+    styles,
+    cellsByAddress,
+    cellsByRowColumn,
+    rowMetaByIndex,
+    columnMetaByIndex,
+    mergeMasterByAddress,
+    mergeFollowerByAddress,
+    maxRow,
+    maxColumn
+  };
+}
+__name(buildSpreadsheetSheetRenderModel, "buildSpreadsheetSheetRenderModel");
+function getRenderCell(model, row, column) {
+  return model.cellsByRowColumn.get(rowColumnKey(row, column));
+}
+__name(getRenderCell, "getRenderCell");
+function toRenderCell(cell, styles, formulaResults) {
+  var _a, _b;
+  const formulaResult = formulaResults == null ? void 0 : formulaResults.get(cell.address);
+  const resultValue = formulaResult && !formulaResult.error ? formulaResult.value : void 0;
+  const value = Array.isArray(resultValue) ? (_b = (_a = resultValue[0]) == null ? void 0 : _a[0]) != null ? _b : null : resultValue != null ? resultValue : cell.value;
+  return {
+    row: cell.row,
+    column: cell.column,
+    address: cell.address,
+    kind: cell.kind,
+    value,
+    displayText: cellToDisplayText(cell, styles, value, formulaResult),
+    formula: cell.formula,
+    styleId: cell.styleId,
+    source: cell
+  };
+}
+__name(toRenderCell, "toRenderCell");
+function cellToDisplayText(cell, styles, value, formulaResult) {
+  if (formulaResult == null ? void 0 : formulaResult.error) return formulaResult.displayText;
+  if (value !== null) return formatSpreadsheetDisplayValue(value, numberFormatCodeForCell(cell, styles));
+  return "";
+}
+__name(cellToDisplayText, "cellToDisplayText");
+function numberFormatCodeForCell(cell, styles) {
+  var _a, _b;
+  return (_b = styles.cellFormats[(_a = cell.styleId) != null ? _a : 0]) == null ? void 0 : _b.numberFormatCode;
+}
+__name(numberFormatCodeForCell, "numberFormatCodeForCell");
+function formatSpreadsheetDisplayValue(value, formatCode) {
+  if (value === null) return "";
+  if (typeof value !== "number" || !formatCode) return String(value);
+  const normalized = formatCode.toLowerCase();
+  if (normalized.includes("%")) return `${formatFixedNumber(value * 100, decimalPlaces(formatCode))}%`;
+  if (normalized.includes("$")) return `$${formatFixedNumber(value, decimalPlaces(formatCode), true)}`;
+  if (looksLikeDateFormat(normalized)) return formatExcelSerialDate(value);
+  if (formatCode.includes(",")) return formatFixedNumber(value, decimalPlaces(formatCode), true);
+  if (formatCode.includes(".")) return formatFixedNumber(value, decimalPlaces(formatCode));
+  return String(value);
+}
+__name(formatSpreadsheetDisplayValue, "formatSpreadsheetDisplayValue");
+function decimalPlaces(formatCode) {
+  var _a, _b;
+  const match = /\.(0+)/.exec(formatCode);
+  return (_b = (_a = match == null ? void 0 : match[1]) == null ? void 0 : _a.length) != null ? _b : 0;
+}
+__name(decimalPlaces, "decimalPlaces");
+function formatFixedNumber(value, digits, grouping = false) {
+  return new Intl.NumberFormat("en-US", {
+    minimumFractionDigits: digits,
+    maximumFractionDigits: digits,
+    useGrouping: grouping
+  }).format(value);
+}
+__name(formatFixedNumber, "formatFixedNumber");
+function looksLikeDateFormat(formatCode) {
+  return /(^|[^a-z])y{2,4}([^a-z]|$)/.test(formatCode) && /(^|[^a-z])d{1,2}([^a-z]|$)/.test(formatCode);
+}
+__name(looksLikeDateFormat, "looksLikeDateFormat");
+function formatExcelSerialDate(serial) {
+  if (!Number.isFinite(serial)) return String(serial);
+  const epoch = Date.UTC(1899, 11, 30);
+  const date = new Date(epoch + Math.round(serial) * 864e5);
+  const year = date.getUTCFullYear();
+  const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+  const day = String(date.getUTCDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+__name(formatExcelSerialDate, "formatExcelSerialDate");
+var DEFAULT_ROW_HEIGHT = 22;
+var DEFAULT_COLUMN_WIDTH = 96;
+var DEFAULT_ROW_HEADER_WIDTH = 48;
+var DEFAULT_COLUMN_HEADER_HEIGHT = 24;
+var EXCEL_POINTS_TO_CSS_PIXELS = 96 / 72;
+var EXCEL_MAX_DIGIT_WIDTH_PX = 7;
+var EXCEL_COLUMN_PADDING_PX = 5;
+var _SpreadsheetLayout = class _SpreadsheetLayout {
+  constructor(model, options = {}) {
+    __publicField(this, "model", model);
+    __publicField(this, "defaultRowHeight");
+    __publicField(this, "defaultColumnWidth");
+    __publicField(this, "rowHeaderWidth");
+    __publicField(this, "columnHeaderHeight");
+    __publicField(this, "rowCount");
+    __publicField(this, "columnCount");
+    __publicField(this, "rowOffsets");
+    __publicField(this, "columnOffsets");
+    __publicField(this, "rowHeights");
+    __publicField(this, "columnWidths");
+    var _a, _b, _c, _d, _e, _f;
+    this.defaultRowHeight = (_a = options.defaultRowHeight) != null ? _a : DEFAULT_ROW_HEIGHT;
+    this.defaultColumnWidth = (_b = options.defaultColumnWidth) != null ? _b : DEFAULT_COLUMN_WIDTH;
+    this.rowHeaderWidth = (_c = options.rowHeaderWidth) != null ? _c : DEFAULT_ROW_HEADER_WIDTH;
+    this.columnHeaderHeight = (_d = options.columnHeaderHeight) != null ? _d : DEFAULT_COLUMN_HEADER_HEIGHT;
+    this.rowCount = Math.max((_e = options.rowCount) != null ? _e : 0, model.maxRow);
+    this.columnCount = Math.max((_f = options.columnCount) != null ? _f : 0, model.maxColumn);
+    this.rowHeights = buildRowHeights(model, this.rowCount, this.defaultRowHeight);
+    this.columnWidths = buildColumnWidths(model, this.columnCount, this.defaultColumnWidth);
+    this.rowOffsets = buildOffsets(this.rowHeights);
+    this.columnOffsets = buildOffsets(this.columnWidths);
+  }
+  totalWidth() {
+    var _a;
+    return (_a = this.columnOffsets[this.columnOffsets.length - 1]) != null ? _a : 0;
+  }
+  totalHeight() {
+    var _a;
+    return (_a = this.rowOffsets[this.rowOffsets.length - 1]) != null ? _a : 0;
+  }
+  getColumnWidth(column) {
+    var _a;
+    return (_a = this.columnWidths[column - 1]) != null ? _a : this.defaultColumnWidth;
+  }
+  getRowHeight(row) {
+    var _a;
+    return (_a = this.rowHeights[row - 1]) != null ? _a : this.defaultRowHeight;
+  }
+  getColumnX(column) {
+    var _a;
+    return (_a = this.columnOffsets[Math.max(0, column - 1)]) != null ? _a : 0;
+  }
+  getRowY(row) {
+    var _a;
+    return (_a = this.rowOffsets[Math.max(0, row - 1)]) != null ? _a : 0;
+  }
+  getCellLogicalRect(row, column) {
+    return {
+      x: this.getColumnX(column),
+      y: this.getRowY(row),
+      width: this.getColumnWidth(column),
+      height: this.getRowHeight(row)
+    };
+  }
+  getRangeLogicalRect(range) {
+    const x = this.getColumnX(range.startColumn);
+    const y = this.getRowY(range.startRow);
+    const endX = this.getColumnX(range.endColumn) + this.getColumnWidth(range.endColumn);
+    const endY = this.getRowY(range.endRow) + this.getRowHeight(range.endRow);
+    return { x, y, width: endX - x, height: endY - y };
+  }
+  getVisibleRange(originX, originY, size, minimumRow = 1, minimumColumn = 1) {
+    const startColumn = Math.max(minimumColumn, this.columnAt(originX));
+    const startRow = Math.max(minimumRow, this.rowAt(originY));
+    const endColumn = Math.max(
+      startColumn,
+      Math.min(this.columnCount, this.columnAt(originX + size.width) + 1)
+    );
+    const endRow = Math.max(
+      startRow,
+      Math.min(this.rowCount, this.rowAt(originY + size.height) + 1)
+    );
+    return { startRow, startColumn, endRow, endColumn };
+  }
+  rowAt(logicalY) {
+    return clampIndex(binarySearchOffset(this.rowOffsets, logicalY), this.rowCount);
+  }
+  columnAt(logicalX) {
+    return clampIndex(binarySearchOffset(this.columnOffsets, logicalX), this.columnCount);
+  }
+  hitTestLogical(logicalX, logicalY) {
+    const column = this.columnAt(logicalX);
+    const row = this.rowAt(logicalY);
+    if (row < 1 || column < 1 || row > this.rowCount || column > this.columnCount) {
+      return { kind: "none" };
+    }
+    return { kind: "cell", row, column, address: formatCellAddress(row, column) };
+  }
+};
+__name(_SpreadsheetLayout, "SpreadsheetLayout");
+var SpreadsheetLayout = _SpreadsheetLayout;
+function buildRowHeights(model, rowCount, defaultHeight) {
+  const heights = [];
+  for (let row = 1; row <= rowCount; row++) {
+    const meta = model.rowMetaByIndex.get(row);
+    heights.push((meta == null ? void 0 : meta.hidden) ? 0 : (meta == null ? void 0 : meta.height) === void 0 ? defaultHeight : meta.height * EXCEL_POINTS_TO_CSS_PIXELS);
+  }
+  return heights;
+}
+__name(buildRowHeights, "buildRowHeights");
+function buildColumnWidths(model, columnCount, defaultWidth) {
+  const widths = [];
+  for (let column = 1; column <= columnCount; column++) {
+    const meta = model.columnMetaByIndex.get(column);
+    widths.push((meta == null ? void 0 : meta.hidden) ? 0 : (meta == null ? void 0 : meta.width) === void 0 ? defaultWidth : excelColumnWidthToCssPixels(meta.width));
+  }
+  return widths;
+}
+__name(buildColumnWidths, "buildColumnWidths");
+function excelColumnWidthToCssPixels(width) {
+  if (!Number.isFinite(width) || width <= 0) return 0;
+  return Math.floor(
+    (256 * width + Math.floor(128 / EXCEL_MAX_DIGIT_WIDTH_PX)) / 256 * EXCEL_MAX_DIGIT_WIDTH_PX
+  );
+}
+__name(excelColumnWidthToCssPixels, "excelColumnWidthToCssPixels");
+function cssPixelsToExcelColumnWidth(width) {
+  if (!Number.isFinite(width) || width <= 0) return 0;
+  return Math.floor((width - EXCEL_COLUMN_PADDING_PX) / EXCEL_MAX_DIGIT_WIDTH_PX * 256) / 256;
+}
+__name(cssPixelsToExcelColumnWidth, "cssPixelsToExcelColumnWidth");
+function buildOffsets(sizes) {
+  var _a;
+  const offsets = [0];
+  for (const size of sizes) offsets.push(((_a = offsets[offsets.length - 1]) != null ? _a : 0) + size);
+  return offsets;
+}
+__name(buildOffsets, "buildOffsets");
+function binarySearchOffset(offsets, value) {
+  var _a;
+  if (value <= 0) return 1;
+  let low = 0;
+  let high = offsets.length - 1;
+  while (low < high) {
+    const mid = Math.floor((low + high + 1) / 2);
+    if (((_a = offsets[mid]) != null ? _a : 0) <= value) low = mid;
+    else high = mid - 1;
+  }
+  return low + 1;
+}
+__name(binarySearchOffset, "binarySearchOffset");
+function clampIndex(index, max) {
+  return Math.max(1, Math.min(max, index));
+}
+__name(clampIndex, "clampIndex");
+
+// src/spreadsheet/viewport.ts
+var _SpreadsheetViewportManager = class _SpreadsheetViewportManager {
+  constructor(layout, options) {
+    __publicField(this, "layout", layout);
+    __publicField(this, "scroll");
+    __publicField(this, "freeze");
+    __publicField(this, "viewportSize");
+    __publicField(this, "viewports");
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    this.viewportSize = options.viewportSize;
+    this.freeze = {
+      frozenRows: Math.max(0, (_b = (_a = options.freeze) == null ? void 0 : _a.frozenRows) != null ? _b : 0),
+      frozenColumns: Math.max(0, (_d = (_c = options.freeze) == null ? void 0 : _c.frozenColumns) != null ? _d : 0)
+    };
+    this.scroll = clampScroll(layout, this.freeze, options.viewportSize, {
+      x: (_f = (_e = options.scroll) == null ? void 0 : _e.x) != null ? _f : 0,
+      y: (_h = (_g = options.scroll) == null ? void 0 : _g.y) != null ? _h : 0
+    });
+    this.viewports = computeViewports(layout, this.viewportSize, this.scroll, this.freeze);
+  }
+  hitTest(point) {
+    const viewport = this.findViewport(point);
+    if (!viewport) return { kind: "none" };
+    if (viewport.kind === "corner") return { kind: "corner" };
+    const logicalX = point.x - viewport.screenRect.x + viewport.originX;
+    const logicalY = point.y - viewport.screenRect.y + viewport.originY;
+    if (viewport.kind === "columnHeaderScrollable" || viewport.kind === "columnHeaderFrozen") {
+      return { kind: "columnHeader", column: this.layout.columnAt(logicalX) };
+    }
+    if (viewport.kind === "rowHeaderScrollable" || viewport.kind === "rowHeaderFrozen") {
+      return { kind: "rowHeader", row: this.layout.rowAt(logicalY) };
+    }
+    return this.layout.hitTestLogical(logicalX, logicalY);
+  }
+  findViewport(point) {
+    for (let index = this.viewports.length - 1; index >= 0; index--) {
+      const viewport = this.viewports[index];
+      if (viewport && containsPoint(viewport.screenRect, point)) return viewport;
+    }
+    return void 0;
+  }
+  cellScreenRect(row, column, viewport) {
+    const logicalRect = this.layout.getCellLogicalRect(row, column);
+    return {
+      x: viewport.screenRect.x + logicalRect.x - viewport.originX,
+      y: viewport.screenRect.y + logicalRect.y - viewport.originY,
+      width: logicalRect.width,
+      height: logicalRect.height
+    };
+  }
+};
+__name(_SpreadsheetViewportManager, "SpreadsheetViewportManager");
+var SpreadsheetViewportManager = _SpreadsheetViewportManager;
+function freezeStateFromSheet(sheet) {
+  var _a;
+  const pane = (_a = sheet.sheetViews[0]) == null ? void 0 : _a.pane;
+  return freezeStateFromPane(pane);
+}
+__name(freezeStateFromSheet, "freezeStateFromSheet");
+function freezeStateFromPane(pane) {
+  var _a, _b;
+  if (!pane || pane.state !== "frozen") return { frozenRows: 0, frozenColumns: 0 };
+  return {
+    frozenRows: Math.max(0, Math.floor((_a = pane.ySplit) != null ? _a : 0)),
+    frozenColumns: Math.max(0, Math.floor((_b = pane.xSplit) != null ? _b : 0))
+  };
+}
+__name(freezeStateFromPane, "freezeStateFromPane");
+function clampScroll(layout, freeze, viewportSize, scroll) {
+  const frozenWidth = layout.getColumnX(freeze.frozenColumns + 1);
+  const frozenHeight = layout.getRowY(freeze.frozenRows + 1);
+  const mainWidth = Math.max(0, viewportSize.width - layout.rowHeaderWidth - frozenWidth);
+  const mainHeight = Math.max(0, viewportSize.height - layout.columnHeaderHeight - frozenHeight);
+  const maxX = Math.max(0, layout.totalWidth() - frozenWidth - mainWidth);
+  const maxY = Math.max(0, layout.totalHeight() - frozenHeight - mainHeight);
+  return {
+    x: Math.max(0, Math.min(maxX, scroll.x)),
+    y: Math.max(0, Math.min(maxY, scroll.y))
+  };
+}
+__name(clampScroll, "clampScroll");
+function computeViewports(layout, viewportSize, scroll, freeze) {
+  const headerW = layout.rowHeaderWidth;
+  const headerH = layout.columnHeaderHeight;
+  const frozenW = layout.getColumnX(freeze.frozenColumns + 1);
+  const frozenH = layout.getRowY(freeze.frozenRows + 1);
+  const scrollableX = frozenW + scroll.x;
+  const scrollableY = frozenH + scroll.y;
+  const bodyW = Math.max(0, viewportSize.width - headerW);
+  const bodyH = Math.max(0, viewportSize.height - headerH);
+  const mainX = headerW + frozenW;
+  const mainY = headerH + frozenH;
+  const mainW = Math.max(0, viewportSize.width - mainX);
+  const mainH = Math.max(0, viewportSize.height - mainY);
+  const viewports = [];
+  viewports.push({
+    kind: "corner",
+    screenRect: { x: 0, y: 0, width: headerW, height: headerH },
+    originX: 0,
+    originY: 0,
+    rows: { start: 1, end: 0 },
+    columns: { start: 1, end: 0 }
+  });
+  if (freeze.frozenColumns > 0) {
+    viewports.push({
+      kind: "columnHeaderFrozen",
+      screenRect: { x: headerW, y: 0, width: Math.min(frozenW, bodyW), height: headerH },
+      originX: 0,
+      originY: 0,
+      rows: { start: 1, end: 0 },
+      columns: { start: 1, end: freeze.frozenColumns }
+    });
+  }
+  viewports.push({
+    kind: "columnHeaderScrollable",
+    screenRect: {
+      x: headerW + frozenW,
+      y: 0,
+      width: Math.max(0, viewportSize.width - headerW - frozenW),
+      height: headerH
+    },
+    originX: scrollableX,
+    originY: 0,
+    rows: { start: 1, end: 0 },
+    columns: visibleColumns(layout, scrollableX, mainW, freeze.frozenColumns + 1)
+  });
+  if (freeze.frozenRows > 0) {
+    viewports.push({
+      kind: "rowHeaderFrozen",
+      screenRect: { x: 0, y: headerH, width: headerW, height: Math.min(frozenH, bodyH) },
+      originX: 0,
+      originY: 0,
+      rows: { start: 1, end: freeze.frozenRows },
+      columns: { start: 1, end: 0 }
+    });
+  }
+  viewports.push({
+    kind: "rowHeaderScrollable",
+    screenRect: {
+      x: 0,
+      y: headerH + frozenH,
+      width: headerW,
+      height: Math.max(0, viewportSize.height - headerH - frozenH)
+    },
+    originX: 0,
+    originY: scrollableY,
+    rows: visibleRows(layout, scrollableY, mainH, freeze.frozenRows + 1),
+    columns: { start: 1, end: 0 }
+  });
+  if (freeze.frozenRows > 0 && freeze.frozenColumns > 0) {
+    viewports.push({
+      kind: "frozenTopLeft",
+      screenRect: { x: headerW, y: headerH, width: frozenW, height: frozenH },
+      originX: 0,
+      originY: 0,
+      rows: { start: 1, end: freeze.frozenRows },
+      columns: { start: 1, end: freeze.frozenColumns }
+    });
+  }
+  if (freeze.frozenRows > 0) {
+    viewports.push({
+      kind: "frozenTop",
+      screenRect: { x: mainX, y: headerH, width: mainW, height: frozenH },
+      originX: scrollableX,
+      originY: 0,
+      rows: { start: 1, end: freeze.frozenRows },
+      columns: visibleColumns(layout, scrollableX, mainW, freeze.frozenColumns + 1)
+    });
+  }
+  if (freeze.frozenColumns > 0) {
+    viewports.push({
+      kind: "frozenLeft",
+      screenRect: { x: headerW, y: mainY, width: frozenW, height: mainH },
+      originX: 0,
+      originY: scrollableY,
+      rows: visibleRows(layout, scrollableY, mainH, freeze.frozenRows + 1),
+      columns: { start: 1, end: freeze.frozenColumns }
+    });
+  }
+  viewports.push({
+    kind: "main",
+    screenRect: { x: mainX, y: mainY, width: mainW, height: mainH },
+    originX: scrollableX,
+    originY: scrollableY,
+    rows: visibleRows(layout, scrollableY, mainH, freeze.frozenRows + 1),
+    columns: visibleColumns(layout, scrollableX, mainW, freeze.frozenColumns + 1)
+  });
+  return viewports.filter((viewport) => viewport.screenRect.width > 0 && viewport.screenRect.height > 0);
+}
+__name(computeViewports, "computeViewports");
+function visibleRows(layout, originY, height, minimumRow) {
+  const range = layout.getVisibleRange(0, originY, { width: 1, height }, minimumRow, 1);
+  return { start: range.startRow, end: range.endRow };
+}
+__name(visibleRows, "visibleRows");
+function visibleColumns(layout, originX, width, minimumColumn) {
+  const range = layout.getVisibleRange(originX, 0, { width, height: 1 }, 1, minimumColumn);
+  return { start: range.startColumn, end: range.endColumn };
+}
+__name(visibleColumns, "visibleColumns");
+function containsPoint(rect, point) {
+  return point.x >= rect.x && point.y >= rect.y && point.x < rect.x + rect.width && point.y < rect.y + rect.height;
+}
+__name(containsPoint, "containsPoint");
+
+// src/spreadsheet/style-resolver.ts
+function resolveSpreadsheetCellStyle(styles, styleId, cell) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
+  const format = (_a = styles.cellFormats[styleId != null ? styleId : 0]) != null ? _a : {};
+  const font = (_c = styles.fonts[(_b = format.fontId) != null ? _b : 0]) != null ? _c : {};
+  const fontSize = (_d = font.size) != null ? _d : 11;
+  const fill = (_f = styles.fills[(_e = format.fillId) != null ? _e : 0]) != null ? _f : {};
+  const border = (_h = styles.borders[(_g = format.borderId) != null ? _g : 0]) != null ? _h : {};
+  return {
+    font: canvasFont(font.bold, font.italic, fontSize, (_i = font.name) != null ? _i : "Arial"),
+    fontSize,
+    underline: font.underline === true,
+    fontColor: (_k = (_j = font.color) == null ? void 0 : _j.rgb) != null ? _k : "#111827",
+    fillColor: (_m = (_l = fill.foregroundColor) == null ? void 0 : _l.rgb) != null ? _m : "#FFFFFF",
+    wrapText: ((_n = format.alignment) == null ? void 0 : _n.wrapText) === true,
+    border,
+    horizontalAlign: resolveHorizontalAlign(format, cell),
+    verticalAlign: resolveVerticalAlign(format)
+  };
+}
+__name(resolveSpreadsheetCellStyle, "resolveSpreadsheetCellStyle");
+function resolveSpreadsheetRangeBorder(model, range) {
+  var _a, _b, _c, _d;
+  const border = {};
+  for (let column = range.startColumn; column <= range.endColumn; column++) {
+    (_a = border.top) != null ? _a : border.top = cellBorderSide(model, range.startRow, column, "top");
+    (_b = border.bottom) != null ? _b : border.bottom = cellBorderSide(model, range.endRow, column, "bottom");
+  }
+  for (let row = range.startRow; row <= range.endRow; row++) {
+    (_c = border.left) != null ? _c : border.left = cellBorderSide(model, row, range.startColumn, "left");
+    (_d = border.right) != null ? _d : border.right = cellBorderSide(model, row, range.endColumn, "right");
+  }
+  return border;
+}
+__name(resolveSpreadsheetRangeBorder, "resolveSpreadsheetRangeBorder");
+function cellBorderSide(model, row, column, side) {
+  var _a, _b, _c, _d;
+  const cell = getRenderCell(model, row, column);
+  const format = (_b = model.styles.cellFormats[(_a = cell == null ? void 0 : cell.styleId) != null ? _a : 0]) != null ? _b : {};
+  return (_d = model.styles.borders[(_c = format.borderId) != null ? _c : 0]) == null ? void 0 : _d[side];
+}
+__name(cellBorderSide, "cellBorderSide");
+function canvasFont(bold, italic, size, family) {
+  const parts = [];
+  if (italic) parts.push("italic");
+  if (bold) parts.push("600");
+  parts.push(`${size}px`);
+  parts.push(quoteFontFamily(family));
+  return parts.join(" ");
+}
+__name(canvasFont, "canvasFont");
+function quoteFontFamily(family) {
+  return /\s/.test(family) ? JSON.stringify(family) : family;
+}
+__name(quoteFontFamily, "quoteFontFamily");
+function resolveHorizontalAlign(format, cell) {
+  var _a;
+  switch ((_a = format.alignment) == null ? void 0 : _a.horizontal) {
+    case "left":
+      return "left";
+    case "center":
+      return "center";
+    case "right":
+      return "right";
+  }
+  if ((cell == null ? void 0 : cell.kind) === "number") return "right";
+  if ((cell == null ? void 0 : cell.kind) === "formula" && typeof cell.value === "number") return "right";
+  if ((cell == null ? void 0 : cell.kind) === "boolean" || (cell == null ? void 0 : cell.kind) === "error") return "center";
+  return "left";
+}
+__name(resolveHorizontalAlign, "resolveHorizontalAlign");
+function resolveVerticalAlign(format) {
+  var _a;
+  switch ((_a = format.alignment) == null ? void 0 : _a.vertical) {
+    case "top":
+      return "top";
+    case "center":
+    case "middle":
+      return "middle";
+    case "bottom":
+      return "bottom";
+    default:
+      return "bottom";
+  }
+}
+__name(resolveVerticalAlign, "resolveVerticalAlign");
+var _SpreadsheetCanvasRenderer = class _SpreadsheetCanvasRenderer {
+  constructor(options) {
+    __publicField(this, "options", options);
+    __publicField(this, "baseCtx");
+    __publicField(this, "headerCtx");
+    __publicField(this, "overlayCtx");
+    __publicField(this, "cssWidth", 1);
+    __publicField(this, "cssHeight", 1);
+    __publicField(this, "scaleX", 1);
+    __publicField(this, "scaleY", 1);
+    __publicField(this, "headerFiltersEnabled", true);
+    __publicField(this, "headerFilterColumns", null);
+    __publicField(this, "activeHeaderFilterColumns", /* @__PURE__ */ new Set());
+    this.baseCtx = get2dContext(options.baseCanvas);
+    this.headerCtx = get2dContext(options.headerCanvas);
+    this.overlayCtx = get2dContext(options.overlayCanvas);
+  }
+  resize(width, height, devicePixelRatio = globalThis.devicePixelRatio || 1) {
+    this.cssWidth = Math.max(1, width);
+    this.cssHeight = Math.max(1, height);
+    const ratio = Math.max(1, devicePixelRatio || 1);
+    for (const canvas of [
+      this.options.baseCanvas,
+      this.options.headerCanvas,
+      this.options.overlayCanvas
+    ]) {
+      canvas.style.width = `${this.cssWidth}px`;
+      canvas.style.height = `${this.cssHeight}px`;
+      canvas.width = Math.max(1, Math.ceil(this.cssWidth * ratio));
+      canvas.height = Math.max(1, Math.ceil(this.cssHeight * ratio));
+      const ctx = get2dContext(canvas);
+      this.scaleX = canvas.width / this.cssWidth;
+      this.scaleY = canvas.height / this.cssHeight;
+      ctx.setTransform(this.scaleX, 0, 0, this.scaleY, 0, 0);
+      ctx.imageSmoothingEnabled = false;
+    }
+  }
+  setHeaderFiltersEnabled(enabled) {
+    this.headerFiltersEnabled = enabled;
+  }
+  setHeaderFilterColumns(columns) {
+    this.headerFilterColumns = columns === null ? null : new Set(columns);
+  }
+  setActiveHeaderFilterColumns(columns) {
+    this.activeHeaderFilterColumns = new Set(columns);
+  }
+  render(layout, viewportManager) {
+    this.clearAll(layout, viewportManager);
+    this.drawCells(layout, viewportManager);
+    this.drawHeaders(layout, viewportManager);
+  }
+  clearOverlay() {
+    clearCanvas(this.overlayCtx, this.options.overlayCanvas);
+  }
+  renderSelection(layout, viewportManager, range, options = {}) {
+    this.clearOverlay();
+    const ctx = this.overlayCtx;
+    for (const viewport of viewportManager.viewports) {
+      if (!isCellViewport(viewport)) continue;
+      const intersection = intersectRange(range, {
+        startRow: viewport.rows.start,
+        endRow: viewport.rows.end,
+        startColumn: viewport.columns.start,
+        endColumn: viewport.columns.end
+      });
+      if (!intersection) continue;
+      const logical = layout.getRangeLogicalRect(intersection);
+      const rect = logicalRectToScreen(logical, viewport);
+      withClip(ctx, viewport.screenRect, () => {
+        ctx.fillStyle = "rgba(37, 99, 235, 0.08)";
+        ctx.fillRect(rect.x, rect.y, rect.width, rect.height);
+        ctx.strokeStyle = "#2563EB";
+        ctx.lineWidth = 2 / this.scaleX;
+        ctx.setLineDash([]);
+        strokeCrispRect(ctx, insetRect(rect, 1), this.scaleX, this.scaleY);
+      });
+    }
+    if (options.showFillHandle) this.drawFillHandle(layout, viewportManager, range);
+  }
+  fillHandleRect(layout, viewportManager, range) {
+    for (const viewport of viewportManager.viewports) {
+      if (!isCellViewport(viewport)) continue;
+      if (range.endRow < viewport.rows.start || range.endRow > viewport.rows.end || range.endColumn < viewport.columns.start || range.endColumn > viewport.columns.end) {
+        continue;
+      }
+      const cell = viewportManager.cellScreenRect(range.endRow, range.endColumn, viewport);
+      const size = 7;
+      return {
+        x: cell.x + cell.width - size / 2,
+        y: cell.y + cell.height - size / 2,
+        width: size,
+        height: size
+      };
+    }
+    return null;
+  }
+  renderCopiedRange(layout, viewportManager, range) {
+    this.renderDashedRange(layout, viewportManager, range, {
+      stroke: "#1D4ED8"
+    });
+  }
+  renderDashedRange(layout, viewportManager, range, options) {
+    const ctx = this.overlayCtx;
+    for (const viewport of viewportManager.viewports) {
+      if (!isCellViewport(viewport)) continue;
+      const intersection = intersectRange(range, {
+        startRow: viewport.rows.start,
+        endRow: viewport.rows.end,
+        startColumn: viewport.columns.start,
+        endColumn: viewport.columns.end
+      });
+      if (!intersection) continue;
+      const logical = layout.getRangeLogicalRect(intersection);
+      const rect = logicalRectToScreen(logical, viewport);
+      withClip(ctx, viewport.screenRect, () => {
+        ctx.save();
+        if (options.fill) {
+          ctx.fillStyle = options.fill;
+          ctx.fillRect(rect.x, rect.y, rect.width, rect.height);
+        }
+        ctx.strokeStyle = options.stroke;
+        ctx.lineWidth = 2 / this.scaleX;
+        ctx.setLineDash([4, 3]);
+        ctx.lineDashOffset = 0;
+        strokeCrispRect(ctx, insetRect(rect, 2), this.scaleX, this.scaleY);
+        ctx.restore();
+      });
+    }
+  }
+  clearAll(layout, viewportManager) {
+    clearCanvas(this.baseCtx, this.options.baseCanvas);
+    clearCanvas(this.headerCtx, this.options.headerCanvas);
+    clearCanvas(this.overlayCtx, this.options.overlayCanvas);
+  }
+  drawFillHandle(layout, viewportManager, range) {
+    const rect = this.fillHandleRect(layout, viewportManager, range);
+    if (!rect) return;
+    const ctx = this.overlayCtx;
+    ctx.save();
+    ctx.fillStyle = "#2563EB";
+    ctx.fillRect(rect.x, rect.y, rect.width, rect.height);
+    ctx.strokeStyle = "#FFFFFF";
+    ctx.lineWidth = 1 / this.scaleX;
+    strokeCrispRect(ctx, insetRect(rect, 0.5), this.scaleX, this.scaleY);
+    ctx.restore();
+  }
+  drawCells(layout, viewportManager) {
+    const ctx = this.baseCtx;
+    ctx.save();
+    ctx.fillStyle = "#FFFFFF";
+    ctx.fillRect(0, 0, this.cssWidth, this.cssHeight);
+    ctx.restore();
+    for (const viewport of viewportManager.viewports) {
+      if (!isCellViewport(viewport)) continue;
+      withClip(ctx, viewport.screenRect, () => {
+        for (let row = viewport.rows.start; row <= viewport.rows.end; row++) {
+          for (let column = viewport.columns.start; column <= viewport.columns.end; column++) {
+            const address = formatCellAddress(row, column);
+            const mergeMaster = layout.model.mergeFollowerByAddress.get(address);
+            if (mergeMaster) continue;
+            this.drawCell(ctx, layout, viewportManager, viewport, row, column, {
+              drawBorder: false,
+              reserveTrailingSpace: this.headerFiltersEnabled && row === 1
+            });
+            if (this.headerFiltersEnabled && row === 1 && (this.headerFilterColumns === null || this.headerFilterColumns.has(column))) {
+              const logical = layout.getCellLogicalRect(row, column);
+              const rect = {
+                x: viewport.screenRect.x + logical.x - viewport.originX,
+                y: viewport.screenRect.y + logical.y - viewport.originY,
+                width: logical.width,
+                height: logical.height
+              };
+              drawFilterIcon(
+                ctx,
+                rect,
+                this.scaleX,
+                this.scaleY,
+                this.activeHeaderFilterColumns.has(column)
+              );
+            }
+          }
+        }
+        for (let row = viewport.rows.start; row <= viewport.rows.end; row++) {
+          for (let column = viewport.columns.start; column <= viewport.columns.end; column++) {
+            const address = formatCellAddress(row, column);
+            const mergeMaster = layout.model.mergeFollowerByAddress.get(address);
+            if (mergeMaster) continue;
+            this.drawCell(ctx, layout, viewportManager, viewport, row, column, {
+              drawContent: false
+            });
+          }
+        }
+      });
+    }
+  }
+  drawCell(ctx, layout, viewportManager, viewport, row, column, options = {}) {
+    const cell = getRenderCell(layout.model, row, column);
+    const merge = cell ? layout.model.mergeMasterByAddress.get(cell.address) : void 0;
+    const rect = merge ? logicalRectToScreen(layout.getRangeLogicalRect(merge.range), viewport) : viewportManager.cellScreenRect(row, column, viewport);
+    const style = resolveSpreadsheetCellStyle(layout.model.styles, cell == null ? void 0 : cell.styleId, cell);
+    const border = merge ? resolveSpreadsheetRangeBorder(layout.model, merge.range) : style.border;
+    if (options.drawContent !== false) {
+      ctx.fillStyle = style.fillColor;
+      ctx.fillRect(rect.x, rect.y, rect.width, rect.height);
+      ctx.strokeStyle = "#E5E7EB";
+      ctx.lineWidth = 1 / this.scaleX;
+      strokeCrispRect(ctx, rect, this.scaleX, this.scaleY);
+    }
+    if (options.drawBorder !== false) drawCellBorder(ctx, rect, border, this.scaleX, this.scaleY);
+    if (options.drawContent === false || !(cell == null ? void 0 : cell.displayText)) return;
+    ctx.save();
+    ctx.font = style.font;
+    ctx.fillStyle = style.fontColor;
+    ctx.textAlign = style.horizontalAlign;
+    ctx.textBaseline = "middle";
+    const padding = 6;
+    const trailingSpace = options.reserveTrailingSpace && rect.width >= 28 ? 22 : 0;
+    const contentRect = {
+      x: rect.x,
+      y: rect.y,
+      width: Math.max(1, rect.width - trailingSpace),
+      height: rect.height
+    };
+    const textX = style.horizontalAlign === "right" ? contentRect.x + contentRect.width - padding : style.horizontalAlign === "center" ? contentRect.x + contentRect.width / 2 : contentRect.x + padding;
+    withClip(ctx, contentRect, () => {
+      const lines = style.wrapText || cell.displayText.includes("\n") ? wrapCanvasText(ctx, cell.displayText, Math.max(1, contentRect.width - padding * 2)) : [cell.displayText];
+      const lineHeight = style.fontSize * 1.2;
+      const blockHeight = lines.length * lineHeight;
+      const firstTextY = textBlockStartY(rect, style, padding, blockHeight, lineHeight);
+      for (let index = 0; index < lines.length; index++) {
+        const line = lines[index];
+        const lineY = firstTextY + index * lineHeight;
+        ctx.fillText(line, textX, lineY);
+        if (style.underline) drawTextUnderline(ctx, line, textX, lineY, style, this.scaleX, this.scaleY);
+      }
+    });
+    ctx.restore();
+  }
+  drawHeaders(layout, viewportManager) {
+    const ctx = this.headerCtx;
+    for (const viewport of viewportManager.viewports) {
+      withClip(ctx, viewport.screenRect, () => {
+        if (viewport.kind === "corner") {
+          drawHeaderRect(ctx, viewport.screenRect, "", this.scaleX, this.scaleY);
+        } else if (viewport.kind === "columnHeaderFrozen" || viewport.kind === "columnHeaderScrollable") {
+          for (let column = viewport.columns.start; column <= viewport.columns.end; column++) {
+            const logical = layout.getCellLogicalRect(1, column);
+            const rect = {
+              x: viewport.screenRect.x + logical.x - viewport.originX,
+              y: viewport.screenRect.y,
+              width: logical.width,
+              height: viewport.screenRect.height
+            };
+            drawHeaderRect(ctx, rect, columnIndexToName(column), this.scaleX, this.scaleY);
+          }
+        } else if (viewport.kind === "rowHeaderFrozen" || viewport.kind === "rowHeaderScrollable") {
+          for (let row = viewport.rows.start; row <= viewport.rows.end; row++) {
+            const logical = layout.getCellLogicalRect(row, 1);
+            const rect = {
+              x: viewport.screenRect.x,
+              y: viewport.screenRect.y + logical.y - viewport.originY,
+              width: viewport.screenRect.width,
+              height: logical.height
+            };
+            drawHeaderRect(ctx, rect, String(row), this.scaleX, this.scaleY);
+          }
+        }
+      });
+    }
+  }
+};
+__name(_SpreadsheetCanvasRenderer, "SpreadsheetCanvasRenderer");
+var SpreadsheetCanvasRenderer = _SpreadsheetCanvasRenderer;
+function drawFilterIcon(ctx, rect, scaleX, scaleY, active = false) {
+  if (rect.width < 28) return;
+  const centerX = rect.x + rect.width - 10;
+  const centerY = rect.y + rect.height / 2;
+  ctx.save();
+  ctx.strokeStyle = active ? "#2563EB" : "#64748B";
+  ctx.lineWidth = 1 / scaleX;
+  ctx.lineCap = "round";
+  ctx.beginPath();
+  ctx.moveTo(centerX - 4, centerY - 3);
+  ctx.lineTo(centerX + 4, centerY - 3);
+  ctx.lineTo(centerX + 1, centerY + 1);
+  ctx.lineTo(centerX + 1, centerY + 4);
+  ctx.lineTo(centerX - 1, centerY + 3);
+  ctx.lineTo(centerX - 1, centerY + 1);
+  ctx.closePath();
+  ctx.stroke();
+  ctx.restore();
+}
+__name(drawFilterIcon, "drawFilterIcon");
+function intersectRange(a, b) {
+  const startRow = Math.max(a.startRow, b.startRow);
+  const startColumn = Math.max(a.startColumn, b.startColumn);
+  const endRow = Math.min(a.endRow, b.endRow);
+  const endColumn = Math.min(a.endColumn, b.endColumn);
+  if (startRow > endRow || startColumn > endColumn) return null;
+  return { startRow, startColumn, endRow, endColumn };
+}
+__name(intersectRange, "intersectRange");
+function get2dContext(canvas) {
+  const ctx = canvas.getContext("2d");
+  if (!ctx) throw new Error("SpreadsheetCanvasRenderer: 2D canvas context is unavailable");
+  return ctx;
+}
+__name(get2dContext, "get2dContext");
+function clearCanvas(ctx, canvas) {
+  const width = Number.parseFloat(canvas.style.width) || canvas.width;
+  const height = Number.parseFloat(canvas.style.height) || canvas.height;
+  ctx.clearRect(0, 0, width, height);
+}
+__name(clearCanvas, "clearCanvas");
+function withClip(ctx, rect, draw) {
+  ctx.save();
+  ctx.beginPath();
+  ctx.rect(rect.x, rect.y, rect.width, rect.height);
+  ctx.clip();
+  draw();
+  ctx.restore();
+}
+__name(withClip, "withClip");
+function isCellViewport(viewport) {
+  return viewport.kind === "main" || viewport.kind === "frozenTop" || viewport.kind === "frozenLeft" || viewport.kind === "frozenTopLeft";
+}
+__name(isCellViewport, "isCellViewport");
+function logicalRectToScreen(rect, viewport) {
+  return {
+    x: viewport.screenRect.x + rect.x - viewport.originX,
+    y: viewport.screenRect.y + rect.y - viewport.originY,
+    width: rect.width,
+    height: rect.height
+  };
+}
+__name(logicalRectToScreen, "logicalRectToScreen");
+function drawHeaderRect(ctx, rect, text, scaleX, scaleY) {
+  ctx.fillStyle = "#F3F4F6";
+  ctx.fillRect(rect.x, rect.y, rect.width, rect.height);
+  ctx.strokeStyle = "#D1D5DB";
+  ctx.lineWidth = 1 / scaleX;
+  strokeCrispRect(ctx, rect, scaleX, scaleY);
+  if (!text) return;
+  ctx.font = "12px Arial";
+  ctx.fillStyle = "#374151";
+  ctx.textAlign = "center";
+  ctx.textBaseline = "middle";
+  ctx.fillText(text, rect.x + rect.width / 2, rect.y + rect.height / 2);
+}
+__name(drawHeaderRect, "drawHeaderRect");
+function drawCellBorder(ctx, rect, border, scaleX, scaleY) {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  if (!border.left && !border.right && !border.top && !border.bottom) return;
+  ctx.save();
+  ctx.lineWidth = 1 / scaleX;
+  ctx.setLineDash([]);
+  if (border.top) {
+    ctx.strokeStyle = (_b = (_a = border.top.color) == null ? void 0 : _a.rgb) != null ? _b : "#111827";
+    drawCrispLine(ctx, rect.x, rect.y, rect.x + rect.width, rect.y, scaleX, scaleY);
+  }
+  if (border.right) {
+    ctx.strokeStyle = (_d = (_c = border.right.color) == null ? void 0 : _c.rgb) != null ? _d : "#111827";
+    drawCrispLine(ctx, rect.x + rect.width, rect.y, rect.x + rect.width, rect.y + rect.height, scaleX, scaleY);
+  }
+  if (border.bottom) {
+    ctx.strokeStyle = (_f = (_e = border.bottom.color) == null ? void 0 : _e.rgb) != null ? _f : "#111827";
+    drawCrispLine(ctx, rect.x, rect.y + rect.height, rect.x + rect.width, rect.y + rect.height, scaleX, scaleY);
+  }
+  if (border.left) {
+    ctx.strokeStyle = (_h = (_g = border.left.color) == null ? void 0 : _g.rgb) != null ? _h : "#111827";
+    drawCrispLine(ctx, rect.x, rect.y, rect.x, rect.y + rect.height, scaleX, scaleY);
+  }
+  ctx.restore();
+}
+__name(drawCellBorder, "drawCellBorder");
+function textBlockStartY(rect, style, padding, blockHeight, lineHeight) {
+  if (style.verticalAlign === "top") return rect.y + padding + lineHeight / 2;
+  if (style.verticalAlign === "bottom") return rect.y + rect.height - padding - blockHeight + lineHeight / 2;
+  return rect.y + (rect.height - blockHeight) / 2 + lineHeight / 2;
+}
+__name(textBlockStartY, "textBlockStartY");
+function wrapCanvasText(ctx, text, maxWidth) {
+  const lines = [];
+  for (const paragraph of text.split(/\r?\n/)) {
+    if (paragraph === "") {
+      lines.push("");
+      continue;
+    }
+    let line = "";
+    for (const character of paragraph) {
+      const candidate = line + character;
+      if (line && ctx.measureText(candidate).width > maxWidth) {
+        lines.push(line);
+        line = character;
+      } else {
+        line = candidate;
+      }
+    }
+    if (line) lines.push(line);
+  }
+  return lines.length > 0 ? lines : [""];
+}
+__name(wrapCanvasText, "wrapCanvasText");
+function drawCrispLine(ctx, x1, y1, x2, y2, scaleX, scaleY) {
+  ctx.beginPath();
+  ctx.moveTo(snapStrokeCoordinate(x1, scaleX), snapStrokeCoordinate(y1, scaleY));
+  ctx.lineTo(snapStrokeCoordinate(x2, scaleX), snapStrokeCoordinate(y2, scaleY));
+  ctx.stroke();
+}
+__name(drawCrispLine, "drawCrispLine");
+function drawTextUnderline(ctx, text, textX, textY, style, scaleX, scaleY) {
+  const metrics = ctx.measureText(text);
+  const width = metrics.width;
+  const startX = style.horizontalAlign === "right" ? textX - width : style.horizontalAlign === "center" ? textX - width / 2 : textX;
+  const underlineOffset = Math.max(2, (metrics.actualBoundingBoxDescent || style.fontSize * 0.18) + 1);
+  ctx.save();
+  ctx.strokeStyle = style.fontColor;
+  ctx.lineWidth = 1 / scaleX;
+  drawCrispLine(ctx, startX, textY + underlineOffset, startX + width, textY + underlineOffset, scaleX, scaleY);
+  ctx.restore();
+}
+__name(drawTextUnderline, "drawTextUnderline");
+function insetRect(rect, inset) {
+  return {
+    x: rect.x + inset,
+    y: rect.y + inset,
+    width: Math.max(0, rect.width - inset * 2),
+    height: Math.max(0, rect.height - inset * 2)
+  };
+}
+__name(insetRect, "insetRect");
+function strokeCrispRect(ctx, rect, scaleX, scaleY) {
+  const x = snapStrokeCoordinate(rect.x, scaleX);
+  const y = snapStrokeCoordinate(rect.y, scaleY);
+  const right = snapStrokeCoordinate(rect.x + rect.width, scaleX);
+  const bottom = snapStrokeCoordinate(rect.y + rect.height, scaleY);
+  ctx.strokeRect(x, y, Math.max(0, right - x), Math.max(0, bottom - y));
+}
+__name(strokeCrispRect, "strokeCrispRect");
+function snapStrokeCoordinate(value, scale) {
+  return (Math.round(value * scale) + 0.5) / scale;
+}
+__name(snapStrokeCoordinate, "snapStrokeCoordinate");
+function createSelection(row, column) {
+  return {
+    kind: "cell",
+    active: { row, column },
+    range: { startRow: row, startColumn: column, endRow: row, endColumn: column }
+  };
+}
+__name(createSelection, "createSelection");
+function createRowSelection(row, bounds) {
+  return {
+    kind: "row",
+    active: { row, column: 1 },
+    range: { startRow: row, startColumn: 1, endRow: row, endColumn: bounds.columnCount }
+  };
+}
+__name(createRowSelection, "createRowSelection");
+function createRowRangeSelection(startRow, endRow, bounds) {
+  const range = normalizeSelectionRange({
+    startRow,
+    startColumn: 1,
+    endRow,
+    endColumn: bounds.columnCount
+  });
+  return {
+    kind: "row",
+    active: { row: range.startRow, column: 1 },
+    range
+  };
+}
+__name(createRowRangeSelection, "createRowRangeSelection");
+function createColumnSelection(column, bounds) {
+  return {
+    kind: "column",
+    active: { row: 1, column },
+    range: { startRow: 1, startColumn: column, endRow: bounds.rowCount, endColumn: column }
+  };
+}
+__name(createColumnSelection, "createColumnSelection");
+function createColumnRangeSelection(startColumn, endColumn, bounds) {
+  const range = normalizeSelectionRange({
+    startRow: 1,
+    startColumn,
+    endRow: bounds.rowCount,
+    endColumn
+  });
+  return {
+    kind: "column",
+    active: { row: 1, column: range.startColumn },
+    range
+  };
+}
+__name(createColumnRangeSelection, "createColumnRangeSelection");
+function normalizeSelectionRange(range) {
+  return {
+    startRow: Math.min(range.startRow, range.endRow),
+    startColumn: Math.min(range.startColumn, range.endColumn),
+    endRow: Math.max(range.startRow, range.endRow),
+    endColumn: Math.max(range.startColumn, range.endColumn)
+  };
+}
+__name(normalizeSelectionRange, "normalizeSelectionRange");
+function extendSelection(selection, row, column, bounds) {
+  var _a, _b;
+  if (selection.kind === "row") {
+    return {
+      kind: "row",
+      active: selection.active,
+      range: normalizeSelectionRange({
+        startRow: selection.active.row,
+        startColumn: 1,
+        endRow: row,
+        endColumn: (_a = bounds == null ? void 0 : bounds.columnCount) != null ? _a : selection.range.endColumn
+      })
+    };
+  }
+  if (selection.kind === "column") {
+    return {
+      kind: "column",
+      active: selection.active,
+      range: normalizeSelectionRange({
+        startRow: 1,
+        startColumn: selection.active.column,
+        endRow: (_b = bounds == null ? void 0 : bounds.rowCount) != null ? _b : selection.range.endRow,
+        endColumn: column
+      })
+    };
+  }
+  return {
+    kind: "cell",
+    active: selection.active,
+    range: normalizeSelectionRange({
+      startRow: selection.active.row,
+      startColumn: selection.active.column,
+      endRow: row,
+      endColumn: column
+    })
+  };
+}
+__name(extendSelection, "extendSelection");
+function moveSelection(selection, deltaRow, deltaColumn, bounds) {
+  return createSelection(
+    clamp(selection.active.row + deltaRow, 1, bounds.rowCount),
+    clamp(selection.active.column + deltaColumn, 1, bounds.columnCount)
+  );
+}
+__name(moveSelection, "moveSelection");
+function expandSelectionForMergedRanges(selection, model) {
+  var _a;
+  if (selection.kind !== "cell") return selection;
+  const active = (_a = mergeMasterPointForCell(selection.active.row, selection.active.column, model)) != null ? _a : selection.active;
+  return __spreadProps(__spreadValues({}, selection), { active, range: expandRangeForMergedRanges(selection.range, model) });
+}
+__name(expandSelectionForMergedRanges, "expandSelectionForMergedRanges");
+function expandRangeForMergedRanges(range, model) {
+  let expanded = normalizeSelectionRange(range);
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const merge of model.mergeMasterByAddress.values()) {
+      if (!rangesIntersect(expanded, merge.range)) continue;
+      const next = {
+        startRow: Math.min(expanded.startRow, merge.range.startRow),
+        startColumn: Math.min(expanded.startColumn, merge.range.startColumn),
+        endRow: Math.max(expanded.endRow, merge.range.endRow),
+        endColumn: Math.max(expanded.endColumn, merge.range.endColumn)
+      };
+      changed = next.startRow !== expanded.startRow || next.startColumn !== expanded.startColumn || next.endRow !== expanded.endRow || next.endColumn !== expanded.endColumn;
+      expanded = next;
+    }
+  }
+  return expanded;
+}
+__name(expandRangeForMergedRanges, "expandRangeForMergedRanges");
+function selectionAfterRowDeletion(selection, deletedStartRow, deletedCount, bounds, model) {
+  const nextRow = clamp(positionAfterDeletion(selection.active.row, deletedStartRow, deletedCount), 1, bounds.rowCount);
+  const nextColumn = clamp(selection.active.column, 1, bounds.columnCount);
+  if (selection.kind === "row") {
+    return createRowSelection(nextRow, { columnCount: bounds.columnCount });
+  }
+  return expandSelectionForMergedRanges(createSelection(nextRow, nextColumn), model);
+}
+__name(selectionAfterRowDeletion, "selectionAfterRowDeletion");
+function selectionAfterColumnDeletion(selection, deletedStartColumn, deletedCount, bounds, model) {
+  const nextRow = clamp(selection.active.row, 1, bounds.rowCount);
+  const nextColumn = clamp(positionAfterDeletion(selection.active.column, deletedStartColumn, deletedCount), 1, bounds.columnCount);
+  if (selection.kind === "column") {
+    return createColumnSelection(nextColumn, { rowCount: bounds.rowCount });
+  }
+  return expandSelectionForMergedRanges(createSelection(nextRow, nextColumn), model);
+}
+__name(selectionAfterColumnDeletion, "selectionAfterColumnDeletion");
+function positionAfterDeletion(position, deletedStart, deletedCount) {
+  const deletedEnd = deletedStart + deletedCount - 1;
+  if (position < deletedStart) return position;
+  if (position > deletedEnd) return position - deletedCount;
+  return deletedStart;
+}
+__name(positionAfterDeletion, "positionAfterDeletion");
+function rangesIntersect(a, b) {
+  return !(a.endRow < b.startRow || a.startRow > b.endRow || a.endColumn < b.startColumn || a.startColumn > b.endColumn);
+}
+__name(rangesIntersect, "rangesIntersect");
+function mergeMasterPointForCell(row, column, model) {
+  const masterAddress = model.mergeFollowerByAddress.get(formatCellAddress(row, column));
+  if (!masterAddress) return null;
+  const merge = model.mergeMasterByAddress.get(masterAddress);
+  if (!merge) return null;
+  return { row: merge.range.startRow, column: merge.range.startColumn };
+}
+__name(mergeMasterPointForCell, "mergeMasterPointForCell");
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+__name(clamp, "clamp");
+function buildSpreadsheetClipboardPayload(model, range) {
+  const text = serializeRangeToTsv(model, range);
+  return {
+    text,
+    values: parseTsv(text),
+    styleIds: rangeStyleIdsForClipboard(model, range),
+    merges: mergedRangesForClipboard(model, range)
+  };
+}
+__name(buildSpreadsheetClipboardPayload, "buildSpreadsheetClipboardPayload");
+function serializeRangeToTsv(model, range) {
+  const lines = [];
+  for (let row = range.startRow; row <= range.endRow; row++) {
+    const values = [];
+    for (let column = range.startColumn; column <= range.endColumn; column++) {
+      values.push(escapeTsvValue(clipboardCellText(model, row, column)));
+    }
+    lines.push(values.join("	"));
+  }
+  return lines.join("\n");
+}
+__name(serializeRangeToTsv, "serializeRangeToTsv");
+function parseTsv(text) {
+  return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n").filter((line, index, lines) => !(index === lines.length - 1 && line === "")).map((line) => line.split("	").map(coerceClipboardValue));
+}
+__name(parseTsv, "parseTsv");
+function rangeAddressForMatrix(startRow, startColumn, values) {
+  const rowCount = Math.max(1, values.length);
+  const columnCount = Math.max(1, values.reduce((max, row) => Math.max(max, row.length), 0));
+  return formatRangeAddress(startRow, startColumn, rowCount, columnCount);
+}
+__name(rangeAddressForMatrix, "rangeAddressForMatrix");
+function escapeTsvValue(value) {
+  return value.replace(/\t/g, " ").replace(/\r?\n/g, " ");
+}
+__name(escapeTsvValue, "escapeTsvValue");
+function clipboardCellText(model, row, column) {
+  var _a, _b;
+  const address = formatCellAddress(row, column);
+  if (model.mergeFollowerByAddress.has(address)) return "";
+  return (_b = (_a = getRenderCell(model, row, column)) == null ? void 0 : _a.displayText) != null ? _b : "";
+}
+__name(clipboardCellText, "clipboardCellText");
+function mergedRangesForClipboard(model, range) {
+  const merges = [];
+  for (const merge of model.mergeMasterByAddress.values()) {
+    if (!rangeContainsRange(range, merge.range)) continue;
+    merges.push({
+      startRowOffset: merge.range.startRow - range.startRow,
+      startColumnOffset: merge.range.startColumn - range.startColumn,
+      rowCount: merge.range.endRow - merge.range.startRow + 1,
+      columnCount: merge.range.endColumn - merge.range.startColumn + 1
+    });
+  }
+  return merges;
+}
+__name(mergedRangesForClipboard, "mergedRangesForClipboard");
+function rangeStyleIdsForClipboard(model, range) {
+  var _a;
+  const styleIds = [];
+  for (let row = range.startRow; row <= range.endRow; row++) {
+    const line = [];
+    for (let column = range.startColumn; column <= range.endColumn; column++) {
+      line.push((_a = getRenderCell(model, row, column)) == null ? void 0 : _a.styleId);
+    }
+    styleIds.push(line);
+  }
+  return styleIds;
+}
+__name(rangeStyleIdsForClipboard, "rangeStyleIdsForClipboard");
+function rangeContainsRange(outer, inner) {
+  return inner.startRow >= outer.startRow && inner.endRow <= outer.endRow && inner.startColumn >= outer.startColumn && inner.endColumn <= outer.endColumn;
+}
+__name(rangeContainsRange, "rangeContainsRange");
+function coerceClipboardValue(value) {
+  if (value === "") return null;
+  const number = Number(value);
+  if (Number.isFinite(number) && value.trim() !== "") return number;
+  if (value === "TRUE") return true;
+  if (value === "FALSE") return false;
+  return value;
+}
+__name(coerceClipboardValue, "coerceClipboardValue");
+function buildSpreadsheetAutoFillPlan(model, sourceRange, targetRange) {
+  var _a;
+  const source = normalizeRange(sourceRange);
+  const target = normalizeRange(targetRange);
+  const direction = resolveAutoFillDirection(source, target);
+  if (rangeTouchesMergedCells(source, model) || rangeTouchesMergedCells(target, model)) {
+    throw new Error("Auto fill does not support merged cells");
+  }
+  const cells = [];
+  for (let row = target.startRow; row <= target.endRow; row++) {
+    for (let column = target.startColumn; column <= target.endColumn; column++) {
+      if (isInsideRange(row, column, source)) continue;
+      const sourceRow = direction === "down" ? source.startRow + modulo(row - source.startRow, heightOf(source)) : row;
+      const sourceColumn = direction === "right" ? source.startColumn + modulo(column - source.startColumn, widthOf(source)) : column;
+      const sourceCell = getRenderCell(model, sourceRow, sourceColumn);
+      const sequenceValue = autoFillSequenceValue(model, source, direction, row, column);
+      const formula = (sourceCell == null ? void 0 : sourceCell.formula) ? shiftFormulaReferences(sourceCell.formula, row - sourceRow, column - sourceColumn) : void 0;
+      cells.push({
+        row,
+        column,
+        value: formula ? null : (_a = sequenceValue != null ? sequenceValue : sourceCell == null ? void 0 : sourceCell.source.value) != null ? _a : null,
+        formula,
+        styleId: sourceCell == null ? void 0 : sourceCell.styleId
+      });
+    }
+  }
+  return { direction, source, target, cells };
+}
+__name(buildSpreadsheetAutoFillPlan, "buildSpreadsheetAutoFillPlan");
+function supportsSpreadsheetAutoFill(model, sourceRange) {
+  return !rangeTouchesMergedCells(normalizeRange(sourceRange), model);
+}
+__name(supportsSpreadsheetAutoFill, "supportsSpreadsheetAutoFill");
+function resolveAutoFillDirection(source, target) {
+  const fillsDown = target.startRow === source.startRow && target.startColumn === source.startColumn && target.endColumn === source.endColumn && target.endRow > source.endRow;
+  if (fillsDown) return "down";
+  const fillsRight = target.startRow === source.startRow && target.endRow === source.endRow && target.startColumn === source.startColumn && target.endColumn > source.endColumn;
+  if (fillsRight) return "right";
+  throw new Error("Auto fill target must extend the source selection down or right");
+}
+__name(resolveAutoFillDirection, "resolveAutoFillDirection");
+function autoFillSequenceValue(model, source, direction, row, column) {
+  const length = direction === "down" ? heightOf(source) : widthOf(source);
+  if (length < 2) return void 0;
+  const values = Array.from({ length }, (_, index) => {
+    const sourceRow = direction === "down" ? source.startRow + index : row;
+    const sourceColumn = direction === "right" ? source.startColumn + index : column;
+    const cell = getRenderCell(model, sourceRow, sourceColumn);
+    return (cell == null ? void 0 : cell.formula) ? void 0 : cell == null ? void 0 : cell.source.value;
+  });
+  if (!values.every((value) => typeof value === "number" && Number.isFinite(value))) {
+    return void 0;
+  }
+  const step = values[1] - values[0];
+  if (!values.every((value, index) => index === 0 || value === values[0] + step * index)) return void 0;
+  const position = direction === "down" ? row - source.startRow : column - source.startColumn;
+  return values[0] + step * position;
+}
+__name(autoFillSequenceValue, "autoFillSequenceValue");
+function rangeTouchesMergedCells(range, model) {
+  for (const merge of model.mergeMasterByAddress.values()) {
+    if (rangesIntersect2(range, merge.range)) return true;
+  }
+  return false;
+}
+__name(rangeTouchesMergedCells, "rangeTouchesMergedCells");
+function normalizeRange(range) {
+  return {
+    startRow: Math.min(range.startRow, range.endRow),
+    startColumn: Math.min(range.startColumn, range.endColumn),
+    endRow: Math.max(range.startRow, range.endRow),
+    endColumn: Math.max(range.startColumn, range.endColumn)
+  };
+}
+__name(normalizeRange, "normalizeRange");
+function heightOf(range) {
+  return range.endRow - range.startRow + 1;
+}
+__name(heightOf, "heightOf");
+function widthOf(range) {
+  return range.endColumn - range.startColumn + 1;
+}
+__name(widthOf, "widthOf");
+function isInsideRange(row, column, range) {
+  return row >= range.startRow && row <= range.endRow && column >= range.startColumn && column <= range.endColumn;
+}
+__name(isInsideRange, "isInsideRange");
+function rangesIntersect2(a, b) {
+  return !(a.endRow < b.startRow || a.startRow > b.endRow || a.endColumn < b.startColumn || a.startColumn > b.endColumn);
+}
+__name(rangesIntersect2, "rangesIntersect");
+function modulo(value, divisor) {
+  return (value % divisor + divisor) % divisor;
+}
+__name(modulo, "modulo");
+async function setSpreadsheetCellValue(workbook, sheetName, address, value) {
+  await workbook.worksheets.getItem(sheetName).getCell(address).setValue(value);
+}
+__name(setSpreadsheetCellValue, "setSpreadsheetCellValue");
+async function setSpreadsheetCellFormula(workbook, sheetName, address, formula) {
+  await workbook.worksheets.getItem(sheetName).getCell(address).setFormula(formula);
+}
+__name(setSpreadsheetCellFormula, "setSpreadsheetCellFormula");
+async function setSpreadsheetRangeValues(workbook, sheetName, startRow, startColumn, values) {
+  const rowCount = values.length;
+  const columnCount = values.reduce((max, row) => Math.max(max, row.length), 0);
+  const normalized = values.map((row) => {
+    const next = row.slice();
+    while (next.length < columnCount) next.push(null);
+    return next;
+  });
+  await workbook.worksheets.getItem(sheetName).getRange(formatRangeAddress(startRow, startColumn, rowCount, columnCount)).setValues(normalized);
+}
+__name(setSpreadsheetRangeValues, "setSpreadsheetRangeValues");
+async function clearSpreadsheetRange(workbook, sheetName, startRow, startColumn, rowCount, columnCount) {
+  await workbook.worksheets.getItem(sheetName).getRange(formatRangeAddress(startRow, startColumn, rowCount, columnCount)).clear();
+}
+__name(clearSpreadsheetRange, "clearSpreadsheetRange");
+async function setSpreadsheetRowHeight(workbook, sheetName, row, height) {
+  await workbook.worksheets.getItem(sheetName).getRange(formatCellAddress(row, 1)).setRowHeight(height);
+}
+__name(setSpreadsheetRowHeight, "setSpreadsheetRowHeight");
+async function setSpreadsheetColumnWidth(workbook, sheetName, column, width) {
+  await workbook.worksheets.getItem(sheetName).getRange(formatCellAddress(1, column)).setColumnWidth(cssPixelsToExcelColumnWidth(width));
+}
+__name(setSpreadsheetColumnWidth, "setSpreadsheetColumnWidth");
+
+// src/spreadsheet/search.ts
+function buildSpreadsheetReplacePlan(model, options) {
+  const query = options.query.trim();
+  if (!query) return [];
+  const matches = [];
+  const cells = [...model.cellsByAddress.values()].sort((a, b) => a.row - b.row || a.column - b.column);
+  for (const cell of cells) {
+    if (!searchableCellText(cell, options.matchCase === true).includes(normalizeSearchText(query, options.matchCase === true))) continue;
+    if (cell.formula) {
+      const formulaQuery = query.startsWith("=") ? query.slice(1) : query;
+      matches.push({ address: cell.address, formula: replaceText(cell.formula, formulaQuery, options.replacement, options.matchCase === true) });
+    } else {
+      const source = cell.value === null ? "" : String(cell.value);
+      matches.push({ address: cell.address, value: replaceText(source, query, options.replacement, options.matchCase === true) });
+    }
+  }
+  return matches;
+}
+__name(buildSpreadsheetReplacePlan, "buildSpreadsheetReplacePlan");
+function findSpreadsheetMatches(model, options) {
+  const query = normalizeSearchText(options.query, options.matchCase === true);
+  if (!query) return [];
+  const matches = [];
+  const cells = [...model.cellsByAddress.values()].sort((a, b) => a.row - b.row || a.column - b.column);
+  for (const cell of cells) {
+    const haystack = searchableCellText(cell, options.matchCase === true);
+    if (!haystack.includes(query)) continue;
+    matches.push({ row: cell.row, column: cell.column, address: cell.address, text: cell.displayText });
+  }
+  return matches;
+}
+__name(findSpreadsheetMatches, "findSpreadsheetMatches");
+function nextSpreadsheetMatch(matches, active, direction = "forward") {
+  var _a, _b, _c, _d;
+  if (matches.length === 0) return null;
+  if (direction === "backward") {
+    return (_b = (_a = [...matches].reverse().find((match) => compareCellPosition(match, active) < 0)) != null ? _a : matches[matches.length - 1]) != null ? _b : null;
+  }
+  return (_d = (_c = matches.find((match) => compareCellPosition(match, active) > 0)) != null ? _c : matches[0]) != null ? _d : null;
+}
+__name(nextSpreadsheetMatch, "nextSpreadsheetMatch");
+function rangeForSpreadsheetMatch(match) {
+  return {
+    startRow: match.row,
+    startColumn: match.column,
+    endRow: match.row,
+    endColumn: match.column
+  };
+}
+__name(rangeForSpreadsheetMatch, "rangeForSpreadsheetMatch");
+function searchableCellText(cell, matchCase) {
+  const parts = [
+    cell.displayText,
+    rawCellValueText(cell.value),
+    cell.formula ? `=${cell.formula}` : ""
+  ].filter(Boolean);
+  return normalizeSearchText(parts.join("\n"), matchCase);
+}
+__name(searchableCellText, "searchableCellText");
+function rawCellValueText(value) {
+  return value === null ? "" : String(value);
+}
+__name(rawCellValueText, "rawCellValueText");
+function normalizeSearchText(value, matchCase) {
+  const text = value.trim();
+  return matchCase ? text : text.toLocaleLowerCase();
+}
+__name(normalizeSearchText, "normalizeSearchText");
+function compareCellPosition(a, b) {
+  return a.row === b.row ? a.column - b.column : a.row - b.row;
+}
+__name(compareCellPosition, "compareCellPosition");
+function replaceText(source, query, replacement, matchCase) {
+  if (!query) return source;
+  const escaped = query.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return source.replace(new RegExp(escaped, matchCase ? "g" : "gi"), replacement);
+}
+__name(replaceText, "replaceText");
+
+// src/spreadsheet/filter.ts
+function spreadsheetFilterValues(model, range, column) {
+  var _a, _b;
+  const values = /* @__PURE__ */ new Set();
+  for (let row = range.startRow + 1; row <= range.endRow; row += 1) {
+    values.add((_b = (_a = getRenderCell(model, row, column)) == null ? void 0 : _a.displayText) != null ? _b : "");
+  }
+  return [...values].sort((left, right) => left.localeCompare(right, void 0, { numeric: true }));
+}
+__name(spreadsheetFilterValues, "spreadsheetFilterValues");
+function spreadsheetVisibleFilterValues(model, range, column) {
+  var _a, _b, _c;
+  const visibleValues = /* @__PURE__ */ new Set();
+  for (let row = range.startRow + 1; row <= range.endRow; row += 1) {
+    if ((_a = model.rowMetaByIndex.get(row)) == null ? void 0 : _a.hidden) continue;
+    visibleValues.add((_c = (_b = getRenderCell(model, row, column)) == null ? void 0 : _b.displayText) != null ? _c : "");
+  }
+  return [...visibleValues].sort((left, right) => left.localeCompare(right, void 0, { numeric: true }));
+}
+__name(spreadsheetVisibleFilterValues, "spreadsheetVisibleFilterValues");
+function spreadsheetRowsForFilter(model, range, column, value) {
+  var _a, _b;
+  const values = new Set(typeof value === "string" ? [value] : value);
+  const hiddenRows = [];
+  for (let row = range.startRow + 1; row <= range.endRow; row += 1) {
+    if (!values.has((_b = (_a = getRenderCell(model, row, column)) == null ? void 0 : _a.displayText) != null ? _b : "")) hiddenRows.push(row);
+  }
+  return hiddenRows;
+}
+__name(spreadsheetRowsForFilter, "spreadsheetRowsForFilter");
+function spreadsheetRowsForColumnFilters(model, range, filters) {
+  const allowedByColumn = filters.map((filter) => [filter.column, new Set(filter.values)]);
+  const hiddenRows = [];
+  for (let row = range.startRow + 1; row <= range.endRow; row += 1) {
+    const matchesAll = allowedByColumn.every(
+      ([column, values]) => {
+        var _a, _b;
+        return values.has((_b = (_a = getRenderCell(model, row, column)) == null ? void 0 : _a.displayText) != null ? _b : "");
+      }
+    );
+    if (!matchesAll) hiddenRows.push(row);
+  }
+  return hiddenRows;
+}
+__name(spreadsheetRowsForColumnFilters, "spreadsheetRowsForColumnFilters");
+function spreadsheetSortRows(model, range, column, direction) {
+  const rows = Array.from({ length: range.endRow - range.startRow }, (_, index) => range.startRow + index + 1);
+  rows.sort((leftRow, rightRow) => {
+    var _a, _b, _c, _d;
+    const left = (_b = (_a = getRenderCell(model, leftRow, column)) == null ? void 0 : _a.displayText) != null ? _b : "";
+    const right = (_d = (_c = getRenderCell(model, rightRow, column)) == null ? void 0 : _c.displayText) != null ? _d : "";
+    if (left === "" && right !== "") return 1;
+    if (left !== "" && right === "") return -1;
+    const comparison = left.localeCompare(right, void 0, { numeric: true, sensitivity: "base" });
+    return (direction === "desc" ? -comparison : comparison) || leftRow - rightRow;
+  });
+  return rows;
+}
+__name(spreadsheetSortRows, "spreadsheetSortRows");
+
+// src/spreadsheet/runtime.ts
+var _SpreadsheetEditorRuntime = class _SpreadsheetEditorRuntime {
+  constructor(state) {
+    __publicField(this, "state", state);
+    __publicField(this, "activeTransaction", null);
+    __publicField(this, "activeTransactionSource", null);
+    __publicField(this, "transactionNeedsRefresh", false);
+  }
+  static async fromZip(bytes, options = {}) {
+    const workbook = await ExcelWorkbook.fromZip(bytes, options);
+    return _SpreadsheetEditorRuntime.fromWorkbook(workbook);
+  }
+  static async fromWorkbook(workbook) {
+    const model = await workbook.toModel();
+    const firstSheet = model.sheets[0];
+    if (!firstSheet) throw new Error("SpreadsheetEditorRuntime: workbook has no sheets");
+    const formulaEngine = new SpreadsheetFormulaEngine(firstSheet, { sheets: model.sheets });
+    const formulaResults = formulaEngine.calculate();
+    return new _SpreadsheetEditorRuntime({
+      workbook,
+      model,
+      activeSheetName: firstSheet.name,
+      formulaResults,
+      formulaEngine,
+      activeSheet: buildSpreadsheetSheetRenderModel(firstSheet, model.styles, { formulaResults })
+    });
+  }
+  workbook() {
+    return this.state.workbook;
+  }
+  model() {
+    return this.state.model;
+  }
+  activeSheetName() {
+    return this.state.activeSheetName;
+  }
+  activeSheet() {
+    return this.state.activeSheet;
+  }
+  canUndo() {
+    return this.state.workbook.history().canUndo();
+  }
+  canRedo() {
+    return this.state.workbook.history().canRedo();
+  }
+  async undo() {
+    const result = await this.state.workbook.history().undo();
+    if (!result) return null;
+    await this.refresh();
+    return result;
+  }
+  async redo() {
+    const result = await this.state.workbook.history().redo();
+    if (!result) return null;
+    await this.refresh();
+    return result;
+  }
+  async runUserTransaction(options, run) {
+    return this.runScopedTransaction(
+      "user",
+      (apply) => this.state.workbook.history().runGroup(__spreadProps(__spreadValues({}, options), { source: "user" }), apply),
+      run
+    );
+  }
+  async runAgentTransaction(options, run) {
+    return this.runScopedTransaction(
+      "agent",
+      (apply) => this.state.workbook.history().runAgentGroup(options, apply),
+      () => run(this)
+    );
+  }
+  async previewAgentTransaction(options, run) {
+    var _a;
+    const beforeModel = cloneWorkbookModel(this.state.model);
+    const previewWorkbook = await ExcelWorkbook.fromModel(beforeModel, { mode: "inline" });
+    const previewRuntime = await _SpreadsheetEditorRuntime.fromWorkbook(previewWorkbook);
+    await previewRuntime.setActiveSheet(this.state.activeSheetName);
+    try {
+      const result = await previewRuntime.runAgentTransaction(options, run);
+      const afterModel = cloneWorkbookModel(previewRuntime.model());
+      const diff = diffExcelWorkbookModels(beforeModel, afterModel);
+      return {
+        result,
+        summary: (_a = result == null ? void 0 : result.summary) != null ? _a : null,
+        diff,
+        diffSummary: summarizeSpreadsheetPreviewDiff(diff),
+        beforeModel,
+        afterModel,
+        activeSheetName: previewRuntime.activeSheetName()
+      };
+    } finally {
+      await previewRuntime.dispose();
+    }
+  }
+  async setActiveSheet(sheetName) {
+    const sheet = this.state.model.sheets.find((item) => item.name === sheetName);
+    if (!sheet) throw new Error(`SpreadsheetEditorRuntime: sheet not found: ${sheetName}`);
+    const formulaEngine = new SpreadsheetFormulaEngine(sheet, { sheets: this.state.model.sheets });
+    const formulaResults = formulaEngine.calculate();
+    this.state.activeSheetName = sheet.name;
+    this.state.formulaResults = formulaResults;
+    this.state.formulaEngine = formulaEngine;
+    this.state.activeSheet = buildSpreadsheetSheetRenderModel(sheet, this.state.model.styles, {
+      formulaResults
+    });
+  }
+  async addSheet(name) {
+    await this.runWorksheetStructureMutation(
+      (tx) => tx.addSheet(name),
+      () => this.state.workbook.worksheets.add(name).then(() => void 0)
+    );
+    await this.setActiveSheet(name);
+  }
+  async renameSheet(sheetName, name) {
+    const wasActive = sheetName === this.state.activeSheetName;
+    await this.runWorksheetStructureMutation(
+      (tx) => tx.renameSheet(sheetName, name),
+      () => this.state.workbook.worksheets.getItem(sheetName).rename(name)
+    );
+    if (wasActive) await this.setActiveSheet(name);
+  }
+  async copySheet(sheetName, newName) {
+    await this.runWorksheetStructureMutation(
+      (tx) => tx.copySheet(sheetName, newName),
+      () => this.state.workbook.worksheets.copy(sheetName, newName).then(() => void 0)
+    );
+    await this.setActiveSheet(newName);
+  }
+  async deleteSheet(sheetName) {
+    var _a;
+    const index = this.state.model.sheets.findIndex((sheet) => sheet.name === sheetName);
+    if (index === -1) throw new Error(`SpreadsheetEditorRuntime: sheet not found: ${sheetName}`);
+    if (this.state.model.sheets.length === 1) {
+      throw new Error("SpreadsheetEditorRuntime: cannot delete the last worksheet");
+    }
+    const nextActive = (_a = this.state.model.sheets[index + 1]) != null ? _a : this.state.model.sheets[index - 1];
+    const wasActive = sheetName === this.state.activeSheetName;
+    await this.runWorksheetStructureMutation(
+      (tx) => tx.deleteSheet(sheetName),
+      () => this.state.workbook.worksheets.deleteItem(sheetName)
+    );
+    if (wasActive && nextActive) await this.setActiveSheet(nextActive.name);
+  }
+  async moveSheet(sheetName, toIndex) {
+    await this.runWorksheetStructureMutation(
+      (tx) => tx.moveSheet(sheetName, toIndex),
+      () => this.state.workbook.worksheets.move(sheetName, toIndex)
+    );
+  }
+  async refresh() {
+    var _a;
+    const model = await this.state.workbook.toModel();
+    const sheet = (_a = model.sheets.find((item) => item.name === this.state.activeSheetName)) != null ? _a : model.sheets[0];
+    if (!sheet) throw new Error("SpreadsheetEditorRuntime: workbook has no sheets");
+    const formulaEngine = new SpreadsheetFormulaEngine(sheet, { sheets: model.sheets });
+    const formulaResults = formulaEngine.calculate();
+    this.state = __spreadProps(__spreadValues({}, this.state), {
+      model,
+      activeSheetName: sheet.name,
+      formulaResults,
+      formulaEngine,
+      activeSheet: buildSpreadsheetSheetRenderModel(sheet, model.styles, { formulaResults })
+    });
+  }
+  async setCellValue(address, value, historyOptions = {}) {
+    const targetAddress = this.editableCellAddress(address);
+    await this.runUserMutation(this.cellEditHistoryGroup(`Set ${targetAddress}`, targetAddress, historyOptions), async (tx) => {
+      await tx.setCellValue(this.state.activeSheetName, targetAddress, value);
+    });
+  }
+  async setCellFormula(address, formula, historyOptions = {}) {
+    const targetAddress = this.editableCellAddress(address);
+    await this.runUserMutation(this.cellEditHistoryGroup(`Set ${targetAddress} formula`, targetAddress, historyOptions), async (tx) => {
+      await tx.setCellFormula(this.state.activeSheetName, targetAddress, formula);
+    });
+  }
+  async replaceAll(query, replacement, matchCase = false) {
+    const plan = buildSpreadsheetReplacePlan(this.state.activeSheet, { query, replacement, matchCase });
+    if (plan.length === 0) return 0;
+    await this.runUserMutation({ label: `Replace ${query}` }, async (tx) => {
+      var _a;
+      for (const target of plan) {
+        if (target.formula !== void 0) {
+          await tx.setCellFormula(this.state.activeSheetName, target.address, target.formula);
+        } else {
+          await tx.setCellValue(this.state.activeSheetName, target.address, (_a = target.value) != null ? _a : null);
+        }
+      }
+    });
+    return plan.length;
+  }
+  async filterRows(startRow, endRow, column, value) {
+    const range = { startRow, startColumn: column, endRow, endColumn: column };
+    const hiddenRows = value === null ? [] : spreadsheetRowsForFilter(this.state.activeSheet, __spreadProps(__spreadValues({}, range), { startColumn: 1, endColumn: this.state.activeSheet.maxColumn }), column, value);
+    await this.runUserMutation({ label: value === null ? "Clear filter" : "Filter rows" }, async (tx) => {
+      await tx.runSnapshot("Filter rows", "spreadsheet row filter", async () => {
+        await this.state.workbook.executeCode(
+          `
+          const sheet = workbook.worksheets.getItem(args.sheetName);
+          const hidden = new Set(args.hiddenRows);
+          for (let index = args.startRow + 1; index <= args.endRow; index += 1) {
+            let row = sheet.model.rows.find((item) => item.index === index);
+            if (hidden.has(index)) {
+              row ??= { index };
+              row.hidden = true;
+              if (!sheet.model.rows.includes(row)) sheet.model.rows.push(row);
+            } else if (row) {
+              delete row.hidden;
+            }
+          }
+          sheet.model.rows.sort((left, right) => left.index - right.index);
+          `,
+          { sheetName: this.state.activeSheetName, startRow, endRow, hiddenRows }
+        );
+      });
+    });
+  }
+  async filterRowsByColumns(startRow, endRow, filters) {
+    const range = {
+      startRow,
+      endRow,
+      endColumn: this.state.activeSheet.maxColumn
+    };
+    const hiddenRows = spreadsheetRowsForColumnFilters(this.state.activeSheet, range, filters);
+    await this.runUserMutation({ label: "Filter rows" }, async (tx) => {
+      await tx.runSnapshot("Filter rows", "spreadsheet row filter", async () => {
+        await this.state.workbook.executeCode(
+          `
+          const sheet = workbook.worksheets.getItem(args.sheetName);
+          const hidden = new Set(args.hiddenRows);
+          for (let index = args.startRow + 1; index <= args.endRow; index += 1) {
+            let row = sheet.model.rows.find((item) => item.index === index);
+            if (hidden.has(index)) {
+              row ??= { index };
+              row.hidden = true;
+              if (!sheet.model.rows.includes(row)) sheet.model.rows.push(row);
+            } else if (row) {
+              delete row.hidden;
+            }
+          }
+          sheet.model.rows.sort((left, right) => left.index - right.index);
+          `,
+          { sheetName: this.state.activeSheetName, startRow, endRow, hiddenRows }
+        );
+      });
+    });
+  }
+  async sortRows(startRow, endRow, column, direction) {
+    const range = { startRow, endRow, endColumn: this.state.activeSheet.maxColumn };
+    const orderedRows = spreadsheetSortRows(this.state.activeSheet, range, column, direction);
+    const rowMap = new Map(orderedRows.map((sourceRow, index) => [sourceRow, startRow + index + 1]));
+    const formulaUpdates = this.state.activeSheet.source.cells.filter((cell) => cell.formula).map((cell) => {
+      var _a;
+      return [
+        cell.address,
+        rewriteFormulaForRowSort((_a = cell.formula) != null ? _a : "", rowMap, { sheetName: this.state.activeSheetName })
+      ];
+    });
+    await this.runUserMutation({ label: direction === "asc" ? "Sort ascending" : "Sort descending" }, async (tx) => {
+      await tx.runSnapshot("Sort rows", "spreadsheet row sort", async () => {
+        await this.state.workbook.executeCode(
+          `
+          const sheet = workbook.worksheets.getItem(args.sheetName);
+          const rowMap = new Map(args.rowMap);
+          const formulas = new Map(args.formulas);
+          function formatCellAddress(row, column) {
+            let value = column;
+            let letters = '';
+            while (value > 0) {
+              const remainder = (value - 1) % 26;
+              letters = String.fromCharCode(65 + remainder) + letters;
+              value = Math.floor((value - 1) / 26);
+            }
+            return letters + row;
+          }
+          for (const cell of sheet.model.cells) {
+            const nextFormula = formulas.get(cell.address);
+            if (nextFormula !== undefined) cell.formula = nextFormula;
+            const nextRow = rowMap.get(cell.row);
+            if (nextRow === undefined) continue;
+            cell.row = nextRow;
+            cell.address = formatCellAddress(cell.row, cell.column);
+          }
+          for (const row of sheet.model.rows) {
+            const nextIndex = rowMap.get(row.index);
+            if (nextIndex !== undefined) row.index = nextIndex;
+          }
+          sheet.model.cells.sort((left, right) => left.row - right.row || left.column - right.column);
+          sheet.model.rows.sort((left, right) => left.index - right.index);
+          `,
+          { sheetName: this.state.activeSheetName, rowMap: [...rowMap.entries()], formulas: formulaUpdates }
+        );
+      });
+    });
+  }
+  async setRangeValues(startRow, startColumn, values) {
+    const rowCount = values.length;
+    const columnCount = values.reduce((max, row) => Math.max(max, row.length), 0);
+    const normalized = values.map((row) => {
+      const next = row.slice();
+      while (next.length < columnCount) next.push(null);
+      return next;
+    });
+    await this.runUserMutation({ label: "Set range values" }, async (tx) => {
+      await tx.setRangeValues(
+        this.state.activeSheetName,
+        formatRangeAddress(startRow, startColumn, rowCount, columnCount),
+        normalized
+      );
+    });
+  }
+  async autoFillRange(sourceRange, targetRange) {
+    const plan = buildSpreadsheetAutoFillPlan(this.state.activeSheet, sourceRange, targetRange);
+    if (plan.cells.length === 0) return;
+    await this.runUserMutation({ label: "Auto fill" }, async (tx) => {
+      for (const cell of plan.cells) {
+        const address = formatCellAddress(cell.row, cell.column);
+        if (cell.formula) await tx.setCellFormula(this.state.activeSheetName, address, cell.formula);
+        else await tx.setCellValue(this.state.activeSheetName, address, cell.value);
+        await tx.setRangeStyleId(this.state.activeSheetName, address, cell.styleId);
+      }
+    });
+  }
+  async pasteRangeValues(startRow, startColumn, values, merges = [], styleIds = []) {
+    await this.pasteRange(startRow, startColumn, values, { mode: "all", merges, styleIds });
+  }
+  async pasteRange(startRow, startColumn, values, options = {}) {
+    var _a;
+    const mode = (_a = options.mode) != null ? _a : "all";
+    const rowCount = values.length;
+    const columnCount = values.reduce((max, row) => Math.max(max, row.length), 0);
+    const normalized = values.map((row) => {
+      const next = row.slice();
+      while (next.length < columnCount) next.push(null);
+      return next;
+    });
+    const effectiveRowCount = Math.max(1, rowCount);
+    const effectiveColumnCount = Math.max(1, columnCount);
+    const targetRange = {
+      startRow,
+      startColumn,
+      endRow: startRow + effectiveRowCount - 1,
+      endColumn: startColumn + effectiveColumnCount - 1
+    };
+    const existingMerges = [...this.state.activeSheet.mergeMasterByAddress.values()].filter((merge) => rangesIntersect3(targetRange, merge.range)).map((merge) => merge.address);
+    await this.runUserMutation({ label: pasteHistoryLabel(mode) }, async (tx) => {
+      var _a2, _b;
+      if (mode !== "formats") {
+        for (const address of existingMerges) await tx.unmergeRange(this.state.activeSheetName, address);
+        await tx.setRangeValues(
+          this.state.activeSheetName,
+          formatRangeAddress(startRow, startColumn, effectiveRowCount, effectiveColumnCount),
+          normalized
+        );
+      }
+      if (mode !== "values") {
+        await applySpreadsheetPasteStyles(
+          tx,
+          this.state.activeSheetName,
+          startRow,
+          startColumn,
+          effectiveColumnCount,
+          (_a2 = options.styleIds) != null ? _a2 : []
+        );
+      }
+      if (mode === "all") await applySpreadsheetPasteMerges(tx, this.state.activeSheetName, startRow, startColumn, (_b = options.merges) != null ? _b : []);
+    });
+  }
+  async clearRange(startRow, startColumn, rowCount, columnCount) {
+    await this.runUserMutation({ label: "Clear range" }, async (tx) => {
+      await tx.clearRange(
+        this.state.activeSheetName,
+        formatRangeAddress(startRow, startColumn, rowCount, columnCount)
+      );
+    });
+  }
+  async setRowHeight(row, height) {
+    await this.runUserMutation({ label: "Set row height" }, async (tx) => {
+      await tx.setRowHeight(this.state.activeSheetName, row, height);
+    });
+  }
+  async setColumnWidth(column, width) {
+    await this.runUserMutation({ label: "Set column width" }, async (tx) => {
+      await tx.setColumnWidth(this.state.activeSheetName, column, cssPixelsToExcelColumnWidth(width));
+    });
+  }
+  async setFreezePanes(frozenRows, frozenColumns) {
+    const rows = normalizeFrozenPaneCount(frozenRows);
+    const columns = normalizeFrozenPaneCount(frozenColumns);
+    const views = spreadsheetSheetViewsWithFrozenPane(this.state.activeSheet.source.sheetViews, rows, columns);
+    await this.runUserMutation({ label: rows || columns ? "Freeze panes" : "Unfreeze panes" }, async (tx) => {
+      await tx.setSheetViews(this.state.activeSheetName, views);
+    });
+  }
+  async insertRows(rowIndex, count = 1) {
+    await this.runUserMutation({ label: "Insert rows" }, async (tx) => {
+      await tx.insertRows(this.state.activeSheetName, rowIndex, count);
+    });
+  }
+  async deleteRows(rowIndex, count = 1) {
+    await this.runUserMutation({ label: "Delete rows" }, async (tx) => {
+      await tx.deleteRows(this.state.activeSheetName, rowIndex, count);
+    });
+  }
+  async insertColumns(columnIndex, count = 1) {
+    await this.runUserMutation({ label: "Insert columns" }, async (tx) => {
+      await tx.insertColumns(this.state.activeSheetName, columnIndex, count);
+    });
+  }
+  async deleteColumns(columnIndex, count = 1) {
+    await this.runUserMutation({ label: "Delete columns" }, async (tx) => {
+      await tx.deleteColumns(this.state.activeSheetName, columnIndex, count);
+    });
+  }
+  async setRangeBold(startRow, startColumn, rowCount, columnCount, value) {
+    await this.runUserMutation({ label: "Set bold" }, async (tx) => {
+      await tx.setRangeBold(
+        this.state.activeSheetName,
+        formatRangeAddress(startRow, startColumn, rowCount, columnCount),
+        value
+      );
+    });
+  }
+  async setRangeItalic(startRow, startColumn, rowCount, columnCount, value) {
+    await this.runUserMutation({ label: "Set italic" }, async (tx) => {
+      await tx.setRangeItalic(
+        this.state.activeSheetName,
+        formatRangeAddress(startRow, startColumn, rowCount, columnCount),
+        value
+      );
+    });
+  }
+  async setRangeUnderline(startRow, startColumn, rowCount, columnCount, value) {
+    await this.runUserMutation({ label: "Set underline" }, async (tx) => {
+      await tx.setRangeUnderline(
+        this.state.activeSheetName,
+        formatRangeAddress(startRow, startColumn, rowCount, columnCount),
+        value
+      );
+    });
+  }
+  async setRangeFontColor(startRow, startColumn, rowCount, columnCount, color) {
+    await this.runUserMutation({ label: "Set font color" }, async (tx) => {
+      await tx.setRangeFontColor(
+        this.state.activeSheetName,
+        formatRangeAddress(startRow, startColumn, rowCount, columnCount),
+        color
+      );
+    });
+  }
+  async setRangeFillColor(startRow, startColumn, rowCount, columnCount, color) {
+    await this.runUserMutation({ label: "Set fill color" }, async (tx) => {
+      await tx.setRangeFillColor(
+        this.state.activeSheetName,
+        formatRangeAddress(startRow, startColumn, rowCount, columnCount),
+        color
+      );
+    });
+  }
+  async setRangeHorizontalAlign(startRow, startColumn, rowCount, columnCount, horizontal) {
+    await this.runUserMutation({ label: "Set horizontal align" }, async (tx) => {
+      await tx.setRangeHorizontalAlign(
+        this.state.activeSheetName,
+        formatRangeAddress(startRow, startColumn, rowCount, columnCount),
+        horizontal
+      );
+    });
+  }
+  async setRangeVerticalAlign(startRow, startColumn, rowCount, columnCount, vertical) {
+    await this.runUserMutation({ label: "Set vertical align" }, async (tx) => {
+      await tx.setRangeVerticalAlign(
+        this.state.activeSheetName,
+        formatRangeAddress(startRow, startColumn, rowCount, columnCount),
+        vertical
+      );
+    });
+  }
+  async setRangeNumberFormat(startRow, startColumn, rowCount, columnCount, code) {
+    await this.runUserMutation({ label: "Set number format" }, async (tx) => {
+      await tx.setRangeNumberFormat(
+        this.state.activeSheetName,
+        formatRangeAddress(startRow, startColumn, rowCount, columnCount),
+        code
+      );
+    });
+  }
+  async clearRangeFormat(startRow, startColumn, rowCount, columnCount) {
+    await this.runUserMutation({ label: "Clear format" }, async (tx) => {
+      await tx.clearRangeFormat(
+        this.state.activeSheetName,
+        formatRangeAddress(startRow, startColumn, rowCount, columnCount)
+      );
+    });
+  }
+  async mergeRange(startRow, startColumn, rowCount, columnCount) {
+    const address = formatRangeAddress(startRow, startColumn, rowCount, columnCount);
+    const masterStyleId = await this.cellStyleId(formatCellAddress(startRow, startColumn));
+    await this.runUserMutation({ label: "Merge range" }, async (tx) => {
+      await tx.setRangeStyleId(this.state.activeSheetName, address, masterStyleId);
+      await tx.mergeRange(this.state.activeSheetName, address);
+    });
+  }
+  async unmergeRanges(addresses) {
+    if (addresses.length === 0) return;
+    const merges = addresses.map((address) => {
+      const merge = [...this.state.activeSheet.mergeMasterByAddress.values()].find((item) => item.address === address);
+      const masterAddress = merge ? formatCellAddress(merge.range.startRow, merge.range.startColumn) : masterAddressForRange(address);
+      return { address, masterAddress };
+    });
+    await this.runUserMutation({ label: "Unmerge ranges" }, async (tx) => {
+      for (const merge of merges) {
+        await tx.setRangeStyleId(this.state.activeSheetName, merge.address, await this.cellStyleId(merge.masterAddress));
+        await tx.unmergeRange(this.state.activeSheetName, merge.address);
+      }
+    });
+  }
+  async setRangeBorder(startRow, startColumn, rowCount, columnCount, mode) {
+    if (mode === "clear") {
+      await this.runUserMutation({ label: "Clear border" }, async (tx) => {
+        await tx.setRangeBorder(
+          this.state.activeSheetName,
+          formatRangeAddress(startRow, startColumn, rowCount, columnCount),
+          {}
+        );
+      });
+      return;
+    }
+    const side = spreadsheetDefaultBorderSide();
+    if (mode === "all") {
+      await this.runUserMutation({ label: "Set all borders" }, async (tx) => {
+        await tx.setRangeBorder(
+          this.state.activeSheetName,
+          formatRangeAddress(startRow, startColumn, rowCount, columnCount),
+          { left: side, right: side, top: side, bottom: side }
+        );
+      });
+      return;
+    }
+    await this.runUserMutation({ label: `Set ${mode} borders` }, async (tx) => {
+      await tx.setRangeBorder(
+        this.state.activeSheetName,
+        formatRangeAddress(startRow, startColumn, rowCount, columnCount),
+        {}
+      );
+      for (let rowOffset = 0; rowOffset < rowCount; rowOffset++) {
+        for (let columnOffset = 0; columnOffset < columnCount; columnOffset++) {
+          const border = {};
+          if (mode === "outer") {
+            if (rowOffset === 0) border.top = side;
+            if (rowOffset === rowCount - 1) border.bottom = side;
+            if (columnOffset === 0) border.left = side;
+            if (columnOffset === columnCount - 1) border.right = side;
+          } else {
+            if (columnOffset < columnCount - 1) border.right = side;
+            if (rowOffset < rowCount - 1) border.bottom = side;
+          }
+          if (Object.keys(border).length === 0) continue;
+          await tx.setRangeBorder(
+            this.state.activeSheetName,
+            formatCellAddress(startRow + rowOffset, startColumn + columnOffset),
+            border
+          );
+        }
+      }
+    });
+  }
+  async toZip() {
+    return this.state.workbook.toZip();
+  }
+  async moveChart(chartIndex, position) {
+    await this.runUserMutation({ label: "Move chart" }, async (tx) => {
+      await tx.runSnapshot("Move chart", "spreadsheet chart position", async () => {
+        const sheetModel = this.state.model.sheets.find((sheet) => sheet.name === this.state.activeSheetName);
+        const chart = sheetModel == null ? void 0 : sheetModel.charts[chartIndex];
+        if (!sheetModel || !chart) return;
+        const drawingIndex = sheetModel.drawings.findIndex((drawing2) => drawing2.path === chart.drawingPath);
+        const drawing = drawingIndex >= 0 ? sheetModel.drawings[drawingIndex] : sheetModel.drawings[0];
+        if (!drawing) return;
+        const anchorIndex = drawing.anchors.findIndex(
+          (anchor2) => {
+            var _a;
+            return ((_a = anchor2.object) == null ? void 0 : _a.kind) === "chart" && (!chart.relationshipId || anchor2.object.relationshipId === chart.relationshipId);
+          }
+        );
+        if (anchorIndex < 0) return;
+        const drawings = await this.state.workbook.worksheets.getItem(this.state.activeSheetName).drawings.items();
+        const coreDrawing = drawings[drawingIndex >= 0 ? drawingIndex : 0];
+        const anchor = coreDrawing == null ? void 0 : coreDrawing.anchors.getItem(anchorIndex);
+        if (!anchor) return;
+        anchor.from.setRow(position.from.row);
+        anchor.from.setColumn(position.from.column);
+        anchor.from.setRowOffset(position.from.rowOffset);
+        anchor.from.setColumnOffset(position.from.columnOffset);
+        if (position.to) {
+          anchor.to.setRow(position.to.row);
+          anchor.to.setColumn(position.to.column);
+          anchor.to.setRowOffset(position.to.rowOffset);
+          anchor.to.setColumnOffset(position.to.columnOffset);
+        }
+      });
+    });
+  }
+  async dispose() {
+    await this.state.workbook.dispose();
+  }
+  editableCellAddress(address) {
+    var _a;
+    const cell = parseCellAddress(address);
+    const normalized = formatCellAddress(cell.row, cell.column);
+    return (_a = this.state.activeSheet.mergeFollowerByAddress.get(normalized)) != null ? _a : normalized;
+  }
+  rebuildActiveSheetRenderModel() {
+    this.state.formulaResults = this.state.formulaEngine.calculate();
+    this.state.activeSheet = buildSpreadsheetSheetRenderModel(
+      this.state.activeSheet.source,
+      this.state.model.styles,
+      { formulaResults: this.state.formulaResults }
+    );
+  }
+  async runUserMutation(options, mutate) {
+    if (this.activeTransaction) {
+      await mutate(this.activeTransaction);
+      this.transactionNeedsRefresh = true;
+      return;
+    }
+    await this.runScopedTransaction(
+      "user",
+      (apply) => this.state.workbook.history().runGroup(__spreadProps(__spreadValues({}, options), { source: "user" }), apply),
+      async () => {
+        if (!this.activeTransaction) throw new Error("SpreadsheetEditorRuntime: transaction not active");
+        await mutate(this.activeTransaction);
+        this.transactionNeedsRefresh = true;
+      }
+    );
+  }
+  async runWorksheetStructureMutation(recordAgentMutation, mutate) {
+    if (this.activeTransactionSource === "agent" && this.activeTransaction) {
+      await recordAgentMutation(this.activeTransaction);
+      this.transactionNeedsRefresh = true;
+      await this.refresh();
+      return;
+    }
+    await mutate();
+    await this.refresh();
+  }
+  async cellStyleId(address) {
+    var _a;
+    return (_a = (await this.state.workbook.worksheets.getItem(this.state.activeSheetName).getRange(address).styleIds())[0]) == null ? void 0 : _a[0];
+  }
+  async runScopedTransaction(source, execute, run) {
+    if (this.activeTransaction) {
+      await run();
+      this.transactionNeedsRefresh = true;
+      return null;
+    }
+    const previousNeedsRefresh = this.transactionNeedsRefresh;
+    this.transactionNeedsRefresh = false;
+    try {
+      const result = await execute(async (transaction) => {
+        this.activeTransaction = transaction;
+        this.activeTransactionSource = source;
+        try {
+          await run();
+        } finally {
+          this.activeTransaction = null;
+          this.activeTransactionSource = null;
+        }
+      });
+      const shouldRefresh = this.transactionNeedsRefresh || result !== null;
+      if (shouldRefresh) await this.refresh();
+      return result;
+    } finally {
+      this.activeTransaction = null;
+      this.activeTransactionSource = null;
+      this.transactionNeedsRefresh = previousNeedsRefresh;
+    }
+  }
+  cellEditHistoryGroup(label, address, options) {
+    var _a;
+    const base = { label };
+    if (!options.mergeUndo) return base;
+    return __spreadProps(__spreadValues({}, base), {
+      mergeKey: `edit:${this.state.activeSheetName}!${address}`,
+      mergeWindowMs: (_a = options.mergeWindowMs) != null ? _a : 1e3
+    });
+  }
+  range(startRow, startColumn, rowCount, columnCount) {
+    return this.state.workbook.worksheets.getItem(this.state.activeSheetName).getRange(formatRangeAddress(startRow, startColumn, rowCount, columnCount));
+  }
+};
+__name(_SpreadsheetEditorRuntime, "SpreadsheetEditorRuntime");
+var SpreadsheetEditorRuntime = _SpreadsheetEditorRuntime;
+function spreadsheetDefaultBorderSide() {
+  return { style: "thin", color: { rgb: "#111827" } };
+}
+__name(spreadsheetDefaultBorderSide, "spreadsheetDefaultBorderSide");
+function normalizeFrozenPaneCount(value) {
+  if (!Number.isFinite(value)) return 0;
+  return Math.max(0, Math.floor(value));
+}
+__name(normalizeFrozenPaneCount, "normalizeFrozenPaneCount");
+function spreadsheetSheetViewsWithFrozenPane(sheetViews, frozenRows, frozenColumns) {
+  var _a;
+  if (!frozenRows && !frozenColumns) {
+    return sheetViews.map((view, index) => __spreadProps(__spreadValues({}, view), {
+      pane: index === 0 ? void 0 : view.pane ? __spreadValues({}, view.pane) : void 0,
+      selections: view.selections.map((selection) => __spreadValues({}, selection))
+    }));
+  }
+  const currentView = (_a = sheetViews[0]) != null ? _a : { workbookViewId: 0, selections: [] };
+  const pane = {
+    xSplit: frozenColumns || void 0,
+    ySplit: frozenRows || void 0,
+    topLeftCell: formatCellAddress(frozenRows + 1, frozenColumns + 1),
+    activePane: frozenRows && frozenColumns ? "bottomRight" : frozenRows ? "bottomLeft" : "topRight",
+    state: "frozen"
+  };
+  return [
+    __spreadProps(__spreadValues({}, currentView), {
+      pane,
+      selections: currentView.selections.map((selection) => __spreadValues({}, selection))
+    }),
+    ...sheetViews.slice(1).map((view) => __spreadProps(__spreadValues({}, view), {
+      pane: view.pane ? __spreadValues({}, view.pane) : void 0,
+      selections: view.selections.map((selection) => __spreadValues({}, selection))
+    }))
+  ];
+}
+__name(spreadsheetSheetViewsWithFrozenPane, "spreadsheetSheetViewsWithFrozenPane");
+async function applySpreadsheetPasteStyles(tx, sheetName, startRow, startColumn, columnCount, styleIds) {
+  for (let rowOffset = 0; rowOffset < styleIds.length; rowOffset++) {
+    const styleRow = styleIds[rowOffset];
+    if (!styleRow) continue;
+    for (let columnOffset = 0; columnOffset < columnCount; columnOffset++) {
+      await tx.setRangeStyleId(
+        sheetName,
+        formatCellAddress(startRow + rowOffset, startColumn + columnOffset),
+        styleRow[columnOffset]
+      );
+    }
+  }
+}
+__name(applySpreadsheetPasteStyles, "applySpreadsheetPasteStyles");
+async function applySpreadsheetPasteMerges(tx, sheetName, startRow, startColumn, merges) {
+  for (const merge of merges) {
+    await tx.mergeRange(
+      sheetName,
+      formatRangeAddress(
+        startRow + merge.startRowOffset,
+        startColumn + merge.startColumnOffset,
+        merge.rowCount,
+        merge.columnCount
+      )
+    );
+  }
+}
+__name(applySpreadsheetPasteMerges, "applySpreadsheetPasteMerges");
+function pasteHistoryLabel(mode) {
+  switch (mode) {
+    case "values":
+      return "Paste values";
+    case "formats":
+      return "Paste formats";
+    default:
+      return "Paste range";
+  }
+}
+__name(pasteHistoryLabel, "pasteHistoryLabel");
+function cloneWorkbookModel(model) {
+  return JSON.parse(JSON.stringify(model));
+}
+__name(cloneWorkbookModel, "cloneWorkbookModel");
+function summarizeSpreadsheetPreviewDiff(diff) {
+  var _a, _b, _c, _d, _e, _f;
+  const cellChanges = {
+    total: 0,
+    added: 0,
+    modified: 0,
+    deleted: 0
+  };
+  const sampleCells = [];
+  for (const sheet of diff.sheets) {
+    for (const cell of sheet.cells) {
+      cellChanges.total += 1;
+      cellChanges[cell.kind] += 1;
+      if (sampleCells.length >= 20) continue;
+      sampleCells.push({
+        sheetName: (_b = (_a = sheet.afterName) != null ? _a : sheet.beforeName) != null ? _b : sheet.sheetId,
+        address: cell.address,
+        kind: cell.kind,
+        before: (_d = (_c = cell.before) == null ? void 0 : _c.value) != null ? _d : null,
+        after: (_f = (_e = cell.after) == null ? void 0 : _e.value) != null ? _f : null
+      });
+    }
+  }
+  return {
+    changed: diff.changed,
+    changedSheets: diff.sheets.length,
+    sheetNames: diff.sheets.map((sheet) => {
+      var _a2, _b2;
+      return (_b2 = (_a2 = sheet.afterName) != null ? _a2 : sheet.beforeName) != null ? _b2 : sheet.sheetId;
+    }),
+    cellChanges,
+    structuralChanged: diff.sheets.some((sheet) => sheet.structuralChanged),
+    objectChanged: diff.sheets.some((sheet) => sheet.objectChanged),
+    sampleCells
+  };
+}
+__name(summarizeSpreadsheetPreviewDiff, "summarizeSpreadsheetPreviewDiff");
+function rangesIntersect3(a, b) {
+  return !(a.endRow < b.startRow || a.startRow > b.endRow || a.endColumn < b.startColumn || a.startColumn > b.endColumn);
+}
+__name(rangesIntersect3, "rangesIntersect");
+function masterAddressForRange(address) {
+  const range = parseRangeAddress(address);
+  return formatCellAddress(range.startRow, range.startColumn);
+}
+__name(masterAddressForRange, "masterAddressForRange");
+
+// src/spreadsheet/agent-action.ts
+async function previewSpreadsheetAgentAction(runtime, action, context = {}) {
+  return {
+    action,
+    context,
+    transaction: await runtime.previewAgentTransaction(
+      agentActionTransactionOptions(action),
+      (targetRuntime) => action.run(targetRuntime, context)
+    )
+  };
+}
+__name(previewSpreadsheetAgentAction, "previewSpreadsheetAgentAction");
+async function applySpreadsheetAgentAction(runtime, action, context = {}) {
+  return {
+    action,
+    context,
+    transaction: await runtime.runAgentTransaction(
+      agentActionTransactionOptions(action),
+      (targetRuntime) => action.run(targetRuntime, context)
+    )
+  };
+}
+__name(applySpreadsheetAgentAction, "applySpreadsheetAgentAction");
+function agentActionTransactionOptions(action) {
+  var _a;
+  return {
+    label: action.label,
+    actor: action.actor,
+    description: action.description,
+    agentRunId: action.agentRunId,
+    agentStepId: action.agentStepId,
+    agentActionId: (_a = action.agentActionId) != null ? _a : action.id,
+    metadata: action.metadata
+  };
+}
+__name(agentActionTransactionOptions, "agentActionTransactionOptions");
+
+// src/spreadsheet/editing.ts
+var _SpreadsheetCellEditor = class _SpreadsheetCellEditor {
+  constructor(options) {
+    __publicField(this, "options", options);
+    this.options.textarea.addEventListener("keydown", (event) => {
+      if (event.key === "Escape") {
+        event.preventDefault();
+        this.cancel();
+      } else if (event.key === "Enter" && !event.shiftKey) {
+        event.preventDefault();
+        void this.commit();
+      }
+    });
+  }
+  open(rect, value) {
+    const textarea = this.options.textarea;
+    textarea.value = value;
+    textarea.style.display = "block";
+    textarea.style.position = "absolute";
+    textarea.style.left = `${rect.x}px`;
+    textarea.style.top = `${rect.y}px`;
+    textarea.style.width = `${Math.max(1, rect.width)}px`;
+    textarea.style.height = `${Math.max(1, rect.height)}px`;
+    textarea.focus();
+    textarea.select();
+  }
+  async commit() {
+    const value = this.options.textarea.value;
+    this.close();
+    await this.options.onCommit(value);
+  }
+  cancel() {
+    var _a, _b;
+    this.close();
+    (_b = (_a = this.options).onCancel) == null ? void 0 : _b.call(_a);
+  }
+  close() {
+    this.options.textarea.style.display = "none";
+  }
+};
+__name(_SpreadsheetCellEditor, "SpreadsheetCellEditor");
+var SpreadsheetCellEditor = _SpreadsheetCellEditor;
+
+// src/spreadsheet/scrollbar.ts
+function applyWheelDelta(scroll, deltaX, deltaY) {
+  return {
+    x: Math.max(0, scroll.x + deltaX),
+    y: Math.max(0, scroll.y + deltaY)
+  };
+}
+__name(applyWheelDelta, "applyWheelDelta");
+function computeScrollbarState(layout, viewportSize, freeze, scroll, scrollbarThickness = 12) {
+  const frozenWidth = layout.getColumnX(freeze.frozenColumns + 1);
+  const frozenHeight = layout.getRowY(freeze.frozenRows + 1);
+  const horizontalTrackLength = Math.max(
+    0,
+    viewportSize.width - layout.rowHeaderWidth - frozenWidth - scrollbarThickness
+  );
+  const verticalTrackLength = Math.max(
+    0,
+    viewportSize.height - layout.columnHeaderHeight - frozenHeight - scrollbarThickness
+  );
+  const horizontalViewport = horizontalTrackLength;
+  const verticalViewport = verticalTrackLength;
+  const horizontalContent = Math.max(0, layout.totalWidth() - frozenWidth);
+  const verticalContent = Math.max(0, layout.totalHeight() - frozenHeight);
+  return {
+    horizontal: computeAxisScrollbar(horizontalContent, horizontalViewport, horizontalTrackLength, scroll.x),
+    vertical: computeAxisScrollbar(verticalContent, verticalViewport, verticalTrackLength, scroll.y)
+  };
+}
+__name(computeScrollbarState, "computeScrollbarState");
+function scrollFromThumbPosition(geometry, thumbStart) {
+  if (geometry.maxScroll <= 0) return 0;
+  const maxThumbStart = Math.max(0, geometry.trackLength - geometry.thumbLength);
+  if (maxThumbStart <= 0) return 0;
+  const clamped = Math.max(0, Math.min(maxThumbStart, thumbStart));
+  return clamped / maxThumbStart * geometry.maxScroll;
+}
+__name(scrollFromThumbPosition, "scrollFromThumbPosition");
+function computeAxisScrollbar(contentLength, viewportLength, trackLength, scrollOffset) {
+  const maxScroll = Math.max(0, contentLength - viewportLength);
+  if (trackLength <= 0 || contentLength <= 0 || maxScroll <= 0) {
+    return { trackLength, thumbStart: 0, thumbLength: trackLength, maxScroll: 0 };
+  }
+  const thumbLength = Math.max(24, Math.min(trackLength, viewportLength / contentLength * trackLength));
+  const maxThumbStart = Math.max(0, trackLength - thumbLength);
+  const thumbStart = maxScroll <= 0 ? 0 : Math.max(0, Math.min(maxScroll, scrollOffset)) / maxScroll * maxThumbStart;
+  return { trackLength, thumbStart, thumbLength, maxScroll };
+}
+__name(computeAxisScrollbar, "computeAxisScrollbar");
+
+// src/spreadsheet/resize.ts
+var SPREADSHEET_COLUMN_RESIZE_MIN = 24;
+var SPREADSHEET_ROW_RESIZE_MIN = 12;
+var SPREADSHEET_RESIZE_HIT_TOLERANCE = 4;
+function hitSpreadsheetResizeHandle(layout, viewports, point) {
+  for (const viewport of viewports) {
+    if (viewport.kind === "columnHeaderFrozen" || viewport.kind === "columnHeaderScrollable") {
+      const handle = hitSpreadsheetColumnResizeHandle(layout, viewport, point);
+      if (handle) return handle;
+    }
+    if (viewport.kind === "rowHeaderFrozen" || viewport.kind === "rowHeaderScrollable") {
+      const handle = hitSpreadsheetRowResizeHandle(layout, viewport, point);
+      if (handle) return handle;
+    }
+  }
+  return null;
+}
+__name(hitSpreadsheetResizeHandle, "hitSpreadsheetResizeHandle");
+function startSpreadsheetResizeDrag(handle, event) {
+  return __spreadProps(__spreadValues({}, handle), {
+    startClientX: event.clientX,
+    startClientY: event.clientY,
+    currentSize: handle.startSize,
+    currentGuidePosition: handle.guidePosition
+  });
+}
+__name(startSpreadsheetResizeDrag, "startSpreadsheetResizeDrag");
+function updateSpreadsheetResizeDrag(drag, event) {
+  const delta = drag.kind === "column" ? event.clientX - drag.startClientX : event.clientY - drag.startClientY;
+  const currentSize = Math.max(drag.minSize, Math.round(drag.startSize + delta));
+  return __spreadProps(__spreadValues({}, drag), {
+    currentSize,
+    currentGuidePosition: drag.guidePosition + currentSize - drag.startSize
+  });
+}
+__name(updateSpreadsheetResizeDrag, "updateSpreadsheetResizeDrag");
+function hitSpreadsheetColumnResizeHandle(layout, viewport, point) {
+  if (!containsSpreadsheetPoint(viewport.screenRect, point, SPREADSHEET_RESIZE_HIT_TOLERANCE)) return null;
+  for (let column = viewport.columns.start; column <= viewport.columns.end; column++) {
+    const logical = layout.getCellLogicalRect(1, column);
+    const left = viewport.screenRect.x + logical.x - viewport.originX;
+    const right = left + logical.width;
+    if (Math.abs(point.x - right) <= SPREADSHEET_RESIZE_HIT_TOLERANCE) {
+      return {
+        kind: "column",
+        index: column,
+        startSize: layout.getColumnWidth(column),
+        guidePosition: right,
+        minSize: SPREADSHEET_COLUMN_RESIZE_MIN
+      };
+    }
+  }
+  return null;
+}
+__name(hitSpreadsheetColumnResizeHandle, "hitSpreadsheetColumnResizeHandle");
+function hitSpreadsheetRowResizeHandle(layout, viewport, point) {
+  if (!containsSpreadsheetPoint(viewport.screenRect, point, SPREADSHEET_RESIZE_HIT_TOLERANCE)) return null;
+  for (let row = viewport.rows.start; row <= viewport.rows.end; row++) {
+    const logical = layout.getCellLogicalRect(row, 1);
+    const top = viewport.screenRect.y + logical.y - viewport.originY;
+    const bottom = top + logical.height;
+    if (Math.abs(point.y - bottom) <= SPREADSHEET_RESIZE_HIT_TOLERANCE) {
+      return {
+        kind: "row",
+        index: row,
+        startSize: layout.getRowHeight(row),
+        guidePosition: bottom,
+        minSize: SPREADSHEET_ROW_RESIZE_MIN
+      };
+    }
+  }
+  return null;
+}
+__name(hitSpreadsheetRowResizeHandle, "hitSpreadsheetRowResizeHandle");
+function containsSpreadsheetPoint(rect, point, tolerance = 0) {
+  return point.x >= rect.x - tolerance && point.y >= rect.y - tolerance && point.x <= rect.x + rect.width + tolerance && point.y <= rect.y + rect.height + tolerance;
+}
+__name(containsSpreadsheetPoint, "containsSpreadsheetPoint");
+
+// src/spreadsheet/format-state.ts
+function summarizeSpreadsheetSelectionFormat(model, selection) {
+  var _a, _b, _c, _d, _e, _f;
+  const summary = createEmptyFormatSummary();
+  const range = normalizeSelectionRange(selection.range);
+  for (let row = range.startRow; row <= range.endRow; row++) {
+    for (let column = range.startColumn; column <= range.endColumn; column++) {
+      const format = cellFormatAt(model, row, column);
+      const font = (_b = model.styles.fonts[(_a = format.fontId) != null ? _a : 0]) != null ? _b : {};
+      const fill = (_d = model.styles.fills[(_c = format.fillId) != null ? _c : 0]) != null ? _d : {};
+      const border = (_f = model.styles.borders[(_e = format.borderId) != null ? _e : 0]) != null ? _f : {};
+      collectSummaryValue(summary.bold, font.bold === true);
+      collectSummaryValue(summary.italic, font.italic === true);
+      collectSummaryValue(summary.underline, font.underline === true);
+      collectSummaryValue(summary.fontColor, font.color);
+      collectSummaryValue(summary.fillColor, fill.foregroundColor);
+      collectSummaryValue(summary.numberFormatCode, format.numberFormatCode);
+      collectSummaryValue(summary.horizontal, normalizeHorizontalAlign(format));
+      collectSummaryValue(summary.vertical, normalizeVerticalAlign(format));
+      collectSummaryValue(summary.border, border);
+    }
+  }
+  return {
+    font: {
+      bold: summaryValue(summary.bold),
+      italic: summaryValue(summary.italic),
+      underline: summaryValue(summary.underline),
+      color: summaryValue(summary.fontColor)
+    },
+    fill: {
+      foregroundColor: summaryValue(summary.fillColor)
+    },
+    numberFormatCode: summaryValue(summary.numberFormatCode),
+    alignment: {
+      horizontal: summaryValue(summary.horizontal),
+      vertical: summaryValue(summary.vertical)
+    },
+    border: summaryValue(summary.border)
+  };
+}
+__name(summarizeSpreadsheetSelectionFormat, "summarizeSpreadsheetSelectionFormat");
+function createEmptyFormatSummary() {
+  return {
+    bold: emptySummary(),
+    italic: emptySummary(),
+    underline: emptySummary(),
+    fontColor: emptySummary(),
+    fillColor: emptySummary(),
+    numberFormatCode: emptySummary(),
+    horizontal: emptySummary(),
+    vertical: emptySummary(),
+    border: emptySummary()
+  };
+}
+__name(createEmptyFormatSummary, "createEmptyFormatSummary");
+function emptySummary() {
+  return { hasValue: false, value: void 0, mixed: false };
+}
+__name(emptySummary, "emptySummary");
+function collectSummaryValue(summary, value) {
+  if (!summary.hasValue) {
+    summary.hasValue = true;
+    summary.value = value;
+    return;
+  }
+  if (!formatValuesEqual(summary.value, value)) summary.mixed = true;
+}
+__name(collectSummaryValue, "collectSummaryValue");
+function summaryValue(summary) {
+  return summary.mixed ? "mixed" : summary.value;
+}
+__name(summaryValue, "summaryValue");
+function cellFormatAt(model, row, column) {
+  var _a, _b;
+  const cell = getRenderCell(model, row, column);
+  return (_b = model.styles.cellFormats[(_a = cell == null ? void 0 : cell.styleId) != null ? _a : 0]) != null ? _b : {};
+}
+__name(cellFormatAt, "cellFormatAt");
+function normalizeHorizontalAlign(format) {
+  var _a, _b;
+  return ((_a = format.alignment) == null ? void 0 : _a.horizontal) === "center" || ((_b = format.alignment) == null ? void 0 : _b.horizontal) === "right" ? format.alignment.horizontal : "left";
+}
+__name(normalizeHorizontalAlign, "normalizeHorizontalAlign");
+function normalizeVerticalAlign(format) {
+  var _a, _b;
+  if (((_a = format.alignment) == null ? void 0 : _a.vertical) === "top" || ((_b = format.alignment) == null ? void 0 : _b.vertical) === "center") {
+    return format.alignment.vertical;
+  }
+  return "bottom";
+}
+__name(normalizeVerticalAlign, "normalizeVerticalAlign");
+function formatValuesEqual(a, b) {
+  return JSON.stringify(a != null ? a : null) === JSON.stringify(b != null ? b : null);
+}
+__name(formatValuesEqual, "formatValuesEqual");
+async function renderSpreadsheetEditor(host, bytes, options = {}) {
+  const controller = new NativeSpreadsheetEditor(host, options);
+  await controller.loadWorkbook(bytes);
+  return controller;
+}
+__name(renderSpreadsheetEditor, "renderSpreadsheetEditor");
+var _NativeSpreadsheetEditor = class _NativeSpreadsheetEditor {
+  constructor(host, options) {
+    __publicField(this, "host", host);
+    __publicField(this, "options", options);
+    __publicField(this, "renderRoot");
+    __publicField(this, "runtimeValue", null);
+    __publicField(this, "renderer", null);
+    __publicField(this, "layout", null);
+    __publicField(this, "viewport", null);
+    __publicField(this, "scroll", { x: 0, y: 0 });
+    __publicField(this, "scrollbarState", null);
+    __publicField(this, "listeners", /* @__PURE__ */ new Set());
+    __publicField(this, "stateListeners", /* @__PURE__ */ new Set());
+    __publicField(this, "baseCanvas", document.createElement("canvas"));
+    __publicField(this, "headerCanvas", document.createElement("canvas"));
+    __publicField(this, "overlayCanvas", document.createElement("canvas"));
+    __publicField(this, "unsupportedObjectLayer", document.createElement("div"));
+    __publicField(this, "sheetTabs", document.createElement("div"));
+    __publicField(this, "horizontalScrollbar", document.createElement("div"));
+    __publicField(this, "verticalScrollbar", document.createElement("div"));
+    __publicField(this, "horizontalThumb", document.createElement("div"));
+    __publicField(this, "verticalThumb", document.createElement("div"));
+    __publicField(this, "cellEditorElement", document.createElement("textarea"));
+    __publicField(this, "resizeGuide", document.createElement("div"));
+    __publicField(this, "contextMenu", document.createElement("div"));
+    __publicField(this, "filterMenu", document.createElement("div"));
+    __publicField(this, "cellEditor");
+    __publicField(this, "resizeObserver");
+    __publicField(this, "disposed", false);
+    __publicField(this, "drag", null);
+    __publicField(this, "selectionState", createSelection(1, 1));
+    __publicField(this, "editingCell", null);
+    __publicField(this, "editingCellStyle", null);
+    __publicField(this, "clipboardPayload", null);
+    __publicField(this, "selecting", false);
+    __publicField(this, "resizeDrag", null);
+    __publicField(this, "autoFillDrag", null);
+    __publicField(this, "selectedChartIndex", null);
+    __publicField(this, "chartDrag", null);
+    __publicField(this, "columnFilters", /* @__PURE__ */ new Map());
+    __publicField(this, "filterMenuColumn", null);
+    __publicField(this, "copiedRange", null);
+    __publicField(this, "formulaReferenceRanges", []);
+    __publicField(this, "lastStateKey", "");
+    __publicField(this, "transactionDepth", 0);
+    __publicField(this, "transactionChanged", false);
+    __publicField(this, "handleClick", /* @__PURE__ */ __name((event) => {
+      if (this.eventPathContains(event, this.contextMenu) || this.eventPathContains(event, this.filterMenu)) return;
+      if (this.filterMenu.style.display === "block") this.hideFilterMenu();
+      if (this.editingCell) {
+        if (this.eventPathContains(event, this.cellEditorElement)) return;
+        this.cellEditor.cancel();
+      }
+      if (!this.viewport || !this.layout) return;
+      const chartHit = this.chartAtPoint(this.eventPoint(event));
+      if (chartHit) {
+        this.selectedChartIndex = chartHit.chartIndex;
+        this.render();
+        event.preventDefault();
+        return;
+      }
+      this.selectedChartIndex = null;
+      const hit = this.viewport.hitTest(this.eventPoint(event));
+      if (hit.kind !== "cell" && hit.kind !== "rowHeader" && hit.kind !== "columnHeader") return;
+      if (hit.kind === "cell" && hit.row === 1 && this.isFilterIconHit(hit.column, event)) {
+        this.openFilterMenu(hit.column, event.clientX, event.clientY);
+        event.preventDefault();
+        return;
+      }
+      if (hit.kind === "cell") {
+        const model = this.runtime().activeSheet();
+        this.selectionState = expandSelectionForMergedRanges(
+          createSelection(hit.row, hit.column),
+          model
+        );
+      }
+      this.host.focus();
+      this.render();
+    }, "handleClick"));
+    __publicField(this, "handleFilterMenuClick", /* @__PURE__ */ __name((event) => {
+      var _a;
+      const target = event.target;
+      const action = (_a = target.closest("[data-filter-action]")) == null ? void 0 : _a.dataset.filterAction;
+      if (!action || this.filterMenuColumn === null) return;
+      if (action === "cancel") {
+        this.hideFilterMenu();
+        return;
+      }
+      const column = this.filterMenuColumn;
+      if (action === "clear") {
+        this.columnFilters.delete(column);
+      } else if (action === "apply") {
+        const values = Array.from(this.filterMenu.querySelectorAll("input[data-filter-value]:checked")).map((input) => {
+          var _a2;
+          return (_a2 = input.dataset.filterValue) != null ? _a2 : "";
+        });
+        this.columnFilters.set(column, values);
+      }
+      this.hideFilterMenu();
+      void this.applyColumnFilters();
+    }, "handleFilterMenuClick"));
+    __publicField(this, "handleDoubleClick", /* @__PURE__ */ __name((event) => {
+      if (!this.viewport || !this.layout) return;
+      const hit = this.viewport.hitTest(this.eventPoint(event));
+      if (hit.kind !== "cell") return;
+      this.selectionState = expandSelectionForMergedRanges(createSelection(hit.row, hit.column), this.runtime().activeSheet());
+      this.openCellEditor();
+      event.preventDefault();
+    }, "handleDoubleClick"));
+    __publicField(this, "handlePointerDown", /* @__PURE__ */ __name((event) => {
+      var _a;
+      if (this.editingCell) {
+        if (this.eventPathContains(event, this.cellEditorElement)) return;
+        this.cellEditor.cancel();
+      }
+      if (event.button !== 0 || !this.viewport || !this.layout) return;
+      const point = this.eventPoint(event);
+      const chartHit = this.chartAtPoint(point);
+      if (chartHit) {
+        this.selectedChartIndex = chartHit.chartIndex;
+        this.chartDrag = {
+          chartIndex: chartHit.chartIndex,
+          pointer: point,
+          startRect: chartHit.logicalRect,
+          previewRect: chartHit.logicalRect
+        };
+        this.host.setPointerCapture(event.pointerId);
+        this.render();
+        event.preventDefault();
+        return;
+      }
+      this.selectedChartIndex = null;
+      const resizeHandle = hitSpreadsheetResizeHandle(this.layout, this.viewport.viewports, point);
+      if (resizeHandle) {
+        this.resizeDrag = startSpreadsheetResizeDrag(resizeHandle, event);
+        this.host.setPointerCapture(event.pointerId);
+        this.host.style.cursor = resizeHandle.kind === "column" ? "col-resize" : "row-resize";
+        this.updateResizeGuide(this.resizeDrag);
+        event.preventDefault();
+        return;
+      }
+      const selectionRange = normalizeSelectionRange(this.selectionState.range);
+      const fillHandle = (_a = this.renderer) == null ? void 0 : _a.fillHandleRect(this.layout, this.viewport, selectionRange);
+      if (fillHandle && containsPoint2(fillHandle, point) && supportsSpreadsheetAutoFill(this.runtime().activeSheet(), selectionRange)) {
+        this.autoFillDrag = { source: selectionRange, preview: null };
+        this.host.setPointerCapture(event.pointerId);
+        event.preventDefault();
+        return;
+      }
+      const hit = this.viewport.hitTest(point);
+      if (hit.kind !== "cell" && hit.kind !== "rowHeader" && hit.kind !== "columnHeader") return;
+      const model = this.runtime().activeSheet();
+      if (hit.kind === "cell") {
+        this.selectionState = expandSelectionForMergedRanges(createSelection(hit.row, hit.column), model);
+      } else if (hit.kind === "rowHeader") {
+        this.selectionState = createRowSelection(hit.row, { columnCount: this.layout.columnCount });
+      } else {
+        this.selectionState = createColumnSelection(hit.column, { rowCount: this.layout.rowCount });
+      }
+      this.selecting = true;
+      this.host.setPointerCapture(event.pointerId);
+      this.render();
+      event.preventDefault();
+    }, "handlePointerDown"));
+    __publicField(this, "handlePointerMove", /* @__PURE__ */ __name((event) => {
+      if (!this.viewport || !this.layout) return;
+      if (this.chartDrag) {
+        const point = this.eventPoint(event);
+        const deltaX = point.x - this.chartDrag.pointer.x;
+        const deltaY = point.y - this.chartDrag.pointer.y;
+        this.chartDrag.previewRect = __spreadProps(__spreadValues({}, this.chartDrag.startRect), {
+          x: Math.max(0, this.chartDrag.startRect.x + deltaX),
+          y: Math.max(0, this.chartDrag.startRect.y + deltaY)
+        });
+        this.host.style.cursor = "grabbing";
+        this.render();
+        event.preventDefault();
+        return;
+      }
+      if (!this.resizeDrag && !this.autoFillDrag && !this.selecting && !this.editingCell) {
+        const resizeHandle = hitSpreadsheetResizeHandle(this.layout, this.viewport.viewports, this.eventPoint(event));
+        this.host.style.cursor = resizeHandle ? resizeHandle.kind === "column" ? "col-resize" : "row-resize" : "";
+      }
+      if (this.resizeDrag) {
+        this.resizeDrag = updateSpreadsheetResizeDrag(this.resizeDrag, event);
+        this.updateResizeGuide(this.resizeDrag);
+        return;
+      }
+      if (this.autoFillDrag) {
+        const hit2 = this.viewport.hitTest(this.eventPoint(event));
+        this.autoFillDrag.preview = autoFillPreviewRangeForHit(this.autoFillDrag.source, hit2);
+        this.render();
+        event.preventDefault();
+        return;
+      }
+      if (!this.selecting) return;
+      const hit = this.viewport.hitTest(this.eventPoint(event));
+      if (hit.kind === "none" || hit.kind === "corner") return;
+      const model = this.runtime().activeSheet();
+      if (hit.kind === "cell") {
+        this.selectionState = expandSelectionForMergedRanges(
+          extendSelection(this.selectionState, hit.row, hit.column, {
+            rowCount: this.layout.rowCount,
+            columnCount: this.layout.columnCount
+          }),
+          model
+        );
+      } else if (hit.kind === "rowHeader" && this.selectionState.kind === "row") {
+        this.selectionState = extendSelection(this.selectionState, hit.row, 1, { columnCount: this.layout.columnCount, rowCount: this.layout.rowCount });
+      } else if (hit.kind === "columnHeader" && this.selectionState.kind === "column") {
+        this.selectionState = extendSelection(this.selectionState, 1, hit.column, { columnCount: this.layout.columnCount, rowCount: this.layout.rowCount });
+      }
+      this.render();
+      event.preventDefault();
+    }, "handlePointerMove"));
+    __publicField(this, "handlePointerUp", /* @__PURE__ */ __name((event) => {
+      if (this.chartDrag) {
+        const completed = this.chartDrag;
+        this.chartDrag = null;
+        this.host.style.cursor = "";
+        if (this.host.hasPointerCapture(event.pointerId)) this.host.releasePointerCapture(event.pointerId);
+        if (completed.previewRect.x === completed.startRect.x && completed.previewRect.y === completed.startRect.y) {
+          this.render();
+          event.preventDefault();
+          return;
+        }
+        const anchor = this.chartAnchorAtIndex(completed.chartIndex);
+        if (anchor && this.layout) {
+          const next = chartAnchorForLogicalRect(this.layout, completed.previewRect, anchor);
+          void this.runtime().moveChart(completed.chartIndex, next).then(async () => {
+            this.render();
+            await this.emitChange();
+          });
+        } else {
+          this.render();
+        }
+        event.preventDefault();
+        return;
+      }
+      if (this.resizeDrag) {
+        const completed = updateSpreadsheetResizeDrag(this.resizeDrag, event);
+        this.resizeDrag = null;
+        this.host.style.cursor = "";
+        this.hideResizeGuide();
+        if (this.host.hasPointerCapture(event.pointerId)) this.host.releasePointerCapture(event.pointerId);
+        void this.commitResizeDrag(completed);
+        event.preventDefault();
+        return;
+      }
+      if (this.autoFillDrag) {
+        const completed = this.autoFillDrag;
+        this.autoFillDrag = null;
+        if (this.host.hasPointerCapture(event.pointerId)) this.host.releasePointerCapture(event.pointerId);
+        if (completed.preview) {
+          void this.runtime().autoFillRange(completed.source, completed.preview).then(async () => {
+            this.selectionState = __spreadProps(__spreadValues({}, this.selectionState), { range: completed.preview });
+            this.render();
+            await this.emitChange();
+          });
+        } else {
+          this.render();
+        }
+        event.preventDefault();
+        return;
+      }
+      if (!this.selecting) return;
+      this.selecting = false;
+      if (this.host.hasPointerCapture(event.pointerId)) this.host.releasePointerCapture(event.pointerId);
+      this.host.style.cursor = "";
+    }, "handlePointerUp"));
+    __publicField(this, "handlePointerLeave", /* @__PURE__ */ __name(() => {
+      if (!this.resizeDrag && !this.autoFillDrag && !this.chartDrag) this.host.style.cursor = "";
+    }, "handlePointerLeave"));
+    __publicField(this, "handleKeyDown", /* @__PURE__ */ __name((event) => {
+      if (this.editingCell) return;
+      const { row, column } = this.selectionState.active;
+      if (event.key === "F2" || event.key === "Enter") {
+        event.preventDefault();
+        this.openCellEditor();
+        return;
+      }
+      const deltas = {
+        ArrowUp: [-1, 0],
+        ArrowDown: [1, 0],
+        ArrowLeft: [0, -1],
+        ArrowRight: [0, 1]
+      };
+      const delta = deltas[event.key];
+      if (!delta) return;
+      const model = this.runtime().activeSheet();
+      this.selectionState = createSelection(
+        Math.max(1, Math.min(model.maxRow, row + delta[0])),
+        Math.max(1, Math.min(model.maxColumn, column + delta[1]))
+      );
+      event.preventDefault();
+      this.render();
+    }, "handleKeyDown"));
+    __publicField(this, "handleCopy", /* @__PURE__ */ __name((event) => {
+      var _a;
+      const range = normalizeSelectionRange(this.selectionState.range);
+      const payload = buildSpreadsheetClipboardPayload(this.runtime().activeSheet(), range);
+      this.clipboardPayload = payload;
+      this.copiedRange = range;
+      (_a = event.clipboardData) == null ? void 0 : _a.setData("text/plain", payload.text);
+      event.preventDefault();
+    }, "handleCopy"));
+    __publicField(this, "handlePaste", /* @__PURE__ */ __name((event) => {
+      var _a, _b, _c, _d, _e;
+      const text = (_b = (_a = event.clipboardData) == null ? void 0 : _a.getData("text/plain")) != null ? _b : "";
+      if (!text) return;
+      event.preventDefault();
+      const values = ((_c = this.clipboardPayload) == null ? void 0 : _c.text) === text ? this.clipboardPayload.values : parseTsv(text);
+      void this.runtime().pasteRange(this.selectionState.active.row, this.selectionState.active.column, values, {
+        mode: "all",
+        merges: ((_d = this.clipboardPayload) == null ? void 0 : _d.text) === text ? this.clipboardPayload.merges : [],
+        styleIds: ((_e = this.clipboardPayload) == null ? void 0 : _e.text) === text ? this.clipboardPayload.styleIds : []
+      }).then(async () => {
+        const pastedSelection = expandSelectionForMergedRanges({
+          kind: "cell",
+          active: this.selectionState.active,
+          range: {
+            startRow: this.selectionState.active.row,
+            startColumn: this.selectionState.active.column,
+            endRow: this.selectionState.active.row + values.length - 1,
+            endColumn: this.selectionState.active.column + Math.max(1, values.reduce((max, row) => Math.max(max, row.length), 0)) - 1
+          }
+        }, this.runtime().activeSheet());
+        this.selectionState = pastedSelection;
+        this.copiedRange = normalizeSelectionRange(pastedSelection.range);
+        this.render();
+        await this.emitChange();
+      });
+    }, "handlePaste"));
+    __publicField(this, "handleContextMenu", /* @__PURE__ */ __name((event) => {
+      if (!this.viewport || !this.layout) return;
+      const chartHit = this.chartAtPoint(this.eventPoint(event));
+      if (chartHit) {
+        this.selectedChartIndex = chartHit.chartIndex;
+        this.hideContextMenu();
+        this.hideFilterMenu();
+        this.render();
+        event.preventDefault();
+        return;
+      }
+      const hit = this.viewport.hitTest(this.eventPoint(event));
+      if (hit.kind === "cell" && !this.selectionContainsCell(hit.row, hit.column)) {
+        this.selectionState = expandSelectionForMergedRanges(createSelection(hit.row, hit.column), this.runtime().activeSheet());
+        this.render();
+      }
+      if (hit.kind !== "cell" && hit.kind !== "rowHeader" && hit.kind !== "columnHeader") return;
+      event.preventDefault();
+      this.renderContextMenu(event.clientX, event.clientY, hit.kind === "columnHeader" ? hit.column : void 0);
+    }, "handleContextMenu"));
+    __publicField(this, "handleDocumentPointerDown", /* @__PURE__ */ __name((event) => {
+      const path = event.composedPath();
+      if (path.includes(this.contextMenu) || path.includes(this.filterMenu)) return;
+      this.hideContextMenu();
+      this.hideFilterMenu();
+    }, "handleDocumentPointerDown"));
+    __publicField(this, "handleWheel", /* @__PURE__ */ __name((event) => {
+      if (!this.runtimeValue) return;
+      event.preventDefault();
+      const next = applyWheelDelta(this.scroll, event.deltaX, event.deltaY);
+      this.setScroll(next.x, next.y);
+    }, "handleWheel"));
+    var _a;
+    host.replaceChildren();
+    this.renderRoot = options.styleIsolation === "none" ? host : (_a = host.shadowRoot) != null ? _a : host.attachShadow({ mode: "open" });
+    this.renderRoot.replaceChildren();
+    if (this.renderRoot instanceof ShadowRoot) {
+      const style = document.createElement("style");
+      style.textContent = `
+        :host { display: block; position: relative; min-width: 0; min-height: 0; }
+        *, *::before, *::after { box-sizing: border-box; }
+        button, input, textarea, select { font: 13px Arial, sans-serif; line-height: normal; }
+        button { margin: 0; }
+      `;
+      this.renderRoot.appendChild(style);
+    }
+    host.classList.add("coco-spreadsheet-editor-host");
+    Object.assign(host.style, { position: "relative", overflow: "hidden" });
+    for (const canvas of [this.baseCanvas, this.headerCanvas, this.overlayCanvas]) {
+      Object.assign(canvas.style, { position: "absolute", inset: "0", display: "block" });
+      this.renderRoot.appendChild(canvas);
+    }
+    this.unsupportedObjectLayer.className = "coco-spreadsheet-unsupported-object-layer";
+    Object.assign(this.unsupportedObjectLayer.style, {
+      position: "absolute",
+      inset: "0",
+      zIndex: "4",
+      overflow: "hidden",
+      pointerEvents: "none"
+    });
+    this.renderRoot.appendChild(this.unsupportedObjectLayer);
+    this.cellEditorElement.className = "coco-spreadsheet-cell-editor";
+    Object.assign(this.cellEditorElement.style, {
+      position: "absolute",
+      zIndex: "20",
+      display: "none",
+      resize: "none",
+      overflow: "hidden",
+      padding: "2px 4px",
+      border: "2px solid #2563eb",
+      outline: "none",
+      font: "13px Arial, sans-serif",
+      lineHeight: "normal",
+      whiteSpace: "pre-wrap",
+      overflowWrap: "break-word"
+    });
+    this.renderRoot.appendChild(this.cellEditorElement);
+    this.resizeGuide.className = "coco-spreadsheet-resize-guide";
+    Object.assign(this.resizeGuide.style, {
+      position: "absolute",
+      zIndex: "25",
+      display: "none",
+      pointerEvents: "none",
+      background: "#2563eb"
+    });
+    this.renderRoot.appendChild(this.resizeGuide);
+    this.contextMenu.className = "coco-spreadsheet-context-menu";
+    Object.assign(this.contextMenu.style, {
+      position: "fixed",
+      zIndex: "50",
+      display: "none",
+      minWidth: "160px",
+      padding: "4px",
+      background: "#ffffff",
+      border: "1px solid #cbd5e1",
+      borderRadius: "6px",
+      boxShadow: "0 8px 24px rgba(15, 23, 42, 0.16)"
+    });
+    this.renderRoot.appendChild(this.contextMenu);
+    this.filterMenu.className = "coco-spreadsheet-filter-menu";
+    Object.assign(this.filterMenu.style, {
+      position: "fixed",
+      zIndex: "60",
+      display: "none",
+      width: "240px",
+      maxHeight: "360px",
+      overflow: "auto",
+      padding: "8px",
+      background: "#ffffff",
+      border: "1px solid #cbd5e1",
+      borderRadius: "6px",
+      boxShadow: "0 8px 24px rgba(15, 23, 42, 0.16)"
+    });
+    this.renderRoot.appendChild(this.filterMenu);
+    this.cellEditor = new SpreadsheetCellEditor({
+      textarea: this.cellEditorElement,
+      onCommit: /* @__PURE__ */ __name(async (value) => this.commitCellEdit(value), "onCommit"),
+      onCancel: /* @__PURE__ */ __name(() => {
+        this.editingCell = null;
+        this.editingCellStyle = null;
+        this.formulaReferenceRanges = [];
+        this.render();
+      }, "onCancel")
+    });
+    this.cellEditorElement.addEventListener("input", () => {
+      if (!this.editingCell) return;
+      this.formulaReferenceRanges = formulaReferenceRangesFromText(this.cellEditorElement.value);
+      this.render();
+    });
+    this.configureScrollbar(this.horizontalScrollbar, this.horizontalThumb, true);
+    this.configureScrollbar(this.verticalScrollbar, this.verticalThumb, false);
+    this.renderRoot.append(this.horizontalScrollbar, this.verticalScrollbar);
+    this.sheetTabs.className = "coco-spreadsheet-editor-tabs";
+    if (options.showSheetTabs !== false) this.renderRoot.appendChild(this.sheetTabs);
+    this.renderer = new SpreadsheetCanvasRenderer({
+      baseCanvas: this.baseCanvas,
+      headerCanvas: this.headerCanvas,
+      overlayCanvas: this.overlayCanvas
+    });
+    host.addEventListener("wheel", this.handleWheel, { passive: false });
+    host.addEventListener("click", this.handleClick);
+    host.addEventListener("dblclick", this.handleDoubleClick);
+    host.addEventListener("pointerdown", this.handlePointerDown);
+    host.addEventListener("pointermove", this.handlePointerMove);
+    host.addEventListener("pointerup", this.handlePointerUp);
+    host.addEventListener("pointerleave", this.handlePointerLeave);
+    host.addEventListener("keydown", this.handleKeyDown);
+    host.addEventListener("copy", this.handleCopy);
+    host.addEventListener("paste", this.handlePaste);
+    host.addEventListener("contextmenu", this.handleContextMenu);
+    document.addEventListener("pointerdown", this.handleDocumentPointerDown);
+    this.filterMenu.addEventListener("click", this.handleFilterMenuClick);
+    host.tabIndex = 0;
+    this.resizeObserver = new ResizeObserver(() => this.render());
+    this.resizeObserver.observe(host);
+  }
+  runtime() {
+    if (!this.runtimeValue) throw new Error("SpreadsheetEditor: workbook is not loaded");
+    return this.runtimeValue;
+  }
+  selection() {
+    return this.selectionState;
+  }
+  cellState(address) {
+    var _a, _b, _c, _d;
+    const model = this.runtime().activeSheet();
+    const cell = model.cellsByAddress.get(address);
+    if (!cell) {
+      const match = address.match(/^([A-Z]+)(\d+)$/i);
+      if (!match) throw new Error(`SpreadsheetEditor: invalid cell address ${address}`);
+      const column = columnNumberFromLetters(match[1]);
+      const row = Number(match[2]);
+      return { address: address.toUpperCase(), row, column, value: null, displayText: "" };
+    }
+    const format = model.styles.cellFormats[(_a = cell.styleId) != null ? _a : 0];
+    return {
+      address: cell.address,
+      row: cell.row,
+      column: cell.column,
+      value: cell.value,
+      displayText: cell.displayText,
+      formula: cell.formula,
+      styleId: cell.styleId,
+      format: format ? {
+        font: model.styles.fonts[(_b = format.fontId) != null ? _b : 0],
+        fill: model.styles.fills[(_c = format.fillId) != null ? _c : 0],
+        border: model.styles.borders[(_d = format.borderId) != null ? _d : 0],
+        alignment: format.alignment,
+        numberFormatCode: format.numberFormatCode
+      } : void 0
+    };
+  }
+  freezeState() {
+    return freezeStateFromSheet(this.runtime().activeSheet().source);
+  }
+  filterState() {
+    return new Map([...this.columnFilters.entries()].map(([column, values]) => [column, [...values]]));
+  }
+  activeSheetName() {
+    return this.runtime().activeSheetName();
+  }
+  async setActiveSheet(name) {
+    await this.runtime().setActiveSheet(name);
+    this.scroll = { x: 0, y: 0 };
+    this.selectionState = createSelection(1, 1);
+    this.render();
+    this.renderTabs();
+  }
+  async addSheet(name) {
+    await this.runtime().addSheet(name);
+    this.scroll = { x: 0, y: 0 };
+    this.selectionState = createSelection(1, 1);
+    this.renderTabs();
+    this.render();
+    await this.emitChange();
+  }
+  async renameSheet(sheetName, name) {
+    await this.runtime().renameSheet(sheetName, name);
+    this.renderTabs();
+    this.render();
+    await this.emitChange();
+  }
+  async copySheet(sheetName, newName) {
+    await this.runtime().copySheet(sheetName, newName);
+    this.scroll = { x: 0, y: 0 };
+    this.selectionState = createSelection(1, 1);
+    this.renderTabs();
+    this.render();
+    await this.emitChange();
+  }
+  async deleteSheet(sheetName) {
+    await this.runtime().deleteSheet(sheetName);
+    this.scroll = { x: 0, y: 0 };
+    this.selectionState = createSelection(1, 1);
+    this.renderTabs();
+    this.render();
+    await this.emitChange();
+  }
+  async moveSheet(sheetName, toIndex) {
+    await this.runtime().moveSheet(sheetName, toIndex);
+    this.renderTabs();
+    this.render();
+    await this.emitChange();
+  }
+  async setCellValue(address, value) {
+    await this.runtime().setCellValue(address, value, { mergeUndo: true });
+    this.render();
+    await this.emitChange();
+  }
+  async setCellFormula(address, formula) {
+    await this.runtime().setCellFormula(address, formula, { mergeUndo: true });
+    this.render();
+    await this.emitChange();
+  }
+  async formatSelection(kind) {
+    await this.applyFormat(kind);
+  }
+  async setSelectionFontColor(color) {
+    const range = normalizeSelectionRange(this.selectionState.range);
+    await this.runtime().setRangeFontColor(
+      range.startRow,
+      range.startColumn,
+      range.endRow - range.startRow + 1,
+      range.endColumn - range.startColumn + 1,
+      color
+    );
+    this.render();
+    await this.emitChange();
+  }
+  async setSelectionFillColor(color) {
+    const range = normalizeSelectionRange(this.selectionState.range);
+    await this.runtime().setRangeFillColor(
+      range.startRow,
+      range.startColumn,
+      range.endRow - range.startRow + 1,
+      range.endColumn - range.startColumn + 1,
+      color
+    );
+    this.render();
+    await this.emitChange();
+  }
+  async setSelectionHorizontalAlign(alignment) {
+    await this.applyAlignment(alignment);
+  }
+  async setSelectionVerticalAlign(alignment) {
+    const range = normalizeSelectionRange(this.selectionState.range);
+    await this.runtime().setRangeVerticalAlign(
+      range.startRow,
+      range.startColumn,
+      range.endRow - range.startRow + 1,
+      range.endColumn - range.startColumn + 1,
+      alignment
+    );
+    this.render();
+    await this.emitChange();
+  }
+  async setSelectionNumberFormat(code) {
+    const range = normalizeSelectionRange(this.selectionState.range);
+    await this.runtime().setRangeNumberFormat(
+      range.startRow,
+      range.startColumn,
+      range.endRow - range.startRow + 1,
+      range.endColumn - range.startColumn + 1,
+      code
+    );
+    this.render();
+    await this.emitChange();
+  }
+  async setSelectionBorder(mode) {
+    const range = normalizeSelectionRange(this.selectionState.range);
+    await this.runtime().setRangeBorder(
+      range.startRow,
+      range.startColumn,
+      range.endRow - range.startRow + 1,
+      range.endColumn - range.startColumn + 1,
+      mode
+    );
+    this.render();
+    await this.emitChange();
+  }
+  async loadWorkbook(bytes) {
+    this.assertAlive();
+    const previous = this.runtimeValue;
+    this.runtimeValue = null;
+    this.scroll = { x: 0, y: 0 };
+    if (previous) await previous.dispose();
+    this.runtimeValue = await SpreadsheetEditorRuntime.fromZip(bytes, {
+      workbookId: this.options.workbookId,
+      mode: "inline"
+    });
+    this.renderTabs();
+    this.render();
+  }
+  async toZip() {
+    return this.runtime().toZip();
+  }
+  canUndo() {
+    return this.runtime().canUndo();
+  }
+  canRedo() {
+    return this.runtime().canRedo();
+  }
+  async undo() {
+    await this.runtime().undo();
+    this.render();
+    await this.emitChange();
+  }
+  async redo() {
+    await this.runtime().redo();
+    this.render();
+    await this.emitChange();
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  subscribeState(listener) {
+    this.stateListeners.add(listener);
+    return () => this.stateListeners.delete(listener);
+  }
+  async runTransaction(options, run) {
+    this.transactionDepth += 1;
+    try {
+      await this.runtime().runUserTransaction(options, () => run(this));
+    } finally {
+      this.transactionDepth -= 1;
+      if (this.transactionDepth === 0 && this.transactionChanged) {
+        this.transactionChanged = false;
+        this.render();
+        await this.emitChange();
+      }
+    }
+  }
+  destroy() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.resizeObserver.disconnect();
+    this.host.removeEventListener("wheel", this.handleWheel);
+    this.host.removeEventListener("click", this.handleClick);
+    this.host.removeEventListener("dblclick", this.handleDoubleClick);
+    this.host.removeEventListener("pointerdown", this.handlePointerDown);
+    this.host.removeEventListener("pointermove", this.handlePointerMove);
+    this.host.removeEventListener("pointerup", this.handlePointerUp);
+    this.host.removeEventListener("pointerleave", this.handlePointerLeave);
+    this.host.removeEventListener("keydown", this.handleKeyDown);
+    this.host.removeEventListener("copy", this.handleCopy);
+    this.host.removeEventListener("paste", this.handlePaste);
+    this.host.removeEventListener("contextmenu", this.handleContextMenu);
+    document.removeEventListener("pointerdown", this.handleDocumentPointerDown);
+    this.contextMenu.remove();
+    this.filterMenu.remove();
+    this.unsupportedObjectLayer.remove();
+    this.host.replaceChildren();
+    const runtime = this.runtimeValue;
+    this.runtimeValue = null;
+    void (runtime == null ? void 0 : runtime.dispose());
+  }
+  render() {
+    var _a;
+    const runtime = this.runtimeValue;
+    const renderer = this.renderer;
+    if (!runtime || !renderer || this.disposed) return;
+    const rect = this.host.getBoundingClientRect();
+    const width = Math.max(1, rect.width);
+    const height = Math.max(1, rect.height - (this.options.showSheetTabs === false ? 0 : 40));
+    const layout = new SpreadsheetLayout(runtime.activeSheet());
+    const viewportSize = { width: Math.max(1, width - 12), height: Math.max(1, height - 12) };
+    const viewport = new SpreadsheetViewportManager(layout, {
+      viewportSize,
+      scroll: this.scroll,
+      freeze: freezeStateFromSheet(runtime.activeSheet().source)
+    });
+    this.layout = layout;
+    this.viewport = viewport;
+    this.scroll = viewport.scroll;
+    this.scrollbarState = computeScrollbarState(
+      layout,
+      viewportSize,
+      freezeStateFromSheet(runtime.activeSheet().source),
+      this.scroll
+    );
+    renderer.resize(width, height);
+    renderer.setHeaderFiltersEnabled(this.options.enableHeaderFilters === true);
+    renderer.setHeaderFilterColumns(this.options.enableHeaderFilters === true ? Array.from({ length: layout.columnCount }, (_, index) => index + 1) : null);
+    renderer.setActiveHeaderFilterColumns(Array.from(this.columnFilters.keys()));
+    renderer.render(layout, viewport);
+    const selectionRange = normalizeSelectionRange(this.selectionState.range);
+    renderer.renderSelection(layout, viewport, selectionRange, {
+      showFillHandle: supportsSpreadsheetAutoFill(runtime.activeSheet(), selectionRange)
+    });
+    this.updateCellEditorPosition();
+    if ((_a = this.autoFillDrag) == null ? void 0 : _a.preview) {
+      renderer.renderDashedRange(layout, viewport, this.autoFillDrag.preview, {
+        stroke: "#16A34A",
+        fill: "rgba(34, 197, 94, 0.08)"
+      });
+    }
+    for (const reference of this.formulaReferenceRanges) {
+      renderer.renderDashedRange(layout, viewport, reference.range, { stroke: reference.stroke });
+    }
+    if (this.copiedRange) renderer.renderCopiedRange(layout, viewport, this.copiedRange);
+    this.renderUnsupportedChartNotices(layout, viewport);
+    this.emitStateIfChanged(runtime.activeSheetName());
+    this.updateScrollbars();
+  }
+  renderUnsupportedChartNotices(layout, viewport) {
+    var _a, _b, _c;
+    this.unsupportedObjectLayer.replaceChildren();
+    const sheet = (_a = this.runtimeValue) == null ? void 0 : _a.activeSheet().source;
+    if (!sheet || sheet.charts.length === 0) return;
+    for (let chartIndex = 0; chartIndex < sheet.charts.length; chartIndex += 1) {
+      const chart = sheet.charts[chartIndex];
+      if (!chart) continue;
+      const anchor = findChartAnchor(sheet.drawings, chart);
+      const logicalRect = ((_b = this.chartDrag) == null ? void 0 : _b.chartIndex) === chartIndex ? this.chartDrag.previewRect : chartLogicalRect(layout, anchor);
+      if (!logicalRect) continue;
+      for (const fragment of chartScreenFragments(logicalRect, viewport)) {
+        const notice = document.createElement("div");
+        notice.className = "coco-spreadsheet-unsupported-chart";
+        Object.assign(notice.style, {
+          position: "absolute",
+          left: `${fragment.x}px`,
+          top: `${fragment.y}px`,
+          width: `${Math.max(1, fragment.width)}px`,
+          height: `${Math.max(1, fragment.height)}px`,
+          display: "flex",
+          flexDirection: "column",
+          alignItems: "center",
+          justifyContent: "center",
+          gap: "6px",
+          padding: "12px",
+          boxSizing: "border-box",
+          overflow: "hidden",
+          background: "rgba(248, 250, 252, 0.94)",
+          color: "#475569",
+          textAlign: "center",
+          font: "13px Arial, sans-serif",
+          lineHeight: "1.4",
+          cursor: ((_c = this.chartDrag) == null ? void 0 : _c.chartIndex) === chartIndex ? "grabbing" : "move",
+          border: this.selectedChartIndex === chartIndex ? "2px solid #2563eb" : "1px dashed #94a3b8",
+          boxShadow: this.selectedChartIndex === chartIndex ? "0 0 0 1px rgba(37, 99, 235, 0.18)" : "none"
+        });
+        const title = document.createElement("strong");
+        title.textContent = chart.title ? `\u56FE\u8868\uFF1A${chart.title}` : "\u56FE\u8868";
+        title.style.color = "#334155";
+        const message = document.createElement("span");
+        message.textContent = "\u5F53\u524D\u7F16\u8F91\u5668\u6682\u4E0D\u652F\u6301\u56FE\u8868\u6E32\u67D3";
+        const suggestion = document.createElement("span");
+        suggestion.textContent = "\u8BF7\u4F7F\u7528 Excel \u6216 WPS \u6253\u5F00\u6587\u4EF6\u67E5\u770B";
+        notice.append(title, message, suggestion);
+        this.unsupportedObjectLayer.appendChild(notice);
+      }
+    }
+  }
+  chartAnchorAtIndex(chartIndex) {
+    var _a;
+    const sheet = (_a = this.runtimeValue) == null ? void 0 : _a.activeSheet().source;
+    const chart = sheet == null ? void 0 : sheet.charts[chartIndex];
+    return chart ? findChartAnchor(sheet.drawings, chart) : void 0;
+  }
+  chartAtPoint(point) {
+    var _a;
+    const sheet = (_a = this.runtimeValue) == null ? void 0 : _a.activeSheet().source;
+    if (!sheet || !this.layout || !this.viewport) return null;
+    for (let chartIndex = sheet.charts.length - 1; chartIndex >= 0; chartIndex -= 1) {
+      const chart = sheet.charts[chartIndex];
+      if (!chart) continue;
+      const anchor = findChartAnchor(sheet.drawings, chart);
+      const logicalRect = chartLogicalRect(this.layout, anchor);
+      if (!logicalRect) continue;
+      if (chartScreenFragments(logicalRect, this.viewport).some((fragment) => containsPoint2(fragment, point))) {
+        return { chartIndex, logicalRect };
+      }
+    }
+    return null;
+  }
+  updateResizeGuide(drag) {
+    if (drag.kind === "column") {
+      Object.assign(this.resizeGuide.style, {
+        display: "block",
+        left: `${Math.round(drag.currentGuidePosition)}px`,
+        top: "0",
+        bottom: "0",
+        width: "2px",
+        height: ""
+      });
+    } else {
+      Object.assign(this.resizeGuide.style, {
+        display: "block",
+        left: "0",
+        top: `${Math.round(drag.currentGuidePosition)}px`,
+        right: "0",
+        height: "2px",
+        width: ""
+      });
+    }
+  }
+  hideResizeGuide() {
+    this.resizeGuide.style.display = "none";
+  }
+  renderContextMenu(x, y, columnHeader) {
+    const items = [
+      { label: "Undo", disabled: !this.canUndo(), action: /* @__PURE__ */ __name(() => this.undo(), "action") },
+      { label: "Redo", disabled: !this.canRedo(), action: /* @__PURE__ */ __name(() => this.redo(), "action") },
+      { label: "Copy", action: /* @__PURE__ */ __name(() => this.copySelection(), "action") },
+      { label: "Paste", action: /* @__PURE__ */ __name(() => this.pasteFromClipboard(), "action") },
+      { label: "Clear cells", action: /* @__PURE__ */ __name(() => this.clearSelection(), "action") },
+      { label: "Clear format", action: /* @__PURE__ */ __name(() => this.clearSelectionFormat(), "action") },
+      { label: "Bold", action: /* @__PURE__ */ __name(() => this.applyFormat("bold"), "action") },
+      { label: "Italic", action: /* @__PURE__ */ __name(() => this.applyFormat("italic"), "action") },
+      { label: "Underline", action: /* @__PURE__ */ __name(() => this.applyFormat("underline"), "action") },
+      { label: "Align left", action: /* @__PURE__ */ __name(() => this.applyAlignment("left"), "action") },
+      { label: "Align center", action: /* @__PURE__ */ __name(() => this.applyAlignment("center"), "action") },
+      { label: "Align right", action: /* @__PURE__ */ __name(() => this.applyAlignment("right"), "action") },
+      { label: "Merge cells", action: /* @__PURE__ */ __name(() => this.mergeSelection(), "action") },
+      { label: "Unmerge cells", action: /* @__PURE__ */ __name(() => this.unmergeSelection(), "action") },
+      { label: "Freeze above and left", action: /* @__PURE__ */ __name(() => this.freezeSelection(), "action") }
+    ];
+    if (columnHeader !== void 0) {
+      items.unshift({
+        label: "Filter column",
+        action: /* @__PURE__ */ __name(() => this.openFilterMenu(columnHeader, x, y), "action")
+      });
+      items.splice(
+        1,
+        0,
+        { label: "Sort A-Z", action: /* @__PURE__ */ __name(() => this.sortColumn(columnHeader, "asc"), "action") },
+        { label: "Sort Z-A", action: /* @__PURE__ */ __name(() => this.sortColumn(columnHeader, "desc"), "action") }
+      );
+    }
+    this.contextMenu.replaceChildren();
+    for (const item of items) {
+      const button = document.createElement("button");
+      button.type = "button";
+      button.textContent = item.label;
+      button.disabled = item.disabled === true;
+      Object.assign(button.style, {
+        display: "block",
+        width: "100%",
+        padding: "6px 10px",
+        border: "0",
+        background: "transparent",
+        textAlign: "left",
+        cursor: button.disabled ? "default" : "pointer"
+      });
+      button.addEventListener("mouseenter", () => {
+        if (!button.disabled) button.style.background = "#eff6ff";
+      });
+      button.addEventListener("mouseleave", () => {
+        button.style.background = "transparent";
+      });
+      button.addEventListener("click", () => {
+        this.hideContextMenu();
+        void item.action();
+      });
+      this.contextMenu.appendChild(button);
+    }
+    Object.assign(this.contextMenu.style, { left: `${x}px`, top: `${y}px`, display: "block" });
+  }
+  openFilterMenu(column, x, y) {
+    var _a;
+    if (this.filterMenu.style.display === "block" && this.filterMenuColumn === column) {
+      this.hideFilterMenu();
+      return;
+    }
+    const model = this.runtime().activeSheet();
+    const range = { startRow: 1, endRow: model.maxRow, endColumn: model.maxColumn };
+    const selected = new Set((_a = this.columnFilters.get(column)) != null ? _a : spreadsheetFilterValues(model, range, column));
+    this.filterMenuColumn = column;
+    this.filterMenu.replaceChildren();
+    const title = document.createElement("strong");
+    title.textContent = `Filter ${column}`;
+    title.style.display = "block";
+    title.style.marginBottom = "6px";
+    this.filterMenu.appendChild(title);
+    for (const value of spreadsheetFilterValues(model, range, column)) {
+      const label = document.createElement("label");
+      label.style.display = "block";
+      label.style.padding = "3px 0";
+      const input = document.createElement("input");
+      input.type = "checkbox";
+      input.checked = selected.has(value);
+      input.dataset.filterValue = value;
+      input.style.marginRight = "8px";
+      label.append(input, value === "" ? "(blank)" : value);
+      this.filterMenu.appendChild(label);
+    }
+    const actions = document.createElement("div");
+    actions.style.display = "flex";
+    actions.style.gap = "6px";
+    actions.style.marginTop = "8px";
+    for (const [label, action] of [["Apply", "apply"], ["Clear filter", "clear"], ["Cancel", "cancel"]]) {
+      const button = document.createElement("button");
+      button.type = "button";
+      button.textContent = label;
+      button.dataset.filterAction = action;
+      actions.appendChild(button);
+    }
+    this.filterMenu.appendChild(actions);
+    Object.assign(this.filterMenu.style, { left: `${x}px`, top: `${y}px`, display: "block" });
+  }
+  hideFilterMenu() {
+    this.filterMenu.style.display = "none";
+    this.filterMenuColumn = null;
+  }
+  isFilterIconHit(column, event) {
+    if (!this.layout || !this.viewport) return false;
+    const point = this.eventPoint(event);
+    const viewport = this.viewport.findViewport(point);
+    if (!viewport) return false;
+    const rect = this.viewport.cellScreenRect(1, column, viewport);
+    return rect.width >= 28 && point.x >= rect.x + rect.width - 22 && point.x <= rect.x + rect.width;
+  }
+  async applyColumnFilters() {
+    const model = this.runtime().activeSheet();
+    const filters = Array.from(this.columnFilters.entries()).filter(([, values]) => values.length > 0).map(([column, values]) => ({ column, values }));
+    await this.runtime().filterRowsByColumns(1, model.maxRow, filters);
+    this.render();
+    await this.emitChange();
+  }
+  async sortColumn(column, direction) {
+    const model = this.runtime().activeSheet();
+    await this.runtime().sortRows(1, model.maxRow, column, direction);
+    this.render();
+    await this.emitChange();
+  }
+  async sortActiveColumn(direction) {
+    await this.sortColumn(this.selectionState.active.column, direction);
+  }
+  async filterColumn(column, values) {
+    if (values === null) this.columnFilters.delete(column);
+    else this.columnFilters.set(column, [...values]);
+    await this.applyColumnFilters();
+  }
+  hideContextMenu() {
+    this.contextMenu.style.display = "none";
+  }
+  selectionContainsCell(row, column) {
+    const range = normalizeSelectionRange(this.selectionState.range);
+    return row >= range.startRow && row <= range.endRow && column >= range.startColumn && column <= range.endColumn;
+  }
+  async copySelection() {
+    const payload = buildSpreadsheetClipboardPayload(this.runtime().activeSheet(), normalizeSelectionRange(this.selectionState.range));
+    this.clipboardPayload = payload;
+    try {
+      await navigator.clipboard.writeText(payload.text);
+    } catch (e) {
+    }
+  }
+  async pasteFromClipboard() {
+    var _a;
+    let text = "";
+    try {
+      text = await navigator.clipboard.readText();
+    } catch (e) {
+      return;
+    }
+    if (!text) return;
+    const event = new ClipboardEvent("paste", { clipboardData: new DataTransfer() });
+    (_a = event.clipboardData) == null ? void 0 : _a.setData("text/plain", text);
+    this.handlePaste(event);
+  }
+  async clearSelection() {
+    const range = normalizeSelectionRange(this.selectionState.range);
+    await this.runtime().clearRange(range.startRow, range.startColumn, range.endRow - range.startRow + 1, range.endColumn - range.startColumn + 1);
+    this.render();
+    await this.emitChange();
+  }
+  async clearSelectionFormat() {
+    const range = normalizeSelectionRange(this.selectionState.range);
+    await this.runtime().clearRangeFormat(range.startRow, range.startColumn, range.endRow - range.startRow + 1, range.endColumn - range.startColumn + 1);
+    this.render();
+    await this.emitChange();
+  }
+  async applyFormat(kind) {
+    const range = normalizeSelectionRange(this.selectionState.range);
+    const rows = range.endRow - range.startRow + 1;
+    const columns = range.endColumn - range.startColumn + 1;
+    if (kind === "bold") await this.runtime().setRangeBold(range.startRow, range.startColumn, rows, columns, true);
+    if (kind === "italic") await this.runtime().setRangeItalic(range.startRow, range.startColumn, rows, columns, true);
+    if (kind === "underline") await this.runtime().setRangeUnderline(range.startRow, range.startColumn, rows, columns, true);
+    this.render();
+    await this.emitChange();
+  }
+  async applyAlignment(alignment) {
+    const range = normalizeSelectionRange(this.selectionState.range);
+    await this.runtime().setRangeHorizontalAlign(
+      range.startRow,
+      range.startColumn,
+      range.endRow - range.startRow + 1,
+      range.endColumn - range.startColumn + 1,
+      alignment
+    );
+    this.render();
+    await this.emitChange();
+  }
+  async mergeSelection() {
+    const range = normalizeSelectionRange(this.selectionState.range);
+    if (range.startRow === range.endRow && range.startColumn === range.endColumn) return;
+    await this.runtime().mergeRange(
+      range.startRow,
+      range.startColumn,
+      range.endRow - range.startRow + 1,
+      range.endColumn - range.startColumn + 1
+    );
+    this.selectionState = expandSelectionForMergedRanges(this.selectionState, this.runtime().activeSheet());
+    this.render();
+    await this.emitChange();
+  }
+  async unmergeSelection() {
+    const range = normalizeSelectionRange(this.selectionState.range);
+    const addresses = [...this.runtime().activeSheet().mergeMasterByAddress.values()].filter((merge) => rangesIntersect4(range, merge.range)).map((merge) => merge.address);
+    if (addresses.length === 0) return;
+    await this.runtime().unmergeRanges(addresses);
+    this.render();
+    await this.emitChange();
+  }
+  async freezeSelection() {
+    const active = this.selectionState.active;
+    await this.runtime().setFreezePanes(Math.max(0, active.row - 1), Math.max(0, active.column - 1));
+    this.render();
+    await this.emitChange();
+  }
+  async commitResizeDrag(drag) {
+    if (drag.currentSize === drag.startSize) {
+      this.render();
+      return;
+    }
+    if (drag.kind === "column") await this.runtime().setColumnWidth(drag.index, drag.currentSize);
+    else await this.runtime().setRowHeight(drag.index, drag.currentSize * 72 / 96);
+    this.render();
+    await this.emitChange();
+  }
+  openCellEditor() {
+    var _a, _b;
+    if (!this.layout || !this.viewport) return;
+    const cell = this.selectionState.active;
+    const viewport = this.viewport.findViewport({
+      x: this.layout.rowHeaderWidth + 1,
+      y: this.layout.columnHeaderHeight + 1
+    });
+    const renderCell = getRenderCell(this.runtime().activeSheet(), cell.row, cell.column);
+    const cellStyle = resolveSpreadsheetCellStyle(this.runtime().activeSheet().styles, renderCell == null ? void 0 : renderCell.styleId, renderCell);
+    Object.assign(this.cellEditorElement.style, {
+      font: cellStyle.font,
+      color: cellStyle.fontColor,
+      textDecoration: cellStyle.underline ? "underline" : "none",
+      textAlign: cellStyle.horizontalAlign
+    });
+    const targetViewport = (_a = this.viewport.viewports.find((item) => item.kind === "main")) != null ? _a : viewport;
+    if (!targetViewport) return;
+    const editRange = normalizeSelectionRange(this.selectionState.range);
+    const startRect = this.viewport.cellScreenRect(editRange.startRow, editRange.startColumn, targetViewport);
+    const endRect = this.viewport.cellScreenRect(editRange.endRow, editRange.endColumn, targetViewport);
+    const rect = {
+      x: startRect.x,
+      y: startRect.y,
+      width: endRect.x + endRect.width - startRect.x,
+      height: endRect.y + endRect.height - startRect.y
+    };
+    this.editingCell = cell;
+    this.editingCellStyle = cellStyle;
+    const value = (renderCell == null ? void 0 : renderCell.formula) ? `=${renderCell.formula}` : (_b = renderCell == null ? void 0 : renderCell.displayText) != null ? _b : "";
+    this.formulaReferenceRanges = formulaReferenceRangesFromText(value);
+    this.cellEditor.open(rect, value);
+    this.alignCellEditor(rect, cellStyle);
+    this.render();
+  }
+  async commitCellEdit(value) {
+    const cell = this.editingCell;
+    this.editingCell = null;
+    this.editingCellStyle = null;
+    this.formulaReferenceRanges = [];
+    if (!cell) return;
+    const address = formatCellAddress(cell.row, cell.column);
+    if (value.startsWith("=")) await this.runtime().setCellFormula(address, value.slice(1), { mergeUndo: true });
+    else await this.runtime().setCellValue(address, coerceEditorValue(value), { mergeUndo: true });
+    this.render();
+    await this.emitChange();
+  }
+  eventPoint(event) {
+    const rect = this.host.getBoundingClientRect();
+    return { x: event.clientX - rect.left, y: event.clientY - rect.top };
+  }
+  eventPathContains(event, node) {
+    return event.composedPath().includes(node);
+  }
+  updateCellEditorPosition() {
+    const cell = this.editingCell;
+    const layout = this.layout;
+    const viewportManager = this.viewport;
+    if (!cell || !layout || !viewportManager) return;
+    const targetViewport = viewportManager.viewports.find(
+      (viewport) => viewport.kind !== "columnHeaderFrozen" && viewport.kind !== "columnHeaderScrollable" && viewport.kind !== "rowHeaderFrozen" && viewport.kind !== "rowHeaderScrollable" && cell.row >= viewport.rows.start && cell.row <= viewport.rows.end && cell.column >= viewport.columns.start && cell.column <= viewport.columns.end
+    );
+    if (!targetViewport) {
+      this.cellEditorElement.style.display = "none";
+      return;
+    }
+    const editRange = normalizeSelectionRange(this.selectionState.range);
+    const startRect = viewportManager.cellScreenRect(editRange.startRow, editRange.startColumn, targetViewport);
+    const endRect = viewportManager.cellScreenRect(editRange.endRow, editRange.endColumn, targetViewport);
+    const rect = {
+      x: startRect.x,
+      y: startRect.y,
+      width: endRect.x + endRect.width - startRect.x,
+      height: endRect.y + endRect.height - startRect.y
+    };
+    this.cellEditorElement.style.left = `${rect.x}px`;
+    this.cellEditorElement.style.top = `${rect.y}px`;
+    this.cellEditorElement.style.width = `${Math.max(1, rect.width)}px`;
+    this.cellEditorElement.style.height = `${Math.max(1, rect.height)}px`;
+    this.cellEditorElement.style.display = "block";
+    if (this.editingCellStyle) this.alignCellEditor(rect, this.editingCellStyle);
+  }
+  alignCellEditor(rect, style) {
+    const textarea = this.cellEditorElement;
+    const paddingX = 4;
+    const paddingY = 2;
+    textarea.style.padding = `${paddingY}px ${paddingX}px`;
+    const extraHeight = Math.max(0, rect.height - textarea.scrollHeight);
+    const topPadding = style.verticalAlign === "bottom" ? paddingY + extraHeight : style.verticalAlign === "middle" ? paddingY + extraHeight / 2 : paddingY;
+    textarea.style.paddingTop = `${topPadding}px`;
+  }
+  async emitChange() {
+    var _a, _b;
+    if (this.transactionDepth > 0) {
+      this.transactionChanged = true;
+      return;
+    }
+    const event = { kind: "workbookChange", bytes: await this.toZip() };
+    for (const listener of this.listeners) listener(event);
+    await ((_b = (_a = this.options).onChange) == null ? void 0 : _b.call(_a, event));
+  }
+  emitStateIfChanged(activeSheetName) {
+    var _a, _b, _c, _d;
+    const selection = this.selectionState;
+    const selectionKey = `${selection.kind}:${selection.active.row}:${selection.active.column}:${selection.range.startRow}:${selection.range.startColumn}:${selection.range.endRow}:${selection.range.endColumn}:${(_b = (_a = this.editingCell) == null ? void 0 : _a.row) != null ? _b : 0}:${(_d = (_c = this.editingCell) == null ? void 0 : _c.column) != null ? _d : 0}`;
+    const stateKey = `${activeSheetName}|${selectionKey}`;
+    if (stateKey === this.lastStateKey) return;
+    this.lastStateKey = stateKey;
+    const event = {
+      kind: "stateChange",
+      activeSheetName,
+      selection,
+      editingCell: this.editingCell
+    };
+    for (const listener of this.stateListeners) listener(event);
+  }
+  renderTabs() {
+    if (this.options.showSheetTabs === false || !this.runtimeValue) return;
+    this.sheetTabs.replaceChildren();
+    Object.assign(this.sheetTabs.style, {
+      position: "absolute",
+      left: "0",
+      right: "0",
+      bottom: "0",
+      height: "40px",
+      display: "flex",
+      alignItems: "center",
+      gap: "8px",
+      padding: "0 12px",
+      background: "#eef1f5",
+      borderTop: "1px solid #e2e8f0",
+      boxSizing: "border-box",
+      overflowX: "auto",
+      overflowY: "hidden"
+    });
+    for (const sheet of this.runtimeValue.model().sheets) {
+      const button = document.createElement("button");
+      button.type = "button";
+      button.textContent = sheet.name;
+      button.dataset.active = String(sheet.name === this.runtimeValue.activeSheetName());
+      Object.assign(button.style, {
+        height: "32px",
+        minWidth: "64px",
+        padding: "0 14px",
+        border: "0",
+        borderTop: sheet.name === this.runtimeValue.activeSheetName() ? "2px solid #2563eb" : "2px solid transparent",
+        borderRadius: "3px 3px 0 0",
+        background: sheet.name === this.runtimeValue.activeSheetName() ? "#ffffff" : "transparent",
+        color: sheet.name === this.runtimeValue.activeSheetName() ? "#1d4ed8" : "#475569",
+        font: "13px Arial, sans-serif",
+        fontWeight: sheet.name === this.runtimeValue.activeSheetName() ? "600" : "400",
+        cursor: "pointer",
+        whiteSpace: "nowrap"
+      });
+      button.addEventListener("mouseenter", () => {
+        if (button.dataset.active !== "true") button.style.background = "#e2e8f0";
+      });
+      button.addEventListener("mouseleave", () => {
+        if (button.dataset.active !== "true") button.style.background = "transparent";
+      });
+      button.addEventListener("click", () => void this.setActiveSheet(sheet.name));
+      this.sheetTabs.appendChild(button);
+    }
+  }
+  configureScrollbar(track, thumb, horizontal) {
+    track.className = "coco-spreadsheet-editor-scrollbar";
+    Object.assign(track.style, __spreadValues({
+      position: "absolute",
+      zIndex: "10",
+      background: "#f1f5f9",
+      border: "1px solid #cbd5e1",
+      cursor: "pointer"
+    }, horizontal ? { left: "48px", bottom: "40px", height: "12px" } : { top: "24px", right: "0", bottom: "52px", width: "12px" }));
+    thumb.className = "coco-spreadsheet-editor-scrollbar-thumb";
+    Object.assign(thumb.style, { position: "absolute", background: "#94a3b8", borderRadius: "999px" });
+    track.appendChild(thumb);
+    track.addEventListener("pointerdown", (event) => {
+      var _a;
+      const geometry = (_a = this.scrollbarState) == null ? void 0 : _a[horizontal ? "horizontal" : "vertical"];
+      if (!geometry || geometry.maxScroll <= 0) return;
+      const rect = track.getBoundingClientRect();
+      const pointer = horizontal ? event.clientX - rect.left : event.clientY - rect.top;
+      this.drag = { axis: horizontal ? "horizontal" : "vertical", pointer, thumb: geometry.thumbStart };
+      track.setPointerCapture(event.pointerId);
+      this.setScroll(horizontal ? scrollFromThumbPosition(geometry, pointer - geometry.thumbLength / 2) : this.scroll.x, horizontal ? this.scroll.y : scrollFromThumbPosition(geometry, pointer - geometry.thumbLength / 2));
+    });
+    track.addEventListener("pointermove", (event) => {
+      var _a;
+      const drag = this.drag;
+      const geometry = (_a = this.scrollbarState) == null ? void 0 : _a[horizontal ? "horizontal" : "vertical"];
+      if (!drag || !geometry || drag.axis !== (horizontal ? "horizontal" : "vertical")) return;
+      const rect = track.getBoundingClientRect();
+      const pointer = horizontal ? event.clientX - rect.left : event.clientY - rect.top;
+      const next = scrollFromThumbPosition(geometry, drag.thumb + pointer - drag.pointer);
+      this.setScroll(horizontal ? next : this.scroll.x, horizontal ? this.scroll.y : next);
+    });
+    track.addEventListener("pointerup", () => {
+      this.drag = null;
+    });
+  }
+  updateScrollbars() {
+    const state = this.scrollbarState;
+    const layout = this.layout;
+    const viewport = this.viewport;
+    if (!state || !layout || !viewport) return;
+    const horizontal = state.horizontal;
+    const vertical = state.vertical;
+    this.horizontalScrollbar.style.display = horizontal.maxScroll > 0 ? "block" : "none";
+    this.verticalScrollbar.style.display = vertical.maxScroll > 0 ? "block" : "none";
+    Object.assign(this.horizontalScrollbar.style, { left: `${layout.rowHeaderWidth + layout.getColumnX(viewport.freeze.frozenColumns + 1)}px`, width: `${horizontal.trackLength}px` });
+    Object.assign(this.horizontalThumb.style, { left: `${horizontal.thumbStart}px`, width: `${horizontal.thumbLength}px`, top: "1px", bottom: "1px" });
+    Object.assign(this.verticalScrollbar.style, { top: `${layout.columnHeaderHeight + layout.getRowY(viewport.freeze.frozenRows + 1)}px`, height: `${vertical.trackLength}px` });
+    Object.assign(this.verticalThumb.style, { top: `${vertical.thumbStart}px`, height: `${vertical.thumbLength}px`, left: "1px", right: "1px" });
+  }
+  setScroll(x, y) {
+    this.scroll = { x, y };
+    this.render();
+  }
+  assertAlive() {
+    if (this.disposed) throw new Error("SpreadsheetEditor: editor has been destroyed");
+  }
+};
+__name(_NativeSpreadsheetEditor, "NativeSpreadsheetEditor");
+var NativeSpreadsheetEditor = _NativeSpreadsheetEditor;
+function coerceEditorValue(value) {
+  if (value === "") return null;
+  if (value === "TRUE") return true;
+  if (value === "FALSE") return false;
+  const number = Number(value);
+  return Number.isFinite(number) && value.trim() !== "" ? number : value;
+}
+__name(coerceEditorValue, "coerceEditorValue");
+function containsPoint2(rect, point) {
+  return point.x >= rect.x && point.y >= rect.y && point.x <= rect.x + rect.width && point.y <= rect.y + rect.height;
+}
+__name(containsPoint2, "containsPoint");
+function findChartAnchor(drawings, chart) {
+  var _a;
+  const drawing = drawings.find((item) => item.path === chart.drawingPath);
+  const anchors = (_a = drawing == null ? void 0 : drawing.anchors) != null ? _a : drawings.flatMap((item) => item.anchors);
+  return anchors.find(
+    (anchor) => {
+      var _a2;
+      return ((_a2 = anchor.object) == null ? void 0 : _a2.kind) === "chart" && (!chart.relationshipId || anchor.object.relationshipId === chart.relationshipId);
+    }
+  );
+}
+__name(findChartAnchor, "findChartAnchor");
+function chartLogicalRect(layout, anchor) {
+  var _a, _b;
+  if (!anchor || anchor.kind === "absolute" || !anchor.from) return null;
+  const startColumn = markerIndex(anchor.from.column);
+  const startRow = markerIndex(anchor.from.row);
+  const endColumn = anchor.to ? markerIndex(anchor.to.column) : startColumn + 5;
+  const endRow = anchor.to ? markerIndex(anchor.to.row) : startRow + 12;
+  const startX = layout.getColumnX(startColumn) + markerOffset(anchor.from.columnOffset);
+  const startY = layout.getRowY(startRow) + markerOffset(anchor.from.rowOffset);
+  const endX = layout.getColumnX(endColumn) + markerOffset((_a = anchor.to) == null ? void 0 : _a.columnOffset);
+  const endY = layout.getRowY(endRow) + markerOffset((_b = anchor.to) == null ? void 0 : _b.rowOffset);
+  return {
+    x: startX,
+    y: startY,
+    width: Math.max(1, endX - startX),
+    height: Math.max(1, endY - startY)
+  };
+}
+__name(chartLogicalRect, "chartLogicalRect");
+function chartScreenFragments(logicalRect, viewport) {
+  const fragments = [];
+  for (const item of viewport.viewports) {
+    if (!isBodyViewport(item)) continue;
+    const visibleLeft = item.originX;
+    const visibleTop = item.originY;
+    const visibleRight = item.originX + item.screenRect.width;
+    const visibleBottom = item.originY + item.screenRect.height;
+    const left = Math.max(logicalRect.x, visibleLeft);
+    const top = Math.max(logicalRect.y, visibleTop);
+    const right = Math.min(logicalRect.x + logicalRect.width, visibleRight);
+    const bottom = Math.min(logicalRect.y + logicalRect.height, visibleBottom);
+    if (right <= left || bottom <= top) continue;
+    fragments.push({
+      x: item.screenRect.x + left - item.originX,
+      y: item.screenRect.y + top - item.originY,
+      width: right - left,
+      height: bottom - top
+    });
+  }
+  return fragments;
+}
+__name(chartScreenFragments, "chartScreenFragments");
+function chartAnchorForLogicalRect(layout, rect, original) {
+  const marker = /* @__PURE__ */ __name((x, y) => {
+    const column = layout.columnAt(Math.max(0, x));
+    const row = layout.rowAt(Math.max(0, y));
+    return {
+      column: column - 1,
+      row: row - 1,
+      columnOffset: Math.round((x - layout.getColumnX(column)) * 9525),
+      rowOffset: Math.round((y - layout.getRowY(row)) * 9525)
+    };
+  }, "marker");
+  const from = marker(rect.x, rect.y);
+  const to = original.to ? marker(rect.x + rect.width, rect.y + rect.height) : void 0;
+  return { from, to };
+}
+__name(chartAnchorForLogicalRect, "chartAnchorForLogicalRect");
+function isBodyViewport(viewport) {
+  return viewport.kind === "main" || viewport.kind === "frozenTop" || viewport.kind === "frozenLeft" || viewport.kind === "frozenTopLeft";
+}
+__name(isBodyViewport, "isBodyViewport");
+function markerIndex(value) {
+  return Math.max(1, Math.floor(value != null ? value : 0) + 1);
+}
+__name(markerIndex, "markerIndex");
+function markerOffset(value) {
+  return Number.isFinite(value) ? (value != null ? value : 0) / 9525 : 0;
+}
+__name(markerOffset, "markerOffset");
+function columnNumberFromLetters(letters) {
+  let value = 0;
+  for (const character of letters.toUpperCase()) {
+    value = value * 26 + character.charCodeAt(0) - 64;
+  }
+  return value;
+}
+__name(columnNumberFromLetters, "columnNumberFromLetters");
+function autoFillPreviewRangeForHit(source, hit) {
+  if (hit.kind !== "cell") return null;
+  const down = Math.max(0, hit.row - source.endRow);
+  const right = Math.max(0, hit.column - source.endColumn);
+  if (!down && !right) return null;
+  if (down >= right) return __spreadProps(__spreadValues({}, source), { endRow: source.endRow + down });
+  return __spreadProps(__spreadValues({}, source), { endColumn: source.endColumn + right });
+}
+__name(autoFillPreviewRangeForHit, "autoFillPreviewRangeForHit");
+function rangesIntersect4(left, right) {
+  return !(left.endRow < right.startRow || left.startRow > right.endRow || left.endColumn < right.startColumn || left.startColumn > right.endColumn);
+}
+__name(rangesIntersect4, "rangesIntersect");
+function formulaReferenceRangesFromText(text) {
+  var _a;
+  if (!text.startsWith("=")) return [];
+  const references = (_a = text.match(/(?:\$?[A-Z]{1,3}\$?\d+)(?::(?:\$?[A-Z]{1,3}\$?\d+))?/g)) != null ? _a : [];
+  const colors = ["#DC2626", "#16A34A", "#7C3AED", "#EA580C", "#0891B2"];
+  return references.flatMap((reference, index) => {
+    var _a2, _b, _c;
+    const parts = reference.split(":");
+    const start = (_a2 = parts[0]) != null ? _a2 : "";
+    const end = (_b = parts[1]) != null ? _b : start;
+    const first = formulaReferenceCell(start);
+    const last = formulaReferenceCell(end);
+    if (!first || !last) return [];
+    return [{
+      range: normalizeSelectionRange({
+        startRow: first.row,
+        startColumn: first.column,
+        endRow: last.row,
+        endColumn: last.column
+      }),
+      stroke: (_c = colors[index % colors.length]) != null ? _c : "#DC2626"
+    }];
+  });
+}
+__name(formulaReferenceRangesFromText, "formulaReferenceRangesFromText");
+function formulaReferenceCell(value) {
+  var _a, _b;
+  const match = value.replace(/\$/g, "").match(/^([A-Z]{1,3})(\d+)$/);
+  if (!match) return null;
+  let column = 0;
+  for (const character of (_a = match[1]) != null ? _a : "") column = column * 26 + character.charCodeAt(0) - 64;
+  const row = Number((_b = match[2]) != null ? _b : "");
+  return Number.isFinite(row) && row > 0 && column > 0 ? { row, column } : null;
+}
+__name(formulaReferenceCell, "formulaReferenceCell");
+
+export { SPREADSHEET_COLUMN_RESIZE_MIN, SPREADSHEET_RESIZE_HIT_TOLERANCE, SPREADSHEET_ROW_RESIZE_MIN, SpreadsheetCanvasRenderer, SpreadsheetCellEditor, SpreadsheetEditorRuntime, SpreadsheetLayout, SpreadsheetViewportManager, applySpreadsheetAgentAction, applyWheelDelta, buildSpreadsheetAutoFillPlan, buildSpreadsheetClipboardPayload, buildSpreadsheetReplacePlan, buildSpreadsheetSheetRenderModel, clampScroll, clearSpreadsheetRange, computeScrollbarState, createColumnRangeSelection, createColumnSelection, createRowRangeSelection, createRowSelection, createSelection, cssPixelsToExcelColumnWidth, excelColumnWidthToCssPixels, expandRangeForMergedRanges, expandSelectionForMergedRanges, extendSelection, findSpreadsheetMatches, formatSpreadsheetDisplayValue, freezeStateFromPane, freezeStateFromSheet, getRenderCell, hitSpreadsheetResizeHandle, moveSelection, nextSpreadsheetMatch, normalizeSelectionRange, parseTsv, previewSpreadsheetAgentAction, rangeAddressForMatrix, rangeForSpreadsheetMatch, renderSpreadsheetEditor, resolveSpreadsheetCellStyle, resolveSpreadsheetRangeBorder, rowColumnKey, scrollFromThumbPosition, selectionAfterColumnDeletion, selectionAfterRowDeletion, serializeRangeToTsv, setSpreadsheetCellFormula, setSpreadsheetCellValue, setSpreadsheetColumnWidth, setSpreadsheetRangeValues, setSpreadsheetRowHeight, spreadsheetFilterValues, spreadsheetRowsForColumnFilters, spreadsheetRowsForFilter, spreadsheetSortRows, spreadsheetVisibleFilterValues, startSpreadsheetResizeDrag, summarizeSpreadsheetSelectionFormat, supportsSpreadsheetAutoFill, updateSpreadsheetResizeDrag };
+//# sourceMappingURL=spreadsheet.js.map
+//# sourceMappingURL=spreadsheet.js.map