@stll/folio-core 0.53.0 → 0.54.0

package/dist/prosemirror/clearRunColor.d.ts

@@ -0,0 +1,6 @@
+import { Command } from "prosemirror-state";
+//#region src/prosemirror/clearRunColor.d.ts
+/** Clearing direct color reveals the run's character/paragraph style color. */
+declare const clearRunColor: () => Command;
+//#endregion
+export { clearRunColor };

package/dist/prosemirror/clearRunColor.js

@@ -0,0 +1,46 @@
+import { getDocumentStyleResolver } from "./plugins/documentStyleState.js";
+import { applyMarksToRunFormattingRepresentation, selectRunFormattingCarrierRepresentations } from "./runFormattingInlineCarriers.js";
+import { readAuthoredRunFormatting, reconcileRunFormattingMarks } from "./runFormattingReconciliation.js";
+import { paragraphRunStyleContextAt } from "./runStyleFormatting.js";
+//#region src/prosemirror/clearRunColor.ts
+/** Clearing direct color reveals the run's character/paragraph style color. */
+const clearRunColor = () => (state, dispatch) => {
+	if (!dispatch) return true;
+	const styleResolver = getDocumentStyleResolver(state);
+	const tr = state.tr;
+	const { from, to, empty } = state.selection;
+	const clearedMarks = (node, position) => {
+		const context = paragraphRunStyleContextAt({
+			doc: state.doc,
+			pos: position,
+			styleResolver
+		});
+		const { color: _color, ...authoredFormatting } = readAuthoredRunFormatting({
+			context,
+			marks: node.marks,
+			styleResolver
+		});
+		return reconcileRunFormattingMarks({
+			authoredFormatting,
+			context,
+			node,
+			styleResolver
+		});
+	};
+	if (empty) {
+		const node = state.schema.text(" ", state.storedMarks ?? state.selection.$from.marks());
+		tr.setStoredMarks(clearedMarks(node, from));
+	} else for (const representation of selectRunFormattingCarrierRepresentations({
+		doc: state.doc,
+		from,
+		to
+	})) applyMarksToRunFormattingRepresentation({
+		tr,
+		representation,
+		marks: clearedMarks(representation.node, representation.position)
+	});
+	dispatch(tr.scrollIntoView());
+	return true;
+};
+//#endregion
+export { clearRunColor };

package/dist/prosemirror/commands/comments.js

@@ -7,21 +7,23 @@ import { expectFieldAttrs, expectParagraphAttrs, expectRunPropertyChangeMarkAttr
 import { addedBreakCarrierBefore, finalParagraphsOf, paragraphEndsItsContainer } from "../containerFinalParagraph.js";
 import { enclosingRevisionIds, resolutionRemovesControl, withoutResolvedEnclosures } from "../contentControlRevisions.js";
 import { resolveEmptyFieldResultRuns } from "../emptyFieldResultRuns.js";
+import { JOINED_RUNS_RESTYLED_META } from "../extensions/features/JoinedRunStyleExtension.js";
 import { markChangedParagraphRanges, markStructuralChange, markTrackedSectionEndpointRemoval } from "../extensions/features/ParagraphChangeTrackerExtension.js";
 import "../extensions/nodes/SdtExtension.js";
 import { resolveStateStory } from "../markupViewProjection.js";
 import { joinAtParagraphMark } from "../paragraphMarkJoin.js";
 import { getDocumentNumbering } from "../plugins/documentNumbering.js";
-import { getDocumentStyleResolver } from "../plugins/documentStyles.js";
-import { setParagraphAttrsWithRebasedRunFormatting } from "../rebaseParagraphRunFormatting.js";
+import { getDocumentStyleResolver } from "../plugins/documentStyleState.js";
+import { rebaseParagraphRuns, setParagraphAttrsWithRebasedRunFormatting } from "../rebaseParagraphRunFormatting.js";
 import { rejoinRunsAt } from "../rejoinRunCarriers.js";
 import { getFolioNodeRevisionCarriers, nodePropertyRevisionSites } from "../revisionCarriers.js";
 import { RUN_FORMATTING_MARK_NAMES } from "../runFormattingMarkNames.js";
 import { reconstructRejectedRunFormattingMarks } from "../runPropertyChangeResolution.js";
-import { paragraphRunStyleContextAt } from "../runStyleFormatting.js";
+import { paragraphRunStyleContext, paragraphRunStyleContextAt } from "../runStyleFormatting.js";
 import { getTableCellMergeChange } from "../tableCellMergeRevision.js";
 import { isTableCellRetainedInReviewView } from "../tableCellRevisionVisibility.js";
-import { reconcileTableGridAfterColumnRemoval, removeRowsWithoutCells, removeTableRow } from "../tableGridMutation.js";
+import { markRowEmptiedInBatch, reconcileTableGridAfterColumnRemoval, removeRowsWithoutCellsAfterBatch, removeTableRow } from "../tableGridMutation.js";
+import { runInCellPending, runParagraphIntoTable } from "../tableRunIn.js";
 import { holdsNoContent } from "../zeroWidthAnchors.js";
 import { inlineBookmarksForParagraphJoin } from "./paragraphBookmarkJoin.js";
 import { hasSerializableParagraphPropertyChange, paragraphPropertiesSnapshot } from "./propertyChangeScope.js";
@@ -106,6 +108,7 @@ function resolveChange(from, to, mode, revisionIds) {
 		const matchesRevision = (mark) => revisionSet === null || typeof mark.attrs["revisionId"] === "number" && revisionSet.has(mark.attrs["revisionId"]);
 		if (dispatch) {
 			const tr = state.tr;
+			tr.setMeta(JOINED_RUNS_RESTYLED_META, true);
 			const deleteRanges = [];
 			/** Where resolved inline content began and ended, in `state.doc`. */
 			const resolvedBoundaries = [];
@@ -278,7 +281,7 @@ function resolveChange(from, to, mode, revisionIds) {
 			tableCellStructuralOps.sort((left, right) => right.cellPos - left.cellPos);
 			let resolvedTableCellStructure = false;
 			let failedTableCellMergeResolution = false;
-			const emptiedTables = [];
+			const emptiedTables = { pending: false };
 			for (const op of tableCellStructuralOps) {
 				const mappedPos = tr.mapping.map(op.cellPos);
 				const cell = tr.doc.nodeAt(mappedPos);
@@ -301,9 +304,15 @@ function resolveChange(from, to, mode, revisionIds) {
 				resolvedTableCellStructure = true;
 			}
 			if (failedTableCellMergeResolution) return false;
-			for (const { position, mapFrom } of emptiedTables) removeRowsWithoutCells(tr, tr.mapping.slice(mapFrom).map(position));
+			removeRowsWithoutCellsAfterBatch(tr, emptiedTables);
 			if (resolvedTableCellStructure) markStructuralChange(tr);
 			pPrMarkOps.sort((a, b) => b.paragraphPos - a.paragraphPos);
+			const pendingTables = [];
+			state.doc.descendants((node, position) => {
+				if (node.type.spec["tableRole"] === "table" && runInCellPending(node)) pendingTables.push(position);
+				return !node.isTextblock;
+			});
+			const joinSeams = [];
 			for (const op of pPrMarkOps) {
 				const mappedPos = tr.mapping.map(op.paragraphPos);
 				const paragraph = tr.doc.nodeAt(mappedPos);
@@ -323,7 +332,18 @@ function resolveChange(from, to, mode, revisionIds) {
 					nextPos += boundary.nodeSize;
 				}
 				const nextNode = nextPos < tr.doc.content.size ? tr.doc.nodeAt(nextPos) : null;
-				if (!(nextNode?.type.name === paragraph.type.name)) {
+				const joinable = nextNode?.type.name === paragraph.type.name;
+				const ranIn = nextNode?.type.spec["tableRole"] === "table" && boundaries.length === 0 && !pendingTables.some((position) => tr.mapping.map(position) === nextPos) ? runParagraphIntoTable({
+					tr,
+					paragraphPos: mappedPos,
+					styleResolver
+				}) : null;
+				if (ranIn) {
+					tr.setMeta(JOINED_RUNS_RESTYLED_META, true);
+					markParagraphPropertySourceTransfers(tr, [ranIn.transfer]);
+					continue;
+				}
+				if (!joinable) {
 					const resolved = tr.doc.resolve(mappedPos);
 					const endsItsContainer = paragraphEndsItsContainer(resolved, paragraph.type.name);
 					const canGo = op.markWasAdded || !endsItsContainer;
@@ -340,12 +360,6 @@ function resolveChange(from, to, mode, revisionIds) {
 				}
 				try {
 					if (boundaries.length > 0) {
-						const emptyFirstParagraph = holdsNoContent(paragraph);
-						const joinedAttrs = {
-							...(emptyFirstParagraph ? nextNode : paragraph).attrs,
-							pPrMark: nextNode.attrs["pPrMark"],
-							_sectionProperties: nextNode.attrs["_sectionProperties"]
-						};
 						const leftToken = getProseParagraphPropertySourceToken(paragraph);
 						const rightToken = getProseParagraphPropertySourceToken(nextNode);
 						const inlineBookmarks = inlineBookmarksForParagraphJoin({
@@ -355,16 +369,31 @@ function resolveChange(from, to, mode, revisionIds) {
 						});
 						if (!inlineBookmarks) continue;
 						tr.replaceWith(joinPos - 1, nextPos + 1, inlineBookmarks);
-						tr.setNodeMarkup(mappedPos, void 0, joinedAttrs);
-						if (emptyFirstParagraph) markParagraphPropertySourceTransfers(tr, [{
+						tr.setNodeMarkup(mappedPos, void 0, nextNode.attrs);
+						markParagraphPropertySourceTransfers(tr, [{
 							displacedToken: typeof leftToken === "string" ? leftToken : null,
 							selectedToken: typeof rightToken === "string" ? rightToken : null
 						}]);
+						if (styleResolver && paragraph.content.size > 0) rebaseParagraphRuns({
+							previousContext: paragraphRunStyleContext(paragraph, styleResolver),
+							paragraphPosition: mappedPos,
+							range: {
+								from: 0,
+								to: paragraph.content.size
+							},
+							styleResolver,
+							tr
+						});
 					} else joinAtParagraphMark({
 						tr,
 						paragraphPos: mappedPos,
 						paragraph,
-						next: nextNode
+						next: nextNode,
+						styleResolver
+					});
+					joinSeams.push({
+						position: mappedPos + 1 + paragraph.content.size,
+						step: tr.steps.length
 					});
 					if (ownsSectionEndpoint(paragraph)) {
 						removedSectionEndpointCount++;
@@ -378,9 +407,10 @@ function resolveChange(from, to, mode, revisionIds) {
 				removedReferences: removedSectionReferences
 			});
 			if (!terminalTableDeletionIsPending(tr)) resolveTerminalTableReviewCarrier(tr, mode);
+			const seams = new Set(joinSeams.map(({ position, step }) => tr.mapping.slice(step).map(position)));
 			rejoinRunsAt({
 				tr,
-				boundaries: resolvedBoundaries.map((position) => tr.mapping.map(position)),
+				boundaries: resolvedBoundaries.map((position) => tr.mapping.map(position)).filter((position) => !seams.has(position)),
 				styleResolver
 			});
 			if (tr.steps.length > 0) dispatch(tr);
@@ -559,6 +589,7 @@ function isTableCellRevisionAttr(value) {
 	const info = value.info;
 	return typeof info === "object" && info !== null && "revisionId" in info && typeof info.revisionId === "number";
 }
+/** Record rows for a final sweep after every cell revision has resolved. */
 function deleteTableCellAt(tr, cellPos, emptied) {
 	const cell = tr.doc.nodeAt(cellPos);
 	if (!cell || cell.type.name !== "tableCell" && cell.type.name !== "tableHeader") return;
@@ -573,9 +604,10 @@ function deleteTableCellAt(tr, cellPos, emptied) {
 	const removedColumn = TableMap.get(table).findCell(cellOffset).left;
 	const spansDown = Number(cell.attrs["rowspan"]) > 1;
 	if (row.childCount > 1 || spansDown) {
-		if (row.childCount === 1) emptied.push({
-			position: tablePosition,
-			mapFrom: tr.mapping.maps.length
+		if (row.childCount === 1) markRowEmptiedInBatch({
+			tr,
+			rowPosition: resolved.start() - 1,
+			emptied
 		});
 		tr.delete(cellPos, cellPos + cell.nodeSize);
 		reconcileTableGridAfterColumnRemoval({
@@ -1336,7 +1368,10 @@ const shiftAddedParagraphBreakBefore = ({ tr, paragraphPosition, mark, fallbackA
 	const paragraph = tr.doc.nodeAt(paragraphPosition);
 	if (!paragraph || paragraph.type.name !== "paragraph") return false;
 	const resolved = tr.doc.resolve(paragraphPosition);
-	const carrier = addedBreakCarrierBefore(resolved, paragraph.type.name);
+	const carrier = addedBreakCarrierBefore({
+		at: resolved,
+		paragraphTypeName: paragraph.type.name
+	});
 	if (!carrier) return false;
 	const path = [{
 		node: paragraph,

package/dist/prosemirror/commands/formatPainter.js

@@ -1,6 +1,6 @@
 import { mergeTextFormatting } from "../../utils/textFormattingMerge.js";
 import { expectCharacterStyleMarkAttrs } from "../attrs/index.js";
-import { getDocumentStyleResolver } from "../plugins/documentStyles.js";
+import { getDocumentStyleResolver } from "../plugins/documentStyleState.js";
 import { readAuthoredRunFormatting, reconcileRunFormattingMarks } from "../runFormattingReconciliation.js";
 import { paragraphFormattingForRun, paragraphRunStyleContext, paragraphRunStyleContextAt, resolveEffectiveRunStyleFormatting } from "../runStyleFormatting.js";
 //#region src/prosemirror/commands/formatPainter.ts

package/dist/prosemirror/commands/hyperlink.js

@@ -1,5 +1,6 @@
 import { normalizeUserUrl } from "../../utils/urlSecurity.js";
 import { expectHyperlinkMarkAttrs } from "../attrs/index.js";
+import { removeHyperlinkInRange } from "../hyperlinkRemoval.js";
 //#region src/prosemirror/commands/hyperlink.ts
 const hyperlinkHref = (mark) => expectHyperlinkMarkAttrs(mark).href;
 /**
@@ -87,7 +88,7 @@ const removeHyperlinkAtCursor = (view, { popupHref }) => {
 	const ranges = collectHyperlinkRanges($from.parent, $from.start(), hlType, hyperlinkHref(linkMark));
 	const targetRange = rangeAtCursor(ranges, $from.pos);
 	if (!targetRange) return false;
-	const tr = view.state.tr.removeMark(targetRange.start, targetRange.end, hlType);
+	const tr = removeHyperlinkInRange(view.state, view.state.tr, targetRange.start, targetRange.end);
 	view.dispatch(tr.scrollIntoView());
 	return true;
 };

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

@@ -48,8 +48,9 @@ declare const PPR_CHANGE_SCOPED_ATTR_KEYS: readonly ["styleId", "numPr", "alignm
 declare const paragraphPropertiesSnapshot: (node: Node) => ParagraphPropertySnapshot;
 /**
  * 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`
- * when the stored old pPr does not carry it. Keys the record captured beyond
+ * every in-scope key set to the stored previous value, or to what the style
+ * (`inheritedFormatting`) supplies when the stored old pPr does not carry it,
+ * `null` when neither does. Keys the record captured beyond
  * the scoped set (editor-created list suggestions snapshot list-rendering
  * bookkeeping attrs) merge through 1:1 so their pre-change values restore too.
  */

package/dist/prosemirror/commands/propertyChangeScope.js

@@ -2,7 +2,9 @@ import { expectParagraphAttrs } from "../attrs/index.js";
 import { readParagraphNumberingAttr } from "../numberingAttr.js";
 import { directParagraphAlignment } from "../paragraphAlignment.js";
 import { directionFromBidi } from "../paragraphDirection.js";
+import { PARAGRAPH_FORMATTING_WRITE_BACK, STYLE_RESOLVED_PARAGRAPH_FIELDS } from "../paragraphFormattingProvenance.js";
 import { directParagraphSpacing, paragraphSpacingAttrPatch, paragraphSpacingFromFormatting } from "../paragraphSpacing.js";
+import { sameFormattingValue } from "../runFormattingFromMarks.js";
 //#region src/prosemirror/commands/propertyChangeScope.ts
 /** Editor-only suggestions are rebased away before save; every other entry emits `w:pPrChange`. */
 const hasSerializableParagraphPropertyChange = (changes) => changes?.some(({ info }) => info.provenance !== "suggested") === true;
@@ -106,12 +108,27 @@ const PPR_SPACING_ATTR_KEYS = /* @__PURE__ */ new Set([
 	"spacingExplicit",
 	"_autospacingBase"
 ]);
+/**
+* Whether the attr holds only what the paragraph's style resolves to: the
+* paragraph does not state it (its source `w:pPr` has no such field) and the
+* value is the style's. The same test a save applies before writing it.
+*/
+const styleSuppliedParagraphValue = (attrs, key) => {
+	if (!STYLE_RESOLVED_ATTR_FIELDS.has(key)) return false;
+	const field = key;
+	const inherited = attrs._resolvedFormatting?.[field];
+	return attrs._originalFormatting?.[field] === void 0 && inherited !== void 0 && inherited !== null && sameFormattingValue(Reflect.get(attrs, key), inherited);
+};
+/** Fields whose attr carries the style-resolved value under the field's own name. */
+const STYLE_RESOLVED_ATTR_FIELDS = new Set(STYLE_RESOLVED_PARAGRAPH_FIELDS.filter((field) => PARAGRAPH_FORMATTING_WRITE_BACK[field].attr === field));
 /** The in-scope paragraph properties as they stand, for a `w:pPrChange` record. */
 const paragraphPropertiesSnapshot = (node) => {
 	const attrs = expectParagraphAttrs(node);
 	const snapshot = {};
 	for (const key of PPR_CHANGE_SCOPED_ATTR_KEYS) {
 		if (key === "alignment" || PPR_SPACING_ATTR_KEYS.has(key)) continue;
+		if (styleSuppliedParagraphValue(attrs, key)) continue;
+		if (key === "hangingIndent" && styleSuppliedParagraphValue(attrs, "indentFirstLine")) continue;
 		const value = attrs[key];
 		if (key === "hangingIndent" && value === false && attrs._originalFormatting?.hangingIndent === void 0) continue;
 		if (value !== null && value !== void 0) snapshot[key] = value;
@@ -177,15 +194,19 @@ const PPR_CHANGE_SCOPED_FORMATTING_KEYS = [
 ];
 /**
 * 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`
-* when the stored old pPr does not carry it. Keys the record captured beyond
+* every in-scope key set to the stored previous value, or to what the style
+* (`inheritedFormatting`) supplies when the stored old pPr does not carry it,
+* `null` when neither does. Keys the record captured beyond
 * the scoped set (editor-created list suggestions snapshot list-rendering
 * bookkeeping attrs) merge through 1:1 so their pre-change values restore too.
 */
 function paragraphRejectAttrPatch(previousFormatting, inheritedFormatting) {
 	const prev = previousFormatting ?? {};
 	const patch = {};
-	for (const key of PPR_CHANGE_SCOPED_ATTR_KEYS) patch[key] = Object.hasOwn(prev, key) ? prev[key] ?? null : null;
+	for (const key of PPR_CHANGE_SCOPED_ATTR_KEYS) if (Object.hasOwn(prev, key)) patch[key] = prev[key] ?? null;
+	else if (STYLE_RESOLVED_ATTR_FIELDS.has(key)) patch[key] = Reflect.get(inheritedFormatting ?? {}, key) ?? null;
+	else patch[key] = null;
+	if (!Object.hasOwn(prev, "indentFirstLine") && !Object.hasOwn(prev, "hangingIndent")) patch["hangingIndent"] = inheritedFormatting?.hangingIndent ?? null;
 	if (!Object.hasOwn(prev, "alignment")) patch["alignment"] = inheritedFormatting?.alignment ?? null;
 	patch["alignmentFromStyle"] = inheritedFormatting?.alignment;
 	const directSpacing = paragraphSpacingFromFormatting(prev);

package/dist/prosemirror/commands/resolveAllTableChanges.js

@@ -5,7 +5,7 @@ import { nodePropertyRevisionSites, propertyRevisionRecords } from "../revisionC
 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 { acceptedMergeFoldsIntoCellAbove, createRestoredTableCell, hasMatchingCollapsedTableCellMerge, tableCellContinuationCells, tableCellContinuationFromNode, tableCellContinuationPayload } from "./tableCellMergeResolution.js";
 import { panic } from "better-result";
 import { TableMap } from "prosemirror-tables";
 import { StepMap } from "prosemirror-transform";
@@ -131,10 +131,12 @@ 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;
+	const verticalMerge = "verticalMerge" in marker && isTableCellMergeRevisionValue(marker.verticalMerge) ? marker.verticalMerge : void 0;
 	return {
 		kind: marker.kind,
 		info: { revisionId: marker.info.revisionId },
-		...verticalMergeOriginal ? { verticalMergeOriginal } : {}
+		...verticalMergeOriginal ? { verticalMergeOriginal } : {},
+		...verticalMerge ? { verticalMerge } : {}
 	};
 };
 /**
@@ -435,46 +437,49 @@ const resolvePureTableMerges = ({ table, mode, rowMetadata, tablePropertyTouched
 					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;
+		} else if (marker?.kind === "merge") {
+			const joinsAbove = mode === "accept" ? isTableCellMergeRevisionContinuation(marker.verticalMerge) && acceptedMergeFoldsIntoCellAbove(entry.node) : isTableCellMergeRevisionContinuation(marker.verticalMergeOriginal);
+			if (mode === "accept" && !joinsAbove) {
+				entry.touched = true;
+				entry.node = entry.node.type.create({
+					...entry.node.attrs,
+					cellMarker: null
+				}, entry.node.content, entry.node.marks);
+			} else if (!joinsAbove) {
+				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);
 			}
-			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;

package/dist/prosemirror/commands/resolveParagraphProperties.js

@@ -1,6 +1,7 @@
 import { expectParagraphAttrs } from "../attrs/index.js";
-import { resolveParagraphDefaultTextFormatting } from "../conversion/toProseDoc.js";
-import { rejectedListRenderingPatch } from "../listNumbering.js";
+import { rejectedListRenderingPatch } from "../listRendering.js";
+import { styleResolvedParagraphFormatting } from "../paragraphFormattingProvenance.js";
+import { resolveParagraphDefaultTextFormatting } from "../styles/paragraphStyleCascade.js";
 import { paragraphRejectAttrPatch, paragraphRejectOriginalFormatting, removeParagraphPropertyChanges, sectionRejectProperties } from "./propertyChangeScope.js";
 //#region src/prosemirror/commands/resolveParagraphProperties.ts
 /** Resolve paragraph and section property records before resolving their inline content. */
@@ -20,11 +21,24 @@ const resolveParagraphChangeAttrs = ({ node, boundaryCovered, mode, revisionSet,
 				_propertyChanges: remaining.length > 0 ? remaining : null
 			};
 			if (rejection?.type === "restore-previous") {
-				const inheritedAlignment = expectParagraphAttrs(node).alignmentFromStyle;
+				const currentAttrs = expectParagraphAttrs(node);
+				const inheritedAlignment = currentAttrs.alignmentFromStyle;
+				const restoredStyleId = rejection.previousFormatting?.styleId ?? void 0;
+				const sameStyle = restoredStyleId === (currentAttrs.styleId ?? void 0);
 				let previousFormattingFromStyle;
-				if (styleResolver) previousFormattingFromStyle = styleResolver.resolveParagraphStyle(rejection.previousFormatting?.styleId).paragraphFormatting;
-				else if (inheritedAlignment !== void 0) previousFormattingFromStyle = { alignment: inheritedAlignment };
-				Object.assign(nextAttrs, paragraphRejectAttrPatch(rejection.previousFormatting, previousFormattingFromStyle), rejectedListRenderingPatch({
+				let resolvedFromStyle = sameStyle ? currentAttrs._resolvedFormatting : void 0;
+				if (styleResolver) {
+					previousFormattingFromStyle = styleResolver.resolveParagraphStyle(restoredStyleId).paragraphFormatting;
+					if (!sameStyle) {
+						resolvedFromStyle = styleResolvedParagraphFormatting(previousFormattingFromStyle);
+						nextAttrs["_resolvedFormatting"] = resolvedFromStyle;
+					}
+				} else if (inheritedAlignment !== void 0) previousFormattingFromStyle = { alignment: inheritedAlignment };
+				const inheritedFormatting = previousFormattingFromStyle === void 0 && resolvedFromStyle === void 0 ? void 0 : {
+					...previousFormattingFromStyle,
+					...resolvedFromStyle
+				};
+				Object.assign(nextAttrs, paragraphRejectAttrPatch(rejection.previousFormatting, inheritedFormatting), rejectedListRenderingPatch({
 					current: expectParagraphAttrs(node),
 					previousFormatting: rejection.previousFormatting,
 					numbering

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

@@ -5,10 +5,17 @@ import { Transaction } from "prosemirror-state";
 //#region src/prosemirror/commands/tableCellMergeResolution.d.ts
 declare const tableCellContinuationPayload: (node: Node) => DecodedTableCellParagraphSourcePayload | null;
 declare const hasMatchingCollapsedTableCellMerge: (node: Node, revisionSet: Set<number> | null) => boolean;
+/**
+ * Whether accepting a pending vertical merge folds the cell into the one above.
+ * The saved `w:vMerge` continuation is read back as its own cell when it carries
+ * content, so accepting such a merge keeps the cell standing; folding it would
+ * hide text that reappears when the document is reopened.
+ */
+declare const acceptedMergeFoldsIntoCellAbove: (cell: Node) => boolean;
 declare const resolveVisibleTableCellMerge: (tr: Transaction, cellPos: number, mode: "accept" | "reject") => boolean;
 declare const tableCellContinuationCells: (cell: Node, rowspan: number) => document_d_exports.TableCell[];
 declare const tableCellContinuationFromNode: (cell: Node) => document_d_exports.TableCell;
 declare const resolveCollapsedTableCellMerge: (tr: Transaction, cellPos: number, mode: "accept" | "reject", revisionSet: Set<number> | null) => boolean;
 declare const createRestoredTableCell: (origin: Node, source: document_d_exports.TableCell) => Node | null;
 //#endregion
-export { createRestoredTableCell, hasMatchingCollapsedTableCellMerge, resolveCollapsedTableCellMerge, resolveVisibleTableCellMerge, tableCellContinuationCells, tableCellContinuationFromNode, tableCellContinuationPayload };
+export { acceptedMergeFoldsIntoCellAbove, createRestoredTableCell, hasMatchingCollapsedTableCellMerge, resolveCollapsedTableCellMerge, resolveVisibleTableCellMerge, tableCellContinuationCells, tableCellContinuationFromNode, tableCellContinuationPayload };

package/dist/prosemirror/commands/tableCellMergeResolution.js

@@ -1,8 +1,10 @@
 import { decodeTableCellParagraphSourcePayload, restoreTableCellsWithParagraphPropertySources, transportTableCellsWithParagraphPropertySources } from "../../docx/paragraphPropertySource.js";
+import { isTableCellMergeRevisionContinuation } from "../../docx/tableParser.js";
 import { standaloneTableCellFromProseMirror } from "../conversion/fromProseDoc.js";
-import { standaloneTableCellToProseMirror } from "../conversion/toProseDoc.js";
+import { standaloneTableCellToProseMirror, tableCellHasMeaningfulContent } from "../conversion/toProseDoc.js";
 import { getTableCellMergeChange } from "../tableCellMergeRevision.js";
-import { Result } from "better-result";
+import { removeRowsWithoutCellsInRange } from "../tableGridMutation.js";
+import { Result, panic } from "better-result";
 import { TableMap } from "prosemirror-tables";
 //#region src/prosemirror/commands/tableCellMergeResolution.ts
 const tableCellContinuationPayload = (node) => {
@@ -35,15 +37,22 @@ const tableCellContext = (doc, cellPos) => {
 	}
 	return null;
 };
+/**
+* Whether accepting a pending vertical merge folds the cell into the one above.
+* The saved `w:vMerge` continuation is read back as its own cell when it carries
+* content, so accepting such a merge keeps the cell standing; folding it would
+* hide text that reappears when the document is reopened.
+*/
+const acceptedMergeFoldsIntoCellAbove = (cell) => !tableCellHasMeaningfulContent(standaloneTableCellFromProseMirror(cell));
 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" ? isTableCellMergeRevisionContinuation(marker.verticalMerge) && acceptedMergeFoldsIntoCellAbove(cell) : isTableCellMergeRevisionContinuation(marker.verticalMergeOriginal)) return mergeTableCellWithCellAbove(tr, cellPos);
 	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) {
@@ -73,11 +82,18 @@ const mergeTableCellWithCellAbove = (tr, cellPos) => {
 	const aboveRowspan = aboveCell?.attrs["rowspan"];
 	const cellRowspan = cell.attrs["rowspan"];
 	if (!aboveCell || typeof aboveRowspan !== "number" || typeof cellRowspan !== "number" || aboveRowspan < 1 || cellRowspan < 1) return false;
+	removeRowsWithoutCellsInRange({
+		tr,
+		from: cellPos + 1,
+		to: cellPos + cell.nodeSize - 1
+	});
+	const capturedCell = tr.doc.nodeAt(cellPos);
+	if (!capturedCell) panic("Nested table cleanup removed its owning cell");
 	const continuationCells = tableCellContinuationCells(aboveCell, aboveRowspan);
-	continuationCells.push(tableCellContinuationFromNode(cell));
-	const nestedPayload = tableCellContinuationPayload(cell);
+	continuationCells.push(tableCellContinuationFromNode(capturedCell));
+	const nestedPayload = tableCellContinuationPayload(capturedCell);
 	if (nestedPayload) continuationCells.push(...nestedPayload.cells);
-	tr.delete(cellPos, cellPos + cell.nodeSize);
+	tr.delete(cellPos, cellPos + capturedCell.nodeSize);
 	tr.setNodeMarkup(abovePos, void 0, {
 		...aboveCell.attrs,
 		rowspan: aboveRowspan + cellRowspan,
@@ -185,4 +201,4 @@ const createRestoredTableCell = (origin, source) => {
 	return Result.try(() => origin.type.schema.nodeFromJSON(restored.toJSON())).unwrapOr(null);
 };
 //#endregion
-export { createRestoredTableCell, hasMatchingCollapsedTableCellMerge, resolveCollapsedTableCellMerge, resolveVisibleTableCellMerge, tableCellContinuationCells, tableCellContinuationFromNode, tableCellContinuationPayload };
+export { acceptedMergeFoldsIntoCellAbove, createRestoredTableCell, hasMatchingCollapsedTableCellMerge, resolveCollapsedTableCellMerge, resolveVisibleTableCellMerge, tableCellContinuationCells, tableCellContinuationFromNode, tableCellContinuationPayload };

package/dist/prosemirror/containerFinalParagraph.d.ts

@@ -28,18 +28,24 @@ declare const finalParagraphsOf: (doc: Node, paragraphTypeName: string) => {
   position: number;
   node: Node;
 }[];
+type AddedBreakCarrierBeforeOptions = {
+  at: ResolvedPos;
+  paragraphTypeName: string;
+  canCrossTable?: (table: Node) => boolean;
+};
 /**
  * The paragraph an added break can rotate BACK onto from the one at `at`: the
  * paragraph the run of inserted ones was appended after.
  *
  * The walk crosses the inserted paragraphs — their own marks stay where they
  * are, and only which paragraph is left markless changes — and stops at the
- * first one whose mark is free. `null` when there is none: a table in between,
- * which no mark joins across; a paragraph whose mark says something else,
- * which the rotation must not overwrite; or a container whose every paragraph
- * is new.
+ * first one whose mark is free. A table blocks the walk unless the caller
+ * authorizes a wholly inserted table: rejecting it removes that barrier too.
+ * `null` when there is no carrier: a table the caller cannot cross, a
+ * paragraph whose mark the rotation must not overwrite, or a container whose
+ * every paragraph is new.
  */
-declare const addedBreakCarrierBefore: (at: ResolvedPos, paragraphTypeName: string) => {
+declare const addedBreakCarrierBefore: ({ at, paragraphTypeName, canCrossTable }: AddedBreakCarrierBeforeOptions) => {
   position: number;
   node: Node;
 } | null;

package/dist/prosemirror/containerFinalParagraph.js

@@ -66,18 +66,19 @@ const marksAnAddedBreak = (node) => {
 *
 * The walk crosses the inserted paragraphs — their own marks stay where they
 * are, and only which paragraph is left markless changes — and stops at the
-* first one whose mark is free. `null` when there is none: a table in between,
-* which no mark joins across; a paragraph whose mark says something else,
-* which the rotation must not overwrite; or a container whose every paragraph
-* is new.
+* first one whose mark is free. A table blocks the walk unless the caller
+* authorizes a wholly inserted table: rejecting it removes that barrier too.
+* `null` when there is no carrier: a table the caller cannot cross, a
+* paragraph whose mark the rotation must not overwrite, or a container whose
+* every paragraph is new.
 */
-const addedBreakCarrierBefore = (at, paragraphTypeName) => {
+const addedBreakCarrierBefore = ({ at, paragraphTypeName, canCrossTable }) => {
 	let position = at.pos;
 	for (let index = at.index() - 1; index >= 0; index--) {
 		const sibling = at.parent.child(index);
 		position -= sibling.nodeSize;
 		if (sibling.type.name !== paragraphTypeName) {
-			if (isAContainerChild(sibling, paragraphTypeName)) return null;
+			if (isAContainerChild(sibling, paragraphTypeName) && !canCrossTable?.(sibling)) return null;
 			continue;
 		}
 		if (sibling.attrs["pPrMark"] == null) return {