@stll/folio-core 0.52.0 → 0.54.0

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/runFormattingInlineCarriers.d.ts

@@ -1,5 +1,5 @@
-import { Transaction } from "prosemirror-state";
 import { Mark, Node } from "prosemirror-model";
+import { Transaction } from "prosemirror-state";
 //#region src/prosemirror/runFormattingInlineCarriers.d.ts
 type RunFormattingInlineAtomDisposition = "break-run" | "field-run" | "not-a-run" | "page-break-carrier" | "preserved-xml-run" | "structured-field" | "symbol-run" | "tab-run" | "text-run";
 /**

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/index.d.ts

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

package/dist/prosemirror/schema/index.js

@@ -53,6 +53,9 @@ const requiredCommands = completeCommandNames([
 	"increaseListLevel",
 	"decreaseListLevel",
 	"removeList",
+	"restartNumbering",
+	"continueNumbering",
+	"setNumberingValue",
 	"setSpaceBefore",
 	"setSpaceAfter",
 	"applyStyle",