@stll/folio-core 0.53.0 → 0.54.1

package/dist/prosemirror/runFormattingFromMarks.js

@@ -0,0 +1,567 @@
+import { normalizeHorizontalScalePercent } from "../utils/horizontalScale.js";
+import { mergeTextFormatting } from "../utils/textFormattingMerge.js";
+import { expectCharacterSpacingMarkAttrs, expectCharacterStyleMarkAttrs, expectEmphasisMarkAttrs, expectFontFamilyMarkAttrs, expectFontSizeMarkAttrs, expectHighlightMarkAttrs, expectLanguageMarkAttrs, expectRunFormattingOverrideMarkAttrs, expectRunShadingMarkAttrs, expectStrikeMarkAttrs, expectTextColorMarkAttrs, expectTextEffectMarkAttrs, expectUnderlineMarkAttrs } from "./attrs/index.js";
+import { runShadingAttrsToShading, shadingToRunShadingAttrs } from "./conversion/runShadingMark.js";
+import { applyRunFormattingOverrideAttrs, buildRunFormattingOverrideAttrs } from "./extensions/marks/RunFormattingOverrideExtension.js";
+import { authoredRunFormattingFromAttrs, hasAuthoredRunFormattingProvenance } from "./runFormattingProvenance.js";
+import { paragraphFormattingForRun, resolveEffectiveRunStyleFormatting, suppressParagraphMarkFormatting } from "./runStyleFormatting.js";
+//#region src/prosemirror/runFormattingFromMarks.ts
+const RUN_FORMATTING_VISUAL_GROUPS = {
+	bold: "bold",
+	boldCs: null,
+	italic: "italic",
+	italicCs: null,
+	underline: "underline",
+	strike: "strike",
+	doubleStrike: "strike",
+	vertAlign: "vertAlign",
+	smallCaps: "smallCaps",
+	allCaps: "allCaps",
+	hidden: "hidden",
+	noProof: null,
+	color: "color",
+	highlight: "highlight",
+	shading: "shading",
+	fontSize: "fontSize",
+	fontSizeCs: null,
+	fontFamily: "fontFamily",
+	language: "language",
+	spacing: "characterSpacing",
+	position: "characterSpacing",
+	scale: "characterSpacing",
+	kerning: "characterSpacing",
+	effect: "effect",
+	emphasisMark: "emphasisMark",
+	emboss: "emboss",
+	imprint: "imprint",
+	outline: "outline",
+	shadow: "shadow",
+	rtl: "rtl",
+	cs: null,
+	styleId: null,
+	preserved: null
+};
+const RUN_FORMATTING_FAST_PATH_DISPOSITION = {
+	bold: "visual",
+	boldCs: "structural",
+	italic: "visual",
+	italicCs: "structural",
+	underline: "visual",
+	strike: "visual",
+	doubleStrike: "visual",
+	vertAlign: "visual",
+	smallCaps: "visual",
+	allCaps: "visual",
+	hidden: "visual",
+	noProof: "structural",
+	color: "visual",
+	highlight: "visual",
+	shading: "visual",
+	fontSize: "visual",
+	fontSizeCs: "structural",
+	fontFamily: "visual",
+	language: "visual",
+	spacing: "visual",
+	position: "visual",
+	scale: "visual",
+	kerning: "visual",
+	effect: "visual",
+	emphasisMark: "visual",
+	emboss: "visual",
+	imprint: "visual",
+	outline: "visual",
+	shadow: "visual",
+	rtl: "visual",
+	cs: "structural",
+	styleId: "character-style",
+	preserved: "structural"
+};
+const hasOnlyCarrierlessVisualFormatting = (formatting) => {
+	for (const property of Object.keys(formatting)) if (RUN_FORMATTING_FAST_PATH_DISPOSITION[property] !== "visual") return false;
+	return true;
+};
+const visibleUnderline = (formatting) => {
+	const underline = formatting?.underline;
+	return underline?.style === "none" ? void 0 : underline;
+};
+const visibleStrike = (formatting) => {
+	if (formatting?.doubleStrike === true) return "double";
+	return formatting?.strike === true ? "single" : void 0;
+};
+const visibleColor = (formatting) => formatting?.color?.auto === true ? void 0 : formatting?.color;
+const visibleValue = (value) => value === "none" ? void 0 : value;
+/**
+* Compare the exact presentation encoded by PM run marks without allocating the
+* intermediate maps used by reconciliation. Non-visual authored state is
+* deliberately absent here: the carrierless fast path below excludes every
+* structural carrier before calling this predicate.
+*/
+const sameVisualFormatting = (left, right) => {
+	if (left?.bold === true !== (right?.bold === true) || left?.italic === true !== (right?.italic === true) || !sameFormattingValue(visibleUnderline(left), visibleUnderline(right)) || visibleStrike(left) !== visibleStrike(right) || !sameFormattingValue(visibleColor(left), visibleColor(right)) || visibleValue(left?.highlight) !== visibleValue(right?.highlight) || (left?.fontSize || void 0) !== (right?.fontSize || void 0) || !sameFormattingValue(left?.fontFamily, right?.fontFamily) || !sameFormattingValue(left?.language, right?.language) || (left?.vertAlign === "superscript" || left?.vertAlign === "subscript" ? left.vertAlign : void 0) !== (right?.vertAlign === "superscript" || right?.vertAlign === "subscript" ? right.vertAlign : void 0) || left?.allCaps === true !== (right?.allCaps === true) || left?.smallCaps === true !== (right?.smallCaps === true) || left?.hidden === true !== (right?.hidden === true) || left?.emboss === true !== (right?.emboss === true) || left?.imprint === true !== (right?.imprint === true) || left?.shadow === true !== (right?.shadow === true) || left?.outline === true !== (right?.outline === true) || left?.rtl === true !== (right?.rtl === true) || (typeof left?.spacing === "number" ? left.spacing : null) !== (typeof right?.spacing === "number" ? right.spacing : null) || (typeof left?.position === "number" ? left.position : null) !== (typeof right?.position === "number" ? right.position : null) || (normalizeHorizontalScalePercent(left?.scale) ?? null) !== (normalizeHorizontalScalePercent(right?.scale) ?? null) || (typeof left?.kerning === "number" ? left.kerning : null) !== (typeof right?.kerning === "number" ? right.kerning : null) || visibleValue(left?.effect) !== visibleValue(right?.effect) || visibleValue(left?.emphasisMark) !== visibleValue(right?.emphasisMark)) return false;
+	return sameFormattingValue(shadingToRunShadingAttrs(left?.shading), shadingToRunShadingAttrs(right?.shading));
+};
+const visualFormattingGroups = (formatting) => {
+	const groups = /* @__PURE__ */ new Map();
+	if (!formatting) return groups;
+	if (formatting.bold) groups.set("bold", true);
+	if (formatting.italic) groups.set("italic", true);
+	if (formatting.underline && formatting.underline.style !== "none") groups.set("underline", {
+		style: formatting.underline.style || "single",
+		...formatting.underline.color ? { color: formatting.underline.color } : {}
+	});
+	if (formatting.strike || formatting.doubleStrike) groups.set("strike", formatting.doubleStrike ? "double" : "single");
+	if (formatting.color && !formatting.color.auto) {
+		const { rgb, themeColor, themeTint, themeShade } = formatting.color;
+		groups.set("color", {
+			...rgb ? { rgb } : {},
+			...themeColor ? { themeColor } : {},
+			...themeTint ? { themeTint } : {},
+			...themeShade ? { themeShade } : {}
+		});
+	}
+	if (formatting.highlight && formatting.highlight !== "none") groups.set("highlight", formatting.highlight);
+	const shadingAttrs = shadingToRunShadingAttrs(formatting.shading);
+	if (shadingAttrs) groups.set("shading", runShadingAttrsToShading(shadingAttrs));
+	if (formatting.fontSize) groups.set("fontSize", formatting.fontSize);
+	if (formatting.fontFamily) {
+		const { ascii, hAnsi, eastAsia, cs, hint, asciiTheme, hAnsiTheme, eastAsiaTheme, csTheme } = formatting.fontFamily;
+		groups.set("fontFamily", {
+			...ascii ? { ascii } : {},
+			...hAnsi ? { hAnsi } : {},
+			...eastAsia ? { eastAsia } : {},
+			...cs ? { cs } : {},
+			...hint ? { hint } : {},
+			...asciiTheme ? { asciiTheme } : {},
+			...hAnsiTheme ? { hAnsiTheme } : {},
+			...eastAsiaTheme ? { eastAsiaTheme } : {},
+			...csTheme ? { csTheme } : {}
+		});
+	}
+	if (formatting.language) {
+		const { val, eastAsia, bidi } = formatting.language;
+		groups.set("language", {
+			...val ? { val } : {},
+			...eastAsia ? { eastAsia } : {},
+			...bidi ? { bidi } : {}
+		});
+	}
+	if (formatting.vertAlign === "superscript" || formatting.vertAlign === "subscript") groups.set("vertAlign", formatting.vertAlign);
+	for (const [property, group] of [
+		["allCaps", "allCaps"],
+		["smallCaps", "smallCaps"],
+		["hidden", "hidden"],
+		["emboss", "emboss"],
+		["imprint", "imprint"],
+		["shadow", "shadow"],
+		["outline", "outline"],
+		["rtl", "rtl"]
+	]) if (formatting[property]) groups.set(group, true);
+	const spacing = typeof formatting.spacing === "number" ? formatting.spacing : null;
+	const position = typeof formatting.position === "number" ? formatting.position : null;
+	const scale = normalizeHorizontalScalePercent(formatting.scale) ?? null;
+	const kerning = typeof formatting.kerning === "number" ? formatting.kerning : null;
+	if (spacing !== null || position !== null || scale !== null || kerning !== null) groups.set("characterSpacing", {
+		spacing,
+		position,
+		scale,
+		kerning
+	});
+	if (formatting.effect && formatting.effect !== "none") groups.set("effect", formatting.effect);
+	if (formatting.emphasisMark && formatting.emphasisMark !== "none") groups.set("emphasisMark", formatting.emphasisMark);
+	return groups;
+};
+const expectedRunFormattingOverrideAttrs = (authoredFormatting) => {
+	const attrs = buildRunFormattingOverrideAttrs(authoredFormatting, {
+		type: "authored-baseline",
+		formatting: authoredFormatting
+	});
+	const hasDirectFormatting = Object.keys(authoredFormatting).some((property) => property !== "styleId");
+	if (!attrs && !hasDirectFormatting) return;
+	const expected = { ...attrs };
+	const directFontProperties = [
+		"color",
+		"fontFamily",
+		"fontSize"
+	].filter((property) => authoredFormatting[property] !== void 0);
+	if (directFontProperties.length > 0) expected.directFontProperties = directFontProperties;
+	const complexScriptPropertyAbsences = [
+		["bold", "boldCs"],
+		["italic", "italicCs"],
+		["fontSize", "fontSizeCs"]
+	].filter(([ordinary, complex]) => authoredFormatting[ordinary] !== void 0 && authoredFormatting[complex] === void 0).map(([, complex]) => complex);
+	if (complexScriptPropertyAbsences.length > 0) expected.complexScriptPropertyAbsences = complexScriptPropertyAbsences;
+	return Object.keys(expected).length > 0 ? expected : void 0;
+};
+const changedVisualFormattingGroups = (observedFormatting, expectedFormatting) => {
+	const actual = visualFormattingGroups(observedFormatting);
+	const expected = visualFormattingGroups(expectedFormatting);
+	const changed = /* @__PURE__ */ new Set();
+	for (const group of /* @__PURE__ */ new Set([...actual.keys(), ...expected.keys()])) {
+		const actualValue = actual.get(group);
+		const expectedValue = expected.get(group);
+		if (!sameFormattingValue(actualValue, expectedValue)) changed.add(group);
+	}
+	return changed;
+};
+const VISUAL_BOOLEAN_FORMATTING_PROPERTIES = /* @__PURE__ */ new Set([
+	"allCaps",
+	"bold",
+	"doubleStrike",
+	"emboss",
+	"hidden",
+	"imprint",
+	"italic",
+	"outline",
+	"rtl",
+	"shadow",
+	"smallCaps",
+	"strike"
+]);
+const fontFamilyDifference = (actual, inherited) => {
+	const difference = {};
+	for (const property of [
+		"ascii",
+		"hAnsi",
+		"eastAsia",
+		"cs",
+		"hint",
+		"asciiTheme",
+		"hAnsiTheme",
+		"eastAsiaTheme",
+		"csTheme"
+	]) {
+		const value = actual[property];
+		if (value !== void 0 && value !== inherited?.[property]) Reflect.set(difference, property, value);
+	}
+	return Object.keys(difference).length > 0 ? difference : void 0;
+};
+const DIRECT_OVERRIDE_FORMATTING_PROPERTIES = [
+	"allCaps",
+	"bold",
+	"boldCs",
+	"cs",
+	"doubleStrike",
+	"emboss",
+	"fontSizeCs",
+	"hidden",
+	"noProof",
+	"imprint",
+	"italic",
+	"italicCs",
+	"outline",
+	"rtl",
+	"shadow",
+	"smallCaps",
+	"strike",
+	"underline"
+];
+const POSITIVE_OVERRIDE_PROPERTIES_REPRESENTED_BY_VISUAL_MARKS = /* @__PURE__ */ new Set([
+	"allCaps",
+	"emboss",
+	"hidden",
+	"imprint",
+	"outline",
+	"rtl",
+	"shadow",
+	"smallCaps",
+	"strike"
+]);
+const setFormattingFromOverrideSignal = (formatting, property, value) => {
+	Reflect.deleteProperty(formatting, property);
+	if (value === void 0) return;
+	if (property === "underline") {
+		formatting.underline = { style: "none" };
+		return;
+	}
+	Reflect.set(formatting, property, value);
+};
+const sameFormattingValue = (left, right) => {
+	if (left === right) return true;
+	if (typeof left !== "object" || left === null || typeof right !== "object" || right === null) return false;
+	if (Array.isArray(left) || Array.isArray(right)) {
+		if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length) return false;
+		return left.every((value, index) => sameFormattingValue(value, right[index]));
+	}
+	const leftKeys = Object.keys(left);
+	const rightKeys = Object.keys(right);
+	if (leftKeys.length !== rightKeys.length) return false;
+	return leftKeys.every((key) => Object.prototype.hasOwnProperty.call(right, key) && sameFormattingValue(Reflect.get(left, key), Reflect.get(right, key)));
+};
+const reconcileOverrideSignals = (formatting, current, expected, inheritedFormatting, observedFormatting) => {
+	for (const property of DIRECT_OVERRIDE_FORMATTING_PROPERTIES) {
+		if (sameFormattingValue(current?.[property], expected?.[property])) continue;
+		if (current?.[property] === void 0 && expected?.[property] === true && POSITIVE_OVERRIDE_PROPERTIES_REPRESENTED_BY_VISUAL_MARKS.has(property)) continue;
+		if (current && hasAuthoredRunFormattingProvenance(current) && expected?.[property] === void 0 && sameFormattingValue(current[property], inheritedFormatting?.[property])) continue;
+		setFormattingFromOverrideSignal(formatting, property, current?.[property]);
+	}
+	for (const property of [
+		"color",
+		"fontFamily",
+		"fontSize"
+	]) {
+		const currentIsDirect = current?.directFontProperties?.includes(property) === true;
+		if (currentIsDirect === (expected?.directFontProperties?.includes(property) === true)) continue;
+		if (!currentIsDirect) {
+			Reflect.deleteProperty(formatting, property);
+			continue;
+		}
+		const observed = observedFormatting[property];
+		if (observed !== void 0) Reflect.set(formatting, property, observed);
+	}
+	for (const property of [
+		"boldCs",
+		"italicCs",
+		"fontSizeCs"
+	]) {
+		const currentIsAbsent = current?.complexScriptPropertyAbsences?.includes(property) === true;
+		if (currentIsAbsent !== (expected?.complexScriptPropertyAbsences?.includes(property) === true) && currentIsAbsent) Reflect.deleteProperty(formatting, property);
+	}
+};
+/**
+* Reconcile source-authored provenance with the current visual mark set at the
+* one save boundary shared by editor commands, raw transactions and compare.
+* Unchanged groups keep exact source state (including equal direct values and
+* otherwise invisible sentinels); changed groups derive the smallest direct
+* override needed relative to the current style cascade.
+*/
+const reconcileAuthoredFormatting = ({ authoredFormatting, carrierlessContext, currentOverrideAttrs, inheritedFormatting, observedFormatting }) => {
+	const hasAuthoredFormatting = Object.keys(authoredFormatting).length > 0;
+	if (carrierlessContext === "ordinary" && currentOverrideAttrs === void 0 && !hasAuthoredFormatting && hasOnlyCarrierlessVisualFormatting(observedFormatting)) {
+		if (sameVisualFormatting(observedFormatting, inheritedFormatting)) return authoredFormatting;
+		if (observedFormatting.fontFamily === void 0 && sameVisualFormatting(inheritedFormatting, void 0)) return observedFormatting;
+	}
+	const expectedFormatting = hasAuthoredFormatting ? mergeTextFormatting(inheritedFormatting, authoredFormatting) : inheritedFormatting;
+	const changedGroups = changedVisualFormattingGroups(observedFormatting, expectedFormatting);
+	const reconciled = { ...authoredFormatting };
+	for (const property of Object.keys(RUN_FORMATTING_VISUAL_GROUPS)) {
+		const group = RUN_FORMATTING_VISUAL_GROUPS[property];
+		if (group === null || !changedGroups.has(group)) continue;
+		Reflect.deleteProperty(reconciled, property);
+		if (VISUAL_BOOLEAN_FORMATTING_PROPERTIES.has(property)) {
+			const observed = observedFormatting[property] === true;
+			if (observed !== (inheritedFormatting?.[property] === true)) Reflect.set(reconciled, property, observed);
+			continue;
+		}
+		const observed = observedFormatting[property];
+		if (observed === void 0) continue;
+		if (property === "fontFamily") {
+			const difference = fontFamilyDifference(observed, inheritedFormatting?.fontFamily);
+			if (difference) reconciled.fontFamily = difference;
+			continue;
+		}
+		if (!sameFormattingValue(observed, inheritedFormatting?.[property])) Reflect.set(reconciled, property, observed);
+	}
+	if (currentOverrideAttrs !== void 0) reconcileOverrideSignals(reconciled, currentOverrideAttrs, expectedRunFormattingOverrideAttrs(authoredFormatting), inheritedFormatting, observedFormatting);
+	return reconciled;
+};
+const formattingAuthorshipCost = (formatting) => {
+	let cost = 0;
+	const visit = (value) => {
+		if (value === void 0) return;
+		if (value === null || typeof value !== "object") {
+			cost++;
+			return;
+		}
+		const entries = Object.entries(value);
+		if (entries.length === 0) {
+			cost++;
+			return;
+		}
+		for (const [, nested] of entries) visit(nested);
+	};
+	for (const [property, value] of Object.entries(formatting)) if (property !== "styleId") visit(value);
+	return cost;
+};
+function marksToTextFormatting(marks, options) {
+	const formatting = {};
+	let directOverrideFormatting;
+	let directFontProperties;
+	let characterStyleId;
+	let runFormattingOverrideMark;
+	let currentOverrideAttrs;
+	for (const mark of marks) switch (mark.type.name) {
+		case "bold":
+			formatting.bold = true;
+			break;
+		case "italic":
+			formatting.italic = true;
+			break;
+		case "underline": {
+			const attrs = expectUnderlineMarkAttrs(mark);
+			const uline = { style: attrs.style || "single" };
+			if (attrs.color) uline.color = attrs.color;
+			formatting.underline = uline;
+			break;
+		}
+		case "strike":
+			if (expectStrikeMarkAttrs(mark).double) formatting.doubleStrike = true;
+			else formatting.strike = true;
+			break;
+		case "textColor": {
+			const attrs = expectTextColorMarkAttrs(mark);
+			const colorVal = {};
+			if (attrs.rgb) colorVal.rgb = attrs.rgb;
+			if (attrs.themeColor) colorVal.themeColor = attrs.themeColor;
+			if (attrs.themeTint) colorVal.themeTint = attrs.themeTint;
+			if (attrs.themeShade) colorVal.themeShade = attrs.themeShade;
+			formatting.color = colorVal;
+			break;
+		}
+		case "highlight":
+			formatting.highlight = expectHighlightMarkAttrs(mark).color;
+			break;
+		case "runShading":
+			formatting.shading = runShadingAttrsToShading(expectRunShadingMarkAttrs(mark));
+			break;
+		case "fontSize":
+			formatting.fontSize = expectFontSizeMarkAttrs(mark).size;
+			break;
+		case "fontFamily": {
+			const attrs = expectFontFamilyMarkAttrs(mark);
+			const ff = {};
+			if (attrs.ascii) ff.ascii = attrs.ascii;
+			if (attrs.hAnsi) ff.hAnsi = attrs.hAnsi;
+			if (attrs.eastAsia) ff.eastAsia = attrs.eastAsia;
+			if (attrs.hint) ff.hint = attrs.hint;
+			if (attrs.cs) ff.cs = attrs.cs;
+			if (attrs.asciiTheme) ff.asciiTheme = attrs.asciiTheme;
+			if (attrs.hAnsiTheme) ff.hAnsiTheme = attrs.hAnsiTheme;
+			if (attrs.eastAsiaTheme) ff.eastAsiaTheme = attrs.eastAsiaTheme;
+			if (attrs.csTheme) ff.csTheme = attrs.csTheme;
+			formatting.fontFamily = ff;
+			break;
+		}
+		case "language": {
+			const attrs = expectLanguageMarkAttrs(mark);
+			formatting.language = {
+				...attrs.val ? { val: attrs.val } : {},
+				...attrs.eastAsia ? { eastAsia: attrs.eastAsia } : {},
+				...attrs.bidi ? { bidi: attrs.bidi } : {}
+			};
+			break;
+		}
+		case "superscript":
+			formatting.vertAlign = "superscript";
+			break;
+		case "subscript":
+			formatting.vertAlign = "subscript";
+			break;
+		case "allCaps":
+			formatting.allCaps = true;
+			break;
+		case "smallCaps":
+			formatting.smallCaps = true;
+			break;
+		case "characterSpacing": {
+			const attrs = expectCharacterSpacingMarkAttrs(mark);
+			if (attrs.spacing !== void 0) formatting.spacing = attrs.spacing;
+			if (attrs.position !== void 0) formatting.position = attrs.position;
+			const horizontalScale = normalizeHorizontalScalePercent(attrs.scale);
+			if (horizontalScale !== void 0) formatting.scale = horizontalScale;
+			if (attrs.kerning !== void 0) formatting.kerning = attrs.kerning;
+			break;
+		}
+		case "emboss":
+			formatting.emboss = true;
+			break;
+		case "imprint":
+			formatting.imprint = true;
+			break;
+		case "hidden":
+			formatting.hidden = true;
+			break;
+		case "textShadow":
+			formatting.shadow = true;
+			break;
+		case "emphasisMark":
+			formatting.emphasisMark = expectEmphasisMarkAttrs(mark).type || "dot";
+			break;
+		case "textOutline":
+			formatting.outline = true;
+			break;
+		case "rtl":
+			formatting.rtl = true;
+			break;
+		case "textEffect":
+			formatting.effect = expectTextEffectMarkAttrs(mark).effect;
+			break;
+		case "runFormattingOverride":
+			runFormattingOverrideMark = mark;
+			break;
+		case "characterStyle": {
+			const attrs = expectCharacterStyleMarkAttrs(mark);
+			formatting.styleId = attrs.styleId;
+			characterStyleId = attrs.styleId;
+			break;
+		}
+		default: break;
+	}
+	let authoredFormatting = {};
+	if (runFormattingOverrideMark) {
+		const overrideAttrs = expectRunFormattingOverrideMarkAttrs(runFormattingOverrideMark);
+		currentOverrideAttrs = overrideAttrs;
+		directFontProperties = overrideAttrs.directFontProperties;
+		directOverrideFormatting = {};
+		applyRunFormattingOverrideAttrs(directOverrideFormatting, overrideAttrs);
+		for (const property of directFontProperties ?? []) {
+			const value = formatting[property];
+			if (value !== void 0) Reflect.set(directOverrideFormatting, property, value);
+		}
+		authoredFormatting = authoredRunFormattingFromAttrs(overrideAttrs) ?? directOverrideFormatting;
+	}
+	if (characterStyleId !== void 0 && !options?.styleResolver) {
+		const conservativeFormatting = mergeTextFormatting(formatting, directOverrideFormatting) ?? {};
+		for (const property of currentOverrideAttrs?.complexScriptPropertyAbsences ?? []) Reflect.deleteProperty(conservativeFormatting, property);
+		return {
+			...conservativeFormatting,
+			styleId: characterStyleId
+		};
+	}
+	const inheritedFormatting = resolveEffectiveRunStyleFormatting({
+		marks,
+		paragraphFormatting: paragraphFormattingForRun({
+			context: {
+				baseParagraphFormatting: options?.baseParagraphFormatting,
+				paragraphFormatting: options?.inheritedFormatting,
+				paragraphMarkFormatting: options?.paragraphMarkFormatting,
+				paragraphMarkPrecedesStyle: options?.paragraphMarkPrecedesStyle ?? false
+			},
+			directFormatting: authoredFormatting,
+			marks
+		}),
+		...options?.styleResolver !== void 0 ? { styleResolver: options.styleResolver } : {}
+	});
+	let reconciled = reconcileAuthoredFormatting({
+		authoredFormatting,
+		carrierlessContext: options?.paragraphMarkFormatting === void 0 ? "ordinary" : "paragraph-mark",
+		currentOverrideAttrs,
+		inheritedFormatting,
+		observedFormatting: formatting
+	});
+	if (runFormattingOverrideMark === void 0 && characterStyleId === void 0 && options?.paragraphMarkFormatting !== void 0) {
+		const suppressedInheritedFormatting = resolveEffectiveRunStyleFormatting({
+			marks,
+			paragraphFormatting: suppressParagraphMarkFormatting({
+				baseFormatting: options.baseParagraphFormatting,
+				directFormatting: authoredFormatting,
+				paragraphMarkFormatting: options.paragraphMarkFormatting,
+				paragraphMarkPrecedesStyle: options.paragraphMarkPrecedesStyle ?? false
+			}),
+			...options.styleResolver !== void 0 ? { styleResolver: options.styleResolver } : {}
+		});
+		const suppressed = reconcileAuthoredFormatting({
+			authoredFormatting,
+			carrierlessContext: "paragraph-mark",
+			currentOverrideAttrs,
+			inheritedFormatting: suppressedInheritedFormatting,
+			observedFormatting: formatting
+		});
+		if (formattingAuthorshipCost(suppressed) < formattingAuthorshipCost(reconciled)) reconciled = suppressed;
+	}
+	return {
+		...reconciled,
+		...characterStyleId !== void 0 ? { styleId: characterStyleId } : {}
+	};
+}
+//#endregion
+export { marksToTextFormatting, sameFormattingValue };

package/dist/prosemirror/runFormattingReconciliation.js

@@ -1,10 +1,9 @@
 import { mergeTextFormatting } from "../utils/textFormattingMerge.js";
 import { expectCharacterStyleMarkAttrs } from "./attrs/index.js";
-import { marksToTextFormatting } from "./conversion/fromProseDoc.js";
 import { textFormattingToMarks } from "./extensions/marks/markUtils.js";
+import { marksToTextFormatting } from "./runFormattingFromMarks.js";
 import { RUN_FORMATTING_MARK_NAMES } from "./runFormattingMarkNames.js";
 import { getParagraphMarkSuppressionOverrides, hasDirectRunFormatting, paragraphFormattingForRun, resolveEffectiveRunStyleFormatting } from "./runStyleFormatting.js";
-import { schema } from "./schema/index.js";
 import { Mark } from "prosemirror-model";
 //#region src/prosemirror/runFormattingReconciliation.ts
 /** Read authored run properties without confusing inherited visuals for direct formatting. */
@@ -33,16 +32,18 @@ const reconcileRunFormattingMarks = ({ authoredFormatting, context, node, styleR
 		context,
 		directFormatting: authoredFormatting
 	});
-	const formattingMarks = textFormattingToMarks(mergeTextFormatting(resolveEffectiveRunStyleFormatting({
+	const effectiveFormatting = mergeTextFormatting(resolveEffectiveRunStyleFormatting({
 		marks: styleResolutionMarks,
 		paragraphFormatting,
 		...styleResolver !== void 0 ? { styleResolver } : {}
-	}), authoredFormatting), schema, {
-		overrideFormatting: mergeTextFormatting(getParagraphMarkSuppressionOverrides({
-			directFormatting: authoredFormatting,
-			paragraphMarkFormatting: context.paragraphMarkFormatting,
-			suppressedFormatting: paragraphFormatting
-		}), authoredFormatting),
+	}), authoredFormatting);
+	const overrideFormatting = mergeTextFormatting(getParagraphMarkSuppressionOverrides({
+		directFormatting: authoredFormatting,
+		paragraphMarkFormatting: context.paragraphMarkFormatting,
+		suppressedFormatting: paragraphFormatting
+	}), authoredFormatting);
+	const formattingMarks = textFormattingToMarks(effectiveFormatting, node.type.schema, {
+		overrideFormatting,
 		directFormatting: authoredFormatting
 	});
 	return Mark.setFrom([

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

@@ -1030,6 +1030,8 @@ type TableAttrs = {
  * Table row attributes
  */
 type TableRowAttrs = {
+  /** Transaction-local cleanup state; cleared before dispatch or continuation capture. */
+  _batchRowCleanup?: "pending" | null;
   /** Row height (in twips) */
   height?: number;
   /** Height rule ('auto', 'exact', 'atLeast') */

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

@@ -0,0 +1,59 @@
+import { document_d_exports } from "../../types/document.js";
+import { ParagraphAttrs } from "../schema/nodes.js";
+import { TableCellParagraphSpacingOverlay } from "./styleResolver.js";
+import { StyleEngine } from "../../style-engine/styleEngine.js";
+import "../../style-engine/index.js";
+import { TableStyleRegion } from "./tableStyleRegions.js";
+//#region src/prosemirror/styles/paragraphStyleCascade.d.ts
+/** The resolver surface the paragraph cascade reads. */
+type ParagraphCascadeResolver = Pick<StyleEngine, "getStyle" | "getDocDefaults" | "getDefaultParagraphStyle" | "getDefaultCharacterStyle" | "getRunStyleOwnProperties" | "resolveParagraphStyleInTable">;
+/**
+ * Resolve an embedded character-style reference without importing
+ * `docDefaults`. The caller already has the paragraph cascade, including
+ * document defaults, and will layer these own properties over it.
+ */
+type ParagraphDefaultFormattingResolver = Pick<StyleEngine, "getStyle" | "getDocDefaults" | "getDefaultParagraphStyle" | "getDefaultCharacterStyle" | "getRunStyleOwnProperties">;
+declare function resolveRunFormattingWithoutDefaults(formatting: document_d_exports.TextFormatting | undefined, styleResolver: ParagraphDefaultFormattingResolver | null): document_d_exports.TextFormatting | undefined;
+/** @internal Recompute a paragraph's inherited run defaults from authored package state. */
+declare function resolveParagraphDefaultTextFormatting(styleId: string | undefined, formatting: document_d_exports.Paragraph["formatting"] | undefined, styleResolver: ParagraphDefaultFormattingResolver, options?: {
+  includeParagraphMarkRunProperties?: boolean;
+}): document_d_exports.TextFormatting | undefined;
+type ParagraphStyleCascadeInput = {
+  styleId: string | undefined;
+  /** What the paragraph states itself; each stated field wins over the cascade. */
+  formatting: document_d_exports.ParagraphFormatting | undefined;
+  styleResolver: ParagraphCascadeResolver;
+  /**
+   * The enclosing table style's modeled paragraph fields, layered between
+   * docDefaults and the paragraph's own style chain (cell paragraphs only).
+   */
+  tableParagraphOverlay?: TableCellParagraphSpacingOverlay | undefined;
+  /** Whether the paragraph mark's own run properties join the run defaults. */
+  includeParagraphMarkRunProperties: boolean;
+};
+type ParagraphStyleCascade = {
+  /** The effective attrs, with the provenance a save needs to keep inherited values out of `w:pPr`. */
+  attrs: ParagraphAttrs;
+  /** The resolved style cascade the attrs were read from. */
+  stylePpr: document_d_exports.ParagraphFormatting | undefined;
+};
+/**
+ * Project a paragraph's style cascade onto its editor attrs: each field the
+ * paragraph states wins, every other field reads the cascade, and the
+ * provenance attrs record which is which.
+ */
+declare function paragraphStyleCascadeAttrs({ styleId, formatting, styleResolver, tableParagraphOverlay, includeParagraphMarkRunProperties }: ParagraphStyleCascadeInput): ParagraphStyleCascade;
+/**
+ * Pick the modeled paragraph fields out of a table style's (or conditional
+ * region's) `w:pPr` for use as the cell-paragraph cascade overlay.
+ */
+declare function extractTableParagraphOverlay(pPr: document_d_exports.ParagraphFormatting | undefined): TableCellParagraphSpacingOverlay | undefined;
+/**
+ * The paragraph overlay a table style gives one cell's paragraphs: its base
+ * `w:pPr`, then each applicable region's (`regions`, lowest precedence first,
+ * from `tableCellStyleRegions`). A table naming no style, or a style the part
+ * does not define, reads the default table style (ECMA-376 §17.7.6).
+ */
+declare function tableCellParagraphOverlay(styleResolver: Pick<StyleEngine, "getStyle" | "getDefaultTableStyle">, tableStyleId: string | null | undefined, regions: readonly TableStyleRegion[]): TableCellParagraphSpacingOverlay | undefined;
+//#endregion
+export { ParagraphCascadeResolver, ParagraphStyleCascade, ParagraphStyleCascadeInput, extractTableParagraphOverlay, paragraphStyleCascadeAttrs, resolveParagraphDefaultTextFormatting, resolveRunFormattingWithoutDefaults, tableCellParagraphOverlay };