@stll/folio-core 0.28.0 → 0.28.1

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

package/dist/prosemirror/styles/styleResolver.js

@@ -1,5 +1,5 @@
 import { mergeParagraphFormatting } from "../../utils/paragraphFormattingMerge.js";
-import { mergeTextFormatting } from "../../utils/textFormattingMerge.js";
+import { cascadeStyleTextFormatting } from "./styleToggleCascade.js";
 //#region src/prosemirror/styles/styleResolver.ts
 /**
 * Word's default-template Normal style, used as a last-resort fallback for a
@@ -102,21 +102,23 @@ var StyleResolver = class {
 	resolveParagraphStyleCascade(styleId, tableParagraphOverlay) {
 		const result = {};
 		if (this.docDefaults?.pPr) result.paragraphFormatting = { ...this.docDefaults.pPr };
-		if (this.docDefaults?.rPr) result.runFormatting = { ...this.docDefaults.rPr };
 		if (tableParagraphOverlay) {
 			const merged = mergeParagraphFormatting(result.paragraphFormatting, tableParagraphOverlay);
 			if (merged !== void 0) result.paragraphFormatting = merged;
 		}
-		if (!styleId) {
-			if (this.defaultParagraphStyle) this.mergeStyleIntoResult(result, this.defaultParagraphStyle);
-			return result;
-		}
-		const style = this.stylesById.get(styleId);
-		if (!style) {
-			if (this.defaultParagraphStyle) this.mergeStyleIntoResult(result, this.defaultParagraphStyle);
-			return result;
+		const style = styleId ? this.stylesById.get(styleId) ?? this.defaultParagraphStyle : this.defaultParagraphStyle;
+		if (style?.pPr) {
+			const merged = mergeParagraphFormatting(result.paragraphFormatting, style.pPr);
+			if (merged) result.paragraphFormatting = merged;
 		}
-		this.mergeStyleIntoResult(result, style);
+		const runFormatting = cascadeStyleTextFormatting([{
+			formatting: this.docDefaults?.rPr,
+			type: "defaults"
+		}, {
+			formatting: style?.rPr,
+			type: "style"
+		}]).formatting;
+		if (runFormatting) result.runFormatting = runFormatting;
 		return result;
 	}
 	/**
@@ -159,14 +161,15 @@ var StyleResolver = class {
 	* @returns Resolved text formatting
 	*/
 	resolveRunStyle(styleId) {
-		let result = {};
-		if (this.docDefaults?.rPr) result = { ...this.docDefaults.rPr };
-		const defaultCharacterRpr = this.defaultCharacterStyle?.rPr;
-		if (defaultCharacterRpr) result = mergeTextFormatting(result, defaultCharacterRpr) ?? {};
-		const style = styleId ? this.stylesById.get(styleId) : void 0;
-		if (!style?.rPr) return Object.keys(result).length > 0 ? result : void 0;
-		const merged = mergeTextFormatting(result, style.rPr);
-		return merged && Object.keys(merged).length > 0 ? merged : void 0;
+		const style = styleId ? this.stylesById.get(styleId) : this.defaultCharacterStyle;
+		const result = cascadeStyleTextFormatting([{
+			formatting: this.docDefaults?.rPr,
+			type: "defaults"
+		}, {
+			formatting: style?.rPr,
+			type: "style"
+		}]).formatting;
+		return result && Object.keys(result).length > 0 ? result : void 0;
 	}
 	/**
 	* Get a character style's own properties WITHOUT docDefaults.
@@ -213,16 +216,6 @@ var StyleResolver = class {
 		for (const style of this.stylesById.values()) if (style.type === type && style.default) return style;
 		if (type === "paragraph") return this.stylesById.get("Normal") ?? (this.docDefaults ? void 0 : BUILTIN_NORMAL_STYLE);
 	}
-	mergeStyleIntoResult(result, style) {
-		if (style.pPr) {
-			const merged = mergeParagraphFormatting(result.paragraphFormatting, style.pPr);
-			if (merged !== void 0) result.paragraphFormatting = merged;
-		}
-		if (style.rPr) {
-			const merged = mergeTextFormatting(result.runFormatting, style.rPr);
-			if (merged !== void 0) result.runFormatting = merged;
-		}
-	}
 };
 /**
 * Create a style resolver from document's style definitions

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

@@ -0,0 +1,37 @@
+import { document_d_exports } from "../../types/document.js";
+import { STYLE_TOGGLE_KEYS } from "../../utils/textFormattingMerge.js";
+//#region src/prosemirror/styles/styleToggleCascade.d.ts
+type StyleToggleKey = (typeof STYLE_TOGGLE_KEYS)[number];
+type ToggleState = {
+  value: boolean;
+  defaultsActive: boolean;
+};
+/** Internal formatting value whose toggle history survives copying and separate cascade passes. */
+type StyleTextFormattingCascade = {
+  formatting: document_d_exports.TextFormatting | undefined;
+  toggleStates: ReadonlyMap<StyleToggleKey, ToggleState>;
+  type: "styleToggleCascade";
+};
+type StyleToggleLevel = {
+  formatting: document_d_exports.TextFormatting | undefined;
+  type: "defaults" | "style" | "direct";
+} | {
+  cascade: StyleTextFormattingCascade;
+  type: "carried";
+};
+type StyleToggleCascadeOptions = {
+  /** Existing ordinary-property merge whose toggle fields this cascade replaces. */
+  ordinaryFormatting: document_d_exports.TextFormatting | undefined;
+};
+/**
+ * Resolve run formatting across OOXML style hierarchy levels.
+ *
+ * Ordinary properties retain Folio's existing low-to-high, last-defined merge. Toggle
+ * properties reverse inherited state when a style level states `true`; `false` leaves inherited
+ * style state unchanged, while direct formatting remains an absolute value. The returned value
+ * carries its toggle history explicitly, so paragraph and character style resolution may happen
+ * in separate passes without an object-identity contract.
+ */
+declare function cascadeStyleTextFormatting(levels: readonly StyleToggleLevel[], options?: StyleToggleCascadeOptions): StyleTextFormattingCascade;
+//#endregion
+export { cascadeStyleTextFormatting };

package/dist/prosemirror/styles/styleToggleCascade.js

@@ -0,0 +1,52 @@
+import { STYLE_TOGGLE_KEYS, mergeTextFormatting } from "../../utils/textFormattingMerge.js";
+//#region src/prosemirror/styles/styleToggleCascade.ts
+/**
+* Resolve run formatting across OOXML style hierarchy levels.
+*
+* Ordinary properties retain Folio's existing low-to-high, last-defined merge. Toggle
+* properties reverse inherited state when a style level states `true`; `false` leaves inherited
+* style state unchanged, while direct formatting remains an absolute value. The returned value
+* carries its toggle history explicitly, so paragraph and character style resolution may happen
+* in separate passes without an object-identity contract.
+*/
+function cascadeStyleTextFormatting(levels, options) {
+	let formatting = options ? mergeTextFormatting(void 0, options.ordinaryFormatting) : void 0;
+	const mergeOrdinaryFormatting = options === void 0;
+	const toggleStates = /* @__PURE__ */ new Map();
+	for (const level of levels) {
+		if (level.type === "carried") {
+			if (mergeOrdinaryFormatting) formatting = mergeTextFormatting(formatting, level.cascade.formatting);
+			for (const [key, state] of level.cascade.toggleStates) toggleStates.set(key, state);
+			continue;
+		}
+		if (!level.formatting) continue;
+		if (mergeOrdinaryFormatting) formatting = mergeTextFormatting(formatting, level.formatting);
+		for (const key of STYLE_TOGGLE_KEYS) {
+			const value = level.formatting[key];
+			if (value === void 0) continue;
+			const inherited = toggleStates.get(key);
+			if (level.type === "direct") toggleStates.set(key, {
+				value,
+				defaultsActive: false
+			});
+			else if (!value) continue;
+			else if (level.type === "defaults") toggleStates.set(key, {
+				value: true,
+				defaultsActive: true
+			});
+			else toggleStates.set(key, {
+				value: inherited?.defaultsActive === true ? true : !(inherited?.value ?? false),
+				defaultsActive: inherited?.defaultsActive === true
+			});
+		}
+	}
+	if (!formatting && toggleStates.size > 0) formatting = {};
+	for (const [key, state] of toggleStates) if (formatting) formatting[key] = state.value;
+	return {
+		formatting,
+		toggleStates,
+		type: "styleToggleCascade"
+	};
+}
+//#endregion
+export { cascadeStyleTextFormatting };

package/dist/utils/textFormattingMerge.d.ts

@@ -1,5 +1,13 @@
 import { document_d_exports } from "../types/document.js";
 //#region src/utils/textFormattingMerge.d.ts
+declare const STYLE_TOGGLE_KEYS: readonly ["bold", "boldCs", "italic", "italicCs", "allCaps", "emboss", "imprint", "outline", "shadow", "smallCaps", "strike", "hidden"];
+/**
+ * Merge the properties exposed by one resolved style definition.
+ *
+ * A false toggle at a child style level does not cancel the inherited state. The
+ * ordinary merge remains unchanged for direct formatting and non-toggle properties.
+ */
+declare function mergeStyleTextFormatting(target: document_d_exports.TextFormatting | undefined, source: document_d_exports.TextFormatting | undefined): document_d_exports.TextFormatting | undefined;
 declare function mergeTextFormatting(target: document_d_exports.TextFormatting | undefined, source: document_d_exports.TextFormatting | undefined): document_d_exports.TextFormatting | undefined;
 //#endregion
-export { mergeTextFormatting };
+export { STYLE_TOGGLE_KEYS, mergeStyleTextFormatting, mergeTextFormatting };

package/dist/utils/textFormattingMerge.js

@@ -1,5 +1,36 @@
 import { mergeFontFamily } from "./fontFamilyMerge.js";
 //#region src/utils/textFormattingMerge.ts
+const STYLE_TOGGLE_KEYS = [
+	"bold",
+	"boldCs",
+	"italic",
+	"italicCs",
+	"allCaps",
+	"emboss",
+	"imprint",
+	"outline",
+	"shadow",
+	"smallCaps",
+	"strike",
+	"hidden"
+];
+/**
+* Merge the properties exposed by one resolved style definition.
+*
+* A false toggle at a child style level does not cancel the inherited state. The
+* ordinary merge remains unchanged for direct formatting and non-toggle properties.
+*/
+function mergeStyleTextFormatting(target, source) {
+	const result = mergeTextFormatting(target, source);
+	if (!result || !source) return result;
+	for (const key of STYLE_TOGGLE_KEYS) {
+		if (source[key] !== false) continue;
+		const inherited = target?.[key];
+		if (inherited === void 0) Reflect.deleteProperty(result, key);
+		else result[key] = inherited;
+	}
+	return result;
+}
 function mergeTextFormatting(target, source) {
 	if (!source && !target) return;
 	if (!source) return target;
@@ -28,4 +59,4 @@ function mergeTextFormatting(target, source) {
 	return result;
 }
 //#endregion
-export { mergeTextFormatting };
+export { STYLE_TOGGLE_KEYS, mergeStyleTextFormatting, mergeTextFormatting };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stll/folio-core",
-  "version": "0.28.0",
+  "version": "0.28.1",
   "description": "Headless, framework-neutral core of folio: the OOXML (.docx) parser, document model, ProseMirror integration, and page-layout engine. No React.",
   "keywords": [
     "document-model",