@stll/folio-core 0.62.0 → 0.63.0

package/dist/prosemirror/runFormattingFromMarks.js

@@ -508,7 +508,6 @@ function marksToTextFormatting(marks, options) {
 			characterStyleId = attrs.styleId;
 			break;
 		}
-		default: break;
 	}
 	let authoredFormatting = {};
 	if (runFormattingOverrideMark) {
@@ -531,18 +530,20 @@ function marksToTextFormatting(marks, options) {
 			styleId: characterStyleId
 		};
 	}
+	const runContext = {
+		baseParagraphFormatting: options?.baseParagraphFormatting,
+		paragraphFormatting: options?.inheritedFormatting,
+		paragraphMarkFormatting: options?.paragraphMarkFormatting,
+		paragraphMarkPrecedesStyle: options?.paragraphMarkPrecedesStyle ?? false
+	};
+	const paragraphFormatting = paragraphFormattingForRun({
+		context: runContext,
+		directFormatting: authoredFormatting,
+		marks
+	});
 	const inheritedFormatting = resolveEffectiveRunStyleFormatting({
 		marks,
-		paragraphFormatting: paragraphFormattingForRun({
-			context: {
-				baseParagraphFormatting: options?.baseParagraphFormatting,
-				paragraphFormatting: options?.inheritedFormatting,
-				paragraphMarkFormatting: options?.paragraphMarkFormatting,
-				paragraphMarkPrecedesStyle: options?.paragraphMarkPrecedesStyle ?? false
-			},
-			directFormatting: authoredFormatting,
-			marks
-		}),
+		paragraphFormatting,
 		...options?.styleResolver !== void 0 ? { styleResolver: options.styleResolver } : {}
 	});
 	let reconciled = reconcileAuthoredFormatting({
@@ -553,14 +554,15 @@ function marksToTextFormatting(marks, options) {
 		observedFormatting: formatting
 	});
 	if (runFormattingOverrideMark === void 0 && characterStyleId === void 0 && options?.paragraphMarkFormatting !== void 0) {
+		const suppressedParagraphFormatting = suppressParagraphMarkFormatting({
+			baseFormatting: options.baseParagraphFormatting,
+			directFormatting: authoredFormatting,
+			paragraphMarkFormatting: options.paragraphMarkFormatting,
+			paragraphMarkPrecedesStyle: options.paragraphMarkPrecedesStyle ?? false
+		});
 		const suppressedInheritedFormatting = resolveEffectiveRunStyleFormatting({
 			marks,
-			paragraphFormatting: suppressParagraphMarkFormatting({
-				baseFormatting: options.baseParagraphFormatting,
-				directFormatting: authoredFormatting,
-				paragraphMarkFormatting: options.paragraphMarkFormatting,
-				paragraphMarkPrecedesStyle: options.paragraphMarkPrecedesStyle ?? false
-			}),
+			paragraphFormatting: suppressedParagraphFormatting,
 			...options.styleResolver !== void 0 ? { styleResolver: options.styleResolver } : {}
 		});
 		const suppressed = reconcileAuthoredFormatting({

package/dist/prosemirror/runFormattingInlineCarriers.d.ts

@@ -1,7 +1,7 @@
 import { Mark, Node } from "prosemirror-model";
 import { Transaction } from "prosemirror-state";
 //#region src/prosemirror/runFormattingInlineCarriers.d.ts
-type RunFormattingInlineAtomDisposition = "break-run" | "field-run" | "not-a-run" | "note-marker-run" | "page-break-carrier" | "preserved-xml-run" | "structured-field" | "symbol-run" | "tab-run" | "text-run";
+export type RunFormattingInlineAtomDisposition = "break-run" | "field-run" | "not-a-run" | "note-marker-run" | "page-break-carrier" | "preserved-xml-run" | "structured-field" | "symbol-run" | "tab-run" | "text-run";
 /**
  * How every inline atom maps to a serialized run-formatting carrier.
  *
@@ -10,8 +10,9 @@ type RunFormattingInlineAtomDisposition = "break-run" | "field-run" | "not-a-run
  * marks do not serialize as run properties. The runtime fixed-point test binds
  * this map to the complete schema atom set.
  */
-declare const RUN_FORMATTING_INLINE_ATOM_DISPOSITIONS: Readonly<{
+export declare const RUN_FORMATTING_INLINE_ATOM_DISPOSITIONS: Readonly<{
   readonly bookmarkBoundary: "not-a-run";
+  readonly commentRangeBoundary: "not-a-run";
   readonly commentReference: "not-a-run";
   readonly field: "field-run";
   readonly hardBreak: "break-run";
@@ -30,7 +31,7 @@ declare const RUN_FORMATTING_INLINE_ATOM_DISPOSITIONS: Readonly<{
   readonly text: "text-run";
   readonly textBoxAnchor: "not-a-run";
 }>;
-declare const runFormattingInlineControlCharacter: (node: Node) => string | null;
+export declare const runFormattingInlineControlCharacter: (node: Node) => string | null;
 /**
  * Text an inline atom contributes to a flattened, reader-facing projection.
  *
@@ -40,26 +41,26 @@ declare const runFormattingInlineControlCharacter: (node: Node) => string | null
  * `getFieldVisibleText` paints for the editor is a rendering decision, not
  * document text, and one of its branches is the current date.
  */
-declare const runFormattingInlineAtomCleanText: (node: Node) => string | null;
+export declare const runFormattingInlineAtomCleanText: (node: Node) => string | null;
 /**
  * Document text an inline atom contributes, as opposed to a control character:
  * today a field's authored result.
  */
-declare const runFormattingInlineAtomResultText: (node: Node) => string | null;
-declare const runFormattingInlineControlNodeName: (character: string) => string | null;
-declare const runFormattingInlineAtomDisposition: (node: Node) => RunFormattingInlineAtomDisposition | null;
-type RunFormattingCarrierRepresentation = {
+export declare const runFormattingInlineAtomResultText: (node: Node) => string | null;
+export declare const runFormattingInlineControlNodeName: (character: string) => string | null;
+export declare const runFormattingInlineAtomDisposition: (node: Node) => RunFormattingInlineAtomDisposition | null;
+export type RunFormattingCarrierRepresentation = {
   node: Node;
   position: number;
   role: "owner" | "serialized-result";
 };
-type RunFormattingCarrier = {
+export type RunFormattingCarrier = {
   disposition: Exclude<RunFormattingInlineAtomDisposition, "not-a-run">;
   node: Node;
   position: number;
   representations: readonly RunFormattingCarrierRepresentation[];
 };
-type SelectedRunFormattingCarrierRepresentation = RunFormattingCarrierRepresentation & {
+export type SelectedRunFormattingCarrierRepresentation = RunFormattingCarrierRepresentation & {
   carrierDisposition: RunFormattingCarrier["disposition"];
   from: number;
   to: number;
@@ -73,13 +74,13 @@ type ApplyMarksToRunFormattingRepresentationOptions = {
   marks: readonly Mark[];
 };
 /** Apply a mark set without changing a carrier's text or serialized ownership. */
-declare const applyMarksToRunFormattingRepresentation: ({ tr, representation, marks }: ApplyMarksToRunFormattingRepresentationOptions) => void;
+export declare const applyMarksToRunFormattingRepresentation: ({ tr, representation, marks }: ApplyMarksToRunFormattingRepresentationOptions) => void;
 /**
  * Expand one logical carrier into every editor node that materializes its run
  * properties. A structured field is owned by its outer atom, while its result
  * runs are derived representations needed by the package serializer.
  */
-declare const expandRunFormattingCarrier: (node: Node, position: number) => RunFormattingCarrier | null;
+export declare const expandRunFormattingCarrier: (node: Node, position: number) => RunFormattingCarrier | null;
 type SelectRunFormattingCarrierRepresentationsOptions = {
   doc: Node;
   from: number;
@@ -90,8 +91,8 @@ type SelectRunFormattingCarrierRepresentationsOptions = {
  * properties. The result is shared by every formatting mutation so preflight,
  * direct edits, and tracked edits cannot disagree about ownership.
  */
-declare const selectRunFormattingCarrierRepresentations: ({ doc, from, to }: SelectRunFormattingCarrierRepresentationsOptions) => SelectedRunFormattingCarrierRepresentation[];
+export declare const selectRunFormattingCarrierRepresentations: ({ doc, from, to }: SelectRunFormattingCarrierRepresentationsOptions) => SelectedRunFormattingCarrierRepresentation[];
 /** Deterministic visible text for one logical formatting revision carrier. */
-declare const runFormattingCarrierReviewText: (carrier: RunFormattingCarrier) => string;
+export declare const runFormattingCarrierReviewText: (carrier: RunFormattingCarrier) => string;
 //#endregion
-export { RUN_FORMATTING_INLINE_ATOM_DISPOSITIONS, RunFormattingCarrier, RunFormattingCarrierRepresentation, RunFormattingInlineAtomDisposition, SelectedRunFormattingCarrierRepresentation, applyMarksToRunFormattingRepresentation, expandRunFormattingCarrier, runFormattingCarrierReviewText, runFormattingInlineAtomCleanText, runFormattingInlineAtomDisposition, runFormattingInlineAtomResultText, runFormattingInlineControlCharacter, runFormattingInlineControlNodeName, selectRunFormattingCarrierRepresentations };
+export {};

package/dist/prosemirror/runFormattingInlineCarriers.js

@@ -14,6 +14,7 @@ import { Mark } from "prosemirror-model";
 */
 const RUN_FORMATTING_INLINE_ATOM_DISPOSITIONS = Object.freeze({
 	bookmarkBoundary: "not-a-run",
+	commentRangeBoundary: "not-a-run",
 	commentReference: "not-a-run",
 	field: "field-run",
 	hardBreak: "break-run",

package/dist/prosemirror/runFormattingMarkNames.d.ts

@@ -9,6 +9,5 @@
  * it structurally impossible for the two paths to drift and let a formatting
  * mark survive a revert.
  */
-declare const RUN_FORMATTING_MARK_NAMES: Set<string>;
-//#endregion
-export { RUN_FORMATTING_MARK_NAMES };
+export declare const RUN_FORMATTING_MARK_NAMES: Set<string>;
+//#endregion

package/dist/prosemirror/runFormattingProvenance.d.ts

@@ -1,12 +1,11 @@
 import { document_d_exports } from "../types/document.js";
 import { RunFormattingOverrideAttrs } from "./schema/marks.js";
 //#region src/prosemirror/runFormattingProvenance.d.ts
-declare const hasAuthoredRunFormattingProvenance: ({ _authoredOff, _authoredOn, _authoredValues }: RunFormattingOverrideAttrs) => boolean;
+export declare const hasAuthoredRunFormattingProvenance: ({ _authoredOff, _authoredOn, _authoredValues }: RunFormattingOverrideAttrs) => boolean;
 /** Whether an override mark still carries any rendering or authorship signal. */
-declare const hasRunFormattingOverrideAttrs: (attrs: RunFormattingOverrideAttrs) => boolean;
+export declare const hasRunFormattingOverrideAttrs: (attrs: RunFormattingOverrideAttrs) => boolean;
 /** Reconstruct the last imported/reconciled direct baseline; inherited values never enter here. */
-declare const authoredRunFormattingFromAttrs: (attrs: RunFormattingOverrideAttrs) => document_d_exports.TextFormatting | undefined;
+export declare const authoredRunFormattingFromAttrs: (attrs: RunFormattingOverrideAttrs) => document_d_exports.TextFormatting | undefined;
 /** Replace the direct baseline while preserving current rendering attributes. */
-declare const withAuthoredRunFormatting: (attrs: RunFormattingOverrideAttrs, formatting: document_d_exports.TextFormatting | undefined) => RunFormattingOverrideAttrs;
-//#endregion
-export { authoredRunFormattingFromAttrs, hasAuthoredRunFormattingProvenance, hasRunFormattingOverrideAttrs, withAuthoredRunFormatting };
+export declare const withAuthoredRunFormatting: (attrs: RunFormattingOverrideAttrs, formatting: document_d_exports.TextFormatting | undefined) => RunFormattingOverrideAttrs;
+//#endregion

package/dist/prosemirror/runFormattingReconciliation.d.ts

@@ -8,9 +8,9 @@ type ReadAuthoredRunFormattingOptions = {
   styleResolver?: RunStyleResolver | null;
 };
 /** Read authored run properties without confusing inherited visuals for direct formatting. */
-declare const readAuthoredRunFormatting: ({ context, marks, styleResolver }: ReadAuthoredRunFormattingOptions) => document_d_exports.TextFormatting;
+export declare const readAuthoredRunFormatting: ({ context, marks, styleResolver }: ReadAuthoredRunFormattingOptions) => document_d_exports.TextFormatting;
 /** Preserve the authored distinction between an absent and empty property set in revisions. */
-declare const readAuthoredRunPropertySnapshot: (options: ReadAuthoredRunFormattingOptions) => document_d_exports.TextFormatting | undefined;
+export declare const readAuthoredRunPropertySnapshot: (options: ReadAuthoredRunFormattingOptions) => document_d_exports.TextFormatting | undefined;
 type ReconcileRunFormattingMarksOptions = {
   authoredFormatting: document_d_exports.TextFormatting;
   context: ParagraphRunStyleContext;
@@ -22,6 +22,6 @@ type ReconcileRunFormattingMarksOptions = {
  * current style context. This is the inverse of {@link readAuthoredRunFormatting}:
  * direct provenance stays direct while inherited formatting remains visual only.
  */
-declare const reconcileRunFormattingMarks: ({ authoredFormatting, context, node, styleResolver }: ReconcileRunFormattingMarksOptions) => readonly Mark[];
+export declare const reconcileRunFormattingMarks: ({ authoredFormatting, context, node, styleResolver }: ReconcileRunFormattingMarksOptions) => readonly Mark[];
 //#endregion
-export { readAuthoredRunFormatting, readAuthoredRunPropertySnapshot, reconcileRunFormattingMarks };
+export {};

package/dist/prosemirror/runFormattingReconciliation.js

@@ -40,16 +40,18 @@ const reconcileRunFormattingMarks = ({ authoredFormatting, context, node, styleR
 		context,
 		directFormatting: authoredFormatting
 	});
-	const effectiveFormatting = mergeTextFormatting(resolveEffectiveRunStyleFormatting({
+	const inheritedFormatting = resolveEffectiveRunStyleFormatting({
 		marks: styleResolutionMarks,
 		paragraphFormatting,
 		...styleResolver !== void 0 ? { styleResolver } : {}
-	}), authoredFormatting);
-	const overrideFormatting = mergeTextFormatting(isParagraphMarkSuppressionEligible(authoredFormatting) ? getParagraphMarkSuppressionOverrides({
+	});
+	const effectiveFormatting = mergeTextFormatting(inheritedFormatting, authoredFormatting);
+	const paragraphMarkOverrides = isParagraphMarkSuppressionEligible(authoredFormatting) ? getParagraphMarkSuppressionOverrides({
 		directFormatting: authoredFormatting,
 		paragraphMarkFormatting: context.paragraphMarkFormatting,
 		suppressedFormatting: paragraphFormatting
-	}) : void 0, authoredFormatting);
+	}) : void 0;
+	const overrideFormatting = mergeTextFormatting(paragraphMarkOverrides, authoredFormatting);
 	const formattingMarks = textFormattingToMarks(effectiveFormatting, node.type.schema, {
 		overrideFormatting,
 		directFormatting: authoredFormatting,

package/dist/prosemirror/runIdentity.d.ts

@@ -2,27 +2,26 @@ import { document_d_exports } from "../types/document.js";
 import { RunIdentityMarkAttrs } from "./schema/marks.js";
 //#region src/prosemirror/runIdentity.d.ts
 /** The DOM attribute that carries a run's identity through copy and paste. */
-declare const RUN_IDENTITY_ATTRIBUTE = "data-docx-run-identity";
+export declare const RUN_IDENTITY_ATTRIBUTE = "data-docx-run-identity";
 /** The schema name of the mark these attrs belong to. */
-declare const RUN_IDENTITY_MARK_NAME = "runIdentity";
+export declare const RUN_IDENTITY_MARK_NAME = "runIdentity";
 /**
  * What a run carries beside its id: absent fields left absent, empty
  * collections normalised to absent so a run with nothing to carry keys the
  * same however it was built.
  */
-type RunIdentityPayload = {
+export type RunIdentityPayload = {
   preservedAttributes?: readonly document_d_exports.PreservedAttribute[] | undefined;
   preserved?: document_d_exports.PreservedMarkup | undefined;
   emptyFormatting?: boolean | undefined;
 };
 /** A run identity's attrs in canonical form. */
-declare const runIdentityAttrs: (id: number, { preservedAttributes, preserved, emptyFormatting }?: RunIdentityPayload) => RunIdentityMarkAttrs;
+export declare const runIdentityAttrs: (id: number, { preservedAttributes, preserved, emptyFormatting }?: RunIdentityPayload) => RunIdentityMarkAttrs;
 /**
  * Whether a run holds markup the mark exists to carry.
  *
  * The payload condition. The conversion also mints an identity for runs whose
  * page break or mixed inline atoms split one authored run into several leaves.
  */
-declare const hasRunIdentityPayload: ({ preservedAttributes, preserved, emptyFormatting }: RunIdentityPayload) => boolean;
-//#endregion
-export { RUN_IDENTITY_ATTRIBUTE, RUN_IDENTITY_MARK_NAME, RunIdentityPayload, hasRunIdentityPayload, runIdentityAttrs };
+export declare const hasRunIdentityPayload: ({ preservedAttributes, preserved, emptyFormatting }: RunIdentityPayload) => boolean;
+//#endregion

package/dist/prosemirror/runIdentityAcrossRevisions.d.ts

@@ -1,8 +1,19 @@
 import { Node } from "prosemirror-model";
 //#region src/prosemirror/runIdentityAcrossRevisions.d.ts
-/** The continuation policy covers every declared source-carrier mark. */
-declare const SOURCE_CARRIER_MARK_NAMES: ("hyperlink" | "runIdentity")[];
+/** Ordered source of truth for source-carrier identities and continuation. */
+export type SourceCarrierMarkName = "runIdentity" | "hyperlink";
+export declare const SOURCE_CARRIER_MARK_NAMES: readonly ["runIdentity", "hyperlink"];
 /** Every source-carrier family uses the same revision-boundary continuation policy. */
-declare const continueSourceCarrierIdentitiesAcrossRevisions: (nodes: readonly Node[]) => readonly Node[];
-//#endregion
-export { SOURCE_CARRIER_MARK_NAMES, continueSourceCarrierIdentitiesAcrossRevisions };
+export declare const continueSourceCarrierIdentitiesAcrossRevisions: (nodes: readonly Node[]) => readonly Node[];
+/**
+ * `blocks`, sibling blocks of one container and everything inside them, with
+ * the source carriers a tracked paragraph split cut apart given one identity.
+ *
+ * A split inside a run or link saves the two halves in two paragraphs, which
+ * reopen as two carriers. Rejecting the inserted paragraph mark rejoins the
+ * halves, and the editor that made the split still holds one carrier there.
+ * A deleted paragraph mark joined two source paragraphs, whose carriers were
+ * always separate, so it is not crossed.
+ */
+export declare const continueSourceCarrierIdentitiesAcrossInsertedParagraphMarks: (blocks: readonly Node[]) => readonly Node[];
+//#endregion

package/dist/prosemirror/runIdentityAcrossRevisions.js

@@ -15,34 +15,37 @@ const REVISION_MARK_NAMES = /* @__PURE__ */ new Set([
 	"deletion",
 	"runPropertyChange"
 ]);
-const CARRIER_OWNERS = [{
-	markName: RUN_IDENTITY_MARK_NAME,
-	read: (mark) => {
-		const attrs = expectRunIdentityMarkAttrs(mark);
-		return {
-			id: attrs.id,
-			payloadKey: JSON.stringify({
-				...attrs,
-				id: 0
-			})
-		};
-	}
-}, {
-	markName: "hyperlink",
-	read: (mark) => {
-		const attrs = expectHyperlinkMarkAttrs(mark);
-		if (typeof attrs._docxHyperlinkIndex !== "number") return void 0;
-		return {
-			id: attrs._docxHyperlinkIndex,
-			payloadKey: JSON.stringify({
-				...attrs,
-				_docxHyperlinkIndex: 0
-			})
-		};
+const SOURCE_CARRIER_MARK_NAMES = [RUN_IDENTITY_MARK_NAME, "hyperlink"];
+/** Every declared carrier has one owner; iteration follows the canonical tuple. */
+const CARRIER_OWNERS = {
+	[SOURCE_CARRIER_MARK_NAMES[0]]: {
+		markName: SOURCE_CARRIER_MARK_NAMES[0],
+		read: (mark) => {
+			const attrs = expectRunIdentityMarkAttrs(mark);
+			return {
+				id: attrs.id,
+				payloadKey: JSON.stringify({
+					...attrs,
+					id: 0
+				})
+			};
+		}
+	},
+	[SOURCE_CARRIER_MARK_NAMES[1]]: {
+		markName: SOURCE_CARRIER_MARK_NAMES[1],
+		read: (mark) => {
+			const attrs = expectHyperlinkMarkAttrs(mark);
+			if (typeof attrs._docxHyperlinkIndex !== "number") return void 0;
+			return {
+				id: attrs._docxHyperlinkIndex,
+				payloadKey: JSON.stringify({
+					...attrs,
+					_docxHyperlinkIndex: 0
+				})
+			};
+		}
 	}
-}];
-/** The continuation policy covers every declared source-carrier mark. */
-const SOURCE_CARRIER_MARK_NAMES = CARRIER_OWNERS.map(({ markName }) => markName);
+};
 const identityOf = (node, owner) => {
 	const mark = node.marks.find((candidate) => candidate.type.name === owner.markName);
 	if (!mark) return void 0;
@@ -65,11 +68,11 @@ const continuesCarrier = ({ left, right, bridged, owner }) => {
 * the identity of its matching source carrier. A control is a container of its
 * own. `nodes` itself comes back when nothing changes.
 */
-const continueIdentities = (nodes, owner) => {
+const continueIdentities = (nodes, owner, before) => {
 	const renamed = /* @__PURE__ */ new Map();
 	/** The last carrier with an identity, while only revised content follows it. */
-	let anchor;
-	let bridged = false;
+	let anchor = before?.anchor;
+	let bridged = before?.bridged ?? false;
 	let changed = false;
 	const result = nodes.map((node) => {
 		if (node.type.name === "sdt") {
@@ -111,8 +114,65 @@ const continueIdentities = (nodes, owner) => {
 /** Every source-carrier family uses the same revision-boundary continuation policy. */
 const continueSourceCarrierIdentitiesAcrossRevisions = (nodes) => {
 	let continued = nodes;
-	for (const owner of CARRIER_OWNERS) continued = continueIdentities(continued, owner);
+	for (const markName of SOURCE_CARRIER_MARK_NAMES) continued = continueIdentities(continued, CARRIER_OWNERS[markName]);
 	return continued;
 };
+/** Paragraph-mark kinds whose rejection joins the paragraph to the next. */
+const INSERTED_PARAGRAPH_MARK_KINDS = /* @__PURE__ */ new Set(["ins", "moveTo"]);
+const endsWithInsertedMark = (node) => {
+	if (node.type.name !== "paragraph") return false;
+	const mark = node.attrs["pPrMark"];
+	return typeof mark === "object" && mark !== null && "kind" in mark && INSERTED_PARAGRAPH_MARK_KINDS.has(mark.kind);
+};
+const childrenOf = (node) => {
+	const children = [];
+	node.forEach((child) => {
+		children.push(child);
+	});
+	return children;
+};
+/**
+* `paragraph`, after `previous` whose inserted mark split one source paragraph
+* in two, with the carriers that continue `previous`'s last one across that
+* mark given its identity, as fragments across a revision boundary are.
+*/
+const continueAcrossInsertedMark = (previous, paragraph) => {
+	const anchor = previous.lastChild;
+	if (anchor === null) return paragraph;
+	const original = childrenOf(paragraph);
+	let continued = original;
+	for (const markName of SOURCE_CARRIER_MARK_NAMES) continued = continueIdentities(continued, CARRIER_OWNERS[markName], {
+		anchor,
+		bridged: true
+	});
+	return continued === original ? paragraph : paragraph.copy(Fragment.fromArray([...continued]));
+};
+/**
+* `blocks`, sibling blocks of one container and everything inside them, with
+* the source carriers a tracked paragraph split cut apart given one identity.
+*
+* A split inside a run or link saves the two halves in two paragraphs, which
+* reopen as two carriers. Rejecting the inserted paragraph mark rejoins the
+* halves, and the editor that made the split still holds one carrier there.
+* A deleted paragraph mark joined two source paragraphs, whose carriers were
+* always separate, so it is not crossed.
+*/
+const continueSourceCarrierIdentitiesAcrossInsertedParagraphMarks = (blocks) => {
+	let changed = false;
+	const result = [];
+	for (const block of blocks) {
+		let next = block;
+		if (!block.isTextblock && !block.isLeaf && !block.inlineContent) {
+			const children = childrenOf(block);
+			const continued = continueSourceCarrierIdentitiesAcrossInsertedParagraphMarks(children);
+			if (continued !== children) next = block.copy(Fragment.fromArray([...continued]));
+		}
+		const previous = result.at(-1);
+		if (previous !== void 0 && next.type.name === "paragraph" && endsWithInsertedMark(previous)) next = continueAcrossInsertedMark(previous, next);
+		changed ||= next !== block;
+		result.push(next);
+	}
+	return changed ? result : blocks;
+};
 //#endregion
-export { SOURCE_CARRIER_MARK_NAMES, continueSourceCarrierIdentitiesAcrossRevisions };
+export { SOURCE_CARRIER_MARK_NAMES, continueSourceCarrierIdentitiesAcrossInsertedParagraphMarks, continueSourceCarrierIdentitiesAcrossRevisions };

package/dist/prosemirror/runPropertyChangeResolution.d.ts

@@ -13,13 +13,13 @@ type ReconstructRejectedRunFormattingMarksOptions = {
  * Both granular editor commands and the headless linear rewriter use this
  * owner so their reject semantics cannot diverge at the bulk threshold.
  */
-declare const reconstructRejectedRunFormattingMarks: ({ node, paragraphContext, previousFormatting, styleResolver }: ReconstructRejectedRunFormattingMarksOptions) => readonly Mark[];
+export 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[];
+export declare const restoreHistoricalRunFormatting: ({ node, paragraphContext, styleResolver }: RestoreHistoricalRunFormattingOptions) => readonly Mark[];
 //#endregion
-export { reconstructRejectedRunFormattingMarks, restoreHistoricalRunFormatting };
+export {};

package/dist/prosemirror/runPropertyChangeResolution.js

@@ -32,17 +32,18 @@ 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;
+	const authoredFormatting = readAuthoredRunFormatting({
+		context: {
+			baseParagraphFormatting: paragraphContext.baseParagraphFormatting,
+			paragraphFormatting: paragraphContext.baseParagraphFormatting,
+			paragraphMarkFormatting: void 0,
+			paragraphMarkPrecedesStyle: false
+		},
+		marks: node.marks,
+		...styleResolver !== void 0 ? { styleResolver } : {}
+	});
 	return reconcileRunFormattingMarks({
-		authoredFormatting: readAuthoredRunFormatting({
-			context: {
-				baseParagraphFormatting: paragraphContext.baseParagraphFormatting,
-				paragraphFormatting: paragraphContext.baseParagraphFormatting,
-				paragraphMarkFormatting: void 0,
-				paragraphMarkPrecedesStyle: false
-			},
-			marks: node.marks,
-			...styleResolver !== void 0 ? { styleResolver } : {}
-		}),
+		authoredFormatting,
 		context: paragraphContext,
 		node,
 		...styleResolver !== void 0 ? { styleResolver } : {}

package/dist/prosemirror/runStyleFormatting.d.ts

@@ -4,38 +4,38 @@ import "../style-engine/index.js";
 import { StyleToggleKey, 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;
+export 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;
+export declare const isParagraphMarkSuppressionEligible: (formatting: document_d_exports.TextFormatting | undefined) => boolean;
+export declare const stripParagraphMarkOnlyFormatting: (formatting: document_d_exports.TextFormatting) => document_d_exports.TextFormatting | undefined;
+export declare const stripParagraphMarkFormattingForBodyRuns: (formatting: document_d_exports.TextFormatting) => document_d_exports.TextFormatting | undefined;
 type SuppressParagraphMarkFormattingOptions = {
   baseFormatting: document_d_exports.TextFormatting | undefined;
   directFormatting: document_d_exports.TextFormatting | undefined;
   paragraphMarkFormatting: document_d_exports.TextFormatting | undefined;
   paragraphMarkPrecedesStyle?: boolean;
 };
-declare const suppressParagraphMarkFormatting: ({ baseFormatting, directFormatting, paragraphMarkFormatting, paragraphMarkPrecedesStyle }: SuppressParagraphMarkFormattingOptions) => document_d_exports.TextFormatting | undefined;
+export declare const suppressParagraphMarkFormatting: ({ baseFormatting, directFormatting, paragraphMarkFormatting, paragraphMarkPrecedesStyle }: SuppressParagraphMarkFormattingOptions) => document_d_exports.TextFormatting | undefined;
 type GetParagraphMarkSuppressionOverridesOptions = {
   directFormatting: document_d_exports.TextFormatting | undefined;
   paragraphMarkFormatting: document_d_exports.TextFormatting | undefined;
   suppressedFormatting: document_d_exports.TextFormatting | undefined;
 };
-declare const getParagraphMarkSuppressionOverrides: ({ directFormatting, paragraphMarkFormatting, suppressedFormatting }: GetParagraphMarkSuppressionOverridesOptions) => document_d_exports.TextFormatting | undefined;
-type ParagraphRunStyleContext = {
+export declare const getParagraphMarkSuppressionOverrides: ({ directFormatting, paragraphMarkFormatting, suppressedFormatting }: GetParagraphMarkSuppressionOverridesOptions) => document_d_exports.TextFormatting | undefined;
+export type ParagraphRunStyleContext = {
   baseParagraphFormatting: document_d_exports.TextFormatting | undefined;
   paragraphFormatting: document_d_exports.TextFormatting | undefined;
   paragraphMarkFormatting: document_d_exports.TextFormatting | undefined;
   paragraphMarkPrecedesStyle: boolean;
 };
-type RunStyleResolver = Pick<StyleEngine, "builtInStyles" | "getDefaultCharacterStyle" | "getDefaultParagraphStyle" | "getDocDefaults" | "getRunStyleOwnProperties" | "getStyle" | "resolveParagraphStyle">;
+export type RunStyleResolver = Pick<StyleEngine, "builtInStyles" | "getDefaultCharacterStyle" | "getDefaultParagraphStyle" | "getDocDefaults" | "getRunStyleOwnProperties" | "getStyle" | "resolveParagraphStyle">;
 type ResolveParagraphBodyRunFormattingOptions = {
   styleId: string | undefined;
   styleResolver?: RunStyleResolver | null | undefined;
   tableRunFormatting?: document_d_exports.TextFormatting | undefined;
 };
 /** Resolve the table, paragraph, and character style cascade before paragraph-mark properties. */
-declare const resolveParagraphBodyRunFormatting: ({ styleId, styleResolver, tableRunFormatting }: ResolveParagraphBodyRunFormattingOptions) => {
+export declare const resolveParagraphBodyRunFormatting: ({ styleId, styleResolver, tableRunFormatting }: ResolveParagraphBodyRunFormattingOptions) => {
   baseFormatting: document_d_exports.TextFormatting | undefined;
   baseToggleCascade: ReturnType<typeof cascadeStyleTextFormatting>;
   defaultFormatting: document_d_exports.TextFormatting | undefined;
@@ -45,7 +45,7 @@ type ResolveParagraphInheritedRunFormattingOptions = ResolveParagraphBodyRunForm
   paragraphMarkFormatting: document_d_exports.TextFormatting | undefined;
 };
 /** One source cascade for imported body runs and the saver inheritance baseline. */
-declare const resolveParagraphInheritedRunFormatting: (options: ResolveParagraphInheritedRunFormattingOptions) => {
+export declare const resolveParagraphInheritedRunFormatting: (options: ResolveParagraphInheritedRunFormattingOptions) => {
   inheritedFormatting: {
     bold?: boolean | undefined;
     boldCs?: boolean | undefined;
@@ -111,31 +111,31 @@ declare const resolveParagraphInheritedRunFormatting: (options: ResolveParagraph
   defaultFormatting: document_d_exports.TextFormatting | undefined;
   defaultToggleCascade: ReturnType<typeof cascadeStyleTextFormatting>;
 };
-declare const paragraphRunStyleContext: (paragraph: Node, styleResolver?: RunStyleResolver | null) => ParagraphRunStyleContext;
+export declare const paragraphRunStyleContext: (paragraph: Node, styleResolver?: RunStyleResolver | null) => ParagraphRunStyleContext;
 type ParagraphFormattingForRunOptions = {
   context: ParagraphRunStyleContext;
   directFormatting?: document_d_exports.TextFormatting;
   marks: readonly Mark[];
 };
-declare const paragraphFormattingForRun: ({ context, directFormatting, marks }: ParagraphFormattingForRunOptions) => document_d_exports.TextFormatting | undefined;
+export declare const paragraphFormattingForRun: ({ context, directFormatting, marks }: ParagraphFormattingForRunOptions) => document_d_exports.TextFormatting | undefined;
 type ParagraphRunStyleContextAtOptions = {
   doc: Node;
   pos: number;
   styleResolver?: RunStyleResolver | null;
 };
-declare const paragraphRunStyleContextAt: ({ doc, pos, styleResolver }: ParagraphRunStyleContextAtOptions) => ParagraphRunStyleContext;
+export declare const paragraphRunStyleContextAt: ({ doc, pos, styleResolver }: ParagraphRunStyleContextAtOptions) => ParagraphRunStyleContext;
 /**
  * {@link paragraphRunStyleContextAt} for a caller that already knows the
  * nearest paragraph, or that there is none. A document walk knows it for free,
  * where `doc.resolve` re-descends from the root once per run.
  */
-declare const nearestParagraphRunStyleContext: (paragraph: Node | null, styleResolver?: RunStyleResolver | null) => ParagraphRunStyleContext;
+export declare const nearestParagraphRunStyleContext: (paragraph: Node | null, styleResolver?: RunStyleResolver | null) => ParagraphRunStyleContext;
 type ResolveEffectiveRunStyleFormattingOptions = {
   marks: readonly Mark[];
   paragraphFormatting: document_d_exports.TextFormatting | undefined;
   styleResolver?: RunStyleResolver | null;
 };
 /** 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;
+export declare const resolveEffectiveRunStyleFormatting: ({ marks, paragraphFormatting, styleResolver }: ResolveEffectiveRunStyleFormattingOptions) => document_d_exports.TextFormatting | undefined;
 //#endregion
-export { ParagraphRunStyleContext, RunStyleResolver, getParagraphMarkSuppressionOverrides, hasDirectRunFormatting, isParagraphMarkSuppressionEligible, nearestParagraphRunStyleContext, paragraphFormattingForRun, paragraphRunStyleContext, paragraphRunStyleContextAt, resolveEffectiveRunStyleFormatting, resolveParagraphBodyRunFormatting, resolveParagraphInheritedRunFormatting, stripParagraphMarkFormattingForBodyRuns, stripParagraphMarkOnlyFormatting, suppressParagraphMarkFormatting };
+export {};

package/dist/prosemirror/runStyleFormatting.js

@@ -138,8 +138,9 @@ const resolveParagraphInheritedRunFormatting = (options) => {
 const paragraphRunStyleContext = (paragraph, styleResolver) => {
 	const attrs = expectParagraphAttrs(paragraph);
 	const paragraphMarkFormatting = attrs._originalFormatting?.runProperties;
+	const characterStyleFormatting = paragraphMarkFormatting?.styleId ? styleResolver?.getRunStyleOwnProperties(paragraphMarkFormatting.styleId) : void 0;
 	const resolvedParagraphMarkFormatting = cascadeStyleTextFormatting([{
-		formatting: paragraphMarkFormatting?.styleId ? styleResolver?.getRunStyleOwnProperties(paragraphMarkFormatting.styleId) : void 0,
+		formatting: characterStyleFormatting,
 		type: "style"
 	}, {
 		formatting: paragraphMarkFormatting,
@@ -194,9 +195,10 @@ const resolveEffectiveRunStyleFormatting = ({ marks, paragraphFormatting, styleR
 	else if (hasDirectFormattingCarrier) styleFormatting = styleResolver?.getDefaultCharacterStyle()?.rPr;
 	if (!styleFormatting) return paragraphFormatting;
 	const docDefaults = styleResolver?.getDocDefaults()?.rPr;
+	const defaultsActiveProperties = STYLE_TOGGLE_KEYS.filter((property) => docDefaults?.[property] === true);
 	return cascadeStyleFromResolvedBase({
 		baseFormatting: paragraphFormatting,
-		defaultsActiveProperties: STYLE_TOGGLE_KEYS.filter((property) => docDefaults?.[property] === true),
+		defaultsActiveProperties,
 		styleFormatting
 	});
 };