@stll/folio-core 0.62.0 → 0.63.1

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,15 +45,15 @@ 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;
     italic?: boolean | undefined;
     italicCs?: boolean | undefined;
     underline?: {
-      style: import("@stll/docx-core/model").UnderlineStyle;
-      color?: import("@stll/docx-core/model").ColorValue;
+      style: document_d_exports.UnderlineStyle;
+      color?: document_d_exports.ColorValue;
     } | undefined;
     strike?: boolean | undefined;
     doubleStrike?: boolean | undefined;
@@ -62,9 +62,9 @@ declare const resolveParagraphInheritedRunFormatting: (options: ResolveParagraph
     allCaps?: boolean | undefined;
     hidden?: boolean | undefined;
     noProof?: boolean | undefined;
-    color?: import("@stll/docx-core/model").ColorValue | undefined;
+    color?: document_d_exports.ColorValue | undefined;
     highlight?: "black" | "blue" | "cyan" | "darkBlue" | "darkCyan" | "darkGray" | "darkGreen" | "darkMagenta" | "darkRed" | "darkYellow" | "green" | "lightGray" | "magenta" | "none" | "red" | "white" | "yellow" | undefined;
-    shading?: import("@stll/docx-core/model").ShadingProperties | undefined;
+    shading?: document_d_exports.ShadingProperties | undefined;
     fontSize?: number | undefined;
     fontSizeCs?: number | undefined;
     fontFamily?: {
@@ -87,8 +87,8 @@ declare const resolveParagraphInheritedRunFormatting: (options: ResolveParagraph
     position?: number | undefined;
     scale?: number | undefined;
     kerning?: number | undefined;
-    effect?: import("@stll/docx-core/model").TextEffect | undefined;
-    emphasisMark?: import("@stll/docx-core/model").EmphasisMark | undefined;
+    effect?: document_d_exports.TextEffect | undefined;
+    emphasisMark?: document_d_exports.EmphasisMark | undefined;
     emboss?: boolean | undefined;
     imprint?: boolean | undefined;
     outline?: boolean | undefined;
@@ -96,7 +96,7 @@ declare const resolveParagraphInheritedRunFormatting: (options: ResolveParagraph
     rtl?: boolean | undefined;
     cs?: boolean | undefined;
     styleId?: string | undefined;
-    preserved?: import("@stll/docx-core/model").PreservedMarkup | undefined;
+    preserved?: document_d_exports.PreservedMarkup | undefined;
   } | undefined;
   inheritedToggleCascade: {
     formatting: document_d_exports.TextFormatting | 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
 	});
 };

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

@@ -1,14 +1,15 @@
 import { CharacterSpacingAttrs, CharacterStyleAttrs, CommentAttrs, EmphasisMarkAttrs, FontFamilyAttrs, FontSizeAttrs, FootnoteRefAttrs, HighlightAttrs, HyperlinkAttrs, InlineWrapperAttrs, InlineWrapperKind, InlineWrapperLayer, LanguageAttrs, RunFormattingOverrideAttrs, RunIdentityMarkAttrs, RunPropertyChangeMarkAttrs, RunShadingAttrs, StrikeAttrs, TextColorAttrs, TextEffectAttrs, TrackedChangeMarkAttrs, TrackedRevisionAncestor, UnderlineAttrs } from "./marks.js";
 import { BlockCustomXmlAttrs, BlockSdtAttrs, BookmarkBoundaryAttrs, FieldAttrs, HardBreakAttrs, ImageAttrs, ImagePositionAttrs, MathAttrs, PageBreakRunAttrs, ParagraphAttrs, ParagraphPropertyChangeAttrs, PreservedBlockAttrs, PreservedXmlAttrs, PreservedXmlLevel, SdtAttrs, ShapeAttrs, SymbolAttrs, TabAttrs, TableAttrs, TableCellAttrs, TableRowAttrs, TextBoxAttrs } from "./nodes.js";
 import { ExtensionManager } from "../extensions/ExtensionManager.js";
+import { Schema } from "prosemirror-model";
 //#region src/prosemirror/schema/index.d.ts
-declare const singletonManager: ExtensionManager;
-declare const schema: import("prosemirror-model").Schema<any, any>;
+export declare const singletonManager: ExtensionManager;
+export declare const schema: Schema;
 /**
  * Export types for convenience
  */
-type DocxSchema = typeof schema;
-type DocxNode = ReturnType<typeof schema.node>;
-type DocxMark = ReturnType<typeof schema.mark>;
+export type DocxSchema = typeof schema;
+export type DocxNode = ReturnType<typeof schema.node>;
+export type DocxMark = ReturnType<typeof schema.mark>;
 //#endregion
-export { type BlockCustomXmlAttrs, type BlockSdtAttrs, type BookmarkBoundaryAttrs, type CharacterSpacingAttrs, type CharacterStyleAttrs, type CommentAttrs, DocxMark, DocxNode, DocxSchema, type EmphasisMarkAttrs, type FieldAttrs, type FontFamilyAttrs, type FontSizeAttrs, type FootnoteRefAttrs, type HardBreakAttrs, type HighlightAttrs, type HyperlinkAttrs, type ImageAttrs, type ImagePositionAttrs, type InlineWrapperAttrs, type InlineWrapperKind, type InlineWrapperLayer, type LanguageAttrs, type MathAttrs, type PageBreakRunAttrs, type ParagraphAttrs, type ParagraphPropertyChangeAttrs, type PreservedBlockAttrs, type PreservedXmlAttrs, type PreservedXmlLevel, type RunFormattingOverrideAttrs, type RunIdentityMarkAttrs, type RunPropertyChangeMarkAttrs, type RunShadingAttrs, type SdtAttrs, type ShapeAttrs, type StrikeAttrs, type SymbolAttrs, type TabAttrs, type TableAttrs, type TableCellAttrs, type TableRowAttrs, type TextBoxAttrs, type TextColorAttrs, type TextEffectAttrs, type TrackedChangeMarkAttrs, type TrackedRevisionAncestor, type UnderlineAttrs, schema, singletonManager };
+export type { BlockCustomXmlAttrs, BlockSdtAttrs, BookmarkBoundaryAttrs, CharacterSpacingAttrs, CharacterStyleAttrs, CommentAttrs, EmphasisMarkAttrs, FieldAttrs, FontFamilyAttrs, FontSizeAttrs, FootnoteRefAttrs, HardBreakAttrs, HighlightAttrs, HyperlinkAttrs, ImageAttrs, ImagePositionAttrs, InlineWrapperAttrs, InlineWrapperKind, InlineWrapperLayer, LanguageAttrs, MathAttrs, PageBreakRunAttrs, ParagraphAttrs, ParagraphPropertyChangeAttrs, PreservedBlockAttrs, PreservedXmlAttrs, PreservedXmlLevel, RunFormattingOverrideAttrs, RunIdentityMarkAttrs, RunPropertyChangeMarkAttrs, RunShadingAttrs, SdtAttrs, ShapeAttrs, StrikeAttrs, SymbolAttrs, TabAttrs, TableAttrs, TableCellAttrs, TableRowAttrs, TextBoxAttrs, TextColorAttrs, TextEffectAttrs, TrackedChangeMarkAttrs, TrackedRevisionAncestor, UnderlineAttrs };