@stll/folio-core 0.52.0 → 0.54.0

package/dist/prosemirror/plugins/suggestionMode.js

@@ -1,11 +1,25 @@
+import { expectParagraphAttrs, expectTrackedChangeMarkAttrs } from "../attrs/index.js";
+import { paragraphPropertiesSnapshot } from "../commands/propertyChangeScope.js";
+import { paragraphEndsItsContainer } from "../containerFinalParagraph.js";
 import { encloseWholeControls } from "../contentControlRevisions.js";
 import { splitBlockClearBorders } from "../extensions/features/BaseKeymapExtension.js";
+import { JOINED_RUNS_RESTYLED_META } from "../extensions/features/JoinedRunStyleExtension.js";
+import { expandNoteReferenceDeletionRange } from "../extensions/marks/noteReferenceDeletion.js";
+import { carryParagraphProperties, paragraphLeftAfter, recordReplacedParagraphProperties } from "../paragraphPropertyCarry.js";
+import { rebaseParagraphRuns } from "../rebaseParagraphRunFormatting.js";
+import { RUN_FORMATTING_MARK_NAMES } from "../runFormattingMarkNames.js";
+import { paragraphRunStyleContext } from "../runStyleFormatting.js";
+import { cellPasteRange, pasteTableCells } from "../tableCellPaste.js";
 import { handleEditorBeforeInput } from "../textInput.js";
 import { canCarryTrackedRunMark } from "../trackedRunInlineAtoms.js";
+import { getDocumentNumbering } from "./documentNumbering.js";
+import { getDocumentStyleResolver } from "./documentStyleState.js";
 import { mintRevisionId, seedRevisionIdsFromDoc } from "./revisionIds.js";
-import { Mapping } from "prosemirror-transform";
-import { Plugin, PluginKey, TextSelection } from "prosemirror-state";
+import { Slice } from "prosemirror-model";
+import { Mapping, ReplaceStep } from "prosemirror-transform";
+import { AllSelection, Plugin, PluginKey, Selection, TextSelection } from "prosemirror-state";
 import { isHistoryTransaction } from "prosemirror-history";
+import { undoInputRule } from "prosemirror-inputrules";
 //#region src/prosemirror/plugins/suggestionMode.ts
 /**
 * Suggestion Mode Plugin
@@ -22,6 +36,12 @@ import { isHistoryTransaction } from "prosemirror-history";
 const suggestionModeKey = new PluginKey("suggestionMode");
 const SUGGESTION_META = "suggestionModeApplied";
 const SUGGESTION_BYPASS_META = "suggestionModeBypass";
+/**
+* The text a tracked text-input transaction typed. Rules that react to typing
+* (list autoformat) read it, because this plugin claims text input before any
+* input rule sees it.
+*/
+const SUGGESTED_TEXT_INPUT_META = "suggestionModeTextInput";
 function makeMarkAttrs(pluginState) {
 	return {
 		revisionId: mintRevisionId(),
@@ -39,6 +59,27 @@ function makeRevisionInfo(state) {
 		date: attrs.date
 	};
 }
+/**
+* A removed paragraph mark leaves the paragraph after it once accepted. An
+* edit that reads as the paragraph before it (Backspace or Delete at the
+* break, a deletion running from inside one paragraph into another) gives the
+* paragraph left that paragraph's properties now, under the mark's revision:
+* accepting reads as the edit made directly, rejecting restores its own.
+*/
+function carryIntoParagraphLeft(state, tr, source, survivorPos, info) {
+	carryParagraphProperties({
+		tr,
+		position: survivorPos,
+		source,
+		styleResolver: getDocumentStyleResolver(state),
+		numbering: getDocumentNumbering(state),
+		revision: {
+			id: info.id,
+			author: info.author ?? "",
+			date: info.date ?? ""
+		}
+	});
+}
 function makeParagraphMarkInfo(pluginState) {
 	const attrs = makeMarkAttrs(pluginState);
 	return {
@@ -69,10 +110,11 @@ function findAdjacentRevisionForRange(doc, from, to, markTypeName, author) {
 	return findAdjacentRevision(doc, from, markTypeName, author) ?? findAdjacentRevision(doc, to, markTypeName, author);
 }
 /**
-* Walk a text range and either mark as deletion or retract own insertions.
+* Walk a selected range and track its text, paragraph breaks, and table rows.
+* Retract the current author's own inserted text.
 * Processes in reverse order to maintain position validity.
 */
-function markRangeAsDeleted(tr, doc, from, to, insertionType, deletionType, pluginState) {
+function markRangeAsDeleted(tr, doc, from, to, insertionType, deletionType, pluginState, joinState) {
 	const ranges = [];
 	doc.nodesBetween(from, to, (node, pos) => {
 		if (!canCarryTrackedRunMark(node)) return;
@@ -87,12 +129,44 @@ function markRangeAsDeleted(tr, doc, from, to, insertionType, deletionType, plug
 			isOwnInsert
 		});
 	});
-	if (ranges.length === 0) return;
 	const delAttrs = findAdjacentRevisionForRange(doc, from, to, "deletion", pluginState.author) || makeMarkAttrs(pluginState);
+	let removedMark = false;
+	doc.nodesBetween(from, to, (node, pos) => {
+		if (node.type.name === "tableRow" && pos >= from && pos + node.nodeSize <= to && node.attrs["trIns"] == null && node.attrs["trDel"] == null) tr.setNodeAttribute(pos, "trDel", delAttrs);
+		if (node.type.name !== "paragraph") return;
+		const boundary = pos + node.nodeSize;
+		if (boundary > from && boundary <= to && node.attrs["pPrMark"] == null) {
+			tr.setNodeAttribute(pos, "pPrMark", {
+				kind: "del",
+				info: {
+					id: delAttrs.revisionId,
+					author: delAttrs.author,
+					date: delAttrs.date
+				}
+			});
+			removedMark = true;
+		}
+	});
+	const $first = doc.resolve(from);
+	const $last = doc.resolve(to);
+	if (joinState && removedMark && $first.parent.type.name === "paragraph" && $last.parent.type.name === "paragraph" && $first.parent !== $last.parent && from > $first.start()) {
+		const lastPos = doc === tr.doc ? $last.before() : tr.mapping.map($last.before());
+		const lastMark = tr.doc.nodeAt(lastPos)?.attrs["pPrMark"];
+		const survivorPos = lastMark?.kind === "del" || lastMark?.kind === "moveFrom" ? paragraphLeftAfter({
+			doc: tr.doc,
+			paragraphPos: lastPos
+		}) ?? lastPos : lastPos;
+		carryIntoParagraphLeft(joinState, tr, $first.parent, survivorPos, {
+			id: delAttrs.revisionId,
+			author: delAttrs.author,
+			date: delAttrs.date
+		});
+	}
+	if (ranges.length === 0) return;
 	encloseWholeControls({
 		tr,
-		from: tr.mapping.map(from),
-		to: tr.mapping.map(to, -1),
+		from,
+		to,
 		revisionId: delAttrs.revisionId
 	});
 	for (let i = ranges.length - 1; i >= 0; i--) {
@@ -101,10 +175,26 @@ function markRangeAsDeleted(tr, doc, from, to, insertionType, deletionType, plug
 		else tr.addMark(range.from, range.to, deletionType.create(delAttrs));
 	}
 }
+/** Preserve clipboard revisions inside the revision that inserted their content. */
+function enclosePastedRunRevisions({ tr, from, to, revision: insertion }) {
+	tr.doc.nodesBetween(from, to, (node, pos) => {
+		if (!canCarryTrackedRunMark(node)) return;
+		const revision = node.marks.find(({ type }) => type.name === "insertion" || type.name === "deletion");
+		if (!revision) return;
+		const previous = expectTrackedChangeMarkAttrs(revision);
+		tr.addMark(Math.max(from, pos), Math.min(to, pos + node.nodeSize), revision.type.create({
+			...revision.attrs,
+			_docxRevisionAncestors: [{
+				type: "insertion",
+				...insertion,
+				outerWrapperCount: 0
+			}, ...previous._docxRevisionAncestors ?? []]
+		}));
+	});
+}
 /**
-* Add the insertion mark to every run carrier in `[from, to)` that does not
-* already carry a tracked-change mark. Content already carrying a revision is
-* left untouched so another author's attribution is not overwritten.
+* Track every inserted run, paragraph break, and table row in `[from, to)`.
+* Content already carrying a revision keeps its attribution.
 */
 function markRangeAsInserted(tr, doc, from, to, insertionType, deletionType, attrs) {
 	doc.nodesBetween(from, to, (node, pos) => {
@@ -115,6 +205,23 @@ function markRangeAsInserted(tr, doc, from, to, insertionType, deletionType, att
 		if (start >= end) return;
 		tr.addMark(start, end, insertionType.create(attrs));
 	});
+	const $end = doc.resolve(to);
+	const endsBetweenBlocks = !$end.parent.isTextblock && $end.nodeBefore !== null && $end.nodeBefore.type.name !== "paragraph";
+	doc.nodesBetween(from, to, (node, pos) => {
+		if (node.type.name === "paragraph") {
+			const boundary = pos + node.nodeSize;
+			const keepsOwnMark = endsBetweenBlocks && boundary - 1 === from;
+			if (boundary > from && boundary < to && !keepsOwnMark && node.attrs["pPrMark"] == null) tr.setNodeAttribute(pos, "pPrMark", {
+				kind: "ins",
+				info: {
+					id: attrs.revisionId,
+					author: attrs.author,
+					date: attrs.date
+				}
+			});
+		}
+		if (node.type.name === "tableRow" && pos >= from && pos + node.nodeSize <= to && node.attrs["trIns"] == null && node.attrs["trDel"] == null) tr.setNodeAttribute(pos, "trIns", attrs);
+	});
 	encloseWholeControls({
 		tr,
 		from,
@@ -126,32 +233,221 @@ function markRangeAsInserted(tr, doc, from, to, insertionType, deletionType, att
 * With track changes on, pasting over a non-empty text selection marks the
 * replaced text as a tracked deletion and the pasted slice as a tracked
 * insertion (so they read as one replacement), matching typing over a
-* selection. Returns false for a collapsed cursor or non-text selection so the
+* selection. Select-all (an `AllSelection`) counts as a text selection over the
+* whole document. Returns false for a collapsed cursor or another selection so the
 * default paste + the `appendTransaction` catch-all marks a plain insertion
 * (eigenpal/docx-editor#784).
 */
 function handleSuggestionPaste(view, slice, pluginState) {
 	const { selection } = view.state;
-	if (!(selection instanceof TextSelection) || selection.empty) return false;
+	const selectsAll = selection instanceof AllSelection;
+	if (!(selection instanceof TextSelection || selectsAll) || selection.empty) return false;
 	const insertionType = view.state.schema.marks["insertion"];
 	const deletionType = view.state.schema.marks["deletion"];
 	if (!insertionType || !deletionType) return false;
-	const { from, to } = selection;
+	if (selectsAll && (slice.openStart > 0 || slice.openEnd > 0)) slice = new Slice(view.state.tr.replaceSelection(slice).doc.content, 0, 0);
+	const { from, to } = selectsAll ? {
+		from: Selection.atStart(view.state.doc).from,
+		to: Selection.atEnd(view.state.doc).to
+	} : selection;
 	const tr = view.state.tr;
 	tr.setMeta(SUGGESTION_META, true);
-	markRangeAsDeleted(tr, view.state.doc, from, to, insertionType, deletionType, pluginState);
-	const insertFrom = tr.mapping.map(to);
-	const sizeBefore = tr.doc.content.size;
-	tr.replaceRange(insertFrom, insertFrom, slice);
-	const insertTo = insertFrom + (tr.doc.content.size - sizeBefore);
-	tr.removeMark(insertFrom, insertTo, deletionType);
-	const insertAttrs = findAdjacentRevision(view.state.doc, from, "insertion", pluginState.author) || makeMarkAttrs(pluginState);
+	const { doc } = view.state;
+	const $from = doc.resolve(from);
+	const $to = doc.resolve(to);
+	const closedBlocks = slice.openStart === 0 && slice.content.firstChild?.isBlock === true;
+	const beforeStruck = closedBlocks && $from.parent.isTextblock && $from.parentOffset === 0;
+	const wholeBlocks = beforeStruck && $to.parent.isTextblock && $to.parentOffset === $to.parent.content.size;
+	const endsContainer = wholeBlocks && paragraphEndsItsContainer(doc.resolve($to.before()), $to.parent.type.name);
+	const rotates = endsContainer && slice.content.firstChild?.type === $to.parent.type && slice.content.lastChild?.type === $to.parent.type;
+	const tableFirst = endsContainer && !rotates;
+	if (!tableFirst) markRangeAsDeleted(tr, doc, from, wholeBlocks && !endsContainer ? $to.after() : to, insertionType, deletionType, pluginState);
+	const carryAcross = () => {
+		if (selectsAll || $from.parent.type.name !== "paragraph" || $from.parent === $to.parent || from <= $from.start()) return;
+		const firstPos = tr.mapping.map($from.before());
+		const mark = tr.doc.nodeAt(firstPos)?.attrs["pPrMark"];
+		const survivorPos = paragraphLeftAfter({
+			doc: tr.doc,
+			paragraphPos: firstPos
+		});
+		if (mark?.kind === "del" && survivorPos !== null) carryIntoParagraphLeft(view.state, tr, $from.parent, survivorPos, mark.info);
+	};
+	const inlineSlice = slice.content.firstChild?.isInline === true;
+	if (inlineSlice) carryAcross();
+	let at = tr.mapping.map(to);
+	if (rotates) at = tr.mapping.map($to.after());
+	else if (tableFirst) at = $from.before();
+	else if (beforeStruck) at = tr.mapping.map(from, -1);
+	const firstStep = tr.steps.length;
+	tr.replaceRange(at, at, slice);
+	const placed = tr.steps.slice(firstStep).flatMap((step, offset) => {
+		const later = new Mapping(tr.mapping.maps.slice(firstStep + offset + 1));
+		const ranges = [];
+		step.getMap().forEach((_oldFrom, _oldTo, newFrom, newTo) => {
+			ranges.push({
+				from: later.map(newFrom, -1),
+				to: later.map(newTo, 1)
+			});
+		});
+		return ranges;
+	});
+	let insertFrom = placed.length === 0 ? at : Math.min(...placed.map((range) => range.from));
+	let insertTo = placed.length === 0 ? at : Math.max(...placed.map((range) => range.to));
+	if (tableFirst) {
+		const struck = tr.steps.length;
+		markRangeAsDeleted(tr, tr.doc, tr.mapping.map(from), tr.mapping.map(to), insertionType, deletionType, pluginState);
+		const since = tr.mapping.slice(struck);
+		insertFrom = since.map(insertFrom, -1);
+		insertTo = since.map(insertTo, -1);
+	}
+	const insertAttrs = findAdjacentRevision(doc, from, "insertion", pluginState.author) || makeMarkAttrs(pluginState);
+	enclosePastedRunRevisions({
+		tr,
+		from: insertFrom,
+		to: insertTo,
+		revision: insertAttrs
+	});
 	markRangeAsInserted(tr, tr.doc, insertFrom, insertTo, insertionType, deletionType, insertAttrs);
+	if (!inlineSlice) carryAcross();
+	if (!closedBlocks && $to.parent.type.name === "paragraph") {
+		const $end = tr.doc.resolve(tr.mapping.map(to));
+		if ($end.parent.type.name === "paragraph" && $end.before() !== tr.mapping.map($from.before())) recordReplacedParagraphProperties({
+			tr,
+			position: $end.before(),
+			replaced: $to.parent,
+			revision: {
+				id: insertAttrs.revisionId,
+				author: insertAttrs.author,
+				date: insertAttrs.date
+			}
+		});
+	}
+	const firstPasted = slice.content.firstChild;
+	if (selectsAll && !closedBlocks && firstPasted?.type.name === "paragraph") {
+		const $first = tr.doc.resolve(insertFrom);
+		if ($first.parent.type.name === "paragraph") carryParagraphProperties({
+			tr,
+			position: $first.before(),
+			source: firstPasted,
+			revision: {
+				id: insertAttrs.revisionId,
+				author: insertAttrs.author,
+				date: insertAttrs.date
+			},
+			styleResolver: getDocumentStyleResolver(view.state),
+			numbering: getDocumentNumbering(view.state)
+		});
+	}
+	if (rotates) {
+		const rotation = tr.steps.length;
+		const joined = rotateIntoFinalParagraph(view.state, tr, tr.mapping.map($to.before()), insertAttrs);
+		insertFrom = Math.min(tr.mapping.slice(rotation).map(insertFrom, -1), joined);
+		insertTo = tr.mapping.slice(rotation).map(insertTo);
+	}
 	tr.setSelection(TextSelection.near(tr.doc.resolve(insertTo)));
 	view.dispatch(tr.scrollIntoView());
 	return true;
 }
 /**
+* With track changes on, a paste into a table's cells (a cell selection, or a
+* block of copied cells) replaces each cell's content the way a paste over a
+* text selection does: the old content struck through, the pasted content
+* after it as an insertion. When the pasted content is whole paragraphs, the
+* last one ends the cell, so its paragraph mark is tracked as added too:
+* rejecting then drops it and accepting joins the struck paragraphs into it.
+*/
+function handleSuggestionTableCellPaste(view, slice, pluginState) {
+	const insertionType = view.state.schema.marks["insertion"];
+	const deletionType = view.state.schema.marks["deletion"];
+	if (!insertionType || !deletionType) return false;
+	const revision = makeMarkAttrs(pluginState);
+	return pasteTableCells(view.state, slice, (tr) => view.dispatch(tr.setMeta(SUGGESTION_META, true)), {
+		revision,
+		replaceCellContent: (tr, cellPos, content) => {
+			const cell = tr.doc.nodeAt(cellPos);
+			if (!cell) return;
+			const { from, to } = cellPasteRange(cell, cellPos, content);
+			const mapFrom = tr.mapping.maps.length;
+			markRangeAsDeleted(tr, tr.doc, from, to, insertionType, deletionType, pluginState);
+			const insertFrom = tr.mapping.slice(mapFrom).map(to);
+			const sizeBefore = tr.doc.content.size;
+			tr.replaceRange(insertFrom, insertFrom, content);
+			const insertTo = insertFrom + (tr.doc.content.size - sizeBefore);
+			enclosePastedRunRevisions({
+				tr,
+				from: insertFrom,
+				to: insertTo,
+				revision
+			});
+			markRangeAsInserted(tr, tr.doc, insertFrom, insertTo, insertionType, deletionType, revision);
+			tr.doc.nodesBetween(insertFrom, insertTo, (node, pos) => {
+				if (node.type.name === "paragraph" && pos >= insertFrom && pos + node.nodeSize <= insertTo && node.attrs["pPrMark"] == null) tr.setNodeAttribute(pos, "pPrMark", {
+					kind: "ins",
+					info: {
+						id: revision.revisionId,
+						author: revision.author,
+						date: revision.date
+					}
+				});
+			});
+		}
+	});
+}
+/**
+* Pasted paragraphs replaced a container's last paragraph. They were placed
+* after it, and the paragraph was struck but keeps its mark, as a container's
+* last paragraph must. Join the first pasted paragraph onto it, so the struck
+* text and the first paste share one paragraph whose break is the inserted one,
+* and record the replaced paragraph's formatting on the paragraph that now ends
+* the container: accepting leaves only the paste, and rejecting closes every
+* pasted break back into one paragraph that returns to its old formatting.
+* Returns the position of the joined paragraph.
+*/
+function rotateIntoFinalParagraph(state, tr, replacedPos, attrs) {
+	const replaced = tr.doc.nodeAt(replacedPos);
+	const first = replaced ? tr.doc.nodeAt(replacedPos + replaced.nodeSize) : null;
+	if (!replaced || !first) return replacedPos;
+	const replacedAttrs = expectParagraphAttrs(replaced);
+	const previousFormatting = {
+		...paragraphPropertiesSnapshot(replaced),
+		numPr: replacedAttrs.numPr ?? null
+	};
+	const { _sectionProperties: sectionProperties } = replaced.attrs;
+	tr.join(replacedPos + replaced.nodeSize);
+	tr.setNodeMarkup(replacedPos, void 0, first.attrs);
+	const styleResolver = getDocumentStyleResolver(state);
+	if (styleResolver && replaced.content.size > 0) rebaseParagraphRuns({
+		previousContext: paragraphRunStyleContext(replaced, styleResolver),
+		paragraphPosition: replacedPos,
+		range: {
+			from: 0,
+			to: replaced.content.size
+		},
+		styleResolver,
+		tr
+	});
+	const $joined = tr.doc.resolve(replacedPos);
+	const container = $joined.parent;
+	let finalPos = replacedPos;
+	for (let index = $joined.index(); index < container.childCount - 1; index += 1) finalPos += container.child(index).nodeSize;
+	const final = tr.doc.nodeAt(finalPos);
+	if (final) tr.setNodeMarkup(finalPos, void 0, {
+		...final.attrs,
+		pPrMark: null,
+		...sectionProperties == null ? {} : { _sectionProperties: sectionProperties },
+		_propertyChanges: [{
+			type: "paragraphPropertyChange",
+			info: {
+				id: attrs.revisionId,
+				author: attrs.author,
+				date: attrs.date
+			},
+			previousFormatting
+		}]
+	});
+	return replacedPos;
+}
+/**
 * Insert text as a tracked insertion, optionally marking replaced selection as deletion.
 */
 function applySuggestionInsert(view, from, to, text, pluginState) {
@@ -159,20 +455,79 @@ function applySuggestionInsert(view, from, to, text, pluginState) {
 	if (!insertionType) return false;
 	const tr = view.state.tr;
 	tr.setMeta(SUGGESTION_META, true);
+	tr.setMeta(SUGGESTED_TEXT_INPUT_META, text);
+	const selectsAll = view.state.selection instanceof AllSelection;
+	if (selectsAll) {
+		from = Math.max(from, Selection.atStart(view.state.doc).from);
+		to = Math.min(to, Selection.atEnd(view.state.doc).to);
+	}
+	const replacedFormatting = selectsAll ? (view.state.doc.resolve(from).nodeAfter?.marks ?? []).filter(({ type }) => RUN_FORMATTING_MARK_NAMES.has(type.name)) : null;
 	const insertAttrs = findAdjacentRevision(view.state.doc, from, "insertion", pluginState.author) || makeMarkAttrs(pluginState);
 	if (from !== to) {
 		const deletionType = view.state.schema.marks["deletion"];
-		if (deletionType) markRangeAsDeleted(tr, view.state.doc, from, to, insertionType, deletionType, pluginState);
+		if (deletionType) markRangeAsDeleted(tr, view.state.doc, from, to, insertionType, deletionType, pluginState, view.state);
 	}
 	const insertAt = tr.mapping.map(to);
 	tr.insertText(text, insertAt, insertAt);
 	const deletionType = view.state.schema.marks["deletion"];
 	if (deletionType) tr.removeMark(insertAt, insertAt + text.length, deletionType);
 	tr.addMark(insertAt, insertAt + text.length, insertionType.create(insertAttrs));
+	if (replacedFormatting) {
+		for (const mark of tr.doc.resolve(insertAt).nodeAfter?.marks ?? []) if (RUN_FORMATTING_MARK_NAMES.has(mark.type.name)) tr.removeMark(insertAt, insertAt + text.length, mark.type);
+		for (const mark of replacedFormatting) tr.addMark(insertAt, insertAt + text.length, mark);
+	}
+	separateSplitStretch(tr, insertAt, insertAt + text.length, insertAttrs.revisionId);
+	if (view.state.selection instanceof AllSelection) tr.setSelection(TextSelection.create(tr.doc, insertAt + text.length));
 	view.dispatch(tr.scrollIntoView());
 	return true;
 }
 /**
+* Text typed inside another revision leaves that revision in two stretches.
+* A saved package writes each stretch as a wrapper of its own with its own
+* `w:id`, so the stretch after the typed text gets a fresh id now: the editor
+* lists, resolves and saves the same changes a reopened package does.
+*/
+function separateSplitStretch(tr, from, to, typedId) {
+	const $from = tr.doc.resolve(from);
+	const $to = tr.doc.resolve(to);
+	const before = $from.nodeBefore;
+	if (!before || $to.parent !== $from.parent) return;
+	const parent = $to.parent;
+	const start = $to.start();
+	for (const mark of before.marks) {
+		if (mark.type.name !== "insertion" && mark.type.name !== "deletion") continue;
+		const revisionId = mark.attrs["revisionId"];
+		if (revisionId === typedId || typeof revisionId !== "number") continue;
+		let end = to;
+		let offset = to - start;
+		while (offset < parent.content.size) {
+			const child = parent.childAfter(offset).node;
+			if (!child?.marks.some((candidate) => candidate.eq(mark))) break;
+			offset += child.nodeSize;
+			end = start + offset;
+		}
+		if (end === to) continue;
+		tr.removeMark(to, end, mark);
+		tr.addMark(to, end, mark.type.create({
+			...mark.attrs,
+			revisionId: mintRevisionId()
+		}));
+	}
+}
+/**
+* Remove `from`..`to` of `tr.doc` as a suggestion: text the current author
+* inserted is retracted, anything else is marked deleted. `false` when the
+* editor is not suggesting.
+*/
+function suggestRangeDeletion(state, tr, from, to) {
+	const pluginState = suggestionModeKey.getState(state);
+	const insertionType = state.schema.marks["insertion"];
+	const deletionType = state.schema.marks["deletion"];
+	if (!pluginState?.active || !insertionType || !deletionType) return false;
+	markRangeAsDeleted(tr, tr.doc, from, to, insertionType, deletionType, pluginState);
+	return true;
+}
+/**
 * Track-changes Enter: split the paragraph and stamp `pPrMark = 'ins'` on the
 * FIRST half of the split (the upper paragraph), per ECMA-376 §17.13.5. The
 * actual splitting reuses `splitBlockClearBorders` so border/style/stored-mark
@@ -198,6 +553,13 @@ function handleSuggestionEnter(view, pluginState) {
 				info: makeParagraphMarkInfo(pluginState)
 			};
 			tr.setNodeAttribute(sourcePos, "pPrMark", markInfo);
+			const $caret = tr.selection.$from;
+			if ($caret.parent.type.name === "paragraph" && $caret.before() !== sourcePos) recordReplacedParagraphProperties({
+				tr,
+				position: $caret.before(),
+				replaced: $from.parent,
+				revision: markInfo.info
+			});
 		}
 	}
 	view.dispatch(tr.scrollIntoView());
@@ -251,9 +613,22 @@ function applyPPrDel(view, targetParagraphPos, pluginState) {
 		const tr = view.state.tr;
 		tr.setMeta(SUGGESTION_META, true);
 		const joinPos = targetParagraphPos + targetNode.nodeSize;
+		const joined = view.state.doc.nodeAt(joinPos);
 		try {
 			tr.join(joinPos);
 			tr.setNodeAttribute(targetParagraphPos, "pPrMark", null);
+			const styleResolver = getDocumentStyleResolver(view.state);
+			if (styleResolver && joined?.type === targetNode.type && joined.content.size > 0) rebaseParagraphRuns({
+				previousContext: paragraphRunStyleContext(joined, styleResolver),
+				paragraphPosition: targetParagraphPos,
+				range: {
+					from: targetNode.content.size,
+					to: targetNode.content.size + joined.content.size
+				},
+				styleResolver,
+				tr
+			});
+			tr.setMeta(JOINED_RUNS_RESTYLED_META, true);
 			view.dispatch(tr.scrollIntoView());
 		} catch {
 			return true;
@@ -268,6 +643,10 @@ function applyPPrDel(view, targetParagraphPos, pluginState) {
 		info: makeParagraphMarkInfo(pluginState)
 	};
 	tr.setNodeAttribute(targetParagraphPos, "pPrMark", markInfo);
+	carryIntoParagraphLeft(view.state, tr, targetNode, paragraphLeftAfter({
+		doc: tr.doc,
+		paragraphPos: targetParagraphPos
+	}) ?? targetParagraphPos + targetNode.nodeSize, markInfo.info);
 	view.dispatch(tr.scrollIntoView());
 	return true;
 }
@@ -291,7 +670,11 @@ function handleSuggestionDelete(state, dispatch, direction) {
 	const tr = state.tr;
 	tr.setMeta(SUGGESTION_META, true);
 	if (!empty) {
-		markRangeAsDeleted(tr, state.doc, $from.pos, $to.pos, insertionType, deletionType, pluginState);
+		const ranges = state.selection.ranges.map(({ $from: rangeFrom, $to: rangeTo }) => expandNoteReferenceDeletionRange(state.doc, rangeFrom.pos, rangeTo.pos) ?? {
+			from: rangeFrom.pos,
+			to: rangeTo.pos
+		}).sort((a, b) => b.from - a.from);
+		for (const { from, to } of ranges) markRangeAsDeleted(tr, state.doc, from, to, insertionType, deletionType, pluginState, state);
 		const cursorPos = tr.mapping.map($to.pos);
 		tr.setSelection(TextSelection.near(tr.doc.resolve(cursorPos)));
 		dispatch(tr.scrollIntoView());
@@ -301,22 +684,27 @@ function handleSuggestionDelete(state, dispatch, direction) {
 	const deletePos = isBackward ? $from.pos - 1 : $from.pos;
 	const deleteEnd = isBackward ? $from.pos : $from.pos + 1;
 	if (deletePos < 0 || deleteEnd > state.doc.content.size) return true;
-	const nodeAfter = state.doc.resolve(deletePos).nodeAfter;
+	const noteRange = expandNoteReferenceDeletionRange(state.doc, deletePos, deleteEnd);
+	const rangeFrom = noteRange?.from ?? deletePos;
+	const rangeTo = noteRange?.to ?? deleteEnd;
+	const nodeAfter = state.doc.resolve(rangeFrom).nodeAfter;
 	if (!nodeAfter || !canCarryTrackedRunMark(nodeAfter)) return false;
 	const hasOwnInsertion = nodeAfter.marks.some((m) => m.type === insertionType && m.attrs["author"] === pluginState.author);
 	if (nodeAfter.marks.some((m) => m.type === deletionType)) {
-		const newPos = isBackward ? deletePos : deleteEnd;
+		const newPos = isBackward ? rangeFrom : rangeTo;
 		tr.setSelection(TextSelection.near(tr.doc.resolve(newPos)));
-	} else if (hasOwnInsertion) tr.delete(deletePos, deleteEnd);
+	} else if (hasOwnInsertion) tr.delete(rangeFrom, rangeTo);
 	else {
-		const delAttrs = findAdjacentRevisionForRange(state.doc, deletePos, deleteEnd, "deletion", pluginState.author) || makeMarkAttrs(pluginState);
-		tr.addMark(deletePos, deleteEnd, deletionType.create(delAttrs));
-		const newPos = isBackward ? deletePos : deleteEnd;
+		const delAttrs = findAdjacentRevisionForRange(state.doc, rangeFrom, rangeTo, "deletion", pluginState.author) || makeMarkAttrs(pluginState);
+		tr.addMark(rangeFrom, rangeTo, deletionType.create(delAttrs));
+		const newPos = isBackward ? rangeFrom : rangeTo;
 		tr.setSelection(TextSelection.near(tr.doc.resolve(newPos)));
 	}
 	dispatch(tr.scrollIntoView());
 	return true;
 }
+/** Apply the editor's selected-content deletion path for a host cut action. */
+const deleteSelectionAsSuggestion = (state, dispatch) => state.selection.empty ? false : handleSuggestionDelete(state, dispatch, "forward");
 /**
 * Mark the text committed by an IME composition as a tracked insertion.
 *
@@ -329,28 +717,66 @@ function handleSuggestionDelete(state, dispatch, direction) {
 * committed range safely. `markRangeAsInserted` skips nodes that already carry a
 * tracked-change mark, so this is idempotent. eigenpal/docx-editor#938.
 */
-function markComposedAsInsertion(view, from, pluginState) {
+function markComposedAsInsertion(view, from, pluginState, replaced) {
 	const insertionType = view.state.schema.marks["insertion"];
 	const deletionType = view.state.schema.marks["deletion"];
 	if (!insertionType || !deletionType) return;
 	const to = view.state.selection.to;
-	if (to <= from) return;
+	if (to <= from && !replaced) return;
 	const tr = view.state.tr;
 	tr.setMeta(SUGGESTION_META, true);
-	const markAttrs = findAdjacentRevisionForRange(view.state.doc, from, to, "insertion", pluginState.author) || makeMarkAttrs(pluginState);
-	markRangeAsInserted(tr, view.state.doc, from, to, insertionType, deletionType, markAttrs);
+	if (replaced) {
+		tr.insert(from, replaced.content);
+		markRangeAsDeleted(tr, tr.doc, from, from + replaced.content.size, insertionType, deletionType, pluginState);
+	}
+	const insertionFrom = tr.mapping.map(from, 1);
+	const insertionTo = tr.mapping.map(to, 1);
+	if (insertionTo <= insertionFrom) {
+		if (tr.steps.length > 0) view.dispatch(tr);
+		return;
+	}
+	const markAttrs = findAdjacentRevisionForRange(tr.doc, insertionFrom, insertionTo, "insertion", pluginState.author) || makeMarkAttrs(pluginState);
+	markRangeAsInserted(tr, tr.doc, insertionFrom, insertionTo, insertionType, deletionType, markAttrs);
 	if (tr.steps.length === 0) return;
-	const caret = tr.mapping.map(to);
+	const caret = tr.mapping.map(to, 1);
 	tr.setSelection(TextSelection.create(tr.doc, caret));
 	view.dispatch(tr);
 }
 /**
+* Paragraphs inserted into one (a paste at the caret) split it: its break ends
+* the last part, which reads as the last inserted paragraph. Rejecting the
+* inserted breaks leaves that part, so it records what the paragraph read as.
+*/
+function recordSplitParagraph(tr, before, step, insertedFrom, insertedTo, attrs) {
+	if (!(step instanceof ReplaceStep) || !before) return;
+	const $at = before.resolve(step.from);
+	if ($at.parent.type.name !== "paragraph" || step.to > $at.after() || before.textBetween(step.from, step.to) !== "") return;
+	const split = $at.parent;
+	const $first = tr.doc.resolve(insertedFrom);
+	const $last = tr.doc.resolve(insertedTo);
+	let lastPos = null;
+	if ($last.parent.type.name === "paragraph") lastPos = $last.before();
+	else if ($last.nodeBefore?.type.name === "paragraph") lastPos = insertedTo - $last.nodeBefore.nodeSize;
+	if ($first.parent.type.name !== "paragraph" || lastPos === null || lastPos === $first.before()) return;
+	recordReplacedParagraphProperties({
+		tr,
+		position: lastPos,
+		replaced: split,
+		revision: {
+			id: attrs.revisionId,
+			author: attrs.author,
+			date: attrs.date
+		}
+	});
+}
+/**
 * Create the suggestion mode plugin.
 * When active, text edits become tracked changes.
 */
 function createSuggestionModePlugin(initialActive = false, author = "User") {
 	let composing = false;
 	let compositionFrom = null;
+	let compositionReplaced = null;
 	return new Plugin({
 		key: suggestionModeKey,
 		state: {
@@ -372,32 +798,32 @@ function createSuggestionModePlugin(initialActive = false, author = "User") {
 		},
 		props: {
 			handleDOMEvents: {
+				cut(view, event) {
+					if (!suggestionModeKey.getState(view.state)?.active || view.state.selection.empty) return false;
+					const data = event.clipboardData;
+					if (!data) return false;
+					const { dom, text } = view.serializeForClipboard(view.state.selection.content());
+					data.clearData();
+					data.setData("text/html", dom.innerHTML);
+					data.setData("text/plain", text);
+					event.preventDefault();
+					return handleSuggestionDelete(view.state, view.dispatch, "forward");
+				},
 				compositionstart(view) {
-					const pluginState = suggestionModeKey.getState(view.state);
-					if (!pluginState?.active) return false;
+					if (!suggestionModeKey.getState(view.state)?.active) return false;
+					if (composing) return false;
 					composing = true;
 					const { from, to } = view.state.selection;
-					if (from !== to) {
-						const insertionType = view.state.schema.marks["insertion"];
-						const deletionType = view.state.schema.marks["deletion"];
-						if (insertionType && deletionType) {
-							const tr = view.state.tr;
-							tr.setMeta(SUGGESTION_META, true);
-							markRangeAsDeleted(tr, view.state.doc, from, to, insertionType, deletionType, pluginState);
-							const caret = tr.mapping.map(to);
-							tr.setSelection(TextSelection.create(tr.doc, caret));
-							view.dispatch(tr);
-							compositionFrom = caret;
-							return false;
-						}
-					}
 					compositionFrom = from;
+					compositionReplaced = from === to ? null : view.state.doc.slice(from, to);
 					return false;
 				},
 				compositionend(view) {
 					const pluginState = suggestionModeKey.getState(view.state);
 					const from = compositionFrom;
+					const replaced = compositionReplaced;
 					compositionFrom = null;
+					compositionReplaced = null;
 					if (!pluginState?.active || from == null) {
 						composing = false;
 						return false;
@@ -405,7 +831,7 @@ function createSuggestionModePlugin(initialActive = false, author = "User") {
 					queueMicrotask(() => {
 						try {
 							const current = suggestionModeKey.getState(view.state);
-							if (current?.active) markComposedAsInsertion(view, from, current);
+							if (current?.active) markComposedAsInsertion(view, from, current, replaced);
 						} finally {
 							composing = false;
 						}
@@ -420,8 +846,15 @@ function createSuggestionModePlugin(initialActive = false, author = "User") {
 			handleKeyDown(view, event) {
 				const pluginState = suggestionModeKey.getState(view.state);
 				if (!pluginState?.active) return false;
-				if (event.key === "Enter") return handleSuggestionEnter(view, pluginState);
+				if (event.key === "Enter" && !event.shiftKey && !event.metaKey && !event.ctrlKey && !event.altKey) {
+					const { $from, empty } = view.state.selection;
+					if (empty && $from.parent.type.name === "paragraph" && expectParagraphAttrs($from.parent).numPr?.kind === "reference") return false;
+					return handleSuggestionEnter(view, pluginState);
+				}
+				if (event.key === "Backspace" && undoInputRule(view.state, view.dispatch)) return true;
 				if (event.key === "Backspace" || event.key === "Delete") {
+					const { $from, empty } = view.state.selection;
+					if (event.key === "Backspace" && empty && $from.parentOffset === 0 && $from.parent.type.name === "paragraph" && expectParagraphAttrs($from.parent).numPr?.kind === "reference") return false;
 					const boundaryTarget = paragraphBoundaryTarget(view.state, event.key === "Backspace" ? "backward" : "forward");
 					if (boundaryTarget !== null) return applyPPrDel(view, boundaryTarget, pluginState);
 					const direction = event.key === "Backspace" ? "backward" : "forward";
@@ -438,7 +871,7 @@ function createSuggestionModePlugin(initialActive = false, author = "User") {
 			handlePaste(view, _event, slice) {
 				const pluginState = suggestionModeKey.getState(view.state);
 				if (!pluginState?.active) return false;
-				return handleSuggestionPaste(view, slice, pluginState);
+				return handleSuggestionTableCellPaste(view, slice, pluginState) || handleSuggestionPaste(view, slice, pluginState);
 			}
 		},
 		appendTransaction(transactions, _oldState, newState) {
@@ -461,20 +894,14 @@ function createSuggestionModePlugin(initialActive = false, author = "User") {
 					const newFrom = following.map(stepFrom, -1);
 					const newTo = following.map(stepTo, 1);
 					if (newTo > newFrom) {
-						newState.doc.nodesBetween(newFrom, newTo, (node, pos) => {
-							if (!canCarryTrackedRunMark(node)) return;
-							if (!node.marks.some((m) => m.type === insertionType || deletionType && m.type === deletionType)) {
-								const nodeStart = Math.max(pos, newFrom);
-								const nodeEnd = Math.min(pos + node.nodeSize, newTo);
-								tr.addMark(nodeStart, nodeEnd, insertionType.create(markAttrs));
-							}
-						});
-						encloseWholeControls({
+						if (userTr.getMeta("paste")) enclosePastedRunRevisions({
 							tr,
 							from: newFrom,
 							to: newTo,
-							revisionId: markAttrs.revisionId
+							revision: markAttrs
 						});
+						if (deletionType) markRangeAsInserted(tr, newState.doc, newFrom, newTo, insertionType, deletionType, markAttrs);
+						recordSplitParagraph(tr, userTr.docs[stepIndex], step, newFrom, newTo, markAttrs);
 					}
 				});
 			}
@@ -509,4 +936,4 @@ function isSuggestionModeActive(state) {
 	return suggestionModeKey.getState(state)?.active ?? false;
 }
 //#endregion
-export { SUGGESTION_BYPASS_META, SUGGESTION_META, createSuggestionModePlugin, handleSuggestionEnter, handleSuggestionPaste, isSuggestionModeActive, makeRevisionInfo, paragraphBoundaryTarget, setSuggestionMode, suggestionModeKey, toggleSuggestionMode };
+export { SUGGESTED_TEXT_INPUT_META, SUGGESTION_BYPASS_META, SUGGESTION_META, createSuggestionModePlugin, deleteSelectionAsSuggestion, handleSuggestionEnter, handleSuggestionPaste, handleSuggestionTableCellPaste, isSuggestionModeActive, makeRevisionInfo, paragraphBoundaryTarget, setSuggestionMode, suggestRangeDeletion, suggestionModeKey, toggleSuggestionMode };