@stll/folio-core 0.56.0 → 0.57.0

package/dist/prosemirror/plugins/suggestionMode.js

@@ -1,3 +1,4 @@
+import { addTrackedDeletionMark } from "../addTrackedDeletionMark.js";
 import { expectParagraphAttrs, expectTrackedChangeMarkAttrs } from "../attrs/index.js";
 import { clearIndentOnBackspace } from "../commands/clearParagraphIndent.js";
 import { paragraphPropertiesSnapshot } from "../commands/propertyChangeScope.js";
@@ -117,20 +118,13 @@ function findAdjacentRevisionForRange(doc, from, to, markTypeName, author) {
 * 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, joinState) {
-	const ranges = [];
+function markRangeAsDeleted(tr, doc, from, to, deletionType, pluginState, joinState) {
+	let hasMarkableContent = false;
 	doc.nodesBetween(from, to, (node, pos) => {
 		if (!canCarryTrackedRunMark(node)) return;
-		const start = Math.max(pos, from);
-		const end = Math.min(pos + node.nodeSize, to);
-		if (start >= end) return;
-		const isOwnInsert = node.marks.some((m) => m.type === insertionType && m.attrs["author"] === pluginState.author);
+		if (Math.max(pos, from) >= Math.min(pos + node.nodeSize, to)) return;
 		if (node.marks.some((m) => m.type === deletionType)) return;
-		ranges.push({
-			from: start,
-			to: end,
-			isOwnInsert
-		});
+		hasMarkableContent = true;
 	});
 	const delAttrs = findAdjacentRevisionForRange(doc, from, to, "deletion", pluginState.author) || makeMarkAttrs(pluginState);
 	let removedMark = false;
@@ -165,18 +159,20 @@ function markRangeAsDeleted(tr, doc, from, to, insertionType, deletionType, plug
 			date: delAttrs.date
 		});
 	}
-	if (ranges.length === 0) return;
+	if (!hasMarkableContent) return;
 	encloseWholeControls({
 		tr,
 		from,
 		to,
 		revisionId: delAttrs.revisionId
 	});
-	for (let i = ranges.length - 1; i >= 0; i--) {
-		const range = ranges[i];
-		if (range.isOwnInsert) tr.delete(range.from, range.to);
-		else tr.addMark(range.from, range.to, deletionType.create(delAttrs));
-	}
+	addTrackedDeletionMark({
+		tr,
+		from,
+		to,
+		mark: deletionType.create(delAttrs),
+		insertionPolicy: "retract-own"
+	});
 }
 /** Preserve clipboard revisions inside the revision that inserted their content. */
 function enclosePastedRunRevisions({ tr, from, to, revision: insertion }) {
@@ -298,7 +294,7 @@ function handleSuggestionPaste(view, slice, pluginState) {
 	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);
+	if (!tableFirst) markRangeAsDeleted(tr, doc, from, wholeBlocks && !endsContainer ? $to.after() : to, 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());
@@ -332,7 +328,7 @@ function handleSuggestionPaste(view, slice, pluginState) {
 	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);
+		markRangeAsDeleted(tr, tr.doc, tr.mapping.map(from), tr.mapping.map(to), deletionType, pluginState);
 		const since = tr.mapping.slice(struck);
 		insertFrom = since.map(insertFrom, -1);
 		insertTo = since.map(insertTo, -1);
@@ -405,7 +401,7 @@ function handleSuggestionTableCellPaste(view, slice, pluginState) {
 			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);
+			markRangeAsDeleted(tr, tr.doc, from, to, deletionType, pluginState);
 			const insertFrom = tr.mapping.slice(mapFrom).map(to);
 			const sizeBefore = tr.doc.content.size;
 			tr.replaceRange(insertFrom, insertFrom, content);
@@ -538,7 +534,7 @@ function applySuggestionInsert(view, from, to, text, pluginState) {
 	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, view.state);
+		if (deletionType) markRangeAsDeleted(tr, view.state.doc, from, to, deletionType, pluginState, view.state);
 	}
 	const insertAt = tr.mapping.map(to);
 	tr.insertText(text, insertAt, insertAt);
@@ -597,7 +593,7 @@ function suggestRangeDeletion(state, tr, from, to) {
 	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);
+	markRangeAsDeleted(tr, tr.doc, from, to, deletionType, pluginState);
 	return true;
 }
 /**
@@ -665,19 +661,19 @@ function handleSuggestionEnter(view, pluginState) {
 function caretDeleteTarget(state, direction) {
 	const { $from } = state.selection;
 	const backward = direction === "backward";
-	let from = backward ? $from.pos - 1 : $from.pos;
-	let to = backward ? $from.pos : $from.pos + 1;
-	while (from >= $from.start() && to <= $from.end()) {
-		const $adjacent = state.doc.resolve(from);
-		const adjacent = $adjacent.nodeAfter;
-		if (!adjacent || adjacent.type.name !== "bookmarkBoundary" && !adjacent.marks.some((mark) => mark.type === state.schema.marks["deletion"])) return {
-			type: "inlineUnit",
-			from,
-			to
-		};
-		const skipped = backward && adjacent.isText ? $adjacent.textOffset + 1 : adjacent.nodeSize;
-		from += backward ? -skipped : skipped;
-		to += backward ? -skipped : skipped;
+	let cursor = $from.pos;
+	while (cursor >= $from.start() && cursor <= $from.end()) {
+		const adjacent = backward ? state.doc.resolve(cursor).nodeBefore : state.doc.resolve(cursor).nodeAfter;
+		if (!adjacent) return { type: "paragraphEdge" };
+		if (adjacent.type.name !== "bookmarkBoundary" && !adjacent.marks.some((mark) => mark.type === state.schema.marks["deletion"])) {
+			const size = adjacent.isAtom && !adjacent.isText ? adjacent.nodeSize : 1;
+			return {
+				type: "inlineUnit",
+				from: backward ? cursor - size : cursor,
+				to: backward ? cursor : cursor + size
+			};
+		}
+		cursor += backward ? -adjacent.nodeSize : adjacent.nodeSize;
 	}
 	return { type: "paragraphEdge" };
 }
@@ -795,7 +791,7 @@ function handleSuggestionDelete(state, dispatch, direction) {
 			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);
+		for (const { from, to } of ranges) markRangeAsDeleted(tr, state.doc, from, to, deletionType, pluginState, state);
 		if (state.selection instanceof CellSelection) tr.setSelection(state.selection.map(tr.doc, tr.mapping));
 		else {
 			const cursorPos = tr.mapping.map($to.pos);
@@ -823,17 +819,20 @@ function handleSuggestionDelete(state, dispatch, direction) {
 	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 ? rangeFrom : rangeTo;
-		tr.setSelection(TextSelection.near(tr.doc.resolve(newPos)));
-	} else if (hasOwnInsertion) tr.delete(rangeFrom, rangeTo);
-	else {
+	const mapFrom = tr.mapping.maps.length;
+	if (noteRange) markRangeAsDeleted(tr, state.doc, noteRange.from, noteRange.to, deletionType, pluginState);
+	else if (!nodeAfter.marks.some((m) => m.type === deletionType)) {
 		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)));
+		addTrackedDeletionMark({
+			insertionPolicy: "retract-own",
+			tr,
+			from: rangeFrom,
+			to: rangeTo,
+			mark: deletionType.create(delAttrs)
+		});
 	}
+	const newPos = tr.mapping.slice(mapFrom).map(isBackward ? rangeFrom : rangeTo);
+	tr.setSelection(TextSelection.near(tr.doc.resolve(newPos)));
 	dispatch(tr.scrollIntoView());
 	return true;
 }
@@ -850,7 +849,7 @@ function markComposedAsInsertion({ view, from, pluginState, replaced, compositio
 	if (compositionId !== null) tr.setMeta("composition", compositionId);
 	if (replaced) {
 		tr.replaceRange(from, from, replaced);
-		markRangeAsDeleted(tr, tr.doc, from, tr.mapping.map(from, 1), insertionType, deletionType, pluginState);
+		markRangeAsDeleted(tr, tr.doc, from, tr.mapping.map(from, 1), deletionType, pluginState);
 		const restoredEnd = tr.doc.resolve(tr.mapping.map(from, 1));
 		const restoredStart = tr.doc.resolve(from);
 		if (restoredStart.parent.type.name === "paragraph" && restoredEnd.parent.type.name === "paragraph" && restoredStart.parent !== restoredEnd.parent) {
@@ -920,14 +919,14 @@ function replacedInline(before, step) {
 * rejecting restores it and accepting removes it. The author's own
 * insertions are retracted instead.
 */
-function restoreReplacedInline({ tr, replaced, insertionType, deletionType, pluginState }) {
+function restoreReplacedInline({ tr, replaced, deletionType, pluginState }) {
 	for (const { at, content } of replaced) {
 		const pos = tr.mapping.map(at, -1);
 		const $pos = tr.doc.resolve(pos);
 		const index = $pos.index();
 		if (!$pos.parent.canReplace(index, index, content)) continue;
 		tr.insert(pos, content);
-		markRangeAsDeleted(tr, tr.doc, pos, pos + content.size, insertionType, deletionType, pluginState);
+		markRangeAsDeleted(tr, tr.doc, pos, pos + content.size, deletionType, pluginState);
 	}
 }
 /**
@@ -1103,7 +1102,6 @@ function createSuggestionModePlugin(initialActive = false, author = "User") {
 			if (deletionType) restoreReplacedInline({
 				tr,
 				replaced,
-				insertionType,
 				deletionType,
 				pluginState
 			});

package/dist/prosemirror/preservedXmlReview.d.ts

@@ -0,0 +1,6 @@
+import { Mark, Node } from "prosemirror-model";
+//#region src/prosemirror/preservedXmlReview.d.ts
+/** A retained opaque deleted result becomes ordinary text when its last deletion resolves. */
+declare const resolvedPreservedXmlAttrs: (node: Node, marks: readonly Mark[]) => import("prosemirror-model").Attrs;
+//#endregion
+export { resolvedPreservedXmlAttrs };

package/dist/prosemirror/preservedXmlReview.js

@@ -0,0 +1,35 @@
+import { captureVerbatimXml } from "../docx/verbatimCapture.js";
+import { OOXML_NAMESPACE_SCOPE, WORDPROCESSINGML_NAMESPACE_URIS, cloneElement, getChildElements, getLocalName, parseXml } from "../docx/xmlParser.js";
+import { expectPreservedXmlAttrs, expectTrackedChangeMarkAttrs } from "./attrs/index.js";
+//#region src/prosemirror/preservedXmlReview.ts
+const restoreDeletedText = (node) => {
+	if (node.type !== "element") return node;
+	const name = getLocalName(node.name);
+	let target;
+	if (name === "delText") target = "t";
+	if (name === "delInstrText") target = "instrText";
+	const renamed = target !== void 0 && WORDPROCESSINGML_NAMESPACE_URIS.has(node.namespaceUri ?? "") ? node.name?.replace(/[^:]+$/u, target) : node.name;
+	const elements = node.elements?.map(restoreDeletedText);
+	if (renamed === node.name && elements?.every((child, index) => child === node.elements?.[index]) !== false) return node;
+	return cloneElement(node, {
+		...renamed !== void 0 && renamed !== node.name ? { name: renamed } : {},
+		...elements ? { elements } : {}
+	});
+};
+const hasPendingDeletion = (marks) => marks.some((mark) => {
+	if (mark.type.name === "deletion") return true;
+	if (mark.type.name !== "insertion") return false;
+	return expectTrackedChangeMarkAttrs(mark)._docxRevisionAncestors?.some((ancestor) => ancestor.type === "deletion" || ancestor.type === "moveFrom") ?? false;
+});
+/** A retained opaque deleted result becomes ordinary text when its last deletion resolves. */
+const resolvedPreservedXmlAttrs = (node, marks) => {
+	if (node.type.name !== "preservedXml" || !hasPendingDeletion(node.marks) || hasPendingDeletion(marks)) return node.attrs;
+	const attrs = expectPreservedXmlAttrs(node);
+	const xml = getChildElements(parseXml(attrs.xml, OOXML_NAMESPACE_SCOPE)).map((element) => captureVerbatimXml(restoreDeletedText(element))).join("");
+	return xml === attrs.xml ? node.attrs : {
+		...node.attrs,
+		xml
+	};
+};
+//#endregion
+export { resolvedPreservedXmlAttrs };

package/dist/prosemirror/runFormattingFromMarks.js

@@ -4,7 +4,7 @@ import { expectCharacterSpacingMarkAttrs, expectCharacterStyleMarkAttrs, expectE
 import { runShadingAttrsToShading, shadingToRunShadingAttrs } from "./conversion/runShadingMark.js";
 import { applyRunFormattingOverrideAttrs, buildRunFormattingOverrideAttrs } from "./extensions/marks/RunFormattingOverrideExtension.js";
 import { authoredRunFormattingFromAttrs, hasAuthoredRunFormattingProvenance } from "./runFormattingProvenance.js";
-import { paragraphFormattingForRun, resolveEffectiveRunStyleFormatting, suppressParagraphMarkFormatting } from "./runStyleFormatting.js";
+import { isParagraphMarkSuppressionEligible, paragraphFormattingForRun, resolveEffectiveRunStyleFormatting, suppressParagraphMarkFormatting } from "./runStyleFormatting.js";
 //#region src/prosemirror/runFormattingFromMarks.ts
 const RUN_FORMATTING_VISUAL_GROUPS = {
 	bold: "bold",
@@ -570,7 +570,7 @@ function marksToTextFormatting(marks, options) {
 			inheritedFormatting: suppressedInheritedFormatting,
 			observedFormatting: formatting
 		});
-		if (formattingAuthorshipCost(suppressed) < formattingAuthorshipCost(reconciled)) reconciled = suppressed;
+		if (isParagraphMarkSuppressionEligible(suppressed) && formattingAuthorshipCost(suppressed) < formattingAuthorshipCost(reconciled)) reconciled = suppressed;
 	}
 	return {
 		...reconciled,

package/dist/prosemirror/runFormattingReconciliation.js

@@ -3,7 +3,7 @@ import { expectCharacterStyleMarkAttrs } from "./attrs/index.js";
 import { textFormattingToMarks } from "./extensions/marks/markUtils.js";
 import { marksToTextFormatting } from "./runFormattingFromMarks.js";
 import { RUN_FORMATTING_MARK_NAMES } from "./runFormattingMarkNames.js";
-import { getParagraphMarkSuppressionOverrides, hasDirectRunFormatting, paragraphFormattingForRun, resolveEffectiveRunStyleFormatting } from "./runStyleFormatting.js";
+import { getParagraphMarkSuppressionOverrides, hasDirectRunFormatting, isParagraphMarkSuppressionEligible, paragraphFormattingForRun, resolveEffectiveRunStyleFormatting } from "./runStyleFormatting.js";
 import { Mark } from "prosemirror-model";
 //#region src/prosemirror/runFormattingReconciliation.ts
 /** Read authored run properties without confusing inherited visuals for direct formatting. */
@@ -37,14 +37,15 @@ const reconcileRunFormattingMarks = ({ authoredFormatting, context, node, styleR
 		paragraphFormatting,
 		...styleResolver !== void 0 ? { styleResolver } : {}
 	}), authoredFormatting);
-	const overrideFormatting = mergeTextFormatting(getParagraphMarkSuppressionOverrides({
+	const overrideFormatting = mergeTextFormatting(isParagraphMarkSuppressionEligible(authoredFormatting) ? getParagraphMarkSuppressionOverrides({
 		directFormatting: authoredFormatting,
 		paragraphMarkFormatting: context.paragraphMarkFormatting,
 		suppressedFormatting: paragraphFormatting
-	}), authoredFormatting);
+	}) : void 0, authoredFormatting);
 	const formattingMarks = textFormattingToMarks(effectiveFormatting, node.type.schema, {
 		overrideFormatting,
-		directFormatting: authoredFormatting
+		directFormatting: authoredFormatting,
+		authoredCarrier: "preserve"
 	});
 	return Mark.setFrom([
 		...marks.filter(({ type }) => !RUN_FORMATTING_MARK_NAMES.has(type.name)),

package/dist/prosemirror/runPropertyChangeResolution.d.ts

@@ -14,5 +14,12 @@ type ReconstructRejectedRunFormattingMarksOptions = {
  * owner so their reject semantics cannot diverge at the bulk threshold.
  */
 declare const reconstructRejectedRunFormattingMarks: ({ node, paragraphContext, previousFormatting, styleResolver }: ReconstructRejectedRunFormattingMarksOptions) => readonly Mark[];
+type RestoreHistoricalRunFormattingOptions = {
+  node: Node;
+  paragraphContext: ParagraphRunStyleContext;
+  styleResolver?: RunStyleResolver | null;
+};
+/** Restored deletions inherit the live paragraph cascade without authoring their historical visuals. */
+declare const restoreHistoricalRunFormatting: ({ node, paragraphContext, styleResolver }: RestoreHistoricalRunFormattingOptions) => readonly Mark[];
 //#endregion
-export { reconstructRejectedRunFormattingMarks };
+export { reconstructRejectedRunFormattingMarks, restoreHistoricalRunFormatting };

package/dist/prosemirror/runPropertyChangeResolution.js

@@ -1,5 +1,6 @@
+import { runFormattingInlineAtomDisposition } from "./runFormattingInlineCarriers.js";
 import { RUN_FORMATTING_MARK_NAMES } from "./runFormattingMarkNames.js";
-import { reconcileRunFormattingMarks } from "./runFormattingReconciliation.js";
+import { readAuthoredRunFormatting, reconcileRunFormattingMarks } from "./runFormattingReconciliation.js";
 //#region src/prosemirror/runPropertyChangeResolution.ts
 /**
 * Rebuild the pre-change run marks against the paragraph's live style cascade.
@@ -14,5 +15,26 @@ const reconstructRejectedRunFormattingMarks = ({ node, paragraphContext, previou
 		...styleResolver !== void 0 ? { styleResolver } : {}
 	}).filter(({ type }) => RUN_FORMATTING_MARK_NAMES.has(type.name));
 };
+/** Restored deletions inherit the live paragraph cascade without authoring their historical visuals. */
+const restoreHistoricalRunFormatting = ({ node, paragraphContext, styleResolver }) => {
+	const disposition = runFormattingInlineAtomDisposition(node);
+	if (disposition === null || disposition === "not-a-run") return node.marks;
+	if (paragraphContext.paragraphMarkFormatting === void 0) return node.marks;
+	return reconcileRunFormattingMarks({
+		authoredFormatting: readAuthoredRunFormatting({
+			context: {
+				baseParagraphFormatting: paragraphContext.baseParagraphFormatting,
+				paragraphFormatting: paragraphContext.baseParagraphFormatting,
+				paragraphMarkFormatting: void 0,
+				paragraphMarkPrecedesStyle: false
+			},
+			marks: node.marks,
+			...styleResolver !== void 0 ? { styleResolver } : {}
+		}),
+		context: paragraphContext,
+		node,
+		...styleResolver !== void 0 ? { styleResolver } : {}
+	});
+};
 //#endregion
-export { reconstructRejectedRunFormattingMarks };
+export { reconstructRejectedRunFormattingMarks, restoreHistoricalRunFormatting };

package/dist/prosemirror/runStyleFormatting.d.ts

@@ -5,6 +5,8 @@ import { cascadeStyleTextFormatting } from "./styles/styleToggleCascade.js";
 import { Mark, Node } from "prosemirror-model";
 //#region src/prosemirror/runStyleFormatting.d.ts
 declare const hasDirectRunFormatting: (formatting: document_d_exports.TextFormatting | undefined) => boolean;
+/** A stated run property or character style establishes paragraph-mark suppression. */
+declare const isParagraphMarkSuppressionEligible: (formatting: document_d_exports.TextFormatting | undefined) => boolean;
 declare const stripParagraphMarkOnlyFormatting: (formatting: document_d_exports.TextFormatting) => document_d_exports.TextFormatting | undefined;
 declare const stripParagraphMarkFormattingForBodyRuns: (formatting: document_d_exports.TextFormatting) => document_d_exports.TextFormatting | undefined;
 type SuppressParagraphMarkFormattingOptions = {
@@ -66,4 +68,4 @@ type ResolveEffectiveRunStyleFormattingOptions = {
 /** Resolve the non-direct run cascade from shared document styles and the current paragraph. */
 declare const resolveEffectiveRunStyleFormatting: ({ marks, paragraphFormatting, styleResolver }: ResolveEffectiveRunStyleFormattingOptions) => document_d_exports.TextFormatting | undefined;
 //#endregion
-export { ParagraphRunStyleContext, RunStyleResolver, getParagraphMarkSuppressionOverrides, hasDirectRunFormatting, nearestParagraphRunStyleContext, paragraphFormattingForRun, paragraphRunStyleContext, paragraphRunStyleContextAt, resolveEffectiveRunStyleFormatting, resolveParagraphBodyRunFormatting, stripParagraphMarkFormattingForBodyRuns, stripParagraphMarkOnlyFormatting, suppressParagraphMarkFormatting };
+export { ParagraphRunStyleContext, RunStyleResolver, getParagraphMarkSuppressionOverrides, hasDirectRunFormatting, isParagraphMarkSuppressionEligible, nearestParagraphRunStyleContext, paragraphFormattingForRun, paragraphRunStyleContext, paragraphRunStyleContextAt, resolveEffectiveRunStyleFormatting, resolveParagraphBodyRunFormatting, stripParagraphMarkFormattingForBodyRuns, stripParagraphMarkOnlyFormatting, suppressParagraphMarkFormatting };

package/dist/prosemirror/runStyleFormatting.js

@@ -20,6 +20,8 @@ const hasDirectRunFormatting = (formatting) => {
 	if (!formatting) return false;
 	return Object.entries(formatting).some(([property, value]) => property !== "styleId" && value !== void 0);
 };
+/** A stated run property or character style establishes paragraph-mark suppression. */
+const isParagraphMarkSuppressionEligible = (formatting) => hasDirectRunFormatting(formatting) || formatting?.styleId !== void 0;
 const stripParagraphMarkOnlyFormatting = (formatting) => {
 	const { allCaps: _allCaps, highlight: _highlight, shading: _shading, smallCaps: _smallCaps, vertAlign: _vertAlign, preserved: _preserved, ...formattingForBody } = formatting;
 	return Object.keys(formattingForBody).length > 0 ? formattingForBody : void 0;
@@ -182,4 +184,4 @@ const resolveEffectiveRunStyleFormatting = ({ marks, paragraphFormatting, styleR
 	});
 };
 //#endregion
-export { getParagraphMarkSuppressionOverrides, hasDirectRunFormatting, nearestParagraphRunStyleContext, paragraphFormattingForRun, paragraphRunStyleContext, paragraphRunStyleContextAt, resolveEffectiveRunStyleFormatting, resolveParagraphBodyRunFormatting, stripParagraphMarkFormattingForBodyRuns, stripParagraphMarkOnlyFormatting, suppressParagraphMarkFormatting };
+export { getParagraphMarkSuppressionOverrides, hasDirectRunFormatting, isParagraphMarkSuppressionEligible, nearestParagraphRunStyleContext, paragraphFormattingForRun, paragraphRunStyleContext, paragraphRunStyleContextAt, resolveEffectiveRunStyleFormatting, resolveParagraphBodyRunFormatting, stripParagraphMarkFormattingForBodyRuns, stripParagraphMarkOnlyFormatting, suppressParagraphMarkFormatting };

package/dist/prosemirror/schema/marks.d.ts

@@ -78,6 +78,7 @@ type TextEffectAttrs = {
   effect: Exclude<document_d_exports.TextEffect, "none">;
 };
 type FootnoteRefAttrs = {
+  occurrenceId: string;
   id: string | number;
   noteType?: "footnote" | "endnote";
   vertAlign?: "baseline" | "superscript";

package/dist/prosemirror/schema/nodes.d.ts

@@ -272,6 +272,8 @@ type ParagraphAttrs = {
    * paragraph. `TableCellAttrs._resolvedBorders` is the same device.
    */
   _resolvedFormatting?: document_d_exports.ParagraphFormatting;
+  /** Style-only inheritance baseline, before numbering-level indentation. PM-only. */
+  _styleResolvedFormatting?: document_d_exports.ParagraphFormatting;
   /** Import-effective spacing baseline for HTML auto-spacing detection.
    *  PM-only; never serialized back into DOCX formatting. */
   _autospacingBase?: {

package/dist/prosemirror/styles/paragraphStyleCascade.js

@@ -59,7 +59,10 @@ function paragraphStyleCascadeAttrs({ styleId, formatting, styleResolver, tableP
 	};
 	const stylePpr = styleResolver.resolveParagraphStyleInTable(styleId, tableParagraphOverlay).paragraphFormatting;
 	const resolvedFormatting = styleResolvedParagraphFormatting(stylePpr);
-	if (resolvedFormatting) attrs._resolvedFormatting = resolvedFormatting;
+	if (resolvedFormatting) {
+		attrs._resolvedFormatting = resolvedFormatting;
+		attrs._styleResolvedFormatting = resolvedFormatting;
+	}
 	set("alignment", formatting?.alignment ?? stylePpr?.alignment);
 	set("alignmentFromStyle", stylePpr?.alignment);
 	set("spaceBefore", formatting?.spaceBefore ?? stylePpr?.spaceBefore);

package/dist/prosemirror/styles/resolvedStyleAttrs.d.ts

@@ -1,3 +1,4 @@
+import { document_d_exports } from "../../types/document.js";
 import { ParagraphAttrs, ParagraphAttrsPatch } from "../schema/nodes.js";
 import { ResolvedParagraphStyle } from "./styleResolver.js";
 import { NumberingMap } from "../../docx/numberingParser.js";
@@ -38,17 +39,18 @@ declare function listAttrsFromNumbering(numPr: {
   numId: number;
   ilvl: number;
 }, numbering: NumberingMap | null | undefined): ParagraphAttrsPatch;
-/**
- * The numbering level's indentation a directly numbered paragraph reads as its
- * own where it states none: the load path folds the level's `w:ind` into the
- * paragraph (a direct `w:ind` wins per group, left vs first line/hanging), so
- * a paragraph a command numbers carries it too, and the save writes it where a
- * reopen reads it back.
- */
-declare function listLevelIndentAttrPatch(stated: DirectParagraphIndentation | undefined, numPr: {
-  numId: number;
-  ilvl: number;
-}, numbering: NumberingMap | null | undefined): ParagraphAttrsPatch;
+type ListIndentationProvenanceOptions = {
+  direct: DirectParagraphIndentation | undefined;
+  styleFormatting: document_d_exports.ParagraphFormatting | undefined;
+  numberingSource: "style" | "paragraph";
+  numPr: {
+    numId: number;
+    ilvl: number;
+  } | undefined;
+  numbering: NumberingMap | null | undefined;
+};
+/** Project effective indentation and both inheritance layers together. */
+declare function listIndentationProvenancePatch({ direct, styleFormatting, numberingSource, numPr, numbering }: ListIndentationProvenanceOptions): ParagraphAttrsPatch;
 /**
  * The indentation a paragraph leaving its list keeps: the level's indentation
  * it only read from its numbering goes with the numbering, back to what its
@@ -57,11 +59,9 @@ declare function listLevelIndentAttrPatch(stated: DirectParagraphIndentation | u
  */
 declare function listLevelIndentRemovalPatch(attrs: Readonly<ParagraphAttrs>, numbering: NumberingMap | null | undefined): ParagraphAttrsPatch;
 /** Recompute every level-dependent attr when a paragraph changes list level. */
-declare function listLevelAttrPatch(attrs: {
-  listImplicitChildLevelAdvances?: number | null;
-}, numPr: {
+declare function listLevelAttrPatch(attrs: Pick<ParagraphAttrs, "listImplicitChildLevelAdvances" | "_originalFormatting" | "_resolvedFormatting" | "_styleResolvedFormatting" | "numPr" | "numPrFromStyle" | "indentLeft" | "indentRight" | "indentFirstLine" | "hangingIndent">, numPr: {
   numId: number;
   ilvl: number;
 }, numbering: NumberingMap | null | undefined): ParagraphAttrsPatch;
 //#endregion
-export { listAttrsFromNumbering, listAttrsFromResolvedStyle, listLevelAttrPatch, listLevelIndentAttrPatch, listLevelIndentRemovalPatch, paragraphAttrsFromResolvedStyle };
+export { listAttrsFromNumbering, listAttrsFromResolvedStyle, listIndentationProvenancePatch, listLevelAttrPatch, listLevelIndentRemovalPatch, paragraphAttrsFromResolvedStyle };

package/dist/prosemirror/styles/resolvedStyleAttrs.js

@@ -6,6 +6,7 @@ import { CLEARED_LIST_RENDERING_ATTRS } from "../listMarker.js";
 import { listRenderingAttrPatch } from "../listRenderingAttrs.js";
 import { paragraphNumberingAttr } from "../numberingAttr.js";
 import { styleResolvedParagraphFormatting } from "../paragraphFormattingProvenance.js";
+import { directParagraphIndentation, paragraphIndentationAttrPatch, paragraphIndentationFromFormatting, withDirectParagraphIndentation } from "../paragraphIndentation.js";
 //#region src/prosemirror/styles/resolvedStyleAttrs.ts
 /**
 * Shared helper for projecting a resolved paragraph style onto ProseMirror
@@ -48,6 +49,7 @@ function paragraphAttrsFromResolvedStyle(resolved, identity) {
 		borders: ppr?.borders ?? null,
 		defaultTextFormatting: hasRunFormatting ? runFormatting : null,
 		_resolvedFormatting: styleResolvedParagraphFormatting(ppr),
+		_styleResolvedFormatting: styleResolvedParagraphFormatting(ppr),
 		_autospacingBase: autospacingBaseFromResolvedParagraphFormatting(ppr),
 		_tableOfContentsLevel: tableOfContentsStyleLevel(identity) ?? null
 	};
@@ -84,19 +86,26 @@ function listAttrsFromResolvedStyle(resolved, numbering) {
 		numId,
 		ilvl
 	}, numbering);
-	const level = numbering?.getLevel(numId, ilvl);
 	attrs.numPrFromStyle = paragraphNumberingAttr(paragraphNumberingReference({
 		numId,
 		ilvl
 	}));
-	const ppr = resolved.paragraphFormatting;
-	if (level?.pPr) {
-		if (ppr?.indentLeft === void 0 && level.pPr.indentLeft !== void 0) attrs.indentLeft = level.pPr.indentLeft;
-		if (!(ppr?.indentFirstLine !== void 0 || ppr?.hangingIndent !== void 0) && numberingLevelHasMarkerSlot(level)) {
-			if (level.pPr.indentFirstLine !== void 0) attrs.indentFirstLine = level.pPr.indentFirstLine;
-			if (level.pPr.hangingIndent !== void 0) attrs.hangingIndent = level.pPr.hangingIndent;
-		}
-	}
+	Object.assign(attrs, listIndentationProvenancePatch({
+		direct: void 0,
+		styleFormatting: resolved.paragraphFormatting,
+		numberingSource: "style",
+		numPr: {
+			numId,
+			ilvl
+		},
+		numbering
+	}));
+	for (const key of [
+		"indentLeft",
+		"indentRight",
+		"indentFirstLine"
+	]) if (attrs[key] == null) Reflect.deleteProperty(attrs, key);
+	if (attrs.indentFirstLine === void 0 && resolved.paragraphFormatting?.hangingIndent === void 0) Reflect.deleteProperty(attrs, "hangingIndent");
 	return attrs;
 }
 /** Project one resolved numbering level into the complete editor attr group. */
@@ -115,9 +124,9 @@ function listAttrsFromNumbering(numPr, numbering) {
 /**
 * The numbering level's indentation a directly numbered paragraph reads as its
 * own where it states none: the load path folds the level's `w:ind` into the
-* paragraph (a direct `w:ind` wins per group, left vs first line/hanging), so
-* a paragraph a command numbers carries it too, and the save writes it where a
-* reopen reads it back.
+* paragraph (a direct `w:ind` wins per group, left vs first line/hanging).
+* Keep this projection private: callers use the paired provenance helper so
+* effective level values cannot be mistaken for authored indentation.
 */
 function listLevelIndentAttrPatch(stated, numPr, numbering) {
 	const level = numbering?.getLevel(numPr.numId, numPr.ilvl);
@@ -130,6 +139,33 @@ function listLevelIndentAttrPatch(stated, numPr, numbering) {
 	}
 	return patch;
 }
+/** Project effective indentation and both inheritance layers together. */
+function listIndentationProvenancePatch({ direct, styleFormatting, numberingSource, numPr, numbering }) {
+	const style = {
+		...styleResolvedParagraphFormatting(styleFormatting),
+		...styleFormatting?.hangingIndent === void 0 ? {} : { hangingIndent: styleFormatting.hangingIndent }
+	};
+	const level = numPr === void 0 ? {} : listLevelIndentAttrPatch(numberingSource === "style" ? paragraphIndentationFromFormatting(style) : void 0, numPr, numbering);
+	if (level.indentLeft === 0 && style.indentLeft === void 0) Reflect.deleteProperty(level, "indentLeft");
+	if (level.indentFirstLine === 0 && style.indentFirstLine === void 0 && style.hangingIndent === void 0) {
+		Reflect.deleteProperty(level, "indentFirstLine");
+		Reflect.deleteProperty(level, "hangingIndent");
+	}
+	const resolved = {
+		...style,
+		...typeof level.indentLeft === "number" ? { indentLeft: level.indentLeft } : {},
+		...typeof level.indentFirstLine === "number" ? { indentFirstLine: level.indentFirstLine } : {},
+		...typeof level.hangingIndent === "boolean" ? { hangingIndent: level.hangingIndent } : {}
+	};
+	return {
+		...paragraphIndentationAttrPatch({
+			direct,
+			inherited: paragraphIndentationFromFormatting(resolved)
+		}),
+		_resolvedFormatting: Object.keys(resolved).length === 0 ? null : resolved,
+		_styleResolvedFormatting: Object.keys(style).length === 0 ? null : style
+	};
+}
 /**
 * The indentation a paragraph leaving its list keeps: the level's indentation
 * it only read from its numbering goes with the numbering, back to what its
@@ -138,28 +174,33 @@ function listLevelIndentAttrPatch(stated, numPr, numbering) {
 */
 function listLevelIndentRemovalPatch(attrs, numbering) {
 	if (attrs.numPr?.kind !== "reference") return {};
-	const level = numbering?.getLevel(attrs.numPr.numId, attrs.numPr.ilvl ?? 0);
-	if (!level?.pPr) return {};
-	const resolved = attrs.numPrFromStyle != null ? void 0 : attrs._resolvedFormatting;
-	const patch = {};
-	if (level.pPr.indentLeft !== void 0 && attrs.indentLeft === level.pPr.indentLeft) patch.indentLeft = resolved?.indentLeft ?? null;
-	if (level.pPr.indentFirstLine !== void 0 && attrs.indentFirstLine === level.pPr.indentFirstLine && attrs.hangingIndent === (level.pPr.hangingIndent ?? false)) {
-		patch.indentFirstLine = resolved?.indentFirstLine ?? null;
-		patch.hangingIndent = resolved?.hangingIndent ?? false;
-	}
-	return patch;
+	const direct = directParagraphIndentation(attrs);
+	return {
+		...listIndentationProvenancePatch({
+			direct,
+			styleFormatting: attrs._styleResolvedFormatting,
+			numberingSource: "paragraph",
+			numPr: void 0,
+			numbering
+		}),
+		_originalFormatting: withDirectParagraphIndentation(attrs._originalFormatting, direct) ?? null
+	};
 }
 /** Recompute every level-dependent attr when a paragraph changes list level. */
 function listLevelAttrPatch(attrs, numPr, numbering) {
-	const level = numbering?.getLevel(numPr.numId, numPr.ilvl);
-	const hasMarkerSlot = level ? numberingLevelHasMarkerSlot(level) : false;
+	const direct = directParagraphIndentation(attrs);
 	return {
 		...listAttrsFromNumbering(numPr, numbering),
 		listImplicitChildLevelAdvances: attrs.listImplicitChildLevelAdvances ?? null,
-		indentLeft: level?.pPr?.indentLeft ?? null,
-		indentFirstLine: hasMarkerSlot ? level?.pPr?.indentFirstLine ?? null : null,
-		hangingIndent: hasMarkerSlot ? level?.pPr?.hangingIndent ?? null : null
+		...listIndentationProvenancePatch({
+			direct,
+			styleFormatting: attrs._styleResolvedFormatting,
+			numberingSource: attrs.numPrFromStyle == null ? "paragraph" : "style",
+			numPr,
+			numbering
+		}),
+		_originalFormatting: withDirectParagraphIndentation(attrs._originalFormatting, direct) ?? null
 	};
 }
 //#endregion
-export { listAttrsFromNumbering, listAttrsFromResolvedStyle, listLevelAttrPatch, listLevelIndentAttrPatch, listLevelIndentRemovalPatch, paragraphAttrsFromResolvedStyle };
+export { listAttrsFromNumbering, listAttrsFromResolvedStyle, listIndentationProvenancePatch, listLevelAttrPatch, listLevelIndentRemovalPatch, paragraphAttrsFromResolvedStyle };

package/dist/prosemirror/textInput.d.ts

@@ -13,6 +13,10 @@ type TextInput = {
   to: number;
 };
 declare const dispatchEditorTextInput: <TView extends TextInputDispatchTarget<TView>>(view: TView, input: string | TextInput) => void;
+declare const getEditorInputTargetRange: (view: EditorView, event: InputEvent) => {
+  from: number;
+  to: number;
+} | null;
 /** Shared DOM boundary for editor runtimes and standalone suggestion views. */
 declare const handleEditorBeforeInput: (view: EditorView, event: InputEvent) => boolean;
 /**
@@ -23,4 +27,4 @@ declare const afterNativeCompositionFlush: (callback: () => void) => void;
 /** Route committed text through the model before the browser mutates mark spans. */
 declare const createTextInputPlugin: () => Plugin<any>;
 //#endregion
-export { afterNativeCompositionFlush, createTextInputPlugin, dispatchEditorTextInput, handleEditorBeforeInput };
+export { afterNativeCompositionFlush, createTextInputPlugin, dispatchEditorTextInput, getEditorInputTargetRange, handleEditorBeforeInput };