@veltra/sheet 2.0.0 → 2.1.1

package/dist/core/address.js

@@ -1,142 +0,0 @@
-//#region src/core/address.ts
-/**
-* cellKey 的列基数（2^20）。
-* key = row * COL_KEY_BASE + col，要求 col < COL_KEY_BASE；
-* JS 安全整数范围内可容纳约 8.5e9 行，远超实际使用。
-*/
-const COL_KEY_BASE = 2 ** 20;
-/** 地址 → 数值 key（Map 索引用） */
-function cellKey(addr) {
-	return addr.row * COL_KEY_BASE + addr.col;
-}
-/** 数值 key → 地址 */
-function addressFromKey(key) {
-	return {
-		row: Math.floor(key / COL_KEY_BASE),
-		col: key % COL_KEY_BASE
-	};
-}
-/** 列号（0-based）→ 列名：0 → 'A'，25 → 'Z'，26 → 'AA' */
-function colIndexToName(col) {
-	if (!Number.isInteger(col) || col < 0) throw new RangeError(`列号必须是非负整数: ${col}`);
-	let name = "";
-	let n = col;
-	do {
-		name = String.fromCharCode(65 + n % 26) + name;
-		n = Math.floor(n / 26) - 1;
-	} while (n >= 0);
-	return name;
-}
-/** 列名 → 列号（0-based）：'A' → 0，'AA' → 26；非法列名返回 -1 */
-function colNameToIndex(name) {
-	if (!/^[A-Za-z]+$/.test(name)) return -1;
-	let index = 0;
-	for (const ch of name.toUpperCase()) index = index * 26 + (ch.charCodeAt(0) - 64);
-	return index - 1;
-}
-const ADDRESS_RE = /^\$?([A-Za-z]+)\$?([1-9]\d*)$/;
-/** 解析 A1 记法（兼容 `$A$1` 绝对引用写法）→ 地址；非法返回 null */
-function parseAddress(text) {
-	const match = ADDRESS_RE.exec(text.trim());
-	if (!match) return null;
-	const col = colNameToIndex(match[1]);
-	return {
-		row: Number.parseInt(match[2], 10) - 1,
-		col
-	};
-}
-/** 地址 → A1 记法：{ row: 1, col: 1 } → 'B2' */
-function formatAddress(addr) {
-	return `${colIndexToName(addr.col)}${addr.row + 1}`;
-}
-/** 由两个角点构造规范化区域（start ≤ end） */
-function createRange(a, b) {
-	return {
-		start: {
-			row: Math.min(a.row, b.row),
-			col: Math.min(a.col, b.col)
-		},
-		end: {
-			row: Math.max(a.row, b.row),
-			col: Math.max(a.col, b.col)
-		}
-	};
-}
-/** 解析区域记法：'B2' 或 'B2:D5'（兼容绝对引用）；非法返回 null */
-function parseRange(text) {
-	const parts = text.trim().split(":");
-	if (parts.length > 2) return null;
-	const start = parseAddress(parts[0]);
-	if (!start) return null;
-	if (parts.length === 1) return {
-		start,
-		end: { ...start }
-	};
-	const end = parseAddress(parts[1]);
-	if (!end) return null;
-	return createRange(start, end);
-}
-/** 区域 → 记法：单格 → 'B2'，多格 → 'B2:D5' */
-function formatRange(range) {
-	const start = formatAddress(range.start);
-	if (range.start.row === range.end.row && range.start.col === range.end.col) return start;
-	return `${start}:${formatAddress(range.end)}`;
-}
-/** 地址相等 */
-function addressesEqual(a, b) {
-	return a.row === b.row && a.col === b.col;
-}
-/** 区域相等 */
-function rangesEqual(a, b) {
-	return addressesEqual(a.start, b.start) && addressesEqual(a.end, b.end);
-}
-/** 两区域是否相交 */
-function rangesIntersect(a, b) {
-	return a.start.row <= b.end.row && a.end.row >= b.start.row && a.start.col <= b.end.col && a.end.col >= b.start.col;
-}
-/** 区域是否包含地址 */
-function rangeContainsAddress(range, addr) {
-	return addr.row >= range.start.row && addr.row <= range.end.row && addr.col >= range.start.col && addr.col <= range.end.col;
-}
-/** 区域是否完整包含另一区域 */
-function rangeContainsRange(outer, inner) {
-	return rangeContainsAddress(outer, inner.start) && rangeContainsAddress(outer, inner.end);
-}
-/** 一组区域的最小包围盒（至少传入一个区域） */
-function boundingBox(ranges) {
-	let minRow = Infinity;
-	let minCol = Infinity;
-	let maxRow = -Infinity;
-	let maxCol = -Infinity;
-	for (const range of ranges) {
-		minRow = Math.min(minRow, range.start.row);
-		minCol = Math.min(minCol, range.start.col);
-		maxRow = Math.max(maxRow, range.end.row);
-		maxCol = Math.max(maxCol, range.end.col);
-	}
-	return {
-		start: {
-			row: minRow,
-			col: minCol
-		},
-		end: {
-			row: maxRow,
-			col: maxCol
-		}
-	};
-}
-/** 按行主序遍历区域内的所有地址 */
-function* iterateRange(range) {
-	for (let row = range.start.row; row <= range.end.row; row++) for (let col = range.start.col; col <= range.end.col; col++) yield {
-		row,
-		col
-	};
-}
-/** 区域内的单元格数量 */
-function rangeSize(range) {
-	return (range.end.row - range.start.row + 1) * (range.end.col - range.start.col + 1);
-}
-//#endregion
-export { COL_KEY_BASE, addressFromKey, addressesEqual, boundingBox, cellKey, colIndexToName, colNameToIndex, createRange, formatAddress, formatRange, iterateRange, parseAddress, parseRange, rangeContainsAddress, rangeContainsRange, rangeSize, rangesEqual, rangesIntersect };
-
-//# sourceMappingURL=address.js.map

package/dist/core/address.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"address.js","names":[],"sources":["../../src/core/address.ts"],"sourcesContent":["/**\n * A1 地址系统（纯函数）。\n *\n * 坐标统一 0-based：`{ row: 0, col: 0 }` 即 A1。\n * 区域为闭区间，且经过规范化：start 恒为左上角，end 恒为右下角。\n */\n\n/** 单元格地址（0-based） */\nexport interface CellAddress {\n  row: number\n  col: number\n}\n\n/** 单元格区域（闭区间，start 左上角，end 右下角） */\nexport interface CellRange {\n  start: CellAddress\n  end: CellAddress\n}\n\n/**\n * cellKey 的列基数（2^20）。\n * key = row * COL_KEY_BASE + col，要求 col < COL_KEY_BASE；\n * JS 安全整数范围内可容纳约 8.5e9 行，远超实际使用。\n */\nexport const COL_KEY_BASE = 2 ** 20\n\n/** 地址 → 数值 key（Map 索引用） */\nexport function cellKey(addr: CellAddress): number {\n  return addr.row * COL_KEY_BASE + addr.col\n}\n\n/** 数值 key → 地址 */\nexport function addressFromKey(key: number): CellAddress {\n  return { row: Math.floor(key / COL_KEY_BASE), col: key % COL_KEY_BASE }\n}\n\n/** 列号（0-based）→ 列名：0 → 'A'，25 → 'Z'，26 → 'AA' */\nexport function colIndexToName(col: number): string {\n  if (!Number.isInteger(col) || col < 0) {\n    throw new RangeError(`列号必须是非负整数: ${col}`)\n  }\n  let name = ''\n  let n = col\n  do {\n    name = String.fromCharCode(65 + (n % 26)) + name\n    n = Math.floor(n / 26) - 1\n  } while (n >= 0)\n  return name\n}\n\n/** 列名 → 列号（0-based）：'A' → 0，'AA' → 26；非法列名返回 -1 */\nexport function colNameToIndex(name: string): number {\n  if (!/^[A-Za-z]+$/.test(name)) return -1\n  let index = 0\n  for (const ch of name.toUpperCase()) {\n    index = index * 26 + (ch.charCodeAt(0) - 64)\n  }\n  return index - 1\n}\n\nconst ADDRESS_RE = /^\\$?([A-Za-z]+)\\$?([1-9]\\d*)$/\n\n/** 解析 A1 记法（兼容 `$A$1` 绝对引用写法）→ 地址；非法返回 null */\nexport function parseAddress(text: string): CellAddress | null {\n  const match = ADDRESS_RE.exec(text.trim())\n  if (!match) return null\n  const col = colNameToIndex(match[1]!)\n  const row = Number.parseInt(match[2]!, 10) - 1\n  return { row, col }\n}\n\n/** 地址 → A1 记法：{ row: 1, col: 1 } → 'B2' */\nexport function formatAddress(addr: CellAddress): string {\n  return `${colIndexToName(addr.col)}${addr.row + 1}`\n}\n\n/** 由两个角点构造规范化区域（start ≤ end） */\nexport function createRange(a: CellAddress, b: CellAddress): CellRange {\n  return {\n    start: { row: Math.min(a.row, b.row), col: Math.min(a.col, b.col) },\n    end: { row: Math.max(a.row, b.row), col: Math.max(a.col, b.col) }\n  }\n}\n\n/** 解析区域记法：'B2' 或 'B2:D5'（兼容绝对引用）；非法返回 null */\nexport function parseRange(text: string): CellRange | null {\n  const parts = text.trim().split(':')\n  if (parts.length > 2) return null\n  const start = parseAddress(parts[0]!)\n  if (!start) return null\n  if (parts.length === 1) return { start, end: { ...start } }\n  const end = parseAddress(parts[1]!)\n  if (!end) return null\n  return createRange(start, end)\n}\n\n/** 区域 → 记法：单格 → 'B2'，多格 → 'B2:D5' */\nexport function formatRange(range: CellRange): string {\n  const start = formatAddress(range.start)\n  if (range.start.row === range.end.row && range.start.col === range.end.col) return start\n  return `${start}:${formatAddress(range.end)}`\n}\n\n/** 地址相等 */\nexport function addressesEqual(a: CellAddress, b: CellAddress): boolean {\n  return a.row === b.row && a.col === b.col\n}\n\n/** 区域相等 */\nexport function rangesEqual(a: CellRange, b: CellRange): boolean {\n  return addressesEqual(a.start, b.start) && addressesEqual(a.end, b.end)\n}\n\n/** 两区域是否相交 */\nexport function rangesIntersect(a: CellRange, b: CellRange): boolean {\n  return (\n    a.start.row <= b.end.row &&\n    a.end.row >= b.start.row &&\n    a.start.col <= b.end.col &&\n    a.end.col >= b.start.col\n  )\n}\n\n/** 区域是否包含地址 */\nexport function rangeContainsAddress(range: CellRange, addr: CellAddress): boolean {\n  return (\n    addr.row >= range.start.row &&\n    addr.row <= range.end.row &&\n    addr.col >= range.start.col &&\n    addr.col <= range.end.col\n  )\n}\n\n/** 区域是否完整包含另一区域 */\nexport function rangeContainsRange(outer: CellRange, inner: CellRange): boolean {\n  return rangeContainsAddress(outer, inner.start) && rangeContainsAddress(outer, inner.end)\n}\n\n/** 一组区域的最小包围盒（至少传入一个区域） */\nexport function boundingBox(ranges: readonly [CellRange, ...CellRange[]]): CellRange {\n  let minRow = Infinity\n  let minCol = Infinity\n  let maxRow = -Infinity\n  let maxCol = -Infinity\n  for (const range of ranges) {\n    minRow = Math.min(minRow, range.start.row)\n    minCol = Math.min(minCol, range.start.col)\n    maxRow = Math.max(maxRow, range.end.row)\n    maxCol = Math.max(maxCol, range.end.col)\n  }\n  return { start: { row: minRow, col: minCol }, end: { row: maxRow, col: maxCol } }\n}\n\n/** 按行主序遍历区域内的所有地址 */\nexport function* iterateRange(range: CellRange): Generator<CellAddress, void, undefined> {\n  for (let row = range.start.row; row <= range.end.row; row++) {\n    for (let col = range.start.col; col <= range.end.col; col++) {\n      yield { row, col }\n    }\n  }\n}\n\n/** 区域内的单元格数量 */\nexport function rangeSize(range: CellRange): number {\n  return (range.end.row - range.start.row + 1) * (range.end.col - range.start.col + 1)\n}\n"],"mappings":";;;;;;AAwBA,MAAa,eAAe,KAAK;;AAGjC,SAAgB,QAAQ,MAA2B;CACjD,OAAO,KAAK,MAAM,eAAe,KAAK;AACxC;;AAGA,SAAgB,eAAe,KAA0B;CACvD,OAAO;EAAE,KAAK,KAAK,MAAM,MAAM,YAAY;EAAG,KAAK,MAAM;CAAa;AACxE;;AAGA,SAAgB,eAAe,KAAqB;CAClD,IAAI,CAAC,OAAO,UAAU,GAAG,KAAK,MAAM,GAClC,MAAM,IAAI,WAAW,cAAc,KAAK;CAE1C,IAAI,OAAO;CACX,IAAI,IAAI;CACR,GAAG;EACD,OAAO,OAAO,aAAa,KAAM,IAAI,EAAG,IAAI;EAC5C,IAAI,KAAK,MAAM,IAAI,EAAE,IAAI;CAC3B,SAAS,KAAK;CACd,OAAO;AACT;;AAGA,SAAgB,eAAe,MAAsB;CACnD,IAAI,CAAC,cAAc,KAAK,IAAI,GAAG,OAAO;CACtC,IAAI,QAAQ;CACZ,KAAK,MAAM,MAAM,KAAK,YAAY,GAChC,QAAQ,QAAQ,MAAM,GAAG,WAAW,CAAC,IAAI;CAE3C,OAAO,QAAQ;AACjB;AAEA,MAAM,aAAa;;AAGnB,SAAgB,aAAa,MAAkC;CAC7D,MAAM,QAAQ,WAAW,KAAK,KAAK,KAAK,CAAC;CACzC,IAAI,CAAC,OAAO,OAAO;CACnB,MAAM,MAAM,eAAe,MAAM,EAAG;CAEpC,OAAO;EAAE,KADG,OAAO,SAAS,MAAM,IAAK,EAAE,IAAI;EAC/B;CAAI;AACpB;;AAGA,SAAgB,cAAc,MAA2B;CACvD,OAAO,GAAG,eAAe,KAAK,GAAG,IAAI,KAAK,MAAM;AAClD;;AAGA,SAAgB,YAAY,GAAgB,GAA2B;CACrE,OAAO;EACL,OAAO;GAAE,KAAK,KAAK,IAAI,EAAE,KAAK,EAAE,GAAG;GAAG,KAAK,KAAK,IAAI,EAAE,KAAK,EAAE,GAAG;EAAE;EAClE,KAAK;GAAE,KAAK,KAAK,IAAI,EAAE,KAAK,EAAE,GAAG;GAAG,KAAK,KAAK,IAAI,EAAE,KAAK,EAAE,GAAG;EAAE;CAClE;AACF;;AAGA,SAAgB,WAAW,MAAgC;CACzD,MAAM,QAAQ,KAAK,KAAK,CAAC,CAAC,MAAM,GAAG;CACnC,IAAI,MAAM,SAAS,GAAG,OAAO;CAC7B,MAAM,QAAQ,aAAa,MAAM,EAAG;CACpC,IAAI,CAAC,OAAO,OAAO;CACnB,IAAI,MAAM,WAAW,GAAG,OAAO;EAAE;EAAO,KAAK,EAAE,GAAG,MAAM;CAAE;CAC1D,MAAM,MAAM,aAAa,MAAM,EAAG;CAClC,IAAI,CAAC,KAAK,OAAO;CACjB,OAAO,YAAY,OAAO,GAAG;AAC/B;;AAGA,SAAgB,YAAY,OAA0B;CACpD,MAAM,QAAQ,cAAc,MAAM,KAAK;CACvC,IAAI,MAAM,MAAM,QAAQ,MAAM,IAAI,OAAO,MAAM,MAAM,QAAQ,MAAM,IAAI,KAAK,OAAO;CACnF,OAAO,GAAG,MAAM,GAAG,cAAc,MAAM,GAAG;AAC5C;;AAGA,SAAgB,eAAe,GAAgB,GAAyB;CACtE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE;AACxC;;AAGA,SAAgB,YAAY,GAAc,GAAuB;CAC/D,OAAO,eAAe,EAAE,OAAO,EAAE,KAAK,KAAK,eAAe,EAAE,KAAK,EAAE,GAAG;AACxE;;AAGA,SAAgB,gBAAgB,GAAc,GAAuB;CACnE,OACE,EAAE,MAAM,OAAO,EAAE,IAAI,OACrB,EAAE,IAAI,OAAO,EAAE,MAAM,OACrB,EAAE,MAAM,OAAO,EAAE,IAAI,OACrB,EAAE,IAAI,OAAO,EAAE,MAAM;AAEzB;;AAGA,SAAgB,qBAAqB,OAAkB,MAA4B;CACjF,OACE,KAAK,OAAO,MAAM,MAAM,OACxB,KAAK,OAAO,MAAM,IAAI,OACtB,KAAK,OAAO,MAAM,MAAM,OACxB,KAAK,OAAO,MAAM,IAAI;AAE1B;;AAGA,SAAgB,mBAAmB,OAAkB,OAA2B;CAC9E,OAAO,qBAAqB,OAAO,MAAM,KAAK,KAAK,qBAAqB,OAAO,MAAM,GAAG;AAC1F;;AAGA,SAAgB,YAAY,QAAyD;CACnF,IAAI,SAAS;CACb,IAAI,SAAS;CACb,IAAI,SAAS;CACb,IAAI,SAAS;CACb,KAAK,MAAM,SAAS,QAAQ;EAC1B,SAAS,KAAK,IAAI,QAAQ,MAAM,MAAM,GAAG;EACzC,SAAS,KAAK,IAAI,QAAQ,MAAM,MAAM,GAAG;EACzC,SAAS,KAAK,IAAI,QAAQ,MAAM,IAAI,GAAG;EACvC,SAAS,KAAK,IAAI,QAAQ,MAAM,IAAI,GAAG;CACzC;CACA,OAAO;EAAE,OAAO;GAAE,KAAK;GAAQ,KAAK;EAAO;EAAG,KAAK;GAAE,KAAK;GAAQ,KAAK;EAAO;CAAE;AAClF;;AAGA,UAAiB,aAAa,OAA2D;CACvF,KAAK,IAAI,MAAM,MAAM,MAAM,KAAK,OAAO,MAAM,IAAI,KAAK,OACpD,KAAK,IAAI,MAAM,MAAM,MAAM,KAAK,OAAO,MAAM,IAAI,KAAK,OACpD,MAAM;EAAE;EAAK;CAAI;AAGvB;;AAGA,SAAgB,UAAU,OAA0B;CAClD,QAAQ,MAAM,IAAI,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,IAAI,MAAM,MAAM,MAAM,MAAM;AACpF"}

package/dist/core/cell-store.d.ts

@@ -1,61 +0,0 @@
-import { CellAddress, CellRange } from "./address.js";
-//#region src/core/cell-store.d.ts
-/**
- * 稀疏矩阵存储：`Map<row, Map<col, CellData>>`。
- * 空单元格 = 存储中不存在该 key（稀疏的第一原则）；
- * rowCount/colCount 只是高水位，用于渲染行数，不分配空间。
- */
-/** 单元格值类型：n=数字 s=字符串 b=布尔 str=公式结果字符串 e=错误 d=日期（序列数） */
-type CellType = 'n' | 's' | 'b' | 'str' | 'e' | 'd';
-/** 单元格原始值 */
-type CellValue = string | number | boolean | null;
-/** 单元格数据（参考 univer ICellData 裁剪版） */
-interface CellData {
-  /** 原始值（公式格为计算缓存值） */
-  v?: CellValue;
-  /** 值类型，缺省按 v 推断 */
-  t?: CellType;
-  /** 公式文本（不含 '='），如 'SUM(A1:B2)+Sheet2!C3' */
-  f?: string;
-}
-/** 序列化条目（snapshot/restore 用） */
-interface CellSnapshotItem extends CellData {
-  row: number;
-  col: number;
-}
-/** 按原始值推断类型 */
-declare function inferCellType(v: CellValue): CellType | undefined;
-/** 判定为空：无公式且值为 null/undefined/'' */
-declare function isEmptyCellData(data: CellData | undefined): boolean;
-/** CellData 相等（v/t/f 三字段逐一比较；命令系统据此跳过无实际变更的补丁） */
-declare function cellDataEqual(a: CellData | undefined, b: CellData | undefined): boolean;
-declare class CellStore {
-  private cells;
-  private _rowCount;
-  private _colCount;
-  /** 行数高水位（只增不减，restore 时重算） */
-  get rowCount(): number;
-  /** 列数高水位 */
-  get colCount(): number;
-  /** 真实存在的单元格数量 */
-  get size(): number;
-  /** 读取（返回副本，外部修改不影响存储） */
-  getCell(addr: CellAddress): CellData | undefined;
-  /** 写入（存储副本）；空数据等价于删除 */
-  setCell(addr: CellAddress, data?: CellData): void;
-  /** 便捷写入原始值，类型自动推断；空值等价于删除 */
-  setCellValue(addr: CellAddress, value: CellValue): void;
-  deleteCell(addr: CellAddress): boolean;
-  /** 只遍历真实存在的单元格（行主序） */
-  entries(): Generator<[CellAddress, CellData], void, undefined>;
-  /** 只遍历区域内真实存在的单元格（行主序；公式区域展开用，空行/空格不分配不访问） */
-  entriesInRange(range: CellRange): Generator<[CellAddress, CellData], void, undefined>;
-  /** 序列化（只含真实存在的格） */
-  snapshot(): CellSnapshotItem[];
-  /** 从序列化恢复（清空重建，重算高水位） */
-  restore(items: readonly CellSnapshotItem[]): void;
-  clear(): void;
-}
-//#endregion
-export { CellData, CellSnapshotItem, CellStore, CellType, CellValue, cellDataEqual, inferCellType, isEmptyCellData };
-//# sourceMappingURL=cell-store.d.ts.map

package/dist/core/cell-store.js

@@ -1,135 +0,0 @@
-//#region src/core/cell-store.ts
-/** 按原始值推断类型 */
-function inferCellType(v) {
-	switch (typeof v) {
-		case "number": return "n";
-		case "boolean": return "b";
-		case "string": return "s";
-		default: return;
-	}
-}
-/** 判定为空：无公式且值为 null/undefined/'' */
-function isEmptyCellData(data) {
-	if (!data) return true;
-	if (data.f != null && data.f !== "") return false;
-	return data.v == null || data.v === "";
-}
-/** CellData 相等（v/t/f 三字段逐一比较；命令系统据此跳过无实际变更的补丁） */
-function cellDataEqual(a, b) {
-	if (a === b) return true;
-	if (!a || !b) return false;
-	return a.v === b.v && a.t === b.t && a.f === b.f;
-}
-var CellStore = class {
-	cells = /* @__PURE__ */ new Map();
-	_rowCount = 0;
-	_colCount = 0;
-	/** 行数高水位（只增不减，restore 时重算） */
-	get rowCount() {
-		return this._rowCount;
-	}
-	/** 列数高水位 */
-	get colCount() {
-		return this._colCount;
-	}
-	/** 真实存在的单元格数量 */
-	get size() {
-		let size = 0;
-		for (const rowMap of this.cells.values()) size += rowMap.size;
-		return size;
-	}
-	/** 读取（返回副本，外部修改不影响存储） */
-	getCell(addr) {
-		const data = this.cells.get(addr.row)?.get(addr.col);
-		return data ? { ...data } : void 0;
-	}
-	/** 写入（存储副本）；空数据等价于删除 */
-	setCell(addr, data) {
-		if (isEmptyCellData(data)) {
-			this.deleteCell(addr);
-			return;
-		}
-		let rowMap = this.cells.get(addr.row);
-		if (!rowMap) {
-			rowMap = /* @__PURE__ */ new Map();
-			this.cells.set(addr.row, rowMap);
-		}
-		rowMap.set(addr.col, { ...data });
-		this._rowCount = Math.max(this._rowCount, addr.row + 1);
-		this._colCount = Math.max(this._colCount, addr.col + 1);
-	}
-	/** 便捷写入原始值，类型自动推断；空值等价于删除 */
-	setCellValue(addr, value) {
-		if (value == null || value === "") {
-			this.deleteCell(addr);
-			return;
-		}
-		this.setCell(addr, {
-			v: value,
-			t: inferCellType(value)
-		});
-	}
-	deleteCell(addr) {
-		const rowMap = this.cells.get(addr.row);
-		if (!rowMap) return false;
-		const deleted = rowMap.delete(addr.col);
-		if (rowMap.size === 0) this.cells.delete(addr.row);
-		return deleted;
-	}
-	/** 只遍历真实存在的单元格（行主序） */
-	*entries() {
-		for (const [row, rowMap] of this.cells) for (const [col, data] of rowMap) yield [{
-			row,
-			col
-		}, { ...data }];
-	}
-	/** 只遍历区域内真实存在的单元格（行主序；公式区域展开用，空行/空格不分配不访问） */
-	*entriesInRange(range) {
-		for (let row = range.start.row; row <= range.end.row; row++) {
-			const rowMap = this.cells.get(row);
-			if (!rowMap) continue;
-			for (let col = range.start.col; col <= range.end.col; col++) {
-				const data = rowMap.get(col);
-				if (data) yield [{
-					row,
-					col
-				}, { ...data }];
-			}
-		}
-	}
-	/** 序列化（只含真实存在的格） */
-	snapshot() {
-		const items = [];
-		for (const [addr, data] of this.entries()) items.push({
-			row: addr.row,
-			col: addr.col,
-			...data
-		});
-		return items;
-	}
-	/** 从序列化恢复（清空重建，重算高水位） */
-	restore(items) {
-		this.clear();
-		for (const item of items) {
-			const { row, col, ...data } = item;
-			if (isEmptyCellData(data)) continue;
-			let rowMap = this.cells.get(row);
-			if (!rowMap) {
-				rowMap = /* @__PURE__ */ new Map();
-				this.cells.set(row, rowMap);
-			}
-			rowMap.set(col, { ...data });
-			this._rowCount = Math.max(this._rowCount, row + 1);
-			this._colCount = Math.max(this._colCount, col + 1);
-		}
-	}
-	clear() {
-		this.cells.clear();
-		this._rowCount = 0;
-		this._colCount = 0;
-	}
-};
-//#endregion
-export { CellStore, cellDataEqual, inferCellType, isEmptyCellData };
-
-//# sourceMappingURL=cell-store.js.map

package/dist/core/cell-store.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"cell-store.js","names":[],"sources":["../../src/core/cell-store.ts"],"sourcesContent":["import type { CellAddress, CellRange } from './address'\n\n/**\n * 稀疏矩阵存储：`Map<row, Map<col, CellData>>`。\n * 空单元格 = 存储中不存在该 key（稀疏的第一原则）；\n * rowCount/colCount 只是高水位，用于渲染行数，不分配空间。\n */\n\n/** 单元格值类型：n=数字 s=字符串 b=布尔 str=公式结果字符串 e=错误 d=日期（序列数） */\nexport type CellType = 'n' | 's' | 'b' | 'str' | 'e' | 'd'\n\n/** 单元格原始值 */\nexport type CellValue = string | number | boolean | null\n\n/** 单元格数据（参考 univer ICellData 裁剪版） */\nexport interface CellData {\n  /** 原始值（公式格为计算缓存值） */\n  v?: CellValue\n  /** 值类型，缺省按 v 推断 */\n  t?: CellType\n  /** 公式文本（不含 '='），如 'SUM(A1:B2)+Sheet2!C3' */\n  f?: string\n  // s?: StyleId —— 预留样式位，本期不实现\n}\n\n/** 序列化条目（snapshot/restore 用） */\nexport interface CellSnapshotItem extends CellData {\n  row: number\n  col: number\n}\n\n/** 按原始值推断类型 */\nexport function inferCellType(v: CellValue): CellType | undefined {\n  switch (typeof v) {\n    case 'number':\n      return 'n'\n    case 'boolean':\n      return 'b'\n    case 'string':\n      return 's'\n    default:\n      return undefined\n  }\n}\n\n/** 判定为空：无公式且值为 null/undefined/'' */\nexport function isEmptyCellData(data: CellData | undefined): boolean {\n  if (!data) return true\n  if (data.f != null && data.f !== '') return false\n  return data.v == null || data.v === ''\n}\n\n/** CellData 相等（v/t/f 三字段逐一比较；命令系统据此跳过无实际变更的补丁） */\nexport function cellDataEqual(a: CellData | undefined, b: CellData | undefined): boolean {\n  if (a === b) return true\n  if (!a || !b) return false\n  return a.v === b.v && a.t === b.t && a.f === b.f\n}\n\nexport class CellStore {\n  private cells = new Map<number, Map<number, CellData>>()\n  private _rowCount = 0\n  private _colCount = 0\n\n  /** 行数高水位（只增不减，restore 时重算） */\n  get rowCount(): number {\n    return this._rowCount\n  }\n\n  /** 列数高水位 */\n  get colCount(): number {\n    return this._colCount\n  }\n\n  /** 真实存在的单元格数量 */\n  get size(): number {\n    let size = 0\n    for (const rowMap of this.cells.values()) size += rowMap.size\n    return size\n  }\n\n  /** 读取（返回副本，外部修改不影响存储） */\n  getCell(addr: CellAddress): CellData | undefined {\n    const data = this.cells.get(addr.row)?.get(addr.col)\n    return data ? { ...data } : undefined\n  }\n\n  /** 写入（存储副本）；空数据等价于删除 */\n  setCell(addr: CellAddress, data?: CellData): void {\n    if (isEmptyCellData(data)) {\n      this.deleteCell(addr)\n      return\n    }\n    let rowMap = this.cells.get(addr.row)\n    if (!rowMap) {\n      rowMap = new Map()\n      this.cells.set(addr.row, rowMap)\n    }\n    rowMap.set(addr.col, { ...data })\n    this._rowCount = Math.max(this._rowCount, addr.row + 1)\n    this._colCount = Math.max(this._colCount, addr.col + 1)\n  }\n\n  /** 便捷写入原始值，类型自动推断；空值等价于删除 */\n  setCellValue(addr: CellAddress, value: CellValue): void {\n    if (value == null || value === '') {\n      this.deleteCell(addr)\n      return\n    }\n    this.setCell(addr, { v: value, t: inferCellType(value) })\n  }\n\n  deleteCell(addr: CellAddress): boolean {\n    const rowMap = this.cells.get(addr.row)\n    if (!rowMap) return false\n    const deleted = rowMap.delete(addr.col)\n    if (rowMap.size === 0) this.cells.delete(addr.row)\n    return deleted\n  }\n\n  /** 只遍历真实存在的单元格（行主序） */\n  *entries(): Generator<[CellAddress, CellData], void, undefined> {\n    for (const [row, rowMap] of this.cells) {\n      for (const [col, data] of rowMap) {\n        yield [{ row, col }, { ...data }]\n      }\n    }\n  }\n\n  /** 只遍历区域内真实存在的单元格（行主序；公式区域展开用，空行/空格不分配不访问） */\n  *entriesInRange(range: CellRange): Generator<[CellAddress, CellData], void, undefined> {\n    for (let row = range.start.row; row <= range.end.row; row++) {\n      const rowMap = this.cells.get(row)\n      if (!rowMap) continue\n      for (let col = range.start.col; col <= range.end.col; col++) {\n        const data = rowMap.get(col)\n        if (data) yield [{ row, col }, { ...data }]\n      }\n    }\n  }\n\n  /** 序列化（只含真实存在的格） */\n  snapshot(): CellSnapshotItem[] {\n    const items: CellSnapshotItem[] = []\n    for (const [addr, data] of this.entries()) {\n      items.push({ row: addr.row, col: addr.col, ...data })\n    }\n    return items\n  }\n\n  /** 从序列化恢复（清空重建，重算高水位） */\n  restore(items: readonly CellSnapshotItem[]): void {\n    this.clear()\n    for (const item of items) {\n      const { row, col, ...data } = item\n      if (isEmptyCellData(data)) continue\n      let rowMap = this.cells.get(row)\n      if (!rowMap) {\n        rowMap = new Map()\n        this.cells.set(row, rowMap)\n      }\n      rowMap.set(col, { ...data })\n      this._rowCount = Math.max(this._rowCount, row + 1)\n      this._colCount = Math.max(this._colCount, col + 1)\n    }\n  }\n\n  clear(): void {\n    this.cells.clear()\n    this._rowCount = 0\n    this._colCount = 0\n  }\n}\n"],"mappings":"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"}

package/dist/core/command/default-registry.d.ts

@@ -1,10 +0,0 @@
-import { CommandRegistry } from "./registry.js";
-//#region src/core/command/default-registry.d.ts
-/**
- * 默认命令注册表：内置命令模块加载时注册一次，全局共享（命令无状态）。
- * Sheet 默认经此表执行命令；阶段 4 工具扩展可继续注册自定义命令。
- */
-declare const defaultCommandRegistry: CommandRegistry;
-//#endregion
-export { defaultCommandRegistry };
-//# sourceMappingURL=default-registry.d.ts.map

package/dist/core/command/default-registry.js

@@ -1,18 +0,0 @@
-import { MergeCellsCommand, UnmergeCellsCommand } from "./merge-cells.js";
-import { CommandRegistry } from "./registry.js";
-import { SetCellFormulaCommand } from "./set-cell-formula.js";
-import { SetCellValueCommand } from "./set-cell-value.js";
-//#region src/core/command/default-registry.ts
-/**
-* 默认命令注册表：内置命令模块加载时注册一次，全局共享（命令无状态）。
-* Sheet 默认经此表执行命令；阶段 4 工具扩展可继续注册自定义命令。
-*/
-const defaultCommandRegistry = new CommandRegistry();
-defaultCommandRegistry.register(SetCellValueCommand);
-defaultCommandRegistry.register(SetCellFormulaCommand);
-defaultCommandRegistry.register(MergeCellsCommand);
-defaultCommandRegistry.register(UnmergeCellsCommand);
-//#endregion
-export { defaultCommandRegistry };
-
-//# sourceMappingURL=default-registry.js.map

package/dist/core/command/default-registry.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"default-registry.js","names":[],"sources":["../../../src/core/command/default-registry.ts"],"sourcesContent":["import { MergeCellsCommand, UnmergeCellsCommand } from './merge-cells'\nimport { CommandRegistry } from './registry'\nimport { SetCellFormulaCommand } from './set-cell-formula'\nimport { SetCellValueCommand } from './set-cell-value'\n\n/**\n * 默认命令注册表：内置命令模块加载时注册一次，全局共享（命令无状态）。\n * Sheet 默认经此表执行命令；阶段 4 工具扩展可继续注册自定义命令。\n */\nexport const defaultCommandRegistry = new CommandRegistry()\n\ndefaultCommandRegistry.register(SetCellValueCommand)\ndefaultCommandRegistry.register(SetCellFormulaCommand)\ndefaultCommandRegistry.register(MergeCellsCommand)\ndefaultCommandRegistry.register(UnmergeCellsCommand)\n"],"mappings":";;;;;;;;;AASA,MAAa,yBAAyB,IAAI,gBAAgB;AAE1D,uBAAuB,SAAS,mBAAmB;AACnD,uBAAuB,SAAS,qBAAqB;AACrD,uBAAuB,SAAS,iBAAiB;AACjD,uBAAuB,SAAS,mBAAmB"}

package/dist/core/command/history.d.ts

@@ -1,64 +0,0 @@
-import { Mutation, Patch, PatchDirection } from "./types.js";
-//#region src/core/command/history.d.ts
-/**
- * HistoryManager：undo/redo 栈 + 事务。
- *
- * - 一个 undo 单元 = 一次命令（或一次事务）的全部 Mutation
- * - 事务：beginTransaction / commit，支持嵌套（深度计数，拍平到最外层）；
- *   rollback 回滚缓冲区中已应用的变更并放弃事务
- * - 容量上限（默认 200）：超出淘汰最旧条目
- * - 新命令入栈即清空 redo 栈
- */
-/** 历史栈容量默认值 */
-declare const DEFAULT_HISTORY_CAPACITY = 200;
-/** 历史状态（history-change 事件负载） */
-interface HistoryState {
-  canUndo: boolean;
-  canRedo: boolean;
-}
-declare class HistoryManager {
-  /** 补丁应用器（由 Sheet 注入，命令执行与回放共用） */
-  private readonly applyPatch;
-  private readonly capacity;
-  private undoStack;
-  private redoStack;
-  /** 事务深度（>0 表示事务进行中） */
-  private transactionDepth;
-  /** 事务缓冲：commit 时合并为一个 undo 单元 */
-  private transactionBuffer;
-  private emitter;
-  constructor(
-  /** 补丁应用器（由 Sheet 注入，命令执行与回放共用） */
-  applyPatch: (patch: Patch, direction: PatchDirection) => void, capacity?: number);
-  get canUndo(): boolean;
-  get canRedo(): boolean;
-  /** undo 栈深度（调试/测试用） */
-  get undoSize(): number;
-  /** redo 栈深度（调试/测试用） */
-  get redoSize(): number;
-  /** 是否处于事务中 */
-  get inTransaction(): boolean;
-  /** 命令执行产生的 mutation 入栈（事务中则缓冲）；空列表直接忽略 */
-  push(mutations: Mutation[]): void;
-  /** 开启事务（可嵌套，拍平到最外层） */
-  beginTransaction(): void;
-  /** 提交事务：缓冲的 mutation 合并为一个 undo 单元入栈 */
-  commit(): void;
-  /**
-   * 回滚事务：逆序应用缓冲区中各 mutation 的 undo 补丁还原模型，
-   * 丢弃缓冲并结束事务（含嵌套）；不动 undo/redo 栈。
-   */
-  rollback(): void;
-  /** 撤销一个单元；事务进行中或栈空时返回 false */
-  undo(): boolean;
-  /** 重做一个单元；事务进行中或栈空时返回 false */
-  redo(): boolean;
-  /** 清空全部历史（含事务缓冲） */
-  clear(): void;
-  onChange(handler: (state: HistoryState) => void): () => void;
-  private pushEntry;
-  private emitChange;
-}
-//#endregion
-export { DEFAULT_HISTORY_CAPACITY, HistoryManager, HistoryState };
-//# sourceMappingURL=history.d.ts.map

package/dist/core/command/history.js

@@ -1,127 +0,0 @@
-import { TypedEventEmitter } from "../events.js";
-//#region src/core/command/history.ts
-/**
-* HistoryManager：undo/redo 栈 + 事务。
-*
-* - 一个 undo 单元 = 一次命令（或一次事务）的全部 Mutation
-* - 事务：beginTransaction / commit，支持嵌套（深度计数，拍平到最外层）；
-*   rollback 回滚缓冲区中已应用的变更并放弃事务
-* - 容量上限（默认 200）：超出淘汰最旧条目
-* - 新命令入栈即清空 redo 栈
-*/
-/** 历史栈容量默认值 */
-const DEFAULT_HISTORY_CAPACITY = 200;
-var HistoryManager = class {
-	applyPatch;
-	capacity;
-	undoStack = [];
-	redoStack = [];
-	/** 事务深度（>0 表示事务进行中） */
-	transactionDepth = 0;
-	/** 事务缓冲：commit 时合并为一个 undo 单元 */
-	transactionBuffer = [];
-	emitter = new TypedEventEmitter();
-	constructor(applyPatch, capacity = 200) {
-		this.applyPatch = applyPatch;
-		this.capacity = capacity;
-	}
-	get canUndo() {
-		return this.undoStack.length > 0;
-	}
-	get canRedo() {
-		return this.redoStack.length > 0;
-	}
-	/** undo 栈深度（调试/测试用） */
-	get undoSize() {
-		return this.undoStack.length;
-	}
-	/** redo 栈深度（调试/测试用） */
-	get redoSize() {
-		return this.redoStack.length;
-	}
-	/** 是否处于事务中 */
-	get inTransaction() {
-		return this.transactionDepth > 0;
-	}
-	/** 命令执行产生的 mutation 入栈（事务中则缓冲）；空列表直接忽略 */
-	push(mutations) {
-		if (mutations.length === 0) return;
-		if (this.transactionDepth > 0) {
-			this.transactionBuffer.push(...mutations);
-			return;
-		}
-		this.pushEntry(mutations);
-	}
-	/** 开启事务（可嵌套，拍平到最外层） */
-	beginTransaction() {
-		this.transactionDepth++;
-	}
-	/** 提交事务：缓冲的 mutation 合并为一个 undo 单元入栈 */
-	commit() {
-		if (this.transactionDepth === 0) throw new Error("HistoryManager.commit：没有进行中的事务");
-		this.transactionDepth--;
-		if (this.transactionDepth === 0 && this.transactionBuffer.length > 0) {
-			const entry = this.transactionBuffer;
-			this.transactionBuffer = [];
-			this.pushEntry(entry);
-		}
-	}
-	/**
-	* 回滚事务：逆序应用缓冲区中各 mutation 的 undo 补丁还原模型，
-	* 丢弃缓冲并结束事务（含嵌套）；不动 undo/redo 栈。
-	*/
-	rollback() {
-		if (this.transactionDepth === 0) return;
-		const buffer = this.transactionBuffer;
-		this.transactionBuffer = [];
-		this.transactionDepth = 0;
-		for (let i = buffer.length - 1; i >= 0; i--) for (const patch of buffer[i].undo) this.applyPatch(patch, "undo");
-	}
-	/** 撤销一个单元；事务进行中或栈空时返回 false */
-	undo() {
-		if (this.transactionDepth > 0) return false;
-		const entry = this.undoStack.pop();
-		if (!entry) return false;
-		for (let i = entry.length - 1; i >= 0; i--) for (const patch of entry[i].undo) this.applyPatch(patch, "undo");
-		this.redoStack.push(entry);
-		this.emitChange();
-		return true;
-	}
-	/** 重做一个单元；事务进行中或栈空时返回 false */
-	redo() {
-		if (this.transactionDepth > 0) return false;
-		const entry = this.redoStack.pop();
-		if (!entry) return false;
-		for (const mutation of entry) for (const patch of mutation.redo) this.applyPatch(patch, "redo");
-		this.undoStack.push(entry);
-		this.emitChange();
-		return true;
-	}
-	/** 清空全部历史（含事务缓冲） */
-	clear() {
-		this.undoStack = [];
-		this.redoStack = [];
-		this.transactionBuffer = [];
-		this.transactionDepth = 0;
-		this.emitChange();
-	}
-	onChange(handler) {
-		return this.emitter.on("change", handler);
-	}
-	pushEntry(entry) {
-		this.undoStack.push(entry);
-		if (this.undoStack.length > this.capacity) this.undoStack.shift();
-		this.redoStack = [];
-		this.emitChange();
-	}
-	emitChange() {
-		this.emitter.emit("change", {
-			canUndo: this.canUndo,
-			canRedo: this.canRedo
-		});
-	}
-};
-//#endregion
-export { DEFAULT_HISTORY_CAPACITY, HistoryManager };
-
-//# sourceMappingURL=history.js.map

package/dist/core/command/history.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"history.js","names":[],"sources":["../../../src/core/command/history.ts"],"sourcesContent":["import { TypedEventEmitter } from '../events'\nimport type { Mutation, Patch, PatchDirection } from './types'\n\n/**\n * HistoryManager：undo/redo 栈 + 事务。\n *\n * - 一个 undo 单元 = 一次命令（或一次事务）的全部 Mutation\n * - 事务：beginTransaction / commit，支持嵌套（深度计数，拍平到最外层）；\n *   rollback 回滚缓冲区中已应用的变更并放弃事务\n * - 容量上限（默认 200）：超出淘汰最旧条目\n * - 新命令入栈即清空 redo 栈\n */\n\n/** 历史栈容量默认值 */\nexport const DEFAULT_HISTORY_CAPACITY = 200\n\n/** 历史状态（history-change 事件负载） */\nexport interface HistoryState {\n  canUndo: boolean\n  canRedo: boolean\n}\n\ntype HistoryEvents = { change: HistoryState }\n\n/** 一个 undo 单元 = 一组 Mutation */\ntype HistoryEntry = Mutation[]\n\nexport class HistoryManager {\n  private undoStack: HistoryEntry[] = []\n  private redoStack: HistoryEntry[] = []\n  /** 事务深度（>0 表示事务进行中） */\n  private transactionDepth = 0\n  /** 事务缓冲：commit 时合并为一个 undo 单元 */\n  private transactionBuffer: Mutation[] = []\n  private emitter = new TypedEventEmitter<HistoryEvents>()\n\n  constructor(\n    /** 补丁应用器（由 Sheet 注入，命令执行与回放共用） */\n    private readonly applyPatch: (patch: Patch, direction: PatchDirection) => void,\n    private readonly capacity: number = DEFAULT_HISTORY_CAPACITY\n  ) {}\n\n  get canUndo(): boolean {\n    return this.undoStack.length > 0\n  }\n\n  get canRedo(): boolean {\n    return this.redoStack.length > 0\n  }\n\n  /** undo 栈深度（调试/测试用） */\n  get undoSize(): number {\n    return this.undoStack.length\n  }\n\n  /** redo 栈深度（调试/测试用） */\n  get redoSize(): number {\n    return this.redoStack.length\n  }\n\n  /** 是否处于事务中 */\n  get inTransaction(): boolean {\n    return this.transactionDepth > 0\n  }\n\n  /** 命令执行产生的 mutation 入栈（事务中则缓冲）；空列表直接忽略 */\n  push(mutations: Mutation[]): void {\n    if (mutations.length === 0) return\n    if (this.transactionDepth > 0) {\n      this.transactionBuffer.push(...mutations)\n      return\n    }\n    this.pushEntry(mutations)\n  }\n\n  /** 开启事务（可嵌套，拍平到最外层） */\n  beginTransaction(): void {\n    this.transactionDepth++\n  }\n\n  /** 提交事务：缓冲的 mutation 合并为一个 undo 单元入栈 */\n  commit(): void {\n    if (this.transactionDepth === 0) {\n      throw new Error('HistoryManager.commit：没有进行中的事务')\n    }\n    this.transactionDepth--\n    if (this.transactionDepth === 0 && this.transactionBuffer.length > 0) {\n      const entry = this.transactionBuffer\n      this.transactionBuffer = []\n      this.pushEntry(entry)\n    }\n  }\n\n  /**\n   * 回滚事务：逆序应用缓冲区中各 mutation 的 undo 补丁还原模型，\n   * 丢弃缓冲并结束事务（含嵌套）；不动 undo/redo 栈。\n   */\n  rollback(): void {\n    if (this.transactionDepth === 0) return\n    const buffer = this.transactionBuffer\n    this.transactionBuffer = []\n    this.transactionDepth = 0\n    for (let i = buffer.length - 1; i >= 0; i--) {\n      for (const patch of buffer[i]!.undo) {\n        this.applyPatch(patch, 'undo')\n      }\n    }\n  }\n\n  /** 撤销一个单元；事务进行中或栈空时返回 false */\n  undo(): boolean {\n    if (this.transactionDepth > 0) return false\n    const entry = this.undoStack.pop()\n    if (!entry) return false\n    for (let i = entry.length - 1; i >= 0; i--) {\n      for (const patch of entry[i]!.undo) {\n        this.applyPatch(patch, 'undo')\n      }\n    }\n    this.redoStack.push(entry)\n    this.emitChange()\n    return true\n  }\n\n  /** 重做一个单元；事务进行中或栈空时返回 false */\n  redo(): boolean {\n    if (this.transactionDepth > 0) return false\n    const entry = this.redoStack.pop()\n    if (!entry) return false\n    for (const mutation of entry) {\n      for (const patch of mutation.redo) {\n        this.applyPatch(patch, 'redo')\n      }\n    }\n    this.undoStack.push(entry)\n    this.emitChange()\n    return true\n  }\n\n  /** 清空全部历史（含事务缓冲） */\n  clear(): void {\n    this.undoStack = []\n    this.redoStack = []\n    this.transactionBuffer = []\n    this.transactionDepth = 0\n    this.emitChange()\n  }\n\n  onChange(handler: (state: HistoryState) => void): () => void {\n    return this.emitter.on('change', handler)\n  }\n\n  private pushEntry(entry: HistoryEntry): void {\n    this.undoStack.push(entry)\n    if (this.undoStack.length > this.capacity) {\n      // 淘汰最旧条目；redo 栈不受影响（淘汰只发生在 undo 栈底部）\n      this.undoStack.shift()\n    }\n    // 新命令清空 redo 栈\n    this.redoStack = []\n    this.emitChange()\n  }\n\n  private emitChange(): void {\n    this.emitter.emit('change', { canUndo: this.canUndo, canRedo: this.canRedo })\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAcA,MAAa,2BAA2B;AAaxC,IAAa,iBAAb,MAA4B;CAWP;CACA;CAXnB,YAAoC,CAAC;CACrC,YAAoC,CAAC;;CAErC,mBAA2B;;CAE3B,oBAAwC,CAAC;CACzC,UAAkB,IAAI,kBAAiC;CAEvD,YAEE,YACA,WAAiB,KACjB;EAFiB,KAAA,aAAA;EACA,KAAA,WAAA;CAChB;CAEH,IAAI,UAAmB;EACrB,OAAO,KAAK,UAAU,SAAS;CACjC;CAEA,IAAI,UAAmB;EACrB,OAAO,KAAK,UAAU,SAAS;CACjC;;CAGA,IAAI,WAAmB;EACrB,OAAO,KAAK,UAAU;CACxB;;CAGA,IAAI,WAAmB;EACrB,OAAO,KAAK,UAAU;CACxB;;CAGA,IAAI,gBAAyB;EAC3B,OAAO,KAAK,mBAAmB;CACjC;;CAGA,KAAK,WAA6B;EAChC,IAAI,UAAU,WAAW,GAAG;EAC5B,IAAI,KAAK,mBAAmB,GAAG;GAC7B,KAAK,kBAAkB,KAAK,GAAG,SAAS;GACxC;EACF;EACA,KAAK,UAAU,SAAS;CAC1B;;CAGA,mBAAyB;EACvB,KAAK;CACP;;CAGA,SAAe;EACb,IAAI,KAAK,qBAAqB,GAC5B,MAAM,IAAI,MAAM,gCAAgC;EAElD,KAAK;EACL,IAAI,KAAK,qBAAqB,KAAK,KAAK,kBAAkB,SAAS,GAAG;GACpE,MAAM,QAAQ,KAAK;GACnB,KAAK,oBAAoB,CAAC;GAC1B,KAAK,UAAU,KAAK;EACtB;CACF;;;;;CAMA,WAAiB;EACf,IAAI,KAAK,qBAAqB,GAAG;EACjC,MAAM,SAAS,KAAK;EACpB,KAAK,oBAAoB,CAAC;EAC1B,KAAK,mBAAmB;EACxB,KAAK,IAAI,IAAI,OAAO,SAAS,GAAG,KAAK,GAAG,KACtC,KAAK,MAAM,SAAS,OAAO,EAAE,CAAE,MAC7B,KAAK,WAAW,OAAO,MAAM;CAGnC;;CAGA,OAAgB;EACd,IAAI,KAAK,mBAAmB,GAAG,OAAO;EACtC,MAAM,QAAQ,KAAK,UAAU,IAAI;EACjC,IAAI,CAAC,OAAO,OAAO;EACnB,KAAK,IAAI,IAAI,MAAM,SAAS,GAAG,KAAK,GAAG,KACrC,KAAK,MAAM,SAAS,MAAM,EAAE,CAAE,MAC5B,KAAK,WAAW,OAAO,MAAM;EAGjC,KAAK,UAAU,KAAK,KAAK;EACzB,KAAK,WAAW;EAChB,OAAO;CACT;;CAGA,OAAgB;EACd,IAAI,KAAK,mBAAmB,GAAG,OAAO;EACtC,MAAM,QAAQ,KAAK,UAAU,IAAI;EACjC,IAAI,CAAC,OAAO,OAAO;EACnB,KAAK,MAAM,YAAY,OACrB,KAAK,MAAM,SAAS,SAAS,MAC3B,KAAK,WAAW,OAAO,MAAM;EAGjC,KAAK,UAAU,KAAK,KAAK;EACzB,KAAK,WAAW;EAChB,OAAO;CACT;;CAGA,QAAc;EACZ,KAAK,YAAY,CAAC;EAClB,KAAK,YAAY,CAAC;EAClB,KAAK,oBAAoB,CAAC;EAC1B,KAAK,mBAAmB;EACxB,KAAK,WAAW;CAClB;CAEA,SAAS,SAAoD;EAC3D,OAAO,KAAK,QAAQ,GAAG,UAAU,OAAO;CAC1C;CAEA,UAAkB,OAA2B;EAC3C,KAAK,UAAU,KAAK,KAAK;EACzB,IAAI,KAAK,UAAU,SAAS,KAAK,UAE/B,KAAK,UAAU,MAAM;EAGvB,KAAK,YAAY,CAAC;EAClB,KAAK,WAAW;CAClB;CAEA,aAA2B;EACzB,KAAK,QAAQ,KAAK,UAAU;GAAE,SAAS,KAAK;GAAS,SAAS,KAAK;EAAQ,CAAC;CAC9E;AACF"}

package/dist/core/command/merge-cells.d.ts

@@ -1,21 +0,0 @@
-import { CellRange } from "../address.js";
-import { Command } from "./types.js";
-//#region src/core/command/merge-cells.d.ts
-interface MergeCellsParams {
-  range: CellRange;
-}
-/**
- * 合并命令。Patch 捕获完整 before 状态：
- * - 被解除的既有合并记录（undo 时逐一恢复）
- * - 包围盒内每一格的原数据（undo 时连被清空的值一起还原）
- * 值保留规则同 Excel/univer：行主序第一个有值格的值写入新锚点，其余清空。
- */
-declare const MergeCellsCommand: Command<MergeCellsParams, CellRange>;
-interface UnmergeCellsParams {
-  range: CellRange;
-}
-/** 取消合并命令：解除与 range 相交的所有合并；undo 恢复合并记录 */
-declare const UnmergeCellsCommand: Command<UnmergeCellsParams>;
-//#endregion
-export { MergeCellsCommand, MergeCellsParams, UnmergeCellsCommand, UnmergeCellsParams };
-//# sourceMappingURL=merge-cells.d.ts.map