@stll/folio-core 0.55.0 → 0.57.0

package/dist/prosemirror/canonicalCommands.js

@@ -1,3 +1,4 @@
+import { canonicalSelectionRange } from "./canonicalSelectionRange.js";
 //#region src/prosemirror/canonicalCommands.ts
 const descriptors = /* @__PURE__ */ new WeakMap();
 /** Registration leaves execution and side-effect-free command probes unchanged. */
@@ -8,11 +9,10 @@ const withCanonicalCommand = (command, descriptor) => {
 const getCanonicalCommandIntents = (command, state) => descriptors.get(command)?.(state);
 const canonicalRunFormatting = (state, patch) => [{
 	type: "formatRun",
-	from: state.selection.from,
-	to: state.selection.to,
+	...canonicalSelectionRange(state),
 	patch
 }];
-const withCanonicalParagraphFormatting = (command, patch) => withCanonicalCommand(command, (state) => {
+const canonicalParagraphFormatting = (state, patch) => {
 	const intents = [];
 	state.doc.nodesBetween(state.selection.from, state.selection.to, (node, position) => {
 		if (node.type.name !== "paragraph") return;
@@ -23,6 +23,13 @@ const withCanonicalParagraphFormatting = (command, patch) => withCanonicalComman
 		});
 	});
 	return intents;
+};
+const withCanonicalParagraphFormatting = (command, patch) => withCanonicalCommand(command, (state) => canonicalParagraphFormatting(state, patch));
+/** Commands that read the selection start apply that same patch across selected paragraphs. */
+const withCanonicalStartParagraphFormatting = (command, patch) => withCanonicalCommand(command, (state) => {
+	const paragraph = state.selection.$from.parent;
+	if (paragraph.type.name !== "paragraph") return [];
+	return canonicalParagraphFormatting(state, patch(paragraph));
 });
 //#endregion
-export { canonicalRunFormatting, getCanonicalCommandIntents, withCanonicalCommand, withCanonicalParagraphFormatting };
+export { canonicalRunFormatting, getCanonicalCommandIntents, withCanonicalCommand, withCanonicalParagraphFormatting, withCanonicalStartParagraphFormatting };

package/dist/prosemirror/canonicalSelectionRange.d.ts

@@ -0,0 +1,9 @@
+import { EditorState } from "prosemirror-state";
+//#region src/prosemirror/canonicalSelectionRange.d.ts
+/** Whole-document selection addresses paragraph content rather than document edges. */
+declare const canonicalSelectionRange: ({ doc, selection }: EditorState) => {
+  from: number;
+  to: number;
+};
+//#endregion
+export { canonicalSelectionRange };

package/dist/prosemirror/canonicalSelectionRange.js

@@ -0,0 +1,15 @@
+import { AllSelection, Selection } from "prosemirror-state";
+//#region src/prosemirror/canonicalSelectionRange.ts
+/** Whole-document selection addresses paragraph content rather than document edges. */
+const canonicalSelectionRange = ({ doc, selection }) => {
+	if (selection instanceof AllSelection) return {
+		from: Selection.atStart(doc).from,
+		to: Selection.atEnd(doc).to
+	};
+	return {
+		from: selection.from,
+		to: selection.to
+	};
+};
+//#endregion
+export { canonicalSelectionRange };

package/dist/prosemirror/clipboardIntent.d.ts

@@ -0,0 +1,7 @@
+import { Slice } from "prosemirror-model";
+import { EditorView } from "prosemirror-view";
+//#region src/prosemirror/clipboardIntent.d.ts
+declare const registerClipboardIntentHandler: (view: EditorView, handler: (slice: Slice, plain: boolean) => boolean) => void;
+declare const dispatchClipboardIntent: (view: EditorView, slice: Slice) => boolean | undefined;
+//#endregion
+export { dispatchClipboardIntent, registerClipboardIntentHandler };

package/dist/prosemirror/clipboardIntent.js

@@ -0,0 +1,9 @@
+//#region src/prosemirror/clipboardIntent.ts
+/** Async clipboard reads resolve against the current owning session and selection. */
+const handlers = /* @__PURE__ */ new WeakMap();
+const registerClipboardIntentHandler = (view, handler) => {
+	handlers.set(view, handler);
+};
+const dispatchClipboardIntent = (view, slice) => handlers.get(view)?.(slice, true);
+//#endregion
+export { dispatchClipboardIntent, registerClipboardIntentHandler };

package/dist/prosemirror/commands/comments.js

@@ -10,20 +10,23 @@ 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 { canonicalFieldNode } from "../fieldRepresentation.js";
 import { resolveStateStory } from "../markupViewProjection.js";
 import { joinAtParagraphMark } from "../paragraphMarkJoin.js";
 import { getDocumentNumbering } from "../plugins/documentNumbering.js";
 import { getDocumentStyleResolver } from "../plugins/documentStyleState.js";
+import { resolvedPreservedXmlAttrs } from "../preservedXmlReview.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 { reconstructRejectedRunFormattingMarks, restoreHistoricalRunFormatting } from "../runPropertyChangeResolution.js";
 import { paragraphRunStyleContext, paragraphRunStyleContextAt } from "../runStyleFormatting.js";
 import { getTableCellMergeChange } from "../tableCellMergeRevision.js";
 import { isTableCellRetainedInReviewView } from "../tableCellRevisionVisibility.js";
 import { markRowEmptiedInBatch, reconcileTableGridAfterColumnRemoval, removeRowsWithoutCellsAfterBatch, removeTableRow } from "../tableGridMutation.js";
 import { runInCellPending, runParagraphIntoTable } from "../tableRunIn.js";
+import { retainedTrackedRevisionMark, trackedRevisionPathOf } from "../trackedRevisionPath.js";
 import { holdsNoContent } from "../zeroWidthAnchors.js";
 import { inlineBookmarksForParagraphJoin } from "./paragraphBookmarkJoin.js";
 import { hasSerializableParagraphPropertyChange, paragraphPropertiesSnapshot } from "./propertyChangeScope.js";
@@ -32,10 +35,16 @@ import { resolveParagraphChangeAttrs } from "./resolveParagraphProperties.js";
 import { hasMatchingCollapsedTableCellMerge, resolveCollapsedTableCellMerge, resolveVisibleTableCellMerge } from "./tableCellMergeResolution.js";
 import { panic } from "better-result";
 import { PARAGRAPH_MARK_CHANGE_KINDS, REVIEW_CARRIERS } from "@stll/docx-core/model";
+import { Fragment } from "prosemirror-model";
 import { TableMap } from "prosemirror-tables";
 import { Mapping } from "prosemirror-transform";
 //#region src/prosemirror/commands/comments.ts
 /**
+* Comment and Track Changes Commands
+*
+* PM commands for adding/removing comments and accepting/rejecting tracked changes.
+*/
+/**
 * Add a comment mark to the current selection.
 */
 function addCommentMark(commentId) {
@@ -67,21 +76,6 @@ function removeCommentMark(commentId) {
 		return true;
 	};
 }
-const revisionLayerOf = (mark) => {
-	const attrs = expectTrackedChangeMarkAttrs(mark);
-	let type;
-	if (mark.type.name === "insertion") type = attrs.moveKind === "moveTo" ? "moveTo" : "insertion";
-	else type = attrs.moveKind === "moveFrom" ? "moveFrom" : "deletion";
-	return {
-		type,
-		revisionId: attrs.revisionId,
-		author: attrs.author,
-		...attrs.date ? { date: attrs.date } : {},
-		...attrs.utcDate ? { utcDate: attrs.utcDate } : {},
-		...attrs.initials ? { initials: attrs.initials } : {},
-		outerWrapperCount: attrs._docxOuterWrapperCount ?? 0
-	};
-};
 const revisionLayerRemovesContent = (layer, mode) => mode === "accept" ? layer.type === "deletion" || layer.type === "moveFrom" : layer.type === "insertion" || layer.type === "moveTo";
 /**
 * Resolve a tracked change: accept or reject.
@@ -189,6 +183,19 @@ function resolveChange(from, to, mode, revisionIds) {
 				const runPropertyChangeMark = node.marks.find((mark) => mark.type.name === "runPropertyChange");
 				const removesNode = removeType !== void 0 && node.marks.some((mark) => mark.type === removeType && matchesRevision(mark));
 				if (removesNode || runPropertyChangeMark !== void 0 || node.marks.some((mark) => (mark.type === insertionType || mark.type === deletionType) && matchesRevision(mark))) resolvedBoundaries.push(rangeFrom, rangeTo);
+				if (mode === "reject" && node.marks.find((mark) => mark.type === keepType && matchesRevision(mark) && expectTrackedChangeMarkAttrs(mark)._historicalFormatting && !expectTrackedChangeMarkAttrs(mark)._docxRevisionAncestors?.some((layer) => (layer.type === "deletion" || layer.type === "moveFrom") && revisionSet !== null && !revisionSet.has(layer.revisionId))) && !removesNode) {
+					const nextMarks = restoreHistoricalRunFormatting({
+						node,
+						paragraphContext: paragraphRunStyleContextAt({
+							doc: tr.doc,
+							pos: rangeFrom,
+							styleResolver
+						}),
+						styleResolver
+					});
+					for (const mark of node.marks) if (RUN_FORMATTING_MARK_NAMES.has(mark.type.name)) tr.removeMark(rangeFrom, rangeTo, mark);
+					for (const mark of nextMarks) if (RUN_FORMATTING_MARK_NAMES.has(mark.type.name)) tr.addMark(rangeFrom, rangeTo, mark);
+				}
 				if (runPropertyChangeMark) resolveRunPropertyChange({
 					tr,
 					node,
@@ -201,7 +208,7 @@ function resolveChange(from, to, mode, revisionIds) {
 				});
 				const nestedMark = node.marks.find((mark) => (mark.type === insertionType || mark.type === deletionType) && (expectTrackedChangeMarkAttrs(mark)._docxRevisionAncestors?.length ?? 0) > 0);
 				if (nestedMark) {
-					const path = [...expectTrackedChangeMarkAttrs(nestedMark)._docxRevisionAncestors ?? [], revisionLayerOf(nestedMark)];
+					const path = trackedRevisionPathOf(nestedMark);
 					const selected = (layer) => revisionSet === null || revisionSet.has(layer.revisionId);
 					if (path.some(selected)) if (path.some((layer) => selected(layer) && revisionLayerRemovesContent(layer, mode))) deleteRanges.push({
 						from: rangeFrom,
@@ -209,23 +216,13 @@ function resolveChange(from, to, mode, revisionIds) {
 					});
 					else {
 						tr.removeMark(rangeFrom, rangeTo, nestedMark);
-						const remaining = path.filter((layer) => !selected(layer));
-						const active = remaining.at(-1);
-						if (active) {
-							const type = active.type === "insertion" || active.type === "moveTo" ? insertionType : deletionType;
-							if (!type) panic("A nested tracked revision has no editor mark type");
-							tr.addMark(rangeFrom, rangeTo, type.create({
-								revisionId: active.revisionId,
-								author: active.author,
-								date: active.date ?? null,
-								utcDate: active.utcDate ?? null,
-								initials: active.initials ?? null,
-								moveKind: active.type === "moveTo" || active.type === "moveFrom" ? active.type : null,
-								_historicalFormatting: active.type === "deletion" || active.type === "moveFrom" ? true : null,
-								_docxOuterWrapperCount: active.outerWrapperCount,
-								_docxRevisionAncestors: remaining.length > 1 ? remaining.slice(0, -1) : null
-							}));
-						}
+						const retained = retainedTrackedRevisionMark(nestedMark, (layer) => !selected(layer));
+						if (retained) tr.addMark(rangeFrom, rangeTo, retained);
+					}
+					const current = tr.doc.nodeAt(pos);
+					if (current) {
+						const attrs = resolvedPreservedXmlAttrs(node, current.marks);
+						if (attrs !== node.attrs) tr.setNodeMarkup(pos, void 0, attrs);
 					}
 					return true;
 				}
@@ -233,6 +230,10 @@ function resolveChange(from, to, mode, revisionIds) {
 					from: rangeFrom,
 					to: rangeTo
 				});
+				if (!removesNode && keepType && node.marks.some((mark) => mark.type === keepType && matchesRevision(mark))) {
+					const attrs = resolvedPreservedXmlAttrs(node, node.marks.filter((mark) => !(mark.type === keepType && matchesRevision(mark))));
+					if (attrs !== node.attrs) tr.setNodeMarkup(pos, void 0, attrs);
+				}
 				if (!removeKeptMarksInBulk) {
 					for (const mark of node.marks) if (keepType && mark.type === keepType && matchesRevision(mark)) tr.removeMark(rangeFrom, rangeTo, mark);
 				}
@@ -255,7 +256,17 @@ function resolveChange(from, to, mode, revisionIds) {
 				}
 				rangesToDelete = coalescedDeleteRanges;
 			}
-			for (const range of rangesToDelete.toReversed()) tr.delete(range.from, range.to);
+			for (const range of rangesToDelete.toReversed()) {
+				const start = tr.doc.resolve(range.from);
+				const field = start.parent;
+				if (field.type.name === "structuredField" && start.parentOffset === 0 && range.to === start.end()) {
+					const position = start.before();
+					const empty = canonicalFieldNode(field.copy(Fragment.empty));
+					tr.replaceWith(position, position + field.nodeSize, empty);
+					continue;
+				}
+				tr.delete(range.from, range.to);
+			}
 			if (deleteTextBoxesAnchoredAt(tr, droppedTextBoxAnchorIds(state.doc, tr.doc))) markStructuralChange(tr);
 			tableRowStructuralOps.sort((left, right) => right.rowPos - left.rowPos);
 			let resolvedTableRowStructure = false;
@@ -418,6 +429,20 @@ function resolveChange(from, to, mode, revisionIds) {
 				boundaries: resolvedBoundaries.map((position) => tr.mapping.map(position)).filter((position) => !seams.has(position)),
 				styleResolver
 			});
+			const resolvedFields = [];
+			tr.doc.descendants((node, position) => {
+				const canonical = canonicalFieldNode(node);
+				if (canonical !== node) resolvedFields.push({
+					node: canonical,
+					position
+				});
+			});
+			for (const { node, position } of resolvedFields.toReversed()) {
+				const field = tr.doc.nodeAt(position);
+				if (!field) continue;
+				if (field.type === node.type) tr.setNodeMarkup(position, void 0, node.attrs, node.marks);
+				else tr.replaceWith(position, position + field.nodeSize, node);
+			}
 			if (tr.steps.length > 0) dispatch(tr);
 		}
 		return true;

package/dist/prosemirror/commands/pageBreak.js

@@ -1,4 +1,5 @@
 import { withCanonicalCommand } from "../canonicalCommands.js";
+import { canonicalSelectionRange } from "../canonicalSelectionRange.js";
 import { pageBreakRunParagraphProjectionDisposition } from "../pageBreakRunProjection.js";
 //#region src/prosemirror/commands/pageBreak.ts
 const UNSUPPORTED_PAGE_BREAK_RUN_ANCESTORS = /* @__PURE__ */ new Set([
@@ -46,8 +47,7 @@ const insertPageBreakCommand = (state, dispatch) => {
 */
 const insertPageBreak = withCanonicalCommand(insertPageBreakCommand, (state) => insertPageBreakCommand(state) ? [{
 	type: "insertBreak",
-	from: state.selection.from,
-	to: state.selection.to,
+	...canonicalSelectionRange(state),
 	breakType: "page"
 }] : []);
 //#endregion

package/dist/prosemirror/commands/pastePlainText.js

@@ -1,3 +1,4 @@
+import { dispatchClipboardIntent } from "../clipboardIntent.js";
 import { Fragment, Slice } from "prosemirror-model";
 //#region src/prosemirror/commands/pastePlainText.ts
 /**
@@ -54,7 +55,7 @@ const pasteWithoutFormatting = (state, dispatch, view) => {
 	navigator.clipboard.readText().then((text) => {
 		if (!text || view.isDestroyed) return;
 		const slice = buildPlainTextSlice(text, schema);
-		view.dispatch(view.state.tr.replaceSelection(slice).scrollIntoView());
+		if (dispatchClipboardIntent(view, slice) === void 0) view.dispatch(view.state.tr.replaceSelection(slice).scrollIntoView());
 	}).catch((error) => {
 		if (typeof CustomEvent === "function" && !view.isDestroyed) view.dom.dispatchEvent(new CustomEvent(CLIPBOARD_READ_ERROR_EVENT, {
 			detail: { error },

package/dist/prosemirror/commands/propertyChangeScope.js

@@ -4,6 +4,7 @@ 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 { directParagraphIndentation } from "../paragraphIndentation.js";
 import { directParagraphSpacing, paragraphSpacingAttrPatch, paragraphSpacingFromFormatting } from "../paragraphSpacing.js";
 import { sameFormattingValue } from "../runFormattingFromMarks.js";
 //#region src/prosemirror/commands/propertyChangeScope.ts
@@ -127,18 +128,14 @@ 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) || key === "numPr" && isStyleSourcedParagraphNumbering(attrs.numPr, attrs.numPrFromStyle)) continue;
+		if (key === "alignment" || key === "indentLeft" || key === "indentRight" || key === "indentFirstLine" || key === "hangingIndent" || PPR_SPACING_ATTR_KEYS.has(key) || key === "numPr" && isStyleSourcedParagraphNumbering(attrs.numPr, attrs.numPrFromStyle)) continue;
 		if (styleSuppliedParagraphValue(attrs, key)) continue;
-		if (key === "hangingIndent" && styleSuppliedParagraphValue(attrs, "indentFirstLine")) 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;
 	}
 	const directAlignment = directParagraphAlignment(attrs);
 	if (directAlignment !== void 0) snapshot["alignment"] = directAlignment;
-	Object.assign(snapshot, directParagraphSpacing(attrs));
+	Object.assign(snapshot, directParagraphSpacing(attrs), directParagraphIndentation(attrs));
 	return snapshot;
 };
 /**

package/dist/prosemirror/commands/resolveParagraphProperties.js

@@ -2,8 +2,9 @@ import { resolveParagraphNumbering } from "../../docx/numberingReference.js";
 import { expectParagraphAttrs } from "../attrs/index.js";
 import { rejectedListRenderingPatch } from "../listRendering.js";
 import { paragraphNumberingAttr } from "../numberingAttr.js";
-import { styleResolvedParagraphFormatting } from "../paragraphFormattingProvenance.js";
+import { paragraphIndentationFromFormatting } from "../paragraphIndentation.js";
 import { resolveParagraphDefaultTextFormatting } from "../styles/paragraphStyleCascade.js";
+import { listIndentationProvenancePatch } from "../styles/resolvedStyleAttrs.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. */
@@ -27,24 +28,32 @@ const resolveParagraphChangeAttrs = ({ node, boundaryCovered, mode, revisionSet,
 				const inheritedAlignment = currentAttrs.alignmentFromStyle;
 				const restoredStyleId = rejection.previousFormatting?.styleId ?? void 0;
 				const sameStyle = restoredStyleId === (currentAttrs.styleId ?? void 0);
-				let previousFormattingFromStyle;
-				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 : {
+				let previousFormattingFromStyle = sameStyle ? currentAttrs._styleResolvedFormatting : void 0;
+				if (styleResolver) previousFormattingFromStyle = styleResolver.resolveParagraphStyle(restoredStyleId).paragraphFormatting;
+				else if (inheritedAlignment !== void 0) previousFormattingFromStyle = {
 					...previousFormattingFromStyle,
-					...resolvedFromStyle
+					alignment: inheritedAlignment
 				};
 				let styleNumbering = previousFormattingFromStyle?.numPr;
 				if (!styleResolver && sameStyle) styleNumbering = currentAttrs.numPrFromStyle ?? void 0;
 				const inheritedNumbering = styleNumbering == null ? null : paragraphNumberingAttr(resolveParagraphNumbering(styleNumbering));
 				const recordedNumbering = rejection.previousFormatting?.numPr;
 				const restoredNumbering = recordedNumbering ?? inheritedNumbering;
+				const restoredFormatting = paragraphRejectOriginalFormatting(rejection.previousFormatting, node.attrs["_originalFormatting"]);
+				const indentation = listIndentationProvenancePatch({
+					direct: paragraphIndentationFromFormatting(restoredFormatting ?? void 0),
+					styleFormatting: previousFormattingFromStyle,
+					numberingSource: recordedNumbering == null ? "style" : "paragraph",
+					numPr: restoredNumbering?.kind === "reference" ? {
+						numId: restoredNumbering.numId,
+						ilvl: restoredNumbering.ilvl ?? 0
+					} : void 0,
+					numbering
+				});
+				const inheritedFormatting = {
+					...previousFormattingFromStyle,
+					...indentation._resolvedFormatting
+				};
 				Object.assign(nextAttrs, paragraphRejectAttrPatch(rejection.previousFormatting, inheritedFormatting), rejectedListRenderingPatch({
 					current: expectParagraphAttrs(node),
 					previousFormatting: rejection.previousFormatting,
@@ -54,7 +63,7 @@ const resolveParagraphChangeAttrs = ({ node, boundaryCovered, mode, revisionSet,
 					numPr: restoredNumbering,
 					numPrFromStyle: recordedNumbering == null ? inheritedNumbering : null
 				});
-				const restoredFormatting = paragraphRejectOriginalFormatting(rejection.previousFormatting, node.attrs["_originalFormatting"]);
+				Object.assign(nextAttrs, indentation);
 				nextAttrs["_originalFormatting"] = restoredFormatting;
 				if (styleResolver) nextAttrs["defaultTextFormatting"] = resolveParagraphDefaultTextFormatting(rejection.previousFormatting?.styleId, restoredFormatting ?? void 0, styleResolver) ?? null;
 			}

package/dist/prosemirror/commentOps.js

@@ -1,6 +1,14 @@
+import { addTrackedDeletionMark } from "./addTrackedDeletionMark.js";
 import { findTextInPmParagraph } from "./paraText.js";
 import { findParagraphByParaId } from "./utils/findParagraphByParaId.js";
 //#region src/prosemirror/commentOps.ts
+/**
+* Comment + tracked-change (proposeChange) PM transaction builders shared by
+* the React and Vue adapters. They locate the target range, apply the mark(s),
+* dispatch, and return a result. ID allocation lives in `commentIdAllocator.ts`
+* and is injected. Adapter-specific state mutation, event emission, and sidebar
+* UI stay in each adapter.
+*/
 /** Build a Comment object with a freshly-allocated ID. */
 function createComment(allocator, text, authorName, parentId) {
 	return {
@@ -95,7 +103,13 @@ function applyProposedChange(view, options, allocator) {
 		date
 	});
 	let tr = view.state.tr;
-	if (!isInsertion) tr = tr.addMark(textFrom, textTo, deletionMark);
+	if (!isInsertion) addTrackedDeletionMark({
+		insertionPolicy: "preserve-pending",
+		tr,
+		from: textFrom,
+		to: textTo,
+		mark: deletionMark
+	});
 	if (!isDeletion) tr = tr.insert(textTo, schema.text(options.replaceWith, [insertionMark]));
 	view.dispatch(tr);
 	return true;

package/dist/prosemirror/conversion/fromProseDoc.js

@@ -4,7 +4,7 @@ import { normalizeFoldedListNumbers } from "../../docx/foldedListNumberFields.js
 import { EDITED_PREVIEW_FINGERPRINT, imageRawXmlFingerprint } from "../../docx/imageRawXml.js";
 import { isInlineSdtContent, isSimpleFieldContent } from "../../docx/inlineWrapperContent.js";
 import { paragraphNumberingReferenceId as paragraphNumberingReferenceId$1, sameStatedParagraphNumbering as sameStatedParagraphNumbering$1 } from "../../docx/numberingReference.js";
-import { PROSE_PARAGRAPH_SOURCE_CONTRACT_ATTR, ParagraphPropertySourceValidationError, copyDocumentParagraphPropertySourceContract, copyDocumentParagraphPropertySources, copyParagraphPropertyCapture, copyParagraphPropertySource, decodeTableCellParagraphSourcePayload, getDocumentParagraphPropertySourceContract, getParagraphPropertySource, getParagraphPropertySourceCandidate, getParagraphPropertySourceToken, getParagraphPropertySourceTransferId, getProseDocumentParagraphPropertySourceContract, getProseParagraphPropertySourceToken, inspectParagraphSourceIdentity, isParagraphPropertySourceToken, linkParagraphPropertySourceCandidate, paragraphPropertySourceTokenMatchesContract, recreateProseNodeWithParagraphPropertySource, restoreTableCellsWithParagraphPropertySources, visitDocumentStoryParagraphs, visitTableCellParagraphPropertySourceBindings } from "../../docx/paragraphPropertySource.js";
+import { PROSE_PARAGRAPH_SOURCE_CONTRACT_ATTR, ParagraphPropertySourceValidationError, assignParagraphIndentationProjection, copyDocumentParagraphPropertySourceContract, copyDocumentParagraphPropertySources, copyParagraphPropertyCapture, copyParagraphPropertySource, decodeTableCellParagraphSourcePayload, getDocumentParagraphPropertySourceContract, getParagraphPropertySource, getParagraphPropertySourceCandidate, getParagraphPropertySourceToken, getParagraphPropertySourceTransferId, getProseDocumentParagraphPropertySourceContract, getProseParagraphPropertySourceToken, inspectParagraphSourceIdentity, isParagraphPropertySourceToken, linkParagraphPropertySourceCandidate, paragraphFormattingWithAuthoredIndentation, paragraphPropertySourceTokenMatchesContract, recreateProseNodeWithParagraphPropertySource, restoreTableCellsWithParagraphPropertySources, visitDocumentStoryParagraphs, visitTableCellParagraphPropertySourceBindings } from "../../docx/paragraphPropertySource.js";
 import { BLOCK_TREE_DESCENT, visitBlockTreeRecords, visitDocxParagraphs } from "../../docx/paragraphTraversal.js";
 import { refingerprintShapeAlternateContent } from "../../docx/shapeAlternateContent.js";
 import { DATE_UTC_ATTRIBUTE } from "../../docx/trackedChangeInfo.js";
@@ -33,9 +33,11 @@ import { inlineWrapperMember, inlineWrapperStackKey } from "../inlineWrapperStac
 import { completeNumberingForDoc } from "../listInstanceReferences.js";
 import { hasListRendering, listRenderingFromAttrs as listRenderingFromAttrs$1 } from "../listRenderingAttrs.js";
 import { expectMoveRangeBoundaryAttrs } from "../moveRangeBoundaryAttrs.js";
+import { assertNoteReferenceOccurrences, coalesceNoteReferenceOccurrences } from "../noteReferenceOccurrences.js";
 import { resolveNumberedRefFields } from "../numberedRefFields.js";
 import { directParagraphAlignment } from "../paragraphAlignment.js";
 import { directionToAuthoredBidi } from "../paragraphDirection.js";
+import { paragraphIndentationFromFormatting } from "../paragraphIndentation.js";
 import { directParagraphSpacing } from "../paragraphSpacing.js";
 import { expectRangeAnchorAttrs } from "../rangeAnchorAttrs.js";
 import { marksToTextFormatting, sameFormattingValue } from "../runFormattingFromMarks.js";
@@ -161,6 +163,13 @@ const restoreParagraphPropertySource = (paragraph, baseParagraph) => {
 	copyParagraphPropertySource(paragraph, baseParagraph);
 	const baseFormatting = baseParagraph.formatting;
 	if (!baseFormatting) return;
+	if (baseFormatting.indentLeft !== void 0 || baseFormatting.indentRight !== void 0 || baseFormatting.indentFirstLine !== void 0 || baseFormatting.hangingIndent !== void 0) {
+		const authored = paragraphFormattingWithAuthoredIndentation(baseParagraph);
+		if ((authored?.indentLeft !== baseFormatting.indentLeft || authored?.indentRight !== baseFormatting.indentRight || authored?.indentFirstLine !== baseFormatting.indentFirstLine || authored?.hangingIndent !== baseFormatting.hangingIndent) && canonicalJson(modelParagraphFormattingEmission(paragraph.formatting)) === canonicalJson(modelParagraphFormattingEmission(authored))) {
+			paragraph.formatting = { ...baseFormatting };
+			return;
+		}
+	}
 	const { numPr, numPrFromStyle } = baseFormatting;
 	if (!numPr || !numPrFromStyle || !isStyleSourcedParagraphNumbering(numPr, numPrFromStyle)) return;
 	if (canonicalJson(modelParagraphFormattingEmission(paragraph.formatting)) !== canonicalJson(modelParagraphFormattingEmission(baseFormatting))) return;
@@ -263,6 +272,7 @@ const restoreLinkedParagraphPropertySources = (content) => {
 };
 /** Convert a ProseMirror document to the document model. */
 function fromProseDoc(pmDoc, baseDocument, { reuse = "none" } = {}) {
+	assertNoteReferenceOccurrences(pmDoc);
 	switch (reuse) {
 		case "none": break;
 		case "matched": panic("fromProseDoc: reuse \"matched\" is not implemented");
@@ -970,6 +980,14 @@ function convertPMParagraph(node, documentCounts, textBoxAnchorMarkers, styleRes
 	if (attrs.reviewCarrier) paragraph.reviewCarrier = attrs.reviewCarrier;
 	const pFormatting = paragraphAttrsToFormatting(attrs);
 	if (pFormatting) paragraph.formatting = pFormatting;
+	if (attrs.numPr?.kind === "reference") {
+		const inheritedIndentation = paragraphIndentationFromFormatting(attrs._resolvedFormatting);
+		if (inheritedIndentation) assignParagraphIndentationProjection({
+			paragraph,
+			authored: pFormatting,
+			inherited: inheritedIndentation
+		});
+	}
 	const listRendering = listRenderingFromAttrs(attrs);
 	if (listRendering) paragraph.listRendering = listRendering;
 	normalizeFoldedListNumbers(paragraph);
@@ -1373,7 +1391,8 @@ const nestInlineWrapperGroups = (items, groups, hyperlinkIndices, revisionOuterW
 	}
 	return coalesced;
 };
-function extractParagraphContent(paragraph, _documentCounts, emptyHyperlinks, textBoxAnchorMarkers, skipLeadingRenderedPageBreak = false, inheritedFormattingOverride) {
+function extractParagraphContent(originalParagraph, _documentCounts, emptyHyperlinks, textBoxAnchorMarkers, skipLeadingRenderedPageBreak = false, inheritedFormattingOverride) {
+	const paragraph = coalesceNoteReferenceOccurrences(originalParagraph);
 	const content = [];
 	const paragraphStyleContext = paragraph.type.name === "paragraph" ? paragraphRunStyleContext(paragraph) : void 0;
 	const formattingContext = inheritedFormattingOverride ?? {
@@ -2463,7 +2482,7 @@ const synchronizeFieldDisplayText = (content, displayText, fallbackRun) => {
 				visit(child);
 				continue;
 			}
-			if (child.type === "hyperlink" || child.type === "inlineWrapper") visitRunsIn(child.type === "hyperlink" ? child.children : child.content, visit);
+			if (child.type === "hyperlink" || child.type === "inlineWrapper" || child.type === "insertion" || child.type === "deletion" || child.type === "moveFrom" || child.type === "moveTo") visitRunsIn(child.type === "hyperlink" ? child.children : child.content, visit);
 		}
 	};
 	const visitRuns = (visit) => {

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

@@ -0,0 +1,8 @@
+//#region src/prosemirror/conversion/hyphenTextCarriers.d.ts
+/** These source units render as native text while keeping one logical atom each. */
+declare const HYPHEN_TEXT_CARRIERS: {
+  readonly softHyphen: "­";
+  readonly noBreakHyphen: "‑";
+};
+//#endregion
+export { HYPHEN_TEXT_CARRIERS };

package/dist/prosemirror/conversion/hyphenTextCarriers.js

@@ -0,0 +1,8 @@
+//#region src/prosemirror/conversion/hyphenTextCarriers.ts
+/** These source units render as native text while keeping one logical atom each. */
+const HYPHEN_TEXT_CARRIERS = {
+	softHyphen: "­",
+	noBreakHyphen: "‑"
+};
+//#endregion
+export { HYPHEN_TEXT_CARRIERS };

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

@@ -18,6 +18,12 @@ type ToProseDocOptions = {
    */
   warn?: ParseContext["warn"];
 };
+/**
+ * Find bookmark pairs across every editable inline wrapper in a document story.
+ * Each endpoint is converted at its own structural position, so a range may
+ * start outside a hyperlink and end inside it (or the inverse).
+ */
+declare const collectPairedBookmarkIds: (blocks: readonly document_d_exports.BlockContent[]) => ReadonlySet<number>;
 /**
  * Convert a Document to a ProseMirror document
  *
@@ -40,4 +46,4 @@ declare function footnoteToProseDoc(content: document_d_exports.BlockContent[],
  */
 declare function createEmptyDoc(): Node;
 //#endregion
-export { ToProseDocOptions, createEmptyDoc, footnoteToProseDoc, headerFooterToProseDoc, standaloneTableCellToProseMirror, toProseDoc };
+export { ToProseDocOptions, collectPairedBookmarkIds, createEmptyDoc, footnoteToProseDoc, headerFooterToProseDoc, standaloneTableCellToProseMirror, toProseDoc };