@stll/folio-core 0.52.0 → 0.53.0

package/dist/prosemirror/commands/resolveAllTableChanges.js

@@ -0,0 +1,615 @@
+import { restoreTableCellsWithParagraphPropertySources, transportTableCellsWithParagraphPropertySources } from "../../docx/paragraphPropertySource.js";
+import { isTableCellMergeRevisionContinuation, isTableCellMergeRevisionValue } from "../../docx/tableParser.js";
+import { expectTableAttrs, mergeTableAttrs } from "../attrs/index.js";
+import { nodePropertyRevisionSites, propertyRevisionRecords } from "../revisionCarriers.js";
+import { getTableCellMergeChange } from "../tableCellMergeRevision.js";
+import { isTableCellRetainedInReviewView } from "../tableCellRevisionVisibility.js";
+import { resolveAllNodePropertyChangeAttrs } from "./resolveNodePropertyChangeAttrs.js";
+import { createRestoredTableCell, hasMatchingCollapsedTableCellMerge, tableCellContinuationCells, tableCellContinuationFromNode, tableCellContinuationPayload } from "./tableCellMergeResolution.js";
+import { panic } from "better-result";
+import { TableMap } from "prosemirror-tables";
+import { StepMap } from "prosemirror-transform";
+//#region src/prosemirror/commands/resolveAllTableChanges.ts
+const indexedTableCells = (map) => {
+	const rectangles = /* @__PURE__ */ new Map();
+	for (let index = 0; index < map.map.length; index++) {
+		const position = map.map[index];
+		if (position === void 0 || rectangles.has(position)) continue;
+		const left = index % map.width;
+		const top = Math.floor(index / map.width);
+		let right = left + 1;
+		let bottom = top + 1;
+		while (right < map.width && map.map[index + right - left] === position) right++;
+		while (bottom < map.height && map.map[index + (bottom - top) * map.width] === position) bottom++;
+		rectangles.set(position, {
+			left,
+			top,
+			right,
+			bottom
+		});
+	}
+	return (position) => rectangles.get(position) ?? panic("Missing table resolution rectangle", { position });
+};
+const elementAt = (items, index) => {
+	const item = items.at(index);
+	return item === void 0 ? panic("Missing table resolution element", { index }) : item;
+};
+const tableResolutionMetadata = ({ sourceTable, table, rows, tableTouched }) => {
+	const changedParagraphRanges = [];
+	const paragraphOffsets = [];
+	const anchors = [];
+	const finalCellStarts = [];
+	if (tableTouched) changedParagraphRanges.push({
+		from: 0,
+		to: table.nodeSize
+	});
+	let rowStart = 1;
+	for (let rowIndex = 0; rowIndex < table.childCount; rowIndex++) {
+		const row = table.child(rowIndex);
+		const metadata = elementAt(rows, rowIndex);
+		if (!tableTouched && metadata.touched) changedParagraphRanges.push({
+			from: rowStart,
+			to: rowStart + row.nodeSize
+		});
+		let cellStart = rowStart + 1;
+		for (let cellIndex = 0; cellIndex < row.childCount; cellIndex++) {
+			const cell = row.child(cellIndex);
+			const cellMetadata = elementAt(metadata.cells, cellIndex);
+			finalCellStarts.push(cellStart);
+			if (cellMetadata.mapSourcePosition >= 0) anchors.push({
+				source: cellMetadata.mapSourcePosition + 1,
+				final: cellStart,
+				size: cell.nodeSize
+			});
+			if (!tableTouched && !metadata.touched && cellMetadata.touched) changedParagraphRanges.push({
+				from: cellStart,
+				to: cellStart + cell.nodeSize
+			});
+			if (cellMetadata.sourcePosition >= 0) {
+				const sourceCellPosition = cellMetadata.sourcePosition;
+				const finalCellPosition = cellStart;
+				cell.descendants((node, offset) => {
+					if (node.type.name === "table") return false;
+					if (node.type.name !== "paragraph") return true;
+					paragraphOffsets.push({
+						source: sourceCellPosition + 2 + offset,
+						final: finalCellPosition + 1 + offset
+					});
+					return false;
+				});
+			}
+			cellStart += cell.nodeSize;
+		}
+		rowStart += row.nodeSize;
+	}
+	const sourceCellStarts = [];
+	let sourceRowStart = 1;
+	for (let rowIndex = 0; rowIndex < sourceTable.childCount; rowIndex++) {
+		const row = sourceTable.child(rowIndex);
+		let cellStart = sourceRowStart + 1;
+		for (let cellIndex = 0; cellIndex < row.childCount; cellIndex++) {
+			sourceCellStarts.push(cellStart);
+			cellStart += row.child(cellIndex).nodeSize;
+		}
+		sourceRowStart += row.nodeSize;
+	}
+	const ranges = [];
+	let sourceCursor = 0;
+	let finalCursor = 0;
+	let sourceCellIndex = 0;
+	let finalCellIndex = 0;
+	for (const anchor of [...anchors, {
+		source: sourceTable.nodeSize,
+		final: table.nodeSize,
+		size: 0
+	}]) {
+		if (anchor.source < sourceCursor || anchor.final < finalCursor) continue;
+		while (sourceCellStarts.at(sourceCellIndex) !== void 0 && elementAt(sourceCellStarts, sourceCellIndex) < sourceCursor) sourceCellIndex++;
+		while (finalCellStarts.at(finalCellIndex) !== void 0 && elementAt(finalCellStarts, finalCellIndex) < finalCursor) finalCellIndex++;
+		const sourceGap = anchor.source - sourceCursor;
+		const finalGap = anchor.final - finalCursor;
+		const hasUnmatchedCell = (sourceCellStarts.at(sourceCellIndex) ?? Infinity) < anchor.source || (finalCellStarts.at(finalCellIndex) ?? Infinity) < anchor.final;
+		if (sourceGap !== finalGap || hasUnmatchedCell) ranges.push(sourceCursor, sourceGap, finalGap);
+		sourceCursor = anchor.source + anchor.size;
+		finalCursor = anchor.final + anchor.size;
+	}
+	return {
+		changedParagraphRanges,
+		paragraphOffsets,
+		positionMap: new StepMap(ranges)
+	};
+};
+const hasNodePropertyRevision = (node) => nodePropertyRevisionSites(node.type.name).some((site) => site.resolution === "node-attrs" && propertyRevisionRecords(node, site).length > 0);
+const rowRevisionKind = (row) => {
+	for (const kind of ["trIns", "trDel"]) {
+		const marker = row.attrs[kind];
+		if (typeof marker === "object" && marker !== null && "revisionId" in marker && typeof marker.revisionId === "number") return kind;
+	}
+	return null;
+};
+const cellRevisionMarker = (cell) => {
+	const marker = cell.attrs["cellMarker"];
+	if (typeof marker !== "object" || marker === null || !("kind" in marker) || marker.kind !== "ins" && marker.kind !== "del" && marker.kind !== "merge" || !("info" in marker) || typeof marker.info !== "object" || marker.info === null || !("revisionId" in marker.info) || typeof marker.info.revisionId !== "number") return null;
+	const verticalMergeOriginal = "verticalMergeOriginal" in marker && isTableCellMergeRevisionValue(marker.verticalMergeOriginal) ? marker.verticalMergeOriginal : void 0;
+	return {
+		kind: marker.kind,
+		info: { revisionId: marker.info.revisionId },
+		...verticalMergeOriginal ? { verticalMergeOriginal } : {}
+	};
+};
+/**
+* Resolve a table in one grid pass for row revisions and ordinary cell
+* membership revisions. The grid records each original cell rectangle once;
+* retaining rows reduces its rowspan, while a cell whose starting row is
+* removed moves to the next retained row inside that rectangle. This is the
+* same topology operation as prosemirror-tables' removeRow.
+*/
+const resolveAllTableChanges = ({ table, resolvedRows, mode }) => {
+	const sourceRows = resolvedRows ?? Array.from({ length: table.childCount }, (_, i) => table.child(i));
+	const tableWithResolvedChildren = table.type.create(table.attrs, sourceRows, table.marks);
+	const tablePropertyTouched = hasNodePropertyRevision(tableWithResolvedChildren);
+	const rowPropertyTouched = sourceRows.map(hasNodePropertyRevision);
+	const propertyResolvedTable = resolveTablePropertyAttrs(tableWithResolvedChildren, mode);
+	const rows = Array.from({ length: propertyResolvedTable.childCount }, (_, i) => propertyResolvedTable.child(i));
+	const rowKinds = rows.map(rowRevisionKind);
+	const keepRows = rowKinds.map((kind) => kind === null || kind === "trIns" === (mode === "accept"));
+	const hasRowRevision = rowKinds.some((kind) => kind !== null);
+	const hasMerge = rows.some((row) => {
+		for (let i = 0; i < row.childCount; i++) {
+			const cell = row.child(i);
+			if (cellRevisionMarker(cell)?.kind === "merge" || hasMatchingCollapsedTableCellMerge(cell, null)) return true;
+		}
+		return false;
+	});
+	const map = TableMap.get(propertyResolvedTable);
+	const cellRectangle = indexedTableCells(map);
+	const cells = [];
+	let rowOffset = 0;
+	let hasCellRevision = false;
+	for (let rowIndex = 0; rowIndex < rows.length; rowIndex++) {
+		const row = elementAt(rows, rowIndex);
+		let cellOffset = rowOffset + 1;
+		for (let cellIndex = 0; cellIndex < row.childCount; cellIndex++) {
+			const cell = row.child(cellIndex);
+			const rectangle = cellRectangle(cellOffset);
+			const marker = cellRevisionMarker(cell);
+			if ((marker?.kind === "ins" || marker?.kind === "del" ? marker : null) !== null) hasCellRevision = true;
+			cells.push({
+				node: cell,
+				left: rectangle.left,
+				originRow: rowIndex,
+				bottom: rectangle.bottom,
+				sourcePosition: cellOffset,
+				mapSourcePosition: cellOffset,
+				touched: hasNodePropertyRevision(elementAt(sourceRows, rowIndex).child(cellIndex))
+			});
+			cellOffset += cell.nodeSize;
+		}
+		rowOffset += row.nodeSize;
+	}
+	if (!keepRows.some(Boolean)) return {
+		node: null,
+		changed: true,
+		structural: hasRowRevision || hasCellRevision,
+		failed: false,
+		changedParagraphRanges: [],
+		paragraphOffsets: [],
+		positionMap: new StepMap([
+			0,
+			tableWithResolvedChildren.nodeSize,
+			0
+		])
+	};
+	const keptBefore = [0];
+	for (const keep of keepRows) keptBefore.push((keptBefore.at(-1) ?? 0) + Number(keep));
+	const nextKeptRow = rows.map(() => rows.length);
+	let next = rows.length;
+	for (let index = rows.length - 1; index >= 0; index--) {
+		if (elementAt(keepRows, index)) next = index;
+		nextKeptRow[index] = next;
+	}
+	const placements = rows.map(() => []);
+	for (const cell of cells) {
+		const destination = elementAt(nextKeptRow, cell.originRow);
+		if (destination >= cell.bottom) continue;
+		const rowspan = elementAt(keptBefore, cell.bottom) - elementAt(keptBefore, destination);
+		elementAt(placements, destination)[cell.left] = {
+			...cell,
+			mapSourcePosition: destination === cell.originRow ? cell.mapSourcePosition : -1,
+			touched: cell.touched || rowspan !== cell.node.attrs["rowspan"],
+			node: rowspan === cell.node.attrs["rowspan"] ? cell.node : cell.node.type.create({
+				...cell.node.attrs,
+				rowspan
+			}, cell.node.content, cell.node.marks)
+		};
+	}
+	const nextRows = [];
+	const rowMetadata = [];
+	for (let index = 0; index < rows.length; index++) {
+		if (!elementAt(keepRows, index)) continue;
+		const row = elementAt(rows, index);
+		const rowCells = elementAt(placements, index).flatMap((placement) => placement === void 0 ? [] : [placement.node]);
+		const kind = elementAt(rowKinds, index);
+		const attrs = kind ? {
+			...row.attrs,
+			[kind]: null
+		} : row.attrs;
+		nextRows.push(row.type.create(attrs, rowCells, row.marks));
+		rowMetadata.push({
+			touched: elementAt(rowPropertyTouched, index) || kind !== null,
+			cells: elementAt(placements, index).flatMap((placement) => placement === void 0 ? [] : [placement])
+		});
+	}
+	const nextTable = propertyResolvedTable.type.create(propertyResolvedTable.attrs, nextRows, propertyResolvedTable.marks);
+	if (hasMerge || hasCellRevision) return resolvePureTableMerges({
+		table: nextTable,
+		mode,
+		rowMetadata,
+		tablePropertyTouched,
+		sourceTable: tableWithResolvedChildren
+	});
+	const structural = hasRowRevision || hasCellRevision || hasTablePropertyRevision(tableWithResolvedChildren);
+	return {
+		node: nextTable,
+		changed: structural || !nextTable.eq(table),
+		structural,
+		failed: false,
+		...tableResolutionMetadata({
+			table: nextTable,
+			rows: rowMetadata,
+			tableTouched: tablePropertyTouched,
+			sourceTable: tableWithResolvedChildren
+		})
+	};
+};
+const resolveTablePropertyAttrs = (table, mode) => {
+	const rows = [];
+	for (let rowIndex = 0; rowIndex < table.childCount; rowIndex++) {
+		const row = table.child(rowIndex);
+		const cells = [];
+		for (let cellIndex = 0; cellIndex < row.childCount; cellIndex++) cells.push(resolveAllNodePropertyChangeAttrs(row.child(cellIndex), mode));
+		rows.push(resolveAllNodePropertyChangeAttrs(row.type.create(row.attrs, cells, row.marks), mode));
+	}
+	return resolveAllNodePropertyChangeAttrs(table.type.create(table.attrs, rows, table.marks), mode);
+};
+const hasTablePropertyRevision = (table) => {
+	if (table.attrs["tblPrChange"] != null) return true;
+	for (let rowIndex = 0; rowIndex < table.childCount; rowIndex++) {
+		const row = table.child(rowIndex);
+		if (row.attrs["trPrChange"] != null || row.attrs["tblPrExChange"] != null) return true;
+		for (let cellIndex = 0; cellIndex < row.childCount; cellIndex++) if (row.child(cellIndex).attrs["tcPrChange"] != null) return true;
+	}
+	return false;
+};
+const appendContinuation = (sequence, cell) => {
+	const link = {
+		cell,
+		next: null
+	};
+	if (sequence.tail) sequence.tail.next = link;
+	else sequence.head = link;
+	sequence.tail = link;
+};
+const continuationSequence = (cells) => {
+	const sequence = {
+		head: null,
+		tail: null
+	};
+	for (const cell of cells) appendContinuation(sequence, cell);
+	return sequence;
+};
+const appendContinuationSequence = (destination, source) => {
+	if (!source.head) return;
+	if (destination.tail) destination.tail.next = source.head;
+	else destination.head = source.head;
+	destination.tail = source.tail;
+};
+const materializeContinuation = (entry) => {
+	if (!entry.continuation) return;
+	const cells = [];
+	for (let link = entry.continuation.head; link !== null; link = link.next) cells.push(link.cell);
+	entry.node = entry.node.type.create({
+		...entry.node.attrs,
+		_docxVMergeContinuationCells: transportTableCellsWithParagraphPropertySources(cells)
+	}, entry.node.content, entry.node.marks);
+	entry.continuation = null;
+};
+const failedTableResolution = (table) => ({
+	node: table,
+	changed: false,
+	structural: false,
+	failed: true,
+	changedParagraphRanges: [],
+	paragraphOffsets: [],
+	positionMap: StepMap.empty
+});
+/** Replay width deletions by live column rank without shifting the remaining array. */
+const compactColumnWidths = (widths, removals) => {
+	if (removals.length === 0) return [...widths];
+	const length = widths.length;
+	const tree = new Int32Array(length + 1);
+	const removed = new Uint8Array(length);
+	for (let index = 1; index <= length; index++) tree[index] = index & -index;
+	let highestBit = 1;
+	while (highestBit * 2 <= length) highestBit *= 2;
+	let remaining = length;
+	for (const { left, count } of removals) {
+		const start = Math.min(left, remaining);
+		const removedCount = Math.min(count, remaining - start);
+		for (let deleted = 0; deleted < removedCount; deleted++) {
+			let rank = start + 1;
+			let originalIndex = 0;
+			for (let bit = highestBit; bit > 0; bit >>= 1) {
+				const next = originalIndex + bit;
+				if (next <= length && (tree[next] ?? 0) < rank) {
+					originalIndex = next;
+					rank -= tree[next] ?? 0;
+				}
+			}
+			removed[originalIndex] = 1;
+			for (let index = originalIndex + 1; index <= length; index += index & -index) tree[index] = (tree[index] ?? 0) - 1;
+			remaining--;
+		}
+	}
+	return widths.filter((_width, index) => removed[index] === 0);
+};
+/** Resolve all cell edits in reverse order against one grid and mutable slots. */
+const resolvePureTableMerges = ({ table, mode, rowMetadata, tablePropertyTouched, sourceTable }) => {
+	const map = TableMap.get(table);
+	const cellRectangle = indexedTableCells(map);
+	const rows = Array.from({ length: table.childCount }, (_, index) => table.child(index));
+	const rowCells = rows.map(() => /* @__PURE__ */ new Map());
+	const rowOccupancy = rows.map(() => 0);
+	const activeRows = rows.map(() => true);
+	const widthCounts = /* @__PURE__ */ new Map();
+	const authoredWidths = expectTableAttrs(table).columnWidths;
+	const columnWidths = authoredWidths?.length === map.width ? [...authoredWidths] : void 0;
+	const widthRemovals = [];
+	let currentWidth = map.width;
+	let removedCell = false;
+	const deletedRows = /* @__PURE__ */ new Set();
+	const byPosition = /* @__PURE__ */ new Map();
+	const ordered = [];
+	let rowOffset = 0;
+	for (let rowIndex = 0; rowIndex < rows.length; rowIndex++) {
+		const row = elementAt(rows, rowIndex);
+		let cellOffset = rowOffset + 1;
+		for (let cellIndex = 0; cellIndex < row.childCount; cellIndex++) {
+			const node = row.child(cellIndex);
+			const rectangle = cellRectangle(cellOffset);
+			const left = rectangle.left;
+			for (let coveredRow = rectangle.top; coveredRow < rectangle.bottom; coveredRow++) rowOccupancy[coveredRow] = elementAt(rowOccupancy, coveredRow) + (rectangle.right - rectangle.left);
+			const initial = elementAt(elementAt(rowMetadata, rowIndex).cells, cellIndex);
+			const entry = {
+				node,
+				position: cellOffset,
+				left,
+				row: rowIndex,
+				sourcePosition: initial.sourcePosition,
+				mapSourcePosition: initial.mapSourcePosition,
+				touched: initial.touched,
+				continuation: null
+			};
+			elementAt(rowCells, rowIndex).set(left, entry);
+			byPosition.set(cellOffset, entry);
+			ordered.push(entry);
+			cellOffset += node.nodeSize;
+		}
+		rowOffset += row.nodeSize;
+	}
+	for (const width of rowOccupancy) widthCounts.set(width, (widthCounts.get(width) ?? 0) + 1);
+	const changeRowWidth = (rowIndex, nextWidth) => {
+		if (!elementAt(activeRows, rowIndex)) return;
+		const previous = elementAt(rowOccupancy, rowIndex);
+		widthCounts.set(previous, (widthCounts.get(previous) ?? 0) - 1);
+		rowOccupancy[rowIndex] = nextWidth;
+		widthCounts.set(nextWidth, (widthCounts.get(nextWidth) ?? 0) + 1);
+	};
+	for (let index = ordered.length - 1; index >= 0; index--) {
+		const entry = elementAt(ordered, index);
+		const marker = cellRevisionMarker(entry.node);
+		if (marker && marker.kind !== "merge") {
+			const view = mode === "accept" ? "final" : "original";
+			if (isTableCellRetainedInReviewView(marker.kind, view)) {
+				entry.touched = true;
+				entry.node = entry.node.type.create({
+					...entry.node.attrs,
+					cellMarker: null
+				}, entry.node.content, entry.node.marks);
+			} else {
+				removedCell = true;
+				const previousWidth = currentWidth;
+				const rectangle = cellRectangle(entry.position);
+				const colspan = rectangle.right - rectangle.left;
+				for (let coveredRow = rectangle.top; coveredRow < rectangle.bottom; coveredRow++) changeRowWidth(coveredRow, elementAt(rowOccupancy, coveredRow) - colspan);
+				elementAt(rowCells, entry.row).delete(entry.left);
+				if (elementAt(rowCells, entry.row).size === 0) {
+					deletedRows.add(entry.row);
+					activeRows[entry.row] = false;
+					const rowWidth = elementAt(rowOccupancy, entry.row);
+					widthCounts.set(rowWidth, (widthCounts.get(rowWidth) ?? 0) - 1);
+				}
+				while (currentWidth > 0 && (widthCounts.get(currentWidth) ?? 0) === 0) currentWidth--;
+				if (columnWidths && currentWidth < previousWidth) widthRemovals.push({
+					left: entry.left,
+					count: previousWidth - currentWidth
+				});
+			}
+		} else if (marker?.kind === "merge") if (mode === "accept") {
+			entry.touched = true;
+			entry.node = entry.node.type.create({
+				...entry.node.attrs,
+				cellMarker: null
+			}, entry.node.content, entry.node.marks);
+		} else if (!isTableCellMergeRevisionContinuation(marker.verticalMergeOriginal)) {
+			entry.touched = true;
+			const original = entry.node.attrs["_originalFormatting"];
+			let formatting = original;
+			if (typeof original === "object" && original !== null) {
+				const copy = { ...original };
+				delete copy["vMerge"];
+				formatting = copy;
+			}
+			entry.node = entry.node.type.create({
+				...entry.node.attrs,
+				cellMarker: null,
+				_originalFormatting: formatting
+			}, entry.node.content, entry.node.marks);
+		} else {
+			const rectangle = cellRectangle(entry.position);
+			if (rectangle.top === 0) return failedTableResolution(table);
+			const abovePosition = map.map[(rectangle.top - 1) * map.width + rectangle.left];
+			if (abovePosition === void 0) return failedTableResolution(table);
+			const aboveRectangle = cellRectangle(abovePosition);
+			const above = byPosition.get(abovePosition);
+			if (!above || !elementAt(rowCells, above.row).has(above.left) || aboveRectangle.left !== rectangle.left || aboveRectangle.right !== rectangle.right || aboveRectangle.bottom !== rectangle.top) return failedTableResolution(table);
+			const aboveRowspan = above.node.attrs["rowspan"];
+			const cellRowspan = entry.node.attrs["rowspan"];
+			if (typeof aboveRowspan !== "number" || typeof cellRowspan !== "number" || aboveRowspan < 1 || cellRowspan < 1) return failedTableResolution(table);
+			above.continuation ??= continuationSequence(tableCellContinuationCells(above.node, aboveRowspan));
+			appendContinuation(above.continuation, tableCellContinuationFromNode(entry.node));
+			const nested = entry.continuation ?? continuationSequence(tableCellContinuationPayload(entry.node)?.cells ?? []);
+			appendContinuationSequence(above.continuation, nested);
+			above.node = above.node.type.create({
+				...above.node.attrs,
+				rowspan: aboveRowspan + cellRowspan
+			}, above.node.content, above.node.marks);
+			elementAt(rowCells, entry.row).delete(entry.left);
+		}
+		if (!elementAt(rowCells, entry.row).has(entry.left)) continue;
+		if (!tableCellContinuationPayload(entry.node)?.cells.some((cell) => getTableCellMergeChange(cell) !== null)) continue;
+		materializeContinuation(entry);
+		const payload = tableCellContinuationPayload(entry.node);
+		if (!payload) return failedTableResolution(table);
+		const stored = payload.cells;
+		const splitIndices = [];
+		let matched = false;
+		const nextCells = stored.map((source, sourceIndex) => {
+			const change = getTableCellMergeChange(source);
+			if (!change) return source;
+			matched = true;
+			if (mode === "reject" && isTableCellMergeRevisionContinuation(change.verticalMerge) && !isTableCellMergeRevisionContinuation(change.verticalMergeOriginal)) splitIndices.push(sourceIndex);
+			const cleaned = { ...source };
+			delete cleaned.structuralChange;
+			return cleaned;
+		});
+		if (!matched) continue;
+		if (mode === "accept" || splitIndices.length === 0) {
+			entry.touched = true;
+			entry.node = entry.node.type.create({
+				...entry.node.attrs,
+				_docxVMergeContinuationCells: nextCells
+			}, entry.node.content, entry.node.marks);
+			continue;
+		}
+		const firstSplitIndex = splitIndices.at(0);
+		if (firstSplitIndex === void 0 || splitIndices.length !== stored.length - firstSplitIndex || splitIndices.some((splitIndex, offset) => splitIndex !== firstSplitIndex + offset)) return failedTableResolution(table);
+		const rectangle = cellRectangle(entry.position);
+		const rowspan = entry.node.attrs["rowspan"];
+		if (typeof rowspan !== "number" || rowspan !== stored.length + 1 || rectangle.bottom - rectangle.top !== rowspan) return failedTableResolution(table);
+		const restored = restoreTableCellsWithParagraphPropertySources(payload);
+		for (const splitIndex of splitIndices) {
+			const source = restored[splitIndex];
+			const restoredCell = source && createRestoredTableCell(entry.node, source);
+			const rowIndex = rectangle.top + splitIndex + 1;
+			if (!restoredCell || elementAt(rowCells, rowIndex).has(rectangle.left)) return failedTableResolution(table);
+			elementAt(rowCells, rowIndex).set(rectangle.left, {
+				node: restoredCell,
+				position: -1,
+				left: rectangle.left,
+				row: rowIndex,
+				sourcePosition: -1,
+				mapSourcePosition: -1,
+				touched: true,
+				continuation: null
+			});
+		}
+		const remaining = nextCells.slice(0, firstSplitIndex);
+		entry.node = entry.node.type.create({
+			...entry.node.attrs,
+			rowspan: firstSplitIndex + 1,
+			_docxVMergeContinuationCells: remaining.length > 0 ? remaining : null
+		}, entry.node.content, entry.node.marks);
+	}
+	if (deletedRows.size === rows.length) return {
+		node: null,
+		changed: true,
+		structural: true,
+		failed: false,
+		changedParagraphRanges: [],
+		paragraphOffsets: [],
+		positionMap: new StepMap([
+			0,
+			sourceTable.nodeSize,
+			0
+		])
+	};
+	const keptBefore = [0];
+	for (let rowIndex = 0; rowIndex < rows.length; rowIndex++) keptBefore.push((keptBefore.at(-1) ?? 0) + Number(!deletedRows.has(rowIndex)));
+	const compacted = rows.map(() => /* @__PURE__ */ new Map());
+	for (let rowIndex = 0; rowIndex < rows.length; rowIndex++) for (const entry of elementAt(rowCells, rowIndex).values()) {
+		materializeContinuation(entry);
+		const originalRowspan = entry.node.attrs["rowspan"];
+		if (typeof originalRowspan !== "number") continue;
+		const bottom = Math.min(rowIndex + originalRowspan, rows.length);
+		let destination = rowIndex;
+		while (destination < bottom && deletedRows.has(destination)) destination++;
+		if (destination === bottom) continue;
+		const rowspan = elementAt(keptBefore, bottom) - elementAt(keptBefore, destination);
+		const node = rowspan === originalRowspan ? entry.node : entry.node.type.create({
+			...entry.node.attrs,
+			rowspan
+		}, entry.node.content, entry.node.marks);
+		elementAt(compacted, destination).set(entry.left, {
+			...entry,
+			node,
+			row: destination,
+			touched: entry.touched || rowspan !== originalRowspan
+		});
+	}
+	const nextRowMetadata = [];
+	const nextRows = rows.flatMap((row, rowIndex) => {
+		if (deletedRows.has(rowIndex)) return [];
+		const cells = [];
+		const cellMetadata = [];
+		for (let column = 0; column < map.width; column++) {
+			const entry = elementAt(compacted, rowIndex).get(column);
+			if (entry) {
+				cells.push(entry.node);
+				cellMetadata.push(entry);
+			}
+		}
+		nextRowMetadata.push({
+			touched: elementAt(rowMetadata, rowIndex).touched,
+			cells: cellMetadata
+		});
+		return [row.type.create(row.attrs, cells, row.marks)];
+	});
+	let nextTable = table.type.create(table.attrs, nextRows, table.marks);
+	const nextWidth = TableMap.get(nextTable).width;
+	const gridChanged = removedCell && nextWidth < map.width;
+	if (gridChanged) {
+		const survivingColumnWidths = columnWidths === void 0 ? void 0 : compactColumnWidths(columnWidths, widthRemovals);
+		const formatting = expectTableAttrs(nextTable)._originalFormatting;
+		const originalFormatting = formatting ? { ...formatting } : void 0;
+		if (originalFormatting) delete originalFormatting.gridSourceXml;
+		nextTable = nextTable.type.create(mergeTableAttrs(nextTable, {
+			columnWidths: survivingColumnWidths?.length === nextWidth ? survivingColumnWidths : void 0,
+			_originalFormatting: originalFormatting
+		}), nextTable.content, nextTable.marks);
+	}
+	return {
+		node: nextTable,
+		changed: true,
+		structural: true,
+		failed: false,
+		...tableResolutionMetadata({
+			table: nextTable,
+			rows: nextRowMetadata,
+			tableTouched: tablePropertyTouched || gridChanged,
+			sourceTable
+		})
+	};
+};
+//#endregion
+export { resolveAllTableChanges };

package/dist/prosemirror/commands/resolveNodePropertyChangeAttrs.d.ts

@@ -0,0 +1,15 @@
+import { NodeAttrsPropertyRevisionSite } from "../revisionCarriers.js";
+import { Node } from "prosemirror-model";
+//#region src/prosemirror/commands/resolveNodePropertyChangeAttrs.d.ts
+/** Resolve one property-change site without a transaction. */
+type ResolveNodePropertyChangeAttrsOptions = {
+  node: Node;
+  site: NodeAttrsPropertyRevisionSite;
+  mode: "accept" | "reject";
+  revisionSet: ReadonlySet<number> | null;
+};
+declare const resolveNodePropertyChangeAttrs: ({ node, site, mode, revisionSet }: ResolveNodePropertyChangeAttrsOptions) => Record<string, unknown> | null;
+/** Resolve every node-attr site, including both independent sites on a row. */
+declare const resolveAllNodePropertyChangeAttrs: (node: Node, mode: "accept" | "reject") => Node;
+//#endregion
+export { resolveAllNodePropertyChangeAttrs, resolveNodePropertyChangeAttrs };

package/dist/prosemirror/commands/resolveNodePropertyChangeAttrs.js

@@ -0,0 +1,46 @@
+import { nodePropertyRevisionSites, propertyRevisionMetadata, propertyRevisionRecords } from "../revisionCarriers.js";
+import { tableCellRejectAttrPatch, tablePropertyExceptionsRejectAttrPatch, tableRejectAttrPatch, tableRowRejectAttrPatch } from "./propertyChangeScope.js";
+//#region src/prosemirror/commands/resolveNodePropertyChangeAttrs.ts
+/** The old property set each node-attr revision restores on rejection. */
+const NODE_ATTRS_REJECT_PATCHES = {
+	tablePropertyChange: (previousFormatting) => tableRejectAttrPatch(previousFormatting),
+	tablePropertyExceptionChange: (previousFormatting) => tablePropertyExceptionsRejectAttrPatch(previousFormatting),
+	tableRowPropertyChange: (previousFormatting) => tableRowRejectAttrPatch(previousFormatting),
+	tableCellPropertyChange: (previousFormatting, node) => tableCellRejectAttrPatch(previousFormatting, node.attrs["_originalFormatting"])
+};
+const resolveNodePropertyChangeAttrs = ({ node, site, mode, revisionSet }) => {
+	const changes = propertyRevisionRecords(node, site);
+	if (changes.length === 0) return null;
+	const matches = changes.filter((change) => {
+		const metadata = propertyRevisionMetadata(change.info);
+		return revisionSet === null || metadata !== null && revisionSet.has(metadata.id);
+	});
+	if (matches.length === 0) return null;
+	const remaining = revisionSet === null ? [] : changes.filter((change) => !matches.includes(change));
+	const nextAttrs = {
+		...node.attrs,
+		[site.attr]: remaining.length > 0 ? remaining : null
+	};
+	if (mode === "reject") {
+		const rejectPatch = NODE_ATTRS_REJECT_PATCHES[site.kind];
+		for (const change of matches.toReversed()) Object.assign(nextAttrs, rejectPatch(change.previousFormatting, node));
+	}
+	return nextAttrs;
+};
+/** Resolve every node-attr site, including both independent sites on a row. */
+const resolveAllNodePropertyChangeAttrs = (node, mode) => {
+	let current = node;
+	for (const site of nodePropertyRevisionSites(node.type.name)) {
+		if (site.resolution !== "node-attrs") continue;
+		const attrs = resolveNodePropertyChangeAttrs({
+			node: current,
+			site,
+			mode,
+			revisionSet: null
+		});
+		if (attrs !== null) current = current.type.create(attrs, current.content, current.marks);
+	}
+	return current;
+};
+//#endregion
+export { resolveAllNodePropertyChangeAttrs, resolveNodePropertyChangeAttrs };