@stll/folio-core 0.11.0 → 0.12.0

package/dist/ai-edits/apply.js

@@ -1,27 +1,17 @@
+import { expectRunPropertyChangeMarkAttrs } from "../prosemirror/attrs/index.js";
+import { marksToTextFormatting } from "../prosemirror/conversion/fromProseDoc.js";
 import { getFolioParaIdFromBlockId } from "../types/block-id.js";
+import { stripBlockIdentityAttrs } from "./block-identity.js";
 import { buildCleanBlockText } from "./clean-text.js";
 import { hasInlineEmphasis, parseInlineEmphasisRuns, stripInlineEmphasisMarkers } from "./inline-emphasis.js";
 import { hashFolioAIBlockText, normalizeFolioAIBlockText } from "./snapshot.js";
+import { planTableMutations } from "./table-mutation-plan.js";
+import { findEnclosingTableBoundary, findEnclosingTableCell, findEnclosingTableRow, tableRectangleCutsMergedCell } from "./table-targets.js";
+import { mergeTableRectangle, mergeTrackedVerticalTableCells, splitTableRectangle, splitTrackedVerticalTableCell } from "./table-cell-mutations.js";
+import { applyTableColumnDeletion, applyTableColumnInsertion, applyTableRowDeletion, applyTableRowInsertion, findTableColumnInsertion, findTableRowInsertion, getTableColumnCoordinateKey } from "./table-row-column-mutations.js";
 import { diffWordSegments } from "./word-diff.js";
+import { TableMap } from "prosemirror-tables";
 //#region src/ai-edits/apply.ts
-/**
-* Block attrs that identify a block instance (Word's
-* `w14:paraId` / `w14:textId`, future tracked-change identifiers).
-* Reuse during inheritFormatting would create duplicate IDs, so
-* we strip them when synthesising a sibling.
-*/
-const IDENTITY_BLOCK_ATTRS = /* @__PURE__ */ new Set(["paraId", "textId"]);
-const stripIdentityAttrs = (attrs) => {
-	const next = {};
-	for (const [key, value] of Object.entries(attrs)) {
-		if (IDENTITY_BLOCK_ATTRS.has(key)) {
-			next[key] = null;
-			continue;
-		}
-		next[key] = value;
-	}
-	return next;
-};
 const applyReplaceBlockStyleId = ({ item, tr }) => {
 	if (item.operation.type !== "replaceBlock" || item.operation.styleId === void 0) return tr;
 	const block = tr.doc.nodeAt(item.blockFrom);
@@ -31,6 +21,61 @@ const applyReplaceBlockStyleId = ({ item, tr }) => {
 		styleId: item.operation.styleId
 	});
 };
+const applyInlineFormatting = ({ tr, schema, from, to, formatting }) => {
+	for (const [name, enabled] of Object.entries(formatting)) {
+		const markType = schema.marks[name];
+		if (!markType) continue;
+		if (enabled) {
+			tr.addMark(from, to, name === "underline" ? markType.create({ style: "single" }) : markType.create());
+			continue;
+		}
+		tr.removeMark(from, to, markType);
+	}
+	return tr;
+};
+const formattingWouldChange = (marks, formatting) => Object.entries(formatting).some(([name, enabled]) => {
+	const mark = marks.find((candidate) => candidate.type.name === name);
+	if (!enabled) return mark !== void 0;
+	if (name === "underline") return mark?.attrs["style"] !== "single";
+	return mark === void 0;
+});
+const applyTrackedInlineFormatting = ({ tr, schema, doc, from, to, formatting, revisionId, author, date }) => {
+	const propertyChangeType = schema.marks["runPropertyChange"];
+	if (!propertyChangeType) return tr;
+	const segments = [];
+	doc.nodesBetween(from, to, (node, pos) => {
+		if (!node.isText || !formattingWouldChange(node.marks, formatting)) return;
+		const segmentFrom = Math.max(from, pos);
+		const segmentTo = Math.min(to, pos + node.nodeSize);
+		const previousFormatting = marksToTextFormatting(node.marks);
+		const existingMark = node.marks.find((mark) => mark.type === propertyChangeType);
+		const existingChanges = existingMark ? expectRunPropertyChangeMarkAttrs(existingMark).changes : [];
+		const change = {
+			type: "runPropertyChange",
+			info: {
+				id: revisionId,
+				author,
+				date
+			},
+			...Object.keys(previousFormatting).length > 0 ? { previousFormatting } : {}
+		};
+		segments.push({
+			from: segmentFrom,
+			to: segmentTo,
+			changes: [...existingChanges, change]
+		});
+	});
+	if (segments.length === 0) return tr;
+	applyInlineFormatting({
+		tr,
+		schema,
+		from,
+		to,
+		formatting
+	});
+	for (const segment of segments) tr.addMark(segment.from, segment.to, propertyChangeType.create({ changes: segment.changes }));
+	return tr;
+};
 /**
 * Module-scoped monotonic counter for tracked-change revision ids.
 * Seeded once from `Date.now()` so ids are roughly time-ordered for
@@ -93,13 +138,21 @@ const collectLiveBlocksByParaId = (doc) => {
 	});
 	return byParaId;
 };
-const findEnclosingTableBoundary = (doc, blockFrom) => {
-	const resolved = doc.resolve(blockFrom);
-	for (let depth = resolved.depth; depth > 0; depth--) if (resolved.node(depth).type.name === "table") return {
-		before: resolved.before(depth),
-		after: resolved.after(depth)
+const getTableMutationPlanTarget = (item) => {
+	if (item.tableCellMerge) return {
+		type: "mergeCells",
+		...item.tableCellMerge
+	};
+	if (item.tableCellSplit) return {
+		type: "splitCell",
+		...item.tableCellSplit
+	};
+	const tablePosition = item.tableRowInsertion?.tableStart !== void 0 ? item.tableRowInsertion.tableStart - 1 : item.tableRowDeletion?.tablePosition ?? item.tableColumnInsertion?.tablePosition ?? item.tableColumnDeletion?.tablePosition;
+	if (tablePosition !== void 0) return {
+		type: "tableStructure",
+		tablePosition
 	};
-	return null;
+	return { type: "none" };
 };
 /**
 * The snapshot recorded an `hashOccurrenceCount` per anchor but
@@ -200,6 +253,8 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 	const insertionType = view.state.schema.marks["insertion"];
 	const deletionType = view.state.schema.marks["deletion"];
 	const commentType = view.state.schema.marks["comment"];
+	const claimedTableRows = /* @__PURE__ */ new Set();
+	const claimedTableColumns = /* @__PURE__ */ new Set();
 	if (mode === "tracked-changes" && (!insertionType || !deletionType)) return {
 		applied,
 		skipped: operations.map((operation) => ({
@@ -210,13 +265,6 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 	const liveBlocks = collectLiveBlocksByHash(view.state.doc);
 	const liveBlocksByParaId = collectLiveBlocksByParaId(view.state.doc);
 	for (const [index, operation] of operations.entries()) {
-		if (mode === "tracked-changes" && operation.type === "formatRange") {
-			skipped.push({
-				id: operation.id,
-				reason: "unsupportedMode"
-			});
-			continue;
-		}
 		const commentText = getOperationCommentText(operation);
 		if (commentText !== void 0 && (!commentType || createCommentId === void 0)) {
 			skipped.push({
@@ -239,6 +287,30 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 			});
 			continue;
 		}
+		const deletion = resolution.operation.tableRowDeletion;
+		if (deletion) {
+			const rowKey = `${deletion.tablePosition}:${deletion.rowIndex}`;
+			if (claimedTableRows.has(rowKey)) {
+				skipped.push({
+					id: operation.id,
+					reason: "noopOperation"
+				});
+				continue;
+			}
+			claimedTableRows.add(rowKey);
+		}
+		const columnDeletion = resolution.operation.tableColumnDeletion;
+		if (columnDeletion) {
+			const columnKey = getTableColumnCoordinateKey(columnDeletion);
+			if (claimedTableColumns.has(columnKey)) {
+				skipped.push({
+					id: operation.id,
+					reason: "noopOperation"
+				});
+				continue;
+			}
+			claimedTableColumns.add(columnKey);
+		}
 		const commentId = commentText !== void 0 ? createCommentId?.(commentText) : void 0;
 		resolved.push({
 			...resolution.operation,
@@ -246,14 +318,43 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 			...commentId !== void 0 && { commentId }
 		});
 	}
-	if (resolved.length === 0) return {
+	const tablePlan = planTableMutations(resolved.map((item) => ({
+		item,
+		operationId: item.operation.id,
+		target: getTableMutationPlanTarget(item)
+	})));
+	skipped.push(...tablePlan.skipped);
+	const executableResolved = tablePlan.executable;
+	if (executableResolved.length === 0) return {
 		applied,
 		skipped
 	};
 	let tr = view.state.tr;
-	let revisionSeed = revisionIdSeed ?? nextRevisionSeed(resolved.length);
+	let revisionSeed = revisionIdSeed ?? nextRevisionSeed(executableResolved.length);
 	const date = (/* @__PURE__ */ new Date()).toISOString();
-	for (const item of resolved.toSorted((left, right) => {
+	const insertedColumnCounts = /* @__PURE__ */ new Map();
+	for (const item of executableResolved.toSorted((left, right) => {
+		const leftCellShape = left.tableCellMerge ?? left.tableCellSplit;
+		const rightCellShape = right.tableCellMerge ?? right.tableCellSplit;
+		if (!leftCellShape && rightCellShape) return -1;
+		if (leftCellShape && !rightCellShape) return 1;
+		if (leftCellShape && rightCellShape) {
+			if (leftCellShape.tablePosition !== rightCellShape.tablePosition) return rightCellShape.tablePosition - leftCellShape.tablePosition;
+			if (leftCellShape.rectangle.bottom !== rightCellShape.rectangle.bottom) return rightCellShape.rectangle.bottom - leftCellShape.rectangle.bottom;
+			if (leftCellShape.rectangle.right !== rightCellShape.rectangle.right) return rightCellShape.rectangle.right - leftCellShape.rectangle.right;
+			return right.originalIndex - left.originalIndex;
+		}
+		const leftColumn = left.tableColumnInsertion ?? left.tableColumnDeletion;
+		const rightColumn = right.tableColumnInsertion ?? right.tableColumnDeletion;
+		if (!leftColumn && rightColumn) return -1;
+		if (leftColumn && !rightColumn) return 1;
+		if (leftColumn && rightColumn) {
+			if (leftColumn.tablePosition !== rightColumn.tablePosition) return rightColumn.tablePosition - leftColumn.tablePosition;
+			if (leftColumn.columnIndex !== rightColumn.columnIndex) return rightColumn.columnIndex - leftColumn.columnIndex;
+			const leftIsInsertion = left.tableColumnInsertion !== void 0;
+			if (leftIsInsertion !== (right.tableColumnInsertion !== void 0)) return leftIsInsertion ? -1 : 1;
+			return right.originalIndex - left.originalIndex;
+		}
 		if (left.from !== right.from) return right.from - left.from;
 		return right.originalIndex - left.originalIndex;
 	})) {
@@ -282,12 +383,29 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 				if (commentMark) tr = tr.addMark(item.from, item.to, commentMark);
 				break;
 			case "formatRange":
-				for (const [name, enabled] of Object.entries(item.operation.formatting)) {
-					const markType = view.state.schema.marks[name];
-					if (!markType) continue;
-					if (enabled) tr = tr.addMark(item.from, item.to, name === "underline" ? markType.create({ style: "single" }) : markType.create());
-					else tr = tr.removeMark(item.from, item.to, markType);
+				if (mode === "tracked-changes") {
+					const revisionId = revisionSeed++;
+					tr = applyTrackedInlineFormatting({
+						tr,
+						schema: view.state.schema,
+						doc: tr.doc,
+						from: item.from,
+						to: item.to,
+						formatting: item.operation.formatting,
+						revisionId,
+						author,
+						date
+					});
+					appliedRevisionIds = [revisionId];
+					break;
 				}
+				tr = applyInlineFormatting({
+					tr,
+					schema: view.state.schema,
+					from: item.from,
+					to: item.to,
+					formatting: item.operation.formatting
+				});
 				break;
 			case "replaceBlock": {
 				const revisionIdDelete = revisionSeed++;
@@ -349,7 +467,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 				}
 				if (commentMark) marks.push(commentMark);
 				const content = item.insertText && item.insertText.length > 0 ? buildEmphasisInlineContent(view.state.schema, item.insertText, marks) : null;
-				const attrs = { ...item.operation.inheritFormatting === false ? {} : stripIdentityAttrs(item.blockNode.attrs) };
+				const attrs = { ...item.operation.inheritFormatting === false ? {} : stripBlockIdentityAttrs(item.blockNode.attrs) };
 				if (item.operation.pageBreakBefore === true) attrs["pageBreakBefore"] = true;
 				if (item.operation.styleId !== void 0) {
 					attrs["styleId"] = item.operation.styleId;
@@ -388,6 +506,223 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations, mode =
 				tr = tr.insert(item.from, node);
 				break;
 			}
+			case "insertTableRow": {
+				const insertion = item.tableRowInsertion;
+				if (!insertion) {
+					skipped.push({
+						id: item.operation.id,
+						reason: "unsupportedBlock"
+					});
+					continue;
+				}
+				const revision = mode === "tracked-changes" ? {
+					revisionId: revisionSeed,
+					author,
+					date
+				} : null;
+				const result = applyTableRowInsertion({
+					tr,
+					insertion,
+					cellTexts: item.operation.cellTexts,
+					revision
+				});
+				if (result.type === "unsupported") {
+					skipped.push({
+						id: item.operation.id,
+						reason: "unsupportedBlock"
+					});
+					continue;
+				}
+				tr = result.transaction;
+				if (result.revisionId !== null) {
+					revisionSeed++;
+					appliedRevisionIds = [result.revisionId];
+				}
+				break;
+			}
+			case "insertTableColumn": {
+				const insertion = item.tableColumnInsertion;
+				if (!insertion) {
+					skipped.push({
+						id: item.operation.id,
+						reason: "unsupportedBlock"
+					});
+					continue;
+				}
+				const revision = mode === "tracked-changes" ? {
+					revisionId: revisionSeed,
+					author,
+					date
+				} : null;
+				const result = applyTableColumnInsertion({
+					tr,
+					insertion,
+					cellTexts: item.operation.cellTexts,
+					revision
+				});
+				if (result.type === "unsupported") {
+					skipped.push({
+						id: item.operation.id,
+						reason: "unsupportedBlock"
+					});
+					continue;
+				}
+				tr = result.transaction;
+				if (result.revisionId !== null) {
+					revisionSeed++;
+					appliedRevisionIds = [result.revisionId];
+				}
+				const columnKey = getTableColumnCoordinateKey(insertion);
+				insertedColumnCounts.set(columnKey, (insertedColumnCounts.get(columnKey) ?? 0) + 1);
+				break;
+			}
+			case "deleteTableColumn": {
+				const deletion = item.tableColumnDeletion;
+				if (!deletion) {
+					skipped.push({
+						id: item.operation.id,
+						reason: "unsupportedBlock"
+					});
+					continue;
+				}
+				const columnKey = getTableColumnCoordinateKey(deletion);
+				const revision = mode === "tracked-changes" ? {
+					revisionId: revisionSeed,
+					author,
+					date
+				} : null;
+				const result = applyTableColumnDeletion({
+					tr,
+					deletion,
+					insertedColumnCount: insertedColumnCounts.get(columnKey) ?? 0,
+					revision
+				});
+				if (result.type === "unsupported") {
+					skipped.push({
+						id: item.operation.id,
+						reason: "unsupportedBlock"
+					});
+					continue;
+				}
+				tr = result.transaction;
+				if (result.revisionId !== null) {
+					revisionSeed++;
+					appliedRevisionIds = [result.revisionId];
+				}
+				break;
+			}
+			case "mergeTableCells": {
+				const merge = item.tableCellMerge;
+				const tablePosition = merge ? tr.mapping.map(merge.tablePosition, 1) : null;
+				const table = tablePosition === null ? null : tr.doc.nodeAt(tablePosition);
+				if (!merge || tablePosition === null || !table || table.type.spec["tableRole"] !== "table") {
+					skipped.push({
+						id: item.operation.id,
+						reason: "unsupportedBlock"
+					});
+					continue;
+				}
+				const revisionId = mode === "tracked-changes" ? revisionSeed : null;
+				const nextTr = revisionId === null ? mergeTableRectangle({
+					tr,
+					tablePosition,
+					table,
+					rectangle: merge.rectangle
+				}) : mergeTrackedVerticalTableCells({
+					tr,
+					tablePosition,
+					table,
+					rectangle: merge.rectangle,
+					revisionId,
+					author,
+					date
+				});
+				if (!nextTr) {
+					skipped.push({
+						id: item.operation.id,
+						reason: "unsupportedBlock"
+					});
+					continue;
+				}
+				tr = nextTr;
+				if (revisionId !== null) {
+					revisionSeed++;
+					appliedRevisionIds = [revisionId];
+				}
+				break;
+			}
+			case "splitTableCell": {
+				const split = item.tableCellSplit;
+				const tablePosition = split ? tr.mapping.map(split.tablePosition, 1) : null;
+				const table = tablePosition === null ? null : tr.doc.nodeAt(tablePosition);
+				if (!split || tablePosition === null || !table || table.type.spec["tableRole"] !== "table") {
+					skipped.push({
+						id: item.operation.id,
+						reason: "unsupportedBlock"
+					});
+					continue;
+				}
+				const revisionId = mode === "tracked-changes" ? revisionSeed : null;
+				const nextTr = revisionId === null ? splitTableRectangle({
+					tr,
+					tablePosition,
+					table,
+					rectangle: split.rectangle
+				}) : splitTrackedVerticalTableCell({
+					tr,
+					tablePosition,
+					table,
+					rectangle: split.rectangle,
+					revisionId,
+					author,
+					date
+				});
+				if (!nextTr) {
+					skipped.push({
+						id: item.operation.id,
+						reason: "unsupportedBlock"
+					});
+					continue;
+				}
+				tr = nextTr;
+				if (revisionId !== null) {
+					revisionSeed++;
+					appliedRevisionIds = [revisionId];
+				}
+				break;
+			}
+			case "deleteTableRow": {
+				const deletion = item.tableRowDeletion;
+				if (!deletion) {
+					skipped.push({
+						id: item.operation.id,
+						reason: "unsupportedBlock"
+					});
+					continue;
+				}
+				const result = applyTableRowDeletion({
+					tr,
+					deletion,
+					revision: mode === "tracked-changes" ? {
+						revisionId: revisionSeed,
+						author,
+						date
+					} : null
+				});
+				if (result.type === "unsupported") {
+					skipped.push({
+						id: item.operation.id,
+						reason: "unsupportedBlock"
+					});
+					continue;
+				}
+				tr = result.transaction;
+				if (result.revisionId !== null) {
+					revisionSeed++;
+					appliedRevisionIds = [result.revisionId];
+				}
+				break;
+			}
 			case "deleteBlock":
 				if (mode === "direct") {
 					tr = tr.delete(item.blockFrom, item.blockTo);
@@ -561,8 +896,7 @@ const applyTextReplacement = ({ tr, item, mode, author, date, revisionIdDelete,
 	}
 	return nextTr;
 };
-const resolveOperation = ({ snapshot, operation, liveBlocks, liveBlocksByParaId, doc }) => {
-	const blockId = operation.type === "replaceRange" || operation.type === "commentOnRange" || operation.type === "formatRange" ? operation.range.blockId : operation.blockId;
+const resolveStableBlock = ({ snapshot, blockId, liveBlocks, liveBlocksByParaId }) => {
 	const anchor = snapshot.anchors[blockId];
 	if (!anchor) return {
 		type: "skip",
@@ -588,20 +922,37 @@ const resolveOperation = ({ snapshot, operation, liveBlocks, liveBlocksByParaId,
 		type: "skip",
 		reason: "changedBlock"
 	};
-	const blockNode = live.node;
-	const blockFrom = live.from;
-	const blockTo = live.to;
-	const cleanBlock = buildCleanBlockText(blockNode, blockFrom);
+	const cleanBlock = buildCleanBlockText(live.node, live.from);
 	const currentText = cleanBlock.text;
 	const currentTextHash = hashFolioAIBlockText(normalizeFolioAIBlockText(currentText));
-	if (operation.precondition !== void 0 && currentTextHash !== operation.precondition.blockTextHash) return {
-		type: "skip",
-		reason: "preconditionFailed"
-	};
 	if (currentTextHash !== anchor.textHash) return {
 		type: "skip",
 		reason: "changedBlock"
 	};
+	return {
+		type: "resolved",
+		blockNode: live.node,
+		blockFrom: live.from,
+		blockTo: live.to,
+		cleanBlock,
+		currentText,
+		currentTextHash
+	};
+};
+const resolveOperation = ({ snapshot, operation, liveBlocks, liveBlocksByParaId, doc }) => {
+	const blockId = operation.type === "replaceRange" || operation.type === "commentOnRange" || operation.type === "formatRange" ? operation.range.blockId : operation.blockId;
+	const primaryBlock = resolveStableBlock({
+		snapshot,
+		blockId,
+		liveBlocks,
+		liveBlocksByParaId
+	});
+	if (primaryBlock.type === "skip") return primaryBlock;
+	const { blockNode, blockFrom, blockTo, cleanBlock, currentText, currentTextHash } = primaryBlock;
+	if (operation.precondition !== void 0 && currentTextHash !== operation.precondition.blockTextHash) return {
+		type: "skip",
+		reason: "preconditionFailed"
+	};
 	if (operation.type === "replaceRange" || operation.type === "commentOnRange" || operation.type === "formatRange") {
 		const { startOffset, endOffset, selectedTextHash } = operation.range;
 		const from = cleanBlock.offsets[startOffset];
@@ -676,6 +1027,207 @@ const resolveOperation = ({ snapshot, operation, liveBlocks, liveBlocksByParaId,
 			}
 		};
 	}
+	if (operation.type === "insertTableRow") {
+		const insertion = findTableRowInsertion({
+			doc,
+			blockFrom,
+			position: operation.position ?? "after"
+		});
+		if (!insertion || (operation.cellTexts?.length ?? 0) > insertion.cells.length) return {
+			type: "skip",
+			reason: "unsupportedBlock"
+		};
+		return {
+			type: "resolved",
+			operation: {
+				operation,
+				from: insertion.rowPosition,
+				to: insertion.rowPosition,
+				blockFrom,
+				blockTo,
+				blockNode,
+				tableRowInsertion: insertion
+			}
+		};
+	}
+	if (operation.type === "deleteTableRow") {
+		const target = findEnclosingTableRow(doc, blockFrom);
+		if (!target) return {
+			type: "skip",
+			reason: "unsupportedBlock"
+		};
+		return {
+			type: "resolved",
+			operation: {
+				operation,
+				from: target.rowPosition,
+				to: target.rowPosition,
+				blockFrom,
+				blockTo,
+				blockNode,
+				tableRowDeletion: {
+					tableStart: target.tableStart,
+					tablePosition: target.tablePosition,
+					rowIndex: target.rowIndex,
+					rowPosition: target.rowPosition
+				}
+			}
+		};
+	}
+	if (operation.type === "insertTableColumn") {
+		const insertion = findTableColumnInsertion({
+			doc,
+			blockFrom,
+			position: operation.position ?? "after"
+		});
+		if (!insertion) return {
+			type: "skip",
+			reason: "unsupportedBlock"
+		};
+		const { boundaryPosition, ...tableColumnInsertion } = insertion;
+		return {
+			type: "resolved",
+			operation: {
+				operation,
+				from: boundaryPosition,
+				to: boundaryPosition,
+				blockFrom,
+				blockTo,
+				blockNode,
+				tableColumnInsertion
+			}
+		};
+	}
+	if (operation.type === "deleteTableColumn") {
+		const target = findEnclosingTableCell(doc, blockFrom);
+		if (!target) return {
+			type: "skip",
+			reason: "unsupportedBlock"
+		};
+		return {
+			type: "resolved",
+			operation: {
+				operation,
+				from: target.cellPosition,
+				to: target.cellPosition,
+				blockFrom,
+				blockTo,
+				blockNode,
+				tableColumnDeletion: {
+					tablePosition: target.tablePosition,
+					columnIndex: target.leftColumnIndex
+				}
+			}
+		};
+	}
+	if (operation.type === "mergeTableCells") {
+		const startCell = findEnclosingTableCell(doc, blockFrom);
+		if (!startCell) return {
+			type: "skip",
+			reason: "unsupportedBlock"
+		};
+		const table = doc.nodeAt(startCell.tablePosition);
+		if (!table || table.type.spec["tableRole"] !== "table") return {
+			type: "skip",
+			reason: "unsupportedBlock"
+		};
+		const map = TableMap.get(table);
+		let rectangle;
+		let endCellPosition;
+		let endCellEndPosition;
+		if (operation.rowCount !== void 0) {
+			rectangle = {
+				left: startCell.leftColumnIndex,
+				top: startCell.topRowIndex,
+				right: startCell.rightColumnIndex,
+				bottom: startCell.topRowIndex + operation.rowCount
+			};
+			if (rectangle.right - rectangle.left !== 1 || rectangle.bottom > map.height || operation.rowCount < 2) return {
+				type: "skip",
+				reason: "unsupportedBlock"
+			};
+			const endRelativePosition = map.map[(rectangle.bottom - 1) * map.width + rectangle.left];
+			const endCell = endRelativePosition === void 0 ? null : table.nodeAt(endRelativePosition);
+			if (!endCell || endRelativePosition === void 0) return {
+				type: "skip",
+				reason: "unsupportedBlock"
+			};
+			endCellPosition = startCell.tablePosition + 1 + endRelativePosition;
+			endCellEndPosition = endCellPosition + endCell.nodeSize;
+		} else {
+			const endTarget = resolveStableBlock({
+				snapshot,
+				blockId: operation.endBlockId,
+				liveBlocks,
+				liveBlocksByParaId
+			});
+			if (endTarget.type === "skip") return endTarget;
+			const endCell = findEnclosingTableCell(doc, endTarget.blockFrom);
+			if (!endCell || startCell.tablePosition !== endCell.tablePosition) return {
+				type: "skip",
+				reason: "unsupportedBlock"
+			};
+			rectangle = {
+				left: Math.min(startCell.leftColumnIndex, endCell.leftColumnIndex),
+				top: Math.min(startCell.topRowIndex, endCell.topRowIndex),
+				right: Math.max(startCell.rightColumnIndex, endCell.rightColumnIndex),
+				bottom: Math.max(startCell.bottomRowIndex, endCell.bottomRowIndex)
+			};
+			endCellPosition = endCell.cellPosition;
+			endCellEndPosition = endCell.cellEndPosition;
+		}
+		if (rectangle.right - rectangle.left === 1 && rectangle.bottom - rectangle.top === 1 || tableRectangleCutsMergedCell(map, rectangle)) return {
+			type: "skip",
+			reason: rectangle.right - rectangle.left === 1 && rectangle.bottom - rectangle.top === 1 ? "noopOperation" : "unsupportedBlock"
+		};
+		return {
+			type: "resolved",
+			operation: {
+				operation,
+				from: Math.min(startCell.cellPosition, endCellPosition),
+				to: Math.max(startCell.cellEndPosition, endCellEndPosition),
+				blockFrom,
+				blockTo,
+				blockNode,
+				tableCellMerge: {
+					tablePosition: startCell.tablePosition,
+					rectangle
+				}
+			}
+		};
+	}
+	if (operation.type === "splitTableCell") {
+		const cell = findEnclosingTableCell(doc, blockFrom);
+		if (!cell) return {
+			type: "skip",
+			reason: "unsupportedBlock"
+		};
+		const rectangle = {
+			left: cell.leftColumnIndex,
+			top: cell.topRowIndex,
+			right: cell.rightColumnIndex,
+			bottom: cell.bottomRowIndex
+		};
+		if (rectangle.right - rectangle.left === 1 && rectangle.bottom - rectangle.top === 1) return {
+			type: "skip",
+			reason: "noopOperation"
+		};
+		return {
+			type: "resolved",
+			operation: {
+				operation,
+				from: cell.cellPosition,
+				to: cell.cellEndPosition,
+				blockFrom,
+				blockTo,
+				blockNode,
+				tableCellSplit: {
+					tablePosition: cell.tablePosition,
+					rectangle
+				}
+			}
+		};
+	}
 	if (operation.type === "deleteBlock" || operation.type === "replaceBlock") {
 		const range = getTextRangeFromCleanBlock(cleanBlock);
 		if (!range) {