@stll/folio-core 0.10.0 → 0.12.0

package/dist/prosemirror/commands/comments.js

@@ -1,4 +1,10 @@
+import { expectRunPropertyChangeMarkAttrs } from "../attrs/index.js";
+import { markStructuralChange } from "../extensions/features/ParagraphChangeTrackerExtension.js";
 import { paragraphRejectAttrPatch, paragraphRejectOriginalFormatting, sectionRejectProperties, tableCellRejectAttrPatch, tableRejectAttrPatch, tableRowRejectAttrPatch } from "./propertyChangeScope.js";
+import { textFormattingToMarks } from "../conversion/toProseDoc.js";
+import { getTableCellMergeChange } from "../tableCellMergeRevision.js";
+import { hasMatchingCollapsedTableCellMerge, resolveCollapsedTableCellMerge, resolveVisibleTableCellMerge } from "./tableCellMergeResolution.js";
+import { TableMap, removeRow } from "prosemirror-tables";
 //#region src/prosemirror/commands/comments.ts
 /**
 * Add a comment mark to the current selection.
@@ -36,18 +42,18 @@ function removeCommentMark(commentId) {
 * Resolve a tracked change: accept or reject.
 * - Accept: keep insertions (remove mark), delete deletions (remove text)
 * - Reject: keep deletions (remove mark), delete insertions (remove text)
+* - Run formatting: accept the current formatting, or restore the previous formatting
 *
 * Pass `revisionId` to scope the operation to one specific
 * revision — otherwise overlapping marks for other revisions get
 * processed too, silently consuming pending work. Without an id
-* the operation matches every insertion/deletion mark in the
+* the operation matches every revision mark or property-change entry in the
 * range (the bulk accept-all/reject-all path).
 */
 function resolveChange(from, to, mode, revisionIds) {
 	return (state, dispatch) => {
 		const insertionType = state.schema.marks["insertion"];
 		const deletionType = state.schema.marks["deletion"];
-		if (!insertionType && !deletionType) return false;
 		const keepType = mode === "accept" ? insertionType : deletionType;
 		const removeType = mode === "accept" ? deletionType : insertionType;
 		const revisionSet = revisionIds === void 0 ? null : new Set(revisionIds);
@@ -56,6 +62,8 @@ function resolveChange(from, to, mode, revisionIds) {
 			const tr = state.tr;
 			const deleteRanges = [];
 			const pPrMarkOps = [];
+			const tableRowStructuralOps = [];
+			const tableCellStructuralOps = [];
 			state.doc.nodesBetween(from, to, (node, pos) => {
 				if (node.type.name === "paragraph") {
 					const op = collectPPrMarkOp(node, pos, from, to, mode, revisionSet);
@@ -95,6 +103,11 @@ function resolveChange(from, to, mode, revisionIds) {
 					if (nextAttrs) tr.setNodeMarkup(pos, void 0, nextAttrs);
 					return true;
 				}
+				if (node.type.name === "tableRow" && rangeCoversNode(from, to, pos, node)) {
+					const op = collectTableRowStructuralOp(node, pos, mode, revisionSet);
+					if (op) tableRowStructuralOps.push(op);
+				}
+				if ((node.type.name === "tableCell" || node.type.name === "tableHeader") && rangeCoversNode(from, to, pos, node)) tableCellStructuralOps.push(...collectTableCellStructuralOps(node, pos, mode, revisionSet));
 				const tableChangeAttrName = TABLE_PROPERTY_CHANGE_ATTR_BY_NODE[node.type.name];
 				if (tableChangeAttrName !== void 0) {
 					if (rangeCoversNode(from, to, pos, node)) {
@@ -107,6 +120,16 @@ function resolveChange(from, to, mode, revisionIds) {
 				const nodeEnd = pos + node.nodeSize;
 				const rangeFrom = Math.max(from, pos);
 				const rangeTo = Math.min(to, nodeEnd);
+				const runPropertyChangeMark = node.marks.find((mark) => mark.type.name === "runPropertyChange");
+				if (runPropertyChangeMark) resolveRunPropertyChange({
+					tr,
+					node,
+					from: rangeFrom,
+					to: rangeTo,
+					mark: runPropertyChangeMark,
+					mode,
+					revisionSet
+				});
 				if (removeType && node.marks.some((m) => m.type === removeType && matchesRevision(m))) deleteRanges.push({
 					from: rangeFrom,
 					to: rangeTo
@@ -131,11 +154,189 @@ function resolveChange(from, to, mode, revisionIds) {
 					tr.setNodeAttribute(mappedPos, "pPrMark", null);
 				} catch {}
 			}
+			tableRowStructuralOps.sort((left, right) => right.rowPos - left.rowPos);
+			let resolvedTableRowStructure = false;
+			for (const op of tableRowStructuralOps) {
+				const mappedPos = tr.mapping.map(op.rowPos);
+				const row = tr.doc.nodeAt(mappedPos);
+				if (!row || row.type.name !== "tableRow") continue;
+				if (op.action === "clear") {
+					tr.setNodeAttribute(mappedPos, op.attrName, null);
+					resolvedTableRowStructure = true;
+					continue;
+				}
+				deleteTableRowAt(tr, mappedPos);
+				resolvedTableRowStructure = true;
+			}
+			if (resolvedTableRowStructure) markStructuralChange(tr);
+			tableCellStructuralOps.sort((left, right) => right.cellPos - left.cellPos);
+			let resolvedTableCellStructure = false;
+			let failedTableCellMergeResolution = false;
+			for (const op of tableCellStructuralOps) {
+				const mappedPos = tr.mapping.map(op.cellPos);
+				const cell = tr.doc.nodeAt(mappedPos);
+				if (!cell || cell.type.name !== "tableCell" && cell.type.name !== "tableHeader") continue;
+				if (op.type === "merge") {
+					const resolved = op.source === "collapsed" ? resolveCollapsedTableCellMerge(tr, mappedPos, op.mode, op.revisionSet) : resolveVisibleTableCellMerge(tr, mappedPos, op.mode);
+					if (!resolved) {
+						failedTableCellMergeResolution = true;
+						break;
+					}
+					resolvedTableCellStructure ||= resolved;
+					continue;
+				}
+				if (op.action === "clear") {
+					tr.setNodeAttribute(mappedPos, "cellMarker", null);
+					resolvedTableCellStructure = true;
+					continue;
+				}
+				deleteTableCellAt(tr, mappedPos);
+				resolvedTableCellStructure = true;
+			}
+			if (failedTableCellMergeResolution) return false;
+			if (resolvedTableCellStructure) markStructuralChange(tr);
 			if (tr.steps.length > 0) dispatch(tr);
 		}
 		return true;
 	};
 }
+const RUN_FORMATTING_MARK_NAMES = /* @__PURE__ */ new Set([
+	"bold",
+	"italic",
+	"underline",
+	"strike",
+	"textColor",
+	"highlight",
+	"runShading",
+	"fontSize",
+	"fontFamily",
+	"language",
+	"superscript",
+	"subscript",
+	"allCaps",
+	"smallCaps",
+	"characterSpacing",
+	"emboss",
+	"imprint",
+	"hidden",
+	"textShadow",
+	"emphasisMark",
+	"textOutline",
+	"rtl",
+	"textEffect",
+	"runFormattingOverride",
+	"characterStyle"
+]);
+const resolveRunPropertyChange = ({ tr, node, from, to, mark, mode, revisionSet }) => {
+	const { changes } = expectRunPropertyChangeMarkAttrs(mark);
+	const matches = changes.filter((change) => revisionSet === null || revisionSet.has(change.info.id));
+	if (matches.length === 0) return;
+	tr.removeMark(from, to, mark);
+	const remaining = changes.filter((change) => revisionSet !== null && !revisionSet.has(change.info.id));
+	if (remaining.length > 0) tr.addMark(from, to, mark.type.create({ changes: remaining }));
+	if (mode === "accept") return;
+	const previousFormatting = matches.at(0)?.previousFormatting;
+	for (const currentMark of node.marks) if (RUN_FORMATTING_MARK_NAMES.has(currentMark.type.name)) tr.removeMark(from, to, currentMark.type);
+	for (const previousMark of textFormattingToMarks(previousFormatting)) tr.addMark(from, to, previousMark);
+	if (previousFormatting?.styleId) {
+		const characterStyle = node.type.schema.marks["characterStyle"];
+		if (characterStyle) tr.addMark(from, to, characterStyle.create({
+			styleId: previousFormatting.styleId,
+			_styleRPr: null
+		}));
+	}
+};
+function collectTableRowStructuralOp(node, rowPos, mode, revisionSet) {
+	for (const attrName of ["trIns", "trDel"]) {
+		const marker = node.attrs[attrName];
+		if (!isTableRowRevisionAttr(marker)) continue;
+		if (revisionSet !== null && !revisionSet.has(marker.revisionId)) continue;
+		return {
+			rowPos,
+			attrName,
+			action: attrName === "trIns" === (mode === "accept") ? "clear" : "remove"
+		};
+	}
+	return null;
+}
+function isTableRowRevisionAttr(value) {
+	return typeof value === "object" && value !== null && "revisionId" in value && typeof value.revisionId === "number";
+}
+function collectTableCellStructuralOps(node, cellPos, mode, revisionSet) {
+	const operations = [];
+	const marker = node.attrs["cellMarker"];
+	if (isTableCellRevisionAttr(marker) && (revisionSet === null || revisionSet.has(marker.info.revisionId))) if (marker.kind === "merge") operations.push({
+		type: "merge",
+		cellPos,
+		source: "visible",
+		mode,
+		revisionSet
+	});
+	else {
+		const keepsCell = marker.kind === "ins" === (mode === "accept");
+		operations.push({
+			type: "membership",
+			cellPos,
+			action: keepsCell ? "clear" : "remove"
+		});
+	}
+	if (hasMatchingCollapsedTableCellMerge(node, revisionSet)) operations.push({
+		type: "merge",
+		cellPos,
+		source: "collapsed",
+		mode,
+		revisionSet
+	});
+	return operations;
+}
+function isTableCellRevisionAttr(value) {
+	if (typeof value !== "object" || value === null || !("kind" in value) || !("info" in value)) return false;
+	if (value.kind !== "ins" && value.kind !== "del" && value.kind !== "merge") return false;
+	const info = value.info;
+	return typeof info === "object" && info !== null && "revisionId" in info && typeof info.revisionId === "number";
+}
+function deleteTableCellAt(tr, cellPos) {
+	const cell = tr.doc.nodeAt(cellPos);
+	if (!cell || cell.type.name !== "tableCell" && cell.type.name !== "tableHeader") return;
+	const resolved = tr.doc.resolve(cellPos);
+	const row = resolved.parent;
+	if (row.type.spec["tableRole"] !== "row") return;
+	if (row.childCount > 1) {
+		tr.delete(cellPos, cellPos + cell.nodeSize);
+		return;
+	}
+	deleteTableRowAt(tr, resolved.start() - 1);
+}
+function deleteTableRowAt(tr, rowPos) {
+	const resolved = tr.doc.resolve(rowPos);
+	const table = resolved.parent;
+	if (table.type.spec["tableRole"] !== "table") return;
+	const rowIndex = resolved.index();
+	if (table.childCount > 1) {
+		const map = TableMap.get(table);
+		removeRow(tr, {
+			map,
+			table,
+			tableStart: resolved.start(),
+			left: 0,
+			top: rowIndex,
+			right: map.width,
+			bottom: rowIndex + 1
+		}, rowIndex);
+		return;
+	}
+	const tablePosition = resolved.start() - 1;
+	const tableEnd = tablePosition + table.nodeSize;
+	const outerResolved = tr.doc.resolve(tablePosition);
+	const parent = outerResolved.parent;
+	const tableIndex = outerResolved.index();
+	if (parent.canReplace(tableIndex, tableIndex + 1)) {
+		tr.delete(tablePosition, tableEnd);
+		return;
+	}
+	const emptyParagraph = tr.doc.type.schema.nodes["paragraph"]?.createAndFill();
+	if (emptyParagraph && parent.canReplaceWith(tableIndex, tableIndex + 1, emptyParagraph.type, emptyParagraph.marks)) tr.replaceWith(tablePosition, tableEnd, emptyParagraph);
+}
 function collectPPrMarkOp(node, pos, from, to, mode, revisionSet) {
 	if (!rangeCoversParagraphBoundary(from, to, pos, node)) return null;
 	const pPrMark = node.attrs["pPrMark"];
@@ -279,30 +480,65 @@ function rejectAllChanges() {
 	return (state, dispatch) => rejectChange(0, state.doc.content.size)(state, dispatch);
 }
 /**
-* Find the document range covered by all insertion/deletion marks
+* Find the document range covered by all inline revision marks
 * carrying any of the given AI-edit `revisionIds`. Returns null when
 * none of those marks are present (already accepted/rejected, or
 * never existed). A replace operation typically passes two ids (one
 * for its deletion side, one for its insertion side); inserts and
-* standalone deletions pass a single id.
+* standalone deletions and formatting changes pass a single id.
 */
 function findAIEditRevisionRange(state, revisionIds) {
 	const insertionType = state.schema.marks["insertion"];
 	const deletionType = state.schema.marks["deletion"];
-	if (!insertionType && !deletionType) return null;
+	const runPropertyChangeType = state.schema.marks["runPropertyChange"];
 	const idSet = new Set(typeof revisionIds === "number" ? [revisionIds] : revisionIds);
 	const range = {
 		from: null,
 		to: null
 	};
 	state.doc.descendants((node, pos) => {
+		if (node.type.name === "tableRow") for (const attrName of ["trIns", "trDel"]) {
+			const marker = node.attrs[attrName];
+			if (isTableRowRevisionAttr(marker) && idSet.has(marker.revisionId)) {
+				const start = pos;
+				const end = pos + node.nodeSize;
+				if (range.from === null || start < range.from) range.from = start;
+				if (range.to === null || end > range.to) range.to = end;
+				return false;
+			}
+		}
+		if (node.type.name === "tableCell" || node.type.name === "tableHeader") {
+			const marker = node.attrs["cellMarker"];
+			const hasDirectRevision = isTableCellRevisionAttr(marker) && idSet.has(marker.info.revisionId);
+			const continuationCells = node.attrs["_docxVMergeContinuationCells"];
+			const hasCollapsedRevision = Array.isArray(continuationCells) && continuationCells.some((cell) => {
+				const change = getTableCellMergeChange(cell);
+				return change !== null && idSet.has(change.info.id);
+			});
+			if (hasDirectRevision || hasCollapsedRevision) {
+				const start = pos;
+				const end = pos + node.nodeSize;
+				if (range.from === null || start < range.from) range.from = start;
+				if (range.to === null || end > range.to) range.to = end;
+				return false;
+			}
+		}
 		if (!node.isInline) return;
-		for (const mark of node.marks) if ((mark.type === insertionType || mark.type === deletionType) && typeof mark.attrs["revisionId"] === "number" && idSet.has(mark.attrs["revisionId"])) {
-			const start = pos;
-			const end = pos + node.nodeSize;
-			if (range.from === null || start < range.from) range.from = start;
-			if (range.to === null || end > range.to) range.to = end;
-			break;
+		for (const mark of node.marks) {
+			if (mark.type === runPropertyChangeType && expectRunPropertyChangeMarkAttrs(mark).changes.some((change) => idSet.has(change.info.id))) {
+				const start = pos;
+				const end = pos + node.nodeSize;
+				if (range.from === null || start < range.from) range.from = start;
+				if (range.to === null || end > range.to) range.to = end;
+				break;
+			}
+			if ((mark.type === insertionType || mark.type === deletionType) && typeof mark.attrs["revisionId"] === "number" && idSet.has(mark.attrs["revisionId"])) {
+				const start = pos;
+				const end = pos + node.nodeSize;
+				if (range.from === null || start < range.from) range.from = start;
+				if (range.to === null || end > range.to) range.to = end;
+				break;
+			}
 		}
 	});
 	if (range.from === null || range.to === null) return null;
@@ -313,7 +549,7 @@ function findAIEditRevisionRange(state, revisionIds) {
 }
 /**
 * Accept the tracked-change marks belonging to an AI-edit operation.
-* Pass a single revisionId for inserts/standalone deletions, or the
+* Pass a single revisionId for inserts, standalone deletions, or formatting changes; or the
 * full id list for a replace (one id per side). Returns false when
 * none of the ids match anything in the doc.
 */

package/dist/prosemirror/commands/contentControls.js

@@ -1,6 +1,6 @@
-import { formatDate } from "../../docx/fieldParser.js";
 import { expectBlockSdtAttrs } from "../attrs/index.js";
 import { ContentControlBoundError, ContentControlLockedError, ContentControlTypeError } from "../../content-controls/errors.js";
+import { formatDate } from "../../docx/fieldParser.js";
 import { SUGGESTION_BYPASS_META } from "../plugins/suggestionMode.js";
 //#region src/prosemirror/commands/contentControls.ts
 function nodeMatchesFilter(node, pos, filter) {

package/dist/prosemirror/commands/index.js

@@ -1,10 +1,10 @@
-import { acceptAIEditRevision, acceptAllChanges, acceptChange, addCommentMark, findAIEditRevisionRange, findNextChange, findPreviousChange, rejectAIEditRevision, rejectAllChanges, rejectChange, removeCommentMark } from "./comments.js";
 import { getParagraphAlignment, getParagraphBidi, getStyleId } from "../extensions/core/ParagraphExtension.js";
 import { clearFormatting, createRemoveMarkCommand, createSetMarkCommand, getMarkAttr, isMarkActive } from "../extensions/marks/markUtils.js";
 import { getTableContext, isInTable as isInTableCell } from "../extensions/nodes/TableExtension.js";
 import { getListInfo, isInList } from "../extensions/features/ListExtension.js";
 import { CLIPBOARD_READ_ERROR_EVENT, buildPlainTextSlice, pasteWithoutFormatting } from "./pastePlainText.js";
 import { getHyperlinkAttrs, getSelectedText, isHyperlinkActive } from "../extensions/marks/HyperlinkExtension.js";
+import { acceptAIEditRevision, acceptAllChanges, acceptChange, addCommentMark, findAIEditRevisionRange, findNextChange, findPreviousChange, rejectAIEditRevision, rejectAllChanges, rejectChange, removeCommentMark } from "./comments.js";
 import { addColumnLeft, addColumnRight, addRowAbove, addRowBelow, applyTableStyle, autoFitContents, deleteColumn, deleteRow, deleteTable, distributeColumns, insertTable, mergeCells, removeTableBorders, selectColumn, selectRow, selectTable, setAllTableBorders, setCellBorder, setCellFillColor, setCellMargins, setCellTextDirection, setCellVerticalAlign, setInsideTableBorders, setOutsideTableBorders, setRowHeight, setTableBorderColor, setTableBorderPreset, setTableBorderWidth, setTableBorders, setTableProperties, splitCell, toggleHeaderRow, toggleNoWrap } from "./table.js";
 import { clearFontFamily, clearFontSize, clearHighlight, clearTextColor, insertHyperlink, removeHyperlink, setFontFamily, setFontSize, setHighlight, setHyperlink, setTextColor, setUnderlineStyle, toggleBold, toggleItalic, toggleStrike, toggleSubscript, toggleSuperscript, toggleUnderline } from "./formatting.js";
 import { addTabStop, alignCenter, alignJustify, alignLeft, alignRight, applyStyle, clearStyle, decreaseIndent, decreaseListLevel, doubleSpacing, generateTOC, increaseIndent, increaseListLevel, oneAndHalfSpacing, removeList, removeTabStop, setAlignment, setIndentFirstLine, setIndentLeft, setIndentRight, setLineSpacing, setLtr, setRtl, setSpaceAfter, setSpaceBefore, singleSpacing, toggleBidi, toggleBulletList, toggleNumberedList } from "./paragraph.js";

package/dist/prosemirror/commands/pageBreak.js

@@ -1,5 +1,5 @@
-import { TextSelection } from "prosemirror-state";
 import { Fragment } from "prosemirror-model";
+import { TextSelection } from "prosemirror-state";
 //#region src/prosemirror/commands/pageBreak.ts
 /**
 * Page Break Commands

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

@@ -18,9 +18,9 @@ type AttrPatch = Record<string, unknown>;
  *   `runInWithNext` (`w:specVanish` lives in that rPr)
  * - load-time style/numbering bookkeeping the command layer cannot recompute
  *   without a style resolver: `numPrFromStyle`, the `list*` rendering attrs,
- *   `spacingFromDocDefaults`
+ *   `spacingFromDocDefaults`, `spacingFromImplicitDefaultStyle`
  */
-declare const PPR_CHANGE_SCOPED_ATTR_KEYS: readonly ["styleId", "numPr", "alignment", "spaceBefore", "spaceAfter", "lineSpacing", "lineSpacingRule", "spacingExplicit", "indentLeft", "indentRight", "indentFirstLine", "hangingIndent", "borders", "shading", "tabs", "pageBreakBefore", "keepNext", "keepLines", "widowControl", "contextualSpacing", "outlineLevel", "direction", "_autospacingBase"];
+declare const PPR_CHANGE_SCOPED_ATTR_KEYS: readonly ["styleId", "numPr", "alignment", "spaceBefore", "spaceAfter", "lineSpacing", "lineSpacingRule", "snapToGrid", "spacingExplicit", "indentLeft", "indentRight", "indentFirstLine", "hangingIndent", "borders", "shading", "tabs", "pageBreakBefore", "keepNext", "keepLines", "widowControl", "contextualSpacing", "outlineLevel", "direction", "_autospacingBase"];
 /**
  * Build the attr patch that rejecting one pPrChange applies to a paragraph:
  * every in-scope key set to the stored previous value, or reset to `null`

package/dist/prosemirror/commands/propertyChangeScope.js

@@ -1,5 +1,5 @@
-import { setAutospacingBaseValue } from "../autospacingBase.js";
 import { directionFromBidi } from "../paragraphDirection.js";
+import { setAutospacingBaseValue } from "../autospacingBase.js";
 //#region src/prosemirror/commands/propertyChangeScope.ts
 /**
 * Paragraph attrs governed by a `w:pPrChange` — the attrs
@@ -17,7 +17,7 @@ import { directionFromBidi } from "../paragraphDirection.js";
 *   `runInWithNext` (`w:specVanish` lives in that rPr)
 * - load-time style/numbering bookkeeping the command layer cannot recompute
 *   without a style resolver: `numPrFromStyle`, the `list*` rendering attrs,
-*   `spacingFromDocDefaults`
+*   `spacingFromDocDefaults`, `spacingFromImplicitDefaultStyle`
 */
 const PPR_CHANGE_SCOPED_ATTR_KEYS = [
 	"styleId",
@@ -27,6 +27,7 @@ const PPR_CHANGE_SCOPED_ATTR_KEYS = [
 	"spaceAfter",
 	"lineSpacing",
 	"lineSpacingRule",
+	"snapToGrid",
 	"spacingExplicit",
 	"indentLeft",
 	"indentRight",

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

@@ -0,0 +1,9 @@
+import { Transaction } from "prosemirror-state";
+import { Node } from "prosemirror-model";
+
+//#region src/prosemirror/commands/tableCellMergeResolution.d.ts
+declare const hasMatchingCollapsedTableCellMerge: (node: Node, revisionSet: Set<number> | null) => boolean;
+declare const resolveVisibleTableCellMerge: (tr: Transaction, cellPos: number, mode: "accept" | "reject") => boolean;
+declare const resolveCollapsedTableCellMerge: (tr: Transaction, cellPos: number, mode: "accept" | "reject", revisionSet: Set<number> | null) => boolean;
+//#endregion
+export { hasMatchingCollapsedTableCellMerge, resolveCollapsedTableCellMerge, resolveVisibleTableCellMerge };

package/dist/prosemirror/commands/tableCellMergeResolution.js

@@ -0,0 +1,181 @@
+import { standaloneTableCellFromProseMirror } from "../conversion/fromProseDoc.js";
+import { standaloneTableCellToProseMirror } from "../conversion/toProseDoc.js";
+import { getTableCellMergeChange } from "../tableCellMergeRevision.js";
+import { Result } from "better-result";
+import { TableMap } from "prosemirror-tables";
+//#region src/prosemirror/commands/tableCellMergeResolution.ts
+const hasMatchingCollapsedTableCellMerge = (node, revisionSet) => {
+	const continuationCells = node.attrs["_docxVMergeContinuationCells"];
+	if (!Array.isArray(continuationCells)) return false;
+	return continuationCells.some((cell) => {
+		const change = getTableCellMergeChange(cell);
+		return change !== null && (revisionSet === null || revisionSet.has(change.info.id));
+	});
+};
+const isTableCellMergeRevisionAttr = (value) => {
+	if (typeof value !== "object" || value === null || !("kind" in value) || value.kind !== "merge" || !("info" in value)) return false;
+	const info = value.info;
+	return typeof info === "object" && info !== null && "revisionId" in info && typeof info.revisionId === "number";
+};
+const tableCellContext = (doc, cellPos) => {
+	const resolved = doc.resolve(cellPos);
+	for (let depth = resolved.depth; depth > 0; depth -= 1) {
+		const node = resolved.node(depth);
+		if (node.type.spec["tableRole"] !== "table") continue;
+		const tablePos = resolved.before(depth);
+		return {
+			table: node,
+			tableStart: tablePos + 1,
+			relativeCellPos: cellPos - tablePos - 1
+		};
+	}
+	return null;
+};
+const resolveVisibleTableCellMerge = (tr, cellPos, mode) => {
+	const cell = tr.doc.nodeAt(cellPos);
+	const marker = cell?.attrs["cellMarker"];
+	if (!cell || !isTableCellMergeRevisionAttr(marker)) return false;
+	if (mode === "accept") {
+		tr.setNodeAttribute(cellPos, "cellMarker", null);
+		return true;
+	}
+	if ((marker.verticalMergeOriginal ?? "rest") === "continue") return mergeTableCellWithCellAbove(tr, cellPos);
+	const originalFormatting = cell.attrs["_originalFormatting"];
+	let nextOriginalFormatting = originalFormatting;
+	if (typeof originalFormatting === "object" && originalFormatting !== null) {
+		nextOriginalFormatting = { ...originalFormatting };
+		delete nextOriginalFormatting.vMerge;
+	}
+	tr.setNodeMarkup(cellPos, void 0, {
+		...cell.attrs,
+		cellMarker: null,
+		_originalFormatting: nextOriginalFormatting
+	});
+	return true;
+};
+const mergeTableCellWithCellAbove = (tr, cellPos) => {
+	const context = tableCellContext(tr.doc, cellPos);
+	const cell = tr.doc.nodeAt(cellPos);
+	if (!context || !cell) return false;
+	const map = TableMap.get(context.table);
+	const rectangle = map.findCell(context.relativeCellPos);
+	if (rectangle.top === 0) return false;
+	const aboveRelativePos = map.map[(rectangle.top - 1) * map.width + rectangle.left];
+	if (aboveRelativePos === void 0 || aboveRelativePos === context.relativeCellPos) return false;
+	const aboveRectangle = map.findCell(aboveRelativePos);
+	if (aboveRectangle.left !== rectangle.left || aboveRectangle.right !== rectangle.right || aboveRectangle.bottom !== rectangle.top) return false;
+	const abovePos = context.tableStart + aboveRelativePos;
+	const aboveCell = tr.doc.nodeAt(abovePos);
+	const aboveRowspan = aboveCell?.attrs["rowspan"];
+	const cellRowspan = cell.attrs["rowspan"];
+	if (!aboveCell || typeof aboveRowspan !== "number" || typeof cellRowspan !== "number" || aboveRowspan < 1 || cellRowspan < 1) return false;
+	const continuationCells = tableCellContinuationCells(aboveCell, aboveRowspan);
+	continuationCells.push(tableCellContinuationFromNode(cell));
+	const nestedContinuations = cell.attrs["_docxVMergeContinuationCells"];
+	if (Array.isArray(nestedContinuations)) continuationCells.push(...nestedContinuations);
+	tr.delete(cellPos, cellPos + cell.nodeSize);
+	tr.setNodeMarkup(abovePos, void 0, {
+		...aboveCell.attrs,
+		rowspan: aboveRowspan + cellRowspan,
+		_docxVMergeContinuationCells: continuationCells
+	});
+	return true;
+};
+const tableCellContinuationCells = (cell, rowspan) => {
+	const stored = cell.attrs["_docxVMergeContinuationCells"];
+	const cells = Array.isArray(stored) ? [...stored] : [];
+	while (cells.length < rowspan - 1) cells.push(emptyVerticalMergeContinuation());
+	return cells;
+};
+const tableCellContinuationFromNode = (cell) => {
+	const continuation = standaloneTableCellFromProseMirror(cell);
+	const formatting = {
+		...continuation.formatting,
+		vMerge: "continue"
+	};
+	const colspan = cell.attrs["colspan"];
+	if (typeof colspan === "number" && colspan > 1) formatting.gridSpan = colspan;
+	continuation.formatting = formatting;
+	delete continuation.structuralChange;
+	return continuation;
+};
+const emptyVerticalMergeContinuation = () => ({
+	type: "tableCell",
+	formatting: { vMerge: "continue" },
+	content: [{
+		type: "paragraph",
+		content: []
+	}]
+});
+const resolveCollapsedTableCellMerge = (tr, cellPos, mode, revisionSet) => {
+	const cell = tr.doc.nodeAt(cellPos);
+	const stored = cell?.attrs["_docxVMergeContinuationCells"];
+	if (!cell || !Array.isArray(stored)) return false;
+	const matchingIndices = [];
+	const nextCells = stored.map((continuationCell, index) => {
+		const change = getTableCellMergeChange(continuationCell);
+		if (!change || revisionSet !== null && !revisionSet.has(change.info.id)) return continuationCell;
+		matchingIndices.push(index);
+		const nextCell = { ...continuationCell };
+		delete nextCell.structuralChange;
+		return nextCell;
+	});
+	if (matchingIndices.length === 0) return false;
+	if (mode === "accept") {
+		tr.setNodeAttribute(cellPos, "_docxVMergeContinuationCells", nextCells);
+		return true;
+	}
+	const splitIndices = matchingIndices.filter((index) => {
+		const change = getTableCellMergeChange(stored[index]);
+		return change?.verticalMerge === "continue" && (change.verticalMergeOriginal ?? "rest") === "rest";
+	});
+	if (splitIndices.length === 0) {
+		tr.setNodeAttribute(cellPos, "_docxVMergeContinuationCells", nextCells);
+		return true;
+	}
+	const firstSplitIndex = splitIndices.at(0);
+	if (firstSplitIndex === void 0 || splitIndices.length !== stored.length - firstSplitIndex || splitIndices.some((index, offset) => index !== firstSplitIndex + offset)) return false;
+	const context = tableCellContext(tr.doc, cellPos);
+	if (!context) return false;
+	const map = TableMap.get(context.table);
+	const rectangle = map.findCell(context.relativeCellPos);
+	const rowspan = cell.attrs["rowspan"];
+	if (typeof rowspan !== "number" || rowspan !== stored.length + 1 || rectangle.bottom - rectangle.top !== rowspan) return false;
+	const restorations = [];
+	for (const index of splitIndices) {
+		const source = nextCells[index];
+		if (!source) return false;
+		const restoredCell = createRestoredTableCell(cell, source);
+		if (!restoredCell) return false;
+		restorations.push({
+			index,
+			cell: restoredCell
+		});
+	}
+	const mapFrom = tr.mapping.maps.length;
+	for (const restoration of restorations) {
+		const row = rectangle.top + restoration.index + 1;
+		const insertionPos = context.tableStart + map.positionAt(row, rectangle.left, context.table);
+		tr.insert(tr.mapping.slice(mapFrom).map(insertionPos, 1), restoration.cell);
+	}
+	const remainingCells = nextCells.slice(0, firstSplitIndex);
+	tr.setNodeMarkup(cellPos, void 0, {
+		...cell.attrs,
+		rowspan: firstSplitIndex + 1,
+		_docxVMergeContinuationCells: remainingCells.length > 0 ? remainingCells : null
+	});
+	return true;
+};
+const createRestoredTableCell = (origin, source) => {
+	const formatting = source.formatting ? { ...source.formatting } : void 0;
+	if (formatting) delete formatting.vMerge;
+	const restored = standaloneTableCellToProseMirror({
+		type: "tableCell",
+		...formatting ? { formatting } : {},
+		...source.propertyChanges ? { propertyChanges: source.propertyChanges } : {},
+		content: source.content
+	}, origin.type.name === "tableHeader" ? "tableHeader" : "tableCell");
+	return Result.try(() => origin.type.schema.nodeFromJSON(restored.toJSON())).unwrapOr(null);
+};
+//#endregion
+export { hasMatchingCollapsedTableCellMerge, resolveCollapsedTableCellMerge, resolveVisibleTableCellMerge };

package/dist/prosemirror/conversion/fromProseDoc.d.ts

@@ -10,6 +10,7 @@ declare function fromProseDoc(pmDoc: Node, baseDocument?: document_d_exports.Doc
  * Convert ProseMirror marks to TextFormatting
  */
 declare function marksToTextFormatting(marks: readonly Mark[]): document_d_exports.TextFormatting;
+declare const standaloneTableCellFromProseMirror: (node: Node) => document_d_exports.TableCell;
 /**
  * Update a Document with content from a ProseMirror document
  * Preserves all non-content parts of the original document
@@ -24,4 +25,4 @@ declare function updateDocumentContent(originalDocument: document_d_exports.Docu
  */
 declare function proseDocToBlocks(pmDoc: Node): document_d_exports.BlockContent[];
 //#endregion
-export { fromProseDoc, marksToTextFormatting, proseDocToBlocks, updateDocumentContent };
+export { fromProseDoc, marksToTextFormatting, proseDocToBlocks, standaloneTableCellFromProseMirror, updateDocumentContent };