@stll/folio-core 0.53.0 → 0.54.1

package/dist/prosemirror/conversion/fromProseDoc.js

@@ -13,11 +13,10 @@ import { createStyleEngine } from "../../style-engine/styleEngine.js";
 import { normalizeShapeTextAnchor, presetDashForOutlineAttr } from "../../types/documentEnumValues.js";
 import { presetDashForCssBorderStyle } from "../../utils/borderCss.js";
 import { canonicalJson } from "../../utils/canonicalJson.js";
-import { normalizeHorizontalScalePercent } from "../../utils/horizontalScale.js";
 import { mergeTextFormatting } from "../../utils/textFormattingMerge.js";
 import { emuToPixels, emuToStrokePixels, pixelsToEmu } from "../../utils/units.js";
 import { unchangedAlternateContentXml } from "../alternateContentAttrs.js";
-import { expectBlockCustomXmlAttrs, expectBlockSdtAttrs, expectCharacterSpacingMarkAttrs, expectCharacterStyleMarkAttrs, expectCommentMarkAttrs, expectEmphasisMarkAttrs, expectFieldAttrs, expectFontFamilyMarkAttrs, expectFontSizeMarkAttrs, expectFootnoteRefMarkAttrs, expectHardBreakAttrs, expectHighlightMarkAttrs, expectHyperlinkMarkAttrs, expectImageAttrs, expectInlineWrapperMarkAttrs, expectLanguageMarkAttrs, expectMathAttrs, expectPageBreakRunAttrs, expectParagraphAttrs, expectPreservedBlockAttrs, expectPreservedXmlAttrs, expectRunFormattingOverrideMarkAttrs, expectRunIdentityMarkAttrs, expectRunPropertyChangeMarkAttrs, expectRunShadingMarkAttrs, expectSdtAttrs, expectShapeAttrs, expectStrikeMarkAttrs, expectSymbolAttrs, expectTabAttrs, expectTableAttrs, expectTableCellAttrs, expectTableRowAttrs, expectTextBoxAttrs, expectTextColorMarkAttrs, expectTextEffectMarkAttrs, expectTrackedChangeMarkAttrs, expectUnderlineMarkAttrs } from "../attrs/index.js";
+import { expectBlockCustomXmlAttrs, expectBlockSdtAttrs, expectCharacterStyleMarkAttrs, expectCommentMarkAttrs, expectFieldAttrs, expectFootnoteRefMarkAttrs, expectHardBreakAttrs, expectHyperlinkMarkAttrs, expectImageAttrs, expectInlineWrapperMarkAttrs, expectMathAttrs, expectPageBreakRunAttrs, expectParagraphAttrs, expectPreservedBlockAttrs, expectPreservedXmlAttrs, expectRunIdentityMarkAttrs, expectRunPropertyChangeMarkAttrs, expectSdtAttrs, expectShapeAttrs, expectSymbolAttrs, expectTabAttrs, expectTableAttrs, expectTableCellAttrs, expectTableRowAttrs, expectTextBoxAttrs, expectTrackedChangeMarkAttrs } from "../attrs/index.js";
 import { readAuthoredTransform } from "../authoredTransformAttrs.js";
 import { autospacingMatchesBase, hasAutospacingBaseSide } from "../autospacingBase.js";
 import { bookmarkMarkerFromAttrs, expectBookmarkBoundaryAttrs } from "../bookmarkBoundaryAttrs.js";
@@ -25,7 +24,6 @@ import { paragraphRejectAttrPatch, paragraphRejectOriginalFormatting, removePara
 import { expectCommentReferenceAttrs } from "../commentReferenceAttrs.js";
 import { enclosingRevisionIds } from "../contentControlRevisions.js";
 import { INLINE_WRAPPER_MARK_NAME } from "../extensions/marks/InlineWrapperExtension.js";
-import { applyRunFormattingOverrideAttrs, buildRunFormattingOverrideAttrs } from "../extensions/marks/RunFormattingOverrideExtension.js";
 import { textFormattingToMarks } from "../extensions/marks/markUtils.js";
 import "../extensions/nodes/MoveRangeBoundaryExtension.js";
 import "../extensions/nodes/RangeAnchorExtension.js";
@@ -38,18 +36,17 @@ import { directParagraphAlignment } from "../paragraphAlignment.js";
 import { directionToAuthoredBidi } from "../paragraphDirection.js";
 import { directParagraphSpacing } from "../paragraphSpacing.js";
 import { expectRangeAnchorAttrs } from "../rangeAnchorAttrs.js";
+import { marksToTextFormatting, sameFormattingValue } from "../runFormattingFromMarks.js";
 import { RUN_FORMATTING_MARK_NAMES } from "../runFormattingMarkNames.js";
-import { authoredRunFormattingFromAttrs, hasAuthoredRunFormattingProvenance } from "../runFormattingProvenance.js";
 import { RUN_IDENTITY_MARK_NAME } from "../runIdentity.js";
-import { paragraphFormattingForRun, paragraphRunStyleContext, resolveEffectiveRunStyleFormatting, suppressParagraphMarkFormatting } from "../runStyleFormatting.js";
-import { schema } from "../schema/index.js";
+import { paragraphFormattingForRun, paragraphRunStyleContext, resolveEffectiveRunStyleFormatting } from "../runStyleFormatting.js";
 import { PRESERVED_XML_LEVELS } from "../schema/nodes.js";
 import { parseShapeGeometryAdjustments } from "../shapeGeometryAdjustments.js";
 import { expectTextBoxAnchorAttrs } from "../textBoxAnchorAttrs.js";
 import { textBoxHostParagraph } from "../textBoxHostParagraph.js";
+import { enclosingInsertionAncestors, inlineWrapperStackOf } from "../trackedRevisionPath.js";
 import { assertValidProseMirrorDocument } from "../validation.js";
 import { hasSinkChildren } from "./preservedSinkCarriers.js";
-import { runShadingAttrsToShading, shadingToRunShadingAttrs } from "./runShadingMark.js";
 import { decodeSdtListItems, sdtPropertiesFromAttrs, sdtPropertiesMatchAttrs } from "./sdtAttrs.js";
 import { panic } from "better-result";
 import { DRAWING_RAW_XML_MODES, relationshipIdOf } from "@stll/docx-core/model";
@@ -336,7 +333,7 @@ function stripSuggestedInlineMarks(marks, { baseParagraphFormatting, inheritedFo
 			styleResolver
 		}) : paragraphFormatting, previousFormatting);
 		next = next.filter((mark) => !RUN_FORMATTING_MARK_NAMES.has(mark.type.name));
-		for (const restored of textFormattingToMarks(effectivePreviousFormatting, schema, {
+		for (const restored of textFormattingToMarks(effectivePreviousFormatting, suggestedRunPropertyChange.type.schema, {
 			overrideFormatting: previousFormatting,
 			directFormatting: previousFormatting
 		})) next = restored.addToSet(next);
@@ -1125,9 +1122,11 @@ function paragraphAttrsToFormatting(attrs) {
 	const outlineLevel = authored("outlineLevel", Reflect.get(attrs, "outlineLevel"));
 	const bidi = authored("bidi", directionToAuthoredBidi(attrs.direction));
 	const snapToGrid = authored("snapToGrid", attrs.snapToGrid);
-	const indentLeft = authored("indentLeft", attrs.indentLeft);
+	const numbered = paragraphNumberingReferenceId$1(attrs.numPr ?? void 0) !== void 0;
+	const statedIndent = (value) => value === 0 && !numbered ? void 0 : value;
+	const indentLeft = statedIndent(authored("indentLeft", attrs.indentLeft));
 	const indentRight = authored("indentRight", attrs.indentRight);
-	const indentFirstLine = authored("indentFirstLine", attrs.indentFirstLine);
+	const indentFirstLine = statedIndent(authored("indentFirstLine", attrs.indentFirstLine));
 	const borders = authored("borders", attrs.borders);
 	const shading = authored("shading", attrs.shading);
 	const tabs = authored("tabs", attrs.tabs);
@@ -1140,7 +1139,7 @@ function paragraphAttrsToFormatting(attrs) {
 	const kinsoku = authored("kinsoku", attrs.kinsoku);
 	const overflowPunctuation = authored("overflowPunctuation", attrs.overflowPunctuation);
 	const suppressAutoHyphens = authored("suppressAutoHyphens", attrs.suppressAutoHyphens);
-	if (!(directAlignment !== void 0 || shouldSerializeSpaceBefore || shouldSerializeSpaceAfter || beforeAutospacingEdited || afterAutospacingEdited || hasDirectLineSpacing || hasDirectLineSpacingRule || snapToGrid != null || indentLeft || indentRight || indentFirstLine || attrs.numPr || attrs.styleId || borders || shading || tabs || outlineLevel !== void 0 || contextualSpacing || attrs.spacingExplicit || bidi != null || pageBreakBefore != null || widowControl != null || keepNext != null || keepLines != null || runInWithNext != null || kinsoku != null || overflowPunctuation != null || suppressAutoHyphens != null)) return;
+	if (!(directAlignment !== void 0 || shouldSerializeSpaceBefore || shouldSerializeSpaceAfter || beforeAutospacingEdited || afterAutospacingEdited || hasDirectLineSpacing || hasDirectLineSpacingRule || snapToGrid != null || indentLeft !== void 0 || indentRight || indentFirstLine !== void 0 || attrs.numPr || attrs.styleId || borders || shading || tabs || outlineLevel !== void 0 || contextualSpacing || attrs.spacingExplicit || bidi != null || pageBreakBefore != null || widowControl != null || keepNext != null || keepLines != null || runInWithNext != null || kinsoku != null || overflowPunctuation != null || suppressAutoHyphens != null)) return;
 	const f = {};
 	if (directAlignment !== void 0) f.alignment = directAlignment;
 	if (shouldSerializeSpaceBefore) f.spaceBefore = spaceBefore;
@@ -1151,9 +1150,9 @@ function paragraphAttrsToFormatting(attrs) {
 	if (hasDirectLineSpacingRule && attrs.lineSpacingRule) f.lineSpacingRule = attrs.lineSpacingRule;
 	if (snapToGrid != null) f.snapToGrid = snapToGrid;
 	if (attrs.spacingExplicit) f.spacingExplicit = attrs.spacingExplicit;
-	if (indentLeft) f.indentLeft = indentLeft;
+	if (indentLeft !== void 0) f.indentLeft = indentLeft;
 	if (indentRight) f.indentRight = indentRight;
-	if (indentFirstLine) f.indentFirstLine = indentFirstLine;
+	if (indentFirstLine !== void 0) f.indentFirstLine = indentFirstLine;
 	if (attrs.hangingIndent && indentFirstLine) f.hangingIndent = attrs.hangingIndent;
 	if (attrs.numPr !== void 0 && !isStyleSourcedParagraphNumbering(attrs.numPr, attrs.numPrFromStyle)) f.numPr = attrs.numPr;
 	if (attrs.styleId) f.styleId = attrs.styleId;
@@ -1205,11 +1204,6 @@ function createTrackedRunWrapper(type, info, child) {
 * document each time the same one is saved.
 */
 const byCommentId = (ids) => [...ids].toSorted((a, b) => a - b);
-/** The wrappers `node` sits inside, outermost first; empty when it sits in none. */
-const inlineWrapperStackOf = (node) => {
-	const mark = node.marks.find((candidate) => candidate.type.name === INLINE_WRAPPER_MARK_NAME);
-	return mark ? expectInlineWrapperMarkAttrs(mark).stack : [];
-};
 /** The authored hyperlink that owns a suffix of the node's wrapper stack. */
 const inlineWrapperHyperlinkOriginOf = (node) => {
 	const mark = node.marks.find((candidate) => candidate.type.name === INLINE_WRAPPER_MARK_NAME);
@@ -1279,21 +1273,6 @@ const nestRevisionAwareInlineWrappers = (items, stack, revisionOuterWrapperCount
 	return nested;
 };
 const sameRevisionLayer = (left, right) => left.type === right.type && left.revisionId === right.revisionId && left.author === right.author && left.date === right.date && left.utcDate === right.utcDate && left.initials === right.initials && left.outerWrapperCount === right.outerWrapperCount;
-/** The deletion's ancestor path, with the insertion it sits in as the outermost layer. */
-const enclosingInsertionAncestors = ({ insertionMark, ancestors, node }) => {
-	if (!insertionMark) return ancestors;
-	const attrs = expectTrackedChangeMarkAttrs(insertionMark);
-	if (ancestors.some(({ revisionId }) => revisionId === attrs.revisionId)) return ancestors;
-	return [{
-		type: attrs.moveKind === "moveTo" ? "moveTo" : "insertion",
-		revisionId: attrs.revisionId,
-		author: attrs.author || "Unknown",
-		...attrs.date ? { date: attrs.date } : {},
-		...attrs.utcDate ? { utcDate: attrs.utcDate } : {},
-		...attrs.initials ? { initials: attrs.initials } : {},
-		outerWrapperCount: attrs._docxOuterWrapperCount ?? inlineWrapperStackOf(node).length
-	}, ...ancestors];
-};
 const revisionInfoFromLayer = (layer) => ({
 	id: layer.revisionId,
 	author: layer.author,
@@ -2711,563 +2690,6 @@ function createShapeRun(node) {
 	restoreRunRecord(run, node.marks);
 	return run;
 }
-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 } : {}
-	};
-}
 /**
 * Convert a ProseMirror table node to our Table type
 */