@stll/folio-core 0.27.1 → 0.28.1

package/dist/prosemirror/conversion/fromProseDoc.js

@@ -8,6 +8,7 @@ import { applyRunFormattingOverrideAttrs } from "../extensions/marks/RunFormatti
 import { directionToBidi } from "../paragraphDirection.js";
 import { RUN_FORMATTING_MARK_NAMES } from "../runFormattingMarkNames.js";
 import { parseShapeGeometryAdjustments } from "../shapeGeometryAdjustments.js";
+import { cascadeStyleTextFormatting } from "../styles/styleToggleCascade.js";
 import { expectTextBoxAnchorAttrs } from "../textBoxAnchorAttrs.js";
 import { assertValidProseMirrorDocument } from "../validation.js";
 import { runShadingAttrsToShading } from "./runShadingMark.js";
@@ -647,6 +648,7 @@ function paragraphAttrsToFormatting(attrs) {
 */
 function extractParagraphContent(paragraph, _documentCounts, emptyHyperlinks, textBoxAnchorMarkers, skipLeadingRenderedPageBreak = false) {
 	const content = [];
+	const inheritedFormatting = paragraph.type.name === "paragraph" ? expectParagraphAttrs(paragraph).defaultTextFormatting ?? void 0 : void 0;
 	const sortedEmptyHyperlinks = (emptyHyperlinks ?? []).map((attrs, order) => ({
 		attrs,
 		order
@@ -763,7 +765,12 @@ function extractParagraphContent(paragraph, _documentCounts, emptyHyperlinks, te
 			const changeMark = insertionMark ?? deletionMark;
 			if (!changeMark) return;
 			const changeAttrs = expectTrackedChangeMarkAttrs(changeMark);
-			const run = createTrackedChangeRun(node, node.marks.filter((m) => m.type.name !== "insertion" && m.type.name !== "deletion"));
+			const otherMarks = node.marks.filter((m) => m.type.name !== "insertion" && m.type.name !== "deletion");
+			const run = createTrackedChangeRun({
+				inheritedFormatting,
+				marks: otherMarks,
+				node
+			});
 			if (!run) return;
 			const trackedContent = linkMark ? {
 				...createHyperlink(linkMark),
@@ -809,7 +816,11 @@ function extractParagraphContent(paragraph, _documentCounts, emptyHyperlinks, te
 				currentHyperlink = createHyperlink(linkMark);
 				currentHyperlinkKey = linkKey;
 			}
-			addNodeToHyperlink(currentHyperlink, node);
+			addNodeToHyperlink({
+				hyperlink: currentHyperlink,
+				inheritedFormatting,
+				node
+			});
 			return;
 		}
 		if (currentHyperlink) flushCurrentInline();
@@ -818,7 +829,11 @@ function extractParagraphContent(paragraph, _documentCounts, emptyHyperlinks, te
 			if (currentRun && currentMarksKey === marksKey) appendTextToRun(currentRun, node.text || "");
 			else {
 				if (currentRun) content.push(currentRun);
-				currentRun = createRunFromText(node.text || "", node.marks);
+				currentRun = createRunFromText({
+					inheritedFormatting,
+					marks: node.marks,
+					text: node.text || ""
+				});
 				currentMarksKey = marksKey;
 			}
 		} else if (node.type.name === "symbol") {
@@ -880,11 +895,11 @@ function extractParagraphContent(paragraph, _documentCounts, emptyHyperlinks, te
 	});
 	return content;
 }
-function createTrackedChangeRun(node, marks) {
+function createTrackedChangeRun({ inheritedFormatting, marks, node }) {
 	const noteRefMark = marks.find((mark) => mark.type.name === "footnoteRef");
 	if (noteRefMark) return createNoteReferenceRun(noteRefMark, marks);
 	if (node.isText) {
-		const formatting = marksToTextFormatting(marks);
+		const formatting = marksToTextFormatting(marks, { inheritedFormatting });
 		const run = {
 			type: "run",
 			content: node.text ? [{
@@ -989,10 +1004,7 @@ function createHyperlink(linkMark) {
 	if (attrs.rId) hyperlink.rId = attrs.rId;
 	return hyperlink;
 }
-/**
-* Add a node to a hyperlink
-*/
-function addNodeToHyperlink(hyperlink, node) {
+function addNodeToHyperlink({ hyperlink, inheritedFormatting, node }) {
 	const noteRefMark = node.marks.find((m) => m.type.name === "footnoteRef");
 	if (noteRefMark) {
 		hyperlink.children.push(createNoteReferenceRun(noteRefMark, node.marks));
@@ -1000,7 +1012,11 @@ function addNodeToHyperlink(hyperlink, node) {
 	}
 	const nonLinkMarks = node.marks.filter((m) => m.type.name !== "hyperlink");
 	if (node.isText && node.text) {
-		const run = createRunFromText(node.text, nonLinkMarks);
+		const run = createRunFromText({
+			inheritedFormatting,
+			marks: nonLinkMarks,
+			text: node.text
+		});
 		hyperlink.children.push(run);
 		return;
 	}
@@ -1044,11 +1060,8 @@ function createNoteReferenceRun(noteRefMark, marks) {
 	if (vertAlign) run.formatting = { vertAlign };
 	return run;
 }
-/**
-* Create a Run from text and marks
-*/
-function createRunFromText(text, marks) {
-	const formatting = getRunFormattingFromMarks(marks);
+function createRunFromText({ inheritedFormatting, marks, text }) {
+	const formatting = getRunFormattingFromMarks(marks, { inheritedFormatting });
 	const run = {
 		type: "run",
 		content: [{
@@ -1082,9 +1095,9 @@ function restoreRunPropertyChanges(run, marks) {
 	if (changes.length === 0) return;
 	run.propertyChanges = [...changes];
 }
-function getRunFormattingFromMarks(marks) {
+function getRunFormattingFromMarks(marks, options) {
 	if (!marks || marks.length === 0) return;
-	const formatting = marksToTextFormatting(marks);
+	const formatting = marksToTextFormatting(marks, options);
 	return Object.keys(formatting).length > 0 ? formatting : void 0;
 }
 /**
@@ -1354,11 +1367,9 @@ function createShapeRun(node) {
 		}]
 	};
 }
-/**
-* Convert ProseMirror marks to TextFormatting
-*/
-function marksToTextFormatting(marks) {
+function marksToTextFormatting(marks, options) {
 	const formatting = {};
+	let directOverrideFormatting;
 	let characterStyleRPr;
 	let runFormattingOverrideMark;
 	for (const mark of marks) switch (mark.type.name) {
@@ -1483,8 +1494,18 @@ function marksToTextFormatting(marks) {
 		}
 		default: break;
 	}
-	if (runFormattingOverrideMark) applyRunFormattingOverrideAttrs(formatting, expectRunFormattingOverrideMarkAttrs(runFormattingOverrideMark));
-	if (characterStyleRPr) return subtractCharacterStyleFormatting(formatting, characterStyleRPr);
+	if (runFormattingOverrideMark) {
+		const overrideAttrs = expectRunFormattingOverrideMarkAttrs(runFormattingOverrideMark);
+		applyRunFormattingOverrideAttrs(formatting, overrideAttrs);
+		directOverrideFormatting = {};
+		applyRunFormattingOverrideAttrs(directOverrideFormatting, overrideAttrs);
+	}
+	if (characterStyleRPr) return subtractCharacterStyleFormatting({
+		directOverrideFormatting,
+		formatting,
+		inheritedFormatting: options?.inheritedFormatting,
+		styleRPr: characterStyleRPr
+	});
 	return formatting;
 }
 /**
@@ -1509,35 +1530,29 @@ const NEGATABLE_STYLE_KEYS = [
 	["outline", null],
 	["rtl", null]
 ];
-/**
-* Drop run formatting values that the run's character style already provides
-* (the `w:rStyle` reference re-imposes them on load), so a styled run
-* serializes back to a style reference instead of baked direct formatting.
-*
-* `styleRPr` is the load-time snapshot from the characterStyle mark, captured
-* in the same normal form this module produces from marks, so value equality
-* is a faithful "came from the style and is unchanged" check. Values that
-* differ (user edits, direct overrides from the source document) stay as
-* direct formatting, which wins over the style per the OOXML cascade.
-*
-* When the user *removes* a boolean property the style supplied (e.g. toggling
-* off bold on text whose `w:rStyle` is bold), that key is no longer present in
-* `formatting`, so the subtraction loop above never sees it. Without a counter,
-* the run keeps the style reference and Word re-applies the removed formatting
-* on load. The second pass emits an explicit negative override (`false`) for
-* each negatable boolean the style set to `true` but the run no longer carries.
-*/
-function subtractCharacterStyleFormatting(formatting, styleRPr) {
+function subtractCharacterStyleFormatting({ directOverrideFormatting, formatting, inheritedFormatting, styleRPr }) {
 	const result = {};
+	const effectiveStyleFormatting = cascadeStyleTextFormatting([{
+		formatting: inheritedFormatting,
+		type: "direct"
+	}, {
+		formatting: styleRPr,
+		type: "style"
+	}]).formatting;
 	for (const key of Object.keys(formatting)) {
 		const value = formatting[key];
 		if (value === void 0) continue;
-		const styleValue = key === "styleId" ? void 0 : styleRPr[key];
+		if (directOverrideFormatting?.[key] !== void 0) {
+			result[key] = value;
+			continue;
+		}
+		const styleValue = key === "styleId" ? void 0 : effectiveStyleFormatting?.[key];
+		if ((key === "boldCs" || key === "italicCs") && styleValue === false && value === true) continue;
 		if (styleValue !== void 0 && JSON.stringify(value) === JSON.stringify(styleValue)) continue;
 		result[key] = value;
 	}
 	for (const [key, csKey] of NEGATABLE_STYLE_KEYS) {
-		if (styleRPr[key] !== true || formatting[key] !== void 0) continue;
+		if (effectiveStyleFormatting?.[key] !== true || formatting[key] !== void 0) continue;
 		result[key] = false;
 		if (csKey !== null) result[csKey] = false;
 	}

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

@@ -22,7 +22,10 @@ declare function standaloneTableCellToProseMirror(cell: document_d_exports.Table
 /**
  * Convert TextFormatting to ProseMirror marks
  */
-declare function textFormattingToMarks(formatting: document_d_exports.TextFormatting | undefined): ReturnType<typeof schema.mark>[];
+type TextFormattingToMarksOptions = {
+  overrideFormatting: document_d_exports.TextFormatting | undefined;
+};
+declare function textFormattingToMarks(formatting: document_d_exports.TextFormatting | undefined, options?: TextFormattingToMarksOptions): ReturnType<typeof schema.mark>[];
 /**
  * Convert HeaderFooter content (array of Paragraph/Table blocks) to a ProseMirror document.
  * Used for editing headers/footers in their own ProseMirror editor and for

package/dist/prosemirror/conversion/toProseDoc.js

@@ -8,6 +8,7 @@ import { setAutospacingBaseValue } from "../autospacingBase.js";
 import { buildRunFormattingOverrideAttrs } from "../extensions/marks/RunFormattingOverrideExtension.js";
 import { directionFromBidi } from "../paragraphDirection.js";
 import { schema } from "../schema/index.js";
+import { cascadeStyleTextFormatting } from "../styles/styleToggleCascade.js";
 import { assertValidProseMirrorDocument } from "../validation.js";
 import { resolveEffectiveTableCellFormatting } from "./effectiveTableCellFormatting.js";
 import { marksToTextFormatting } from "./fromProseDoc.js";
@@ -144,22 +145,66 @@ function convertParagraph(paragraph, styleResolver, nextHyperlinkInstanceIndex,
 		emitInlineNodes([node]);
 	};
 	let styleRunFormatting;
+	let paragraphStyleRunFormatting;
 	let paragraphStyleFontFamily;
 	if (styleResolver) {
 		styleRunFormatting = styleResolver.resolveParagraphStyle(paragraph.formatting?.styleId).runFormatting;
+		const paragraphStyle = paragraph.formatting?.styleId ? styleResolver.getStyle(paragraph.formatting.styleId) ?? styleResolver.getDefaultParagraphStyle() : styleResolver.getDefaultParagraphStyle();
+		paragraphStyleRunFormatting = paragraphStyle?.type === "paragraph" ? paragraphStyle.rPr : void 0;
 		paragraphStyleFontFamily = resolveParagraphStyleFontFamily(paragraph.formatting?.styleId, styleResolver);
 	}
 	const paragraphRunFormatting = resolveRunFormattingWithoutDefaults(paragraph.formatting?.runProperties, styleResolver);
 	let inheritableParagraphRunFormatting;
 	if (paragraphRunFormatting && !isTocParagraph) inheritableParagraphRunFormatting = stripParagraphMarkFormattingForBodyRuns(paragraphRunFormatting);
-	let baseRunFormatting = mergeTextFormatting(styleRunFormatting, extraRunFormatting);
+	const orderedToggleFormatting = cascadeStyleTextFormatting([
+		{
+			formatting: styleResolver?.getDocDefaults()?.rPr,
+			type: "defaults"
+		},
+		{
+			formatting: extraRunFormatting,
+			type: "style"
+		},
+		{
+			formatting: paragraphStyleRunFormatting,
+			type: "style"
+		}
+	], { ordinaryFormatting: mergeTextFormatting(styleRunFormatting, extraRunFormatting) });
+	let baseRunFormatting = orderedToggleFormatting.formatting;
 	if (paragraphStyleFontFamily) baseRunFormatting = mergeTextFormatting(baseRunFormatting, { fontFamily: paragraphStyleFontFamily });
 	const paragraphMarkPrecedesStyle = paragraph.formatting?.styleId !== void 0;
-	const defaultRunFormatting = paragraphMarkPrecedesStyle ? mergeTextFormatting(inheritableParagraphRunFormatting, baseRunFormatting) : mergeTextFormatting(baseRunFormatting, inheritableParagraphRunFormatting);
+	const ordinaryDefaultRunFormatting = paragraphMarkPrecedesStyle ? mergeTextFormatting(inheritableParagraphRunFormatting, baseRunFormatting) : mergeTextFormatting(baseRunFormatting, inheritableParagraphRunFormatting);
+	const defaultToggleCascade = paragraphMarkPrecedesStyle ? cascadeStyleTextFormatting([{
+		cascade: orderedToggleFormatting,
+		type: "carried"
+	}], { ordinaryFormatting: ordinaryDefaultRunFormatting }) : cascadeStyleTextFormatting([{
+		cascade: orderedToggleFormatting,
+		type: "carried"
+	}, {
+		formatting: inheritableParagraphRunFormatting,
+		type: "direct"
+	}], { ordinaryFormatting: ordinaryDefaultRunFormatting });
+	const defaultRunFormatting = defaultToggleCascade.formatting;
 	const getInheritedRunFormatting = (formatting, fieldType) => {
-		if (fieldType === "TOC") return hasDirectRunFormatting(formatting) ? suppressParagraphMarkFormatting(baseRunFormatting, void 0, formatting) : baseRunFormatting;
-		if (!(hasDirectRunFormatting(formatting) || formatting?.styleId !== void 0)) return defaultRunFormatting;
-		return suppressParagraphMarkFormatting(baseRunFormatting, inheritableParagraphRunFormatting, formatting, paragraphMarkPrecedesStyle);
+		if (fieldType === "TOC") return {
+			formatting: hasDirectRunFormatting(formatting) ? suppressParagraphMarkFormatting(baseRunFormatting, void 0, formatting) : baseRunFormatting,
+			toggleCascade: orderedToggleFormatting
+		};
+		if (!(hasDirectRunFormatting(formatting) || formatting?.styleId !== void 0)) return {
+			formatting: defaultRunFormatting,
+			toggleCascade: defaultToggleCascade
+		};
+		const suppressedFormatting = suppressParagraphMarkFormatting(baseRunFormatting, inheritableParagraphRunFormatting, formatting, paragraphMarkPrecedesStyle);
+		const paragraphMarkOverrides = getParagraphMarkSuppressionOverrides({
+			directFormatting: formatting,
+			paragraphMarkFormatting: inheritableParagraphRunFormatting,
+			suppressedFormatting
+		});
+		return {
+			formatting: suppressedFormatting,
+			...paragraphMarkOverrides ? { paragraphMarkOverrides } : {},
+			toggleCascade: orderedToggleFormatting
+		};
 	};
 	const emitTrackedChange = (change, markType, moveKind) => {
 		emitInlineNodes(convertTrackedChange(change, markType, nextHyperlinkInstanceIndex, getInheritedRunFormatting, styleResolver, moveKind, textBoxAnchors));
@@ -499,27 +544,37 @@ function stripParagraphMarkFormattingForBodyRuns(formatting) {
 	const { fontFamily: _fontFamily, ...bodyRunFormatting } = paragraphMarkFormatting;
 	return Object.keys(bodyRunFormatting).length > 0 ? bodyRunFormatting : void 0;
 }
+const PARAGRAPH_MARK_BOOLEAN_KEYS = [
+	"bold",
+	"italic",
+	"strike",
+	"doubleStrike",
+	"allCaps",
+	"smallCaps",
+	"hidden",
+	"emboss",
+	"imprint",
+	"shadow",
+	"outline",
+	"rtl"
+];
 function suppressParagraphMarkFormatting(base, paragraphMark, direct, paragraphMarkPrecedesStyle = false) {
 	if (!paragraphMark) return base;
 	const result = (paragraphMarkPrecedesStyle ? mergeTextFormatting(paragraphMark, base) : mergeTextFormatting(base, paragraphMark)) ?? {};
-	suppressBooleanParagraphMark(result, base, paragraphMark, direct, "bold");
-	suppressBooleanParagraphMark(result, base, paragraphMark, direct, "italic");
-	suppressBooleanParagraphMark(result, base, paragraphMark, direct, "strike");
-	suppressBooleanParagraphMark(result, base, paragraphMark, direct, "doubleStrike");
-	suppressBooleanParagraphMark(result, base, paragraphMark, direct, "allCaps");
-	suppressBooleanParagraphMark(result, base, paragraphMark, direct, "smallCaps");
-	suppressBooleanParagraphMark(result, base, paragraphMark, direct, "hidden");
-	suppressBooleanParagraphMark(result, base, paragraphMark, direct, "emboss");
-	suppressBooleanParagraphMark(result, base, paragraphMark, direct, "imprint");
-	suppressBooleanParagraphMark(result, base, paragraphMark, direct, "shadow");
-	suppressBooleanParagraphMark(result, base, paragraphMark, direct, "outline");
-	suppressBooleanParagraphMark(result, base, paragraphMark, direct, "rtl");
+	for (const key of PARAGRAPH_MARK_BOOLEAN_KEYS) suppressBooleanParagraphMark(result, base, paragraphMark, direct, key);
 	if (paragraphMark.fontSize !== void 0 && direct?.fontSize === void 0 && base?.fontSize !== void 0) result.fontSize = base.fontSize;
 	if (paragraphMark.fontSizeCs !== void 0 && direct?.fontSizeCs === void 0 && base?.fontSizeCs !== void 0) result.fontSizeCs = base.fontSizeCs;
 	if (paragraphMark.underline !== void 0 && direct?.underline === void 0) result.underline = { style: "none" };
 	if (paragraphMark.spacing !== void 0 && direct?.spacing === void 0) result.spacing = 0;
 	return Object.keys(result).length > 0 ? result : void 0;
 }
+function getParagraphMarkSuppressionOverrides({ directFormatting, paragraphMarkFormatting, suppressedFormatting }) {
+	if (!paragraphMarkFormatting) return;
+	const overrides = {};
+	for (const key of PARAGRAPH_MARK_BOOLEAN_KEYS) if (paragraphMarkFormatting[key] !== void 0 && directFormatting?.[key] === void 0 && suppressedFormatting?.[key] === false) overrides[key] = false;
+	if (paragraphMarkFormatting.underline !== void 0 && directFormatting?.underline === void 0 && suppressedFormatting?.underline?.style === "none") overrides.underline = { style: "none" };
+	return Object.keys(overrides).length > 0 ? overrides : void 0;
+}
 function suppressBooleanParagraphMark(result, base, paragraphMark, direct, key) {
 	if (paragraphMark[key] === void 0 || direct?.[key] !== void 0) return;
 	result[key] = base?.[key] ?? false;
@@ -536,15 +591,45 @@ function resolveTextFormatting(formatting, styleResolver) {
 */
 function resolveRunFormattingWithoutDefaults(formatting, styleResolver) {
 	if (!formatting || !styleResolver) return formatting;
-	return mergeTextFormatting(formatting.styleId ? styleResolver.getRunStyleOwnProperties(formatting.styleId) : void 0, formatting);
+	return cascadeStyleTextFormatting([{
+		formatting: formatting.styleId ? styleResolver.getRunStyleOwnProperties(formatting.styleId) : void 0,
+		type: "style"
+	}, {
+		formatting,
+		type: "direct"
+	}]).formatting;
 }
 function resolveParagraphDefaultTextFormatting(styleId, formatting, styleResolver, options = {}) {
 	const style = styleId ? styleResolver.getStyle(styleId) ?? styleResolver.getDefaultParagraphStyle() : styleResolver.getDefaultParagraphStyle();
 	const paragraphStyleRpr = style?.type === "paragraph" ? style.rPr : void 0;
 	const rawParagraphMarkRpr = options.includeParagraphMarkRunProperties === false ? void 0 : formatting?.runProperties;
 	const paragraphRunProperties = rawParagraphMarkRpr ? stripParagraphMarkOnlyFormatting(resolveRunFormattingWithoutDefaults(rawParagraphMarkRpr, styleResolver) ?? {}) : void 0;
-	const bodyRunDefaults = mergeTextFormatting(mergeTextFormatting(styleResolver.getDocDefaults()?.rPr, styleResolver.getDefaultCharacterStyle()?.rPr), paragraphStyleRpr);
-	return styleId === void 0 ? mergeTextFormatting(bodyRunDefaults, paragraphRunProperties) : mergeTextFormatting(paragraphRunProperties, bodyRunDefaults);
+	const orderedBodyToggleFormatting = cascadeStyleTextFormatting([
+		{
+			formatting: styleResolver.getDocDefaults()?.rPr,
+			type: "defaults"
+		},
+		{
+			formatting: paragraphStyleRpr,
+			type: "style"
+		},
+		{
+			formatting: styleResolver.getDefaultCharacterStyle()?.rPr,
+			type: "style"
+		}
+	], { ordinaryFormatting: mergeTextFormatting(mergeTextFormatting(styleResolver.getDocDefaults()?.rPr, styleResolver.getDefaultCharacterStyle()?.rPr), paragraphStyleRpr) });
+	const bodyRunDefaults = orderedBodyToggleFormatting.formatting;
+	if (styleId !== void 0) return cascadeStyleTextFormatting([{
+		cascade: orderedBodyToggleFormatting,
+		type: "carried"
+	}], { ordinaryFormatting: mergeTextFormatting(paragraphRunProperties, bodyRunDefaults) }).formatting;
+	return cascadeStyleTextFormatting([{
+		cascade: orderedBodyToggleFormatting,
+		type: "carried"
+	}, {
+		formatting: paragraphRunProperties,
+		type: "direct"
+	}], { ordinaryFormatting: mergeTextFormatting(bodyRunDefaults, paragraphRunProperties) }).formatting;
 }
 function calculateRowSpans(table) {
 	const result = /* @__PURE__ */ new Map();
@@ -1012,11 +1097,11 @@ function convertInlineSdt(sdt, nextHyperlinkInstanceIndex, getInheritedRunFormat
 * Convert a Run to ProseMirror text nodes with marks
 *
 * @param run - The run to convert
-* @param styleFormatting - Text formatting from the paragraph's style (e.g., Heading1's font size/color)
+* @param resolvedStyleFormatting - Paragraph formatting and its explicit style-toggle state
 */
-function convertRun(run, styleFormatting, styleResolver, textBoxAnchors) {
+function convertRun(run, resolvedStyleFormatting, styleResolver, textBoxAnchors) {
 	const nodes = [];
-	const { marks, mergedFormatting } = buildRunMarks(run.formatting, styleFormatting, styleResolver);
+	const { marks, mergedFormatting } = buildRunMarks(run.formatting, resolvedStyleFormatting, styleResolver);
 	if (run.propertyChanges && run.propertyChanges.length > 0) marks.push(schema.mark("runPropertyChange", { changes: [...run.propertyChanges] }));
 	for (const content of run.content) {
 		const contentNodes = convertRunContent(content, marks, mergedFormatting, textBoxAnchors);
@@ -1024,13 +1109,34 @@ function convertRun(run, styleFormatting, styleResolver, textBoxAnchors) {
 	}
 	return nodes;
 }
-function buildRunMarks(runFormatting, inheritedFormatting, styleResolver) {
+function buildRunMarks(runFormatting, inherited, styleResolver) {
 	const styleId = runFormatting?.styleId;
-	const runStyleFormatting = styleId ? styleResolver?.getRunStyleOwnProperties(styleId) : void 0;
-	const mergedFormatting = mergeTextFormatting(mergeTextFormatting(inheritedFormatting, runStyleFormatting), runFormatting);
-	const marks = textFormattingToMarks(mergedFormatting);
+	const characterStyleFormatting = styleId ? styleResolver?.getRunStyleOwnProperties(styleId) : styleResolver?.getDefaultCharacterStyle()?.rPr;
+	let ordinaryRunStyleFormatting = inherited.formatting ? { ...inherited.formatting } : {};
+	if (styleId) ordinaryRunStyleFormatting = mergeTextFormatting(inherited.formatting, characterStyleFormatting) ?? {};
+	const cascadedStyleFormatting = cascadeStyleTextFormatting([{
+		cascade: inherited.toggleCascade,
+		type: "carried"
+	}, {
+		formatting: characterStyleFormatting,
+		type: "style"
+	}], { ordinaryFormatting: ordinaryRunStyleFormatting });
+	const runStyleFormatting = cascadedStyleFormatting.formatting;
+	const mergedFormatting = cascadeStyleTextFormatting([{
+		cascade: cascadedStyleFormatting,
+		type: "carried"
+	}, {
+		formatting: runFormatting,
+		type: "direct"
+	}], { ordinaryFormatting: mergeTextFormatting(runStyleFormatting, runFormatting) }).formatting;
+	const marks = textFormattingToMarks(mergedFormatting, { overrideFormatting: getRunFormattingOverrides({
+		directFormatting: runFormatting,
+		effectiveStyleFormatting: runStyleFormatting,
+		hasCharacterStyle: styleId !== void 0,
+		paragraphMarkOverrides: inherited.paragraphMarkOverrides
+	}) });
 	if (styleId) {
-		const styleRPr = runStyleFormatting ? marksToTextFormatting(textFormattingToMarks(runStyleFormatting)) : void 0;
+		const styleRPr = characterStyleFormatting ? marksToTextFormatting(textFormattingToMarks(characterStyleFormatting)) : void 0;
 		marks.push(schema.mark("characterStyle", {
 			styleId,
 			_styleRPr: styleRPr && Object.keys(styleRPr).length > 0 ? styleRPr : null
@@ -1041,6 +1147,26 @@ function buildRunMarks(runFormatting, inheritedFormatting, styleResolver) {
 		mergedFormatting
 	};
 }
+const ORDINARY_STYLE_TOGGLE_KEYS = [
+	"bold",
+	"italic",
+	"strike",
+	"allCaps",
+	"smallCaps",
+	"hidden",
+	"emboss",
+	"imprint",
+	"shadow",
+	"outline"
+];
+function getRunFormattingOverrides({ directFormatting, effectiveStyleFormatting, hasCharacterStyle, paragraphMarkOverrides }) {
+	const overrides = mergeTextFormatting(paragraphMarkOverrides, directFormatting);
+	if (!overrides || !directFormatting) return overrides;
+	for (const key of ORDINARY_STYLE_TOGGLE_KEYS) if (directFormatting[key] === true && (!hasCharacterStyle || effectiveStyleFormatting?.[key] !== true)) Reflect.deleteProperty(overrides, key);
+	if (directFormatting.boldCs === true && directFormatting.boldCs === directFormatting.bold && (!hasCharacterStyle || effectiveStyleFormatting?.boldCs === void 0)) Reflect.deleteProperty(overrides, "boldCs");
+	if (directFormatting.italicCs === true && directFormatting.italicCs === directFormatting.italic && (!hasCharacterStyle || effectiveStyleFormatting?.italicCs === void 0)) Reflect.deleteProperty(overrides, "italicCs");
+	return overrides;
+}
 /**
 * Convert RunContent to ProseMirror nodes
 */
@@ -1220,13 +1346,10 @@ function convertHyperlink(hyperlink, { getInheritedRunFormatting, styleResolver,
 	}
 	return nodes;
 }
-/**
-* Convert TextFormatting to ProseMirror marks
-*/
-function textFormattingToMarks(formatting) {
+function textFormattingToMarks(formatting, options) {
 	if (!formatting) return [];
 	const marks = [];
-	const overrideAttrs = buildRunFormattingOverrideAttrs(formatting);
+	const overrideAttrs = buildRunFormattingOverrideAttrs(options ? options.overrideFormatting : formatting);
 	if (overrideAttrs) marks.push(schema.mark("runFormattingOverride", overrideAttrs));
 	if (formatting.bold) marks.push(schema.mark("bold"));
 	if (formatting.italic) marks.push(schema.mark("italic"));

package/dist/prosemirror/extensions/marks/RunFormattingOverrideExtension.js

@@ -4,38 +4,38 @@ import { createMarkExtension } from "../create.js";
 function buildRunFormattingOverrideAttrs(formatting) {
 	if (!formatting) return;
 	const attrs = {};
-	if (formatting.bold === false) attrs.bold = false;
-	if (formatting.italic === false) attrs.italic = false;
+	if (formatting.bold !== void 0) attrs.bold = formatting.bold;
+	if (formatting.italic !== void 0) attrs.italic = formatting.italic;
 	if (formatting.underline?.style === "none") attrs.underline = "none";
-	if (formatting.strike === false) attrs.strike = false;
+	if (formatting.strike !== void 0) attrs.strike = formatting.strike;
 	if (formatting.doubleStrike === false) attrs.doubleStrike = false;
-	if (formatting.allCaps === false) attrs.allCaps = false;
-	if (formatting.smallCaps === false) attrs.smallCaps = false;
-	if (formatting.hidden === false) attrs.hidden = false;
-	if (formatting.emboss === false) attrs.emboss = false;
-	if (formatting.imprint === false) attrs.imprint = false;
-	if (formatting.shadow === false) attrs.shadow = false;
-	if (formatting.outline === false) attrs.outline = false;
+	if (formatting.allCaps !== void 0) attrs.allCaps = formatting.allCaps;
+	if (formatting.smallCaps !== void 0) attrs.smallCaps = formatting.smallCaps;
+	if (formatting.hidden !== void 0) attrs.hidden = formatting.hidden;
+	if (formatting.emboss !== void 0) attrs.emboss = formatting.emboss;
+	if (formatting.imprint !== void 0) attrs.imprint = formatting.imprint;
+	if (formatting.shadow !== void 0) attrs.shadow = formatting.shadow;
+	if (formatting.outline !== void 0) attrs.outline = formatting.outline;
 	if (formatting.rtl === false) attrs.rtl = false;
-	if (formatting.boldCs !== void 0 && formatting.boldCs !== formatting.bold) attrs.boldCs = formatting.boldCs;
-	if (formatting.italicCs !== void 0 && formatting.italicCs !== formatting.italic) attrs.italicCs = formatting.italicCs;
+	if (formatting.boldCs !== void 0) attrs.boldCs = formatting.boldCs;
+	if (formatting.italicCs !== void 0) attrs.italicCs = formatting.italicCs;
 	if (formatting.fontSizeCs !== void 0 && formatting.fontSizeCs !== formatting.fontSize) attrs.fontSizeCs = formatting.fontSizeCs;
 	if (formatting.cs !== void 0) attrs.cs = formatting.cs;
 	return Object.keys(attrs).length > 0 ? attrs : void 0;
 }
 function applyRunFormattingOverrideAttrs(formatting, attrs) {
-	if (attrs.bold === false) formatting.bold = false;
-	if (attrs.italic === false) formatting.italic = false;
+	if (attrs.bold !== void 0) formatting.bold = attrs.bold;
+	if (attrs.italic !== void 0) formatting.italic = attrs.italic;
 	if (attrs.underline === "none") formatting.underline = { style: "none" };
-	if (attrs.strike === false) formatting.strike = false;
+	if (attrs.strike !== void 0) formatting.strike = attrs.strike;
 	if (attrs.doubleStrike === false) formatting.doubleStrike = false;
-	if (attrs.allCaps === false) formatting.allCaps = false;
-	if (attrs.smallCaps === false) formatting.smallCaps = false;
-	if (attrs.hidden === false) formatting.hidden = false;
-	if (attrs.emboss === false) formatting.emboss = false;
-	if (attrs.imprint === false) formatting.imprint = false;
-	if (attrs.shadow === false) formatting.shadow = false;
-	if (attrs.outline === false) formatting.outline = false;
+	if (attrs.allCaps !== void 0) formatting.allCaps = attrs.allCaps;
+	if (attrs.smallCaps !== void 0) formatting.smallCaps = attrs.smallCaps;
+	if (attrs.hidden !== void 0) formatting.hidden = attrs.hidden;
+	if (attrs.emboss !== void 0) formatting.emboss = attrs.emboss;
+	if (attrs.imprint !== void 0) formatting.imprint = attrs.imprint;
+	if (attrs.shadow !== void 0) formatting.shadow = attrs.shadow;
+	if (attrs.outline !== void 0) formatting.outline = attrs.outline;
 	if (attrs.rtl === false) formatting.rtl = false;
 	if (attrs.boldCs !== void 0) formatting.boldCs = attrs.boldCs;
 	if (attrs.italicCs !== void 0) formatting.italicCs = attrs.italicCs;

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

@@ -121,7 +121,9 @@ type RunPropertyChangeMarkAttrs = {
   provenance: TrackedChangeProvenance;
   suggestionId?: string;
 };
-type RunFormattingOverrideAttrs = { [K in keyof Pick<document_d_exports.TextFormatting, "bold" | "italic" | "strike" | "doubleStrike" | "allCaps" | "smallCaps" | "hidden" | "emboss" | "imprint" | "shadow" | "outline" | "rtl">]?: false; } & {
+type RunFormattingOverrideAttrs = { [K in keyof Pick<document_d_exports.TextFormatting, "bold" | "italic" | "strike" | "allCaps" | "smallCaps" | "hidden" | "emboss" | "imprint" | "shadow" | "outline">]?: boolean; } & {
+  doubleStrike?: false;
+  rtl?: false;
   /** Independent complex-script weight (`w:bCs`). */
   boldCs?: boolean;
   /** Force complex-script formatting for the full run (`w:cs`). */

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

@@ -127,7 +127,6 @@ declare class StyleResolver {
    */
   hasStyle(styleId: string): boolean;
   private findDefaultStyle;
-  private mergeStyleIntoResult;
 }
 /**
  * Create a style resolver from document's style definitions