@stll/folio-core 0.45.0 → 0.47.0

package/dist/docx/runParser.js

@@ -1,17 +1,22 @@
 import { parseHorizontalScalePercent } from "../utils/horizontalScale.js";
+import { NO_MODELLED_ATTRIBUTES, attributeRemainder } from "./attributeRemainder.js";
+import { CAPTURE, dispatchChildren, keptUnless, ownedElsewhere, sequencePositions } from "./containerChildren.js";
 import { parseDiagramPreview } from "./diagramPreview.js";
+import { parseFieldState } from "./fieldState.js";
 import { isGroupDrawing, parseGroupDrawing } from "./groupDrawingParser.js";
 import { parseImage } from "./imageParser.js";
 import { imageRawXmlFingerprint } from "./imageRawXml.js";
-import { EmphasisMarkSchema, FontHintSchema, FontThemeSchema, HighlightColorSchema, PositionalTabAlignmentSchema, PositionalTabLeaderSchema, PositionalTabRelativeToSchema, TextEffectSchema, ThemeColorSlotSchema, UnderlineStyleSchema, narrowEnum } from "./parserEnums.js";
+import { EmphasisMarkSchema, FontHintSchema, FontThemeSchema, HighlightColorSchema, PositionalTabAlignmentSchema, PositionalTabLeaderSchema, PositionalTabRelativeToSchema, TextEffectSchema, UnderlineStyleSchema, narrowEnum } from "./parserEnums.js";
+import { preserveRunChild } from "./preservedRunContent.js";
 import { parseShading } from "./shadingParser.js";
 import { parseShapeFromDrawing, shouldPreserveRawShapeDrawing } from "./shapeParser.js";
 import { isTextBoxDrawing } from "./textBoxParser.js";
+import { parseThemeColorAttribute } from "./themeColorAttribute.js";
 import { resolveThemeFontRef } from "./themeParser.js";
 import { parsePropertyChangeInfo } from "./trackedChangeInfo.js";
 import { captureVerbatimXml } from "./verbatimCapture.js";
 import { parseVmlImageContent, shouldPreserveRawVmlPict } from "./vmlImageParser.js";
-import { cloneWithXmlnsDeclarations, findAllDeep, findChild, findChildren, getAttribute, getChildElements, getLocalName, getTextContent, mergeXmlnsDeclarations, parseBooleanElement, parseNumericAttribute, parseOnOffAttribute, selectAlternateContentBranch } from "./xmlParser.js";
+import { WORDPROCESSINGML_NAMESPACE_URIS, cloneWithXmlnsDeclarations, findAllDeep, findChild, findChildren, getAttribute, getChildElements, getLocalName, getNamespaceUri, getTextContent, mergeXmlnsDeclarations, parseBooleanElement, parseNumericAttribute, selectAlternateContentBranch } from "./xmlParser.js";
 import { DRAWING_RAW_XML_MODES } from "@stll/docx-core/model";
 //#region src/docx/runParser.ts
 /**
@@ -22,124 +27,113 @@ import { DRAWING_RAW_XML_MODES } from "@stll/docx-core/model";
 */
 const MAX_LANGUAGE_TAG_LENGTH = 35;
 const truncateLanguageTag = (value) => value === void 0 ? void 0 : value.slice(0, MAX_LANGUAGE_TAG_LENGTH);
-/**
-* Parse color value from attributes
-*/
-function parseColorValue(rgb, themeColor, themeTint, themeShade) {
+function parseColorValue({ rgb, themeColor, themeTint, themeShade, element }) {
 	const color = {};
 	if (rgb && rgb !== "auto") color.rgb = rgb;
 	else if (rgb === "auto") color.auto = true;
-	const validatedThemeColor = narrowEnum(themeColor, ThemeColorSlotSchema);
-	if (validatedThemeColor) color.themeColor = validatedThemeColor;
+	const parsedThemeColor = parseThemeColorAttribute({
+		raw: themeColor,
+		element
+	});
+	if (parsedThemeColor !== void 0) color.themeColor = parsedThemeColor;
 	if (themeTint) color.themeTint = themeTint;
 	if (themeShade) color.themeShade = themeShade;
 	return color;
 }
-function collectFirstRunPropertyChildren(rPr) {
-	const children = {};
-	for (const child of rPr.elements ?? []) {
-		if (child.type !== "element") continue;
-		switch (getLocalName(child.name)) {
-			case "b":
-				children.b ??= child;
-				break;
-			case "bCs":
-				children.bCs ??= child;
-				break;
-			case "caps":
-				children.caps ??= child;
-				break;
-			case "color":
-				children.color ??= child;
-				break;
-			case "noProof":
-				children.noProof ??= child;
-				break;
-			case "cs":
-				children.cs ??= child;
-				break;
-			case "dstrike":
-				children.dstrike ??= child;
-				break;
-			case "effect":
-				children.effect ??= child;
-				break;
-			case "em":
-				children.em ??= child;
-				break;
-			case "emboss":
-				children.emboss ??= child;
-				break;
-			case "highlight":
-				children.highlight ??= child;
-				break;
-			case "i":
-				children.i ??= child;
-				break;
-			case "iCs":
-				children.iCs ??= child;
-				break;
-			case "imprint":
-				children.imprint ??= child;
-				break;
-			case "kern":
-				children.kern ??= child;
-				break;
-			case "lang":
-				children.lang ??= child;
-				break;
-			case "outline":
-				children.outline ??= child;
-				break;
-			case "position":
-				children.position ??= child;
-				break;
-			case "rFonts":
-				children.rFonts ??= child;
-				break;
-			case "rtl":
-				children.rtl ??= child;
-				break;
-			case "rStyle":
-				children.rStyle ??= child;
-				break;
-			case "shadow":
-				children.shadow ??= child;
-				break;
-			case "shd":
-				children.shd ??= child;
-				break;
-			case "smallCaps":
-				children.smallCaps ??= child;
-				break;
-			case "spacing":
-				children.spacing ??= child;
-				break;
-			case "strike":
-				children.strike ??= child;
-				break;
-			case "sz":
-				children.sz ??= child;
-				break;
-			case "szCs":
-				children.szCs ??= child;
-				break;
-			case "u":
-				children.u ??= child;
-				break;
-			case "vanish":
-				children.vanish ??= child;
-				break;
-			case "vertAlign":
-				children.vertAlign ??= child;
-				break;
-			case "w":
-				children.w ??= child;
-				break;
-		}
+/**
+* Which record beside this `w:rPr` reads children out of it.
+*
+* The four owners of a run property set share one handler map, because they
+* share one content model: `CT_RPr` is `EG_RPrBase` plus `w:rPrChange`, and
+* `CT_ParaRPr` opens that with `EG_ParaRPrTrackChanges`. They differ only in
+* which children a *sibling* record has already claimed, and a child claimed
+* twice is written twice. Naming the owner states that once, at the call site
+* that knows it, instead of leaving it to whichever reader ran first.
+*/
+const RUN_PROPERTY_OWNERS = {
+	/** A `w:r`'s own properties: `Run.propertyChanges` reads the `w:rPrChange`. */
+	run: "run",
+	/**
+	* `w:pPr/w:rPr`. The paragraph's record reads the mark's revision
+	* (`ParagraphMarkChange`) and its `w:specVanish`
+	* (`ParagraphFormatting.runInWithNext`).
+	*/
+	paragraphMark: "paragraphMark",
+	/**
+	* A style, a numbering level, a comment's reference mark, the snapshot
+	* inside a `w:rPrChange`: nothing beside it reads any of its children.
+	*/
+	standalone: "standalone"
+};
+/**
+* The children each owner's sibling record claims.
+*
+* Not the decision map: that one is total over the schema and lives in
+* {@link parseRunProperties}. This names only the children a given owner reads
+* somewhere else, so both cannot write the same element.
+*/
+const OWNED_BY_A_SIBLING_RECORD = {
+	run: { rPrChange: ownedElsewhere({
+		container: "run-properties",
+		child: "rPrChange",
+		reader: "runParser#parseRun"
+	}) },
+	paragraphMark: {
+		ins: ownedElsewhere({
+			container: "run-properties",
+			child: "ins",
+			reader: "paragraphProperties#parseParagraphProperties"
+		}),
+		del: ownedElsewhere({
+			container: "run-properties",
+			child: "del",
+			reader: "paragraphProperties#parseParagraphProperties"
+		}),
+		moveFrom: ownedElsewhere({
+			container: "run-properties",
+			child: "moveFrom",
+			reader: "paragraphProperties#parseParagraphProperties"
+		}),
+		moveTo: ownedElsewhere({
+			container: "run-properties",
+			child: "moveTo",
+			reader: "paragraphProperties#parseParagraphProperties"
+		})
+	},
+	standalone: {}
+};
+/**
+* A property stated twice in one `w:rPr` resolves to the last statement.
+*
+* `EG_RPrBase` is an `xsd:choice` referenced `maxOccurs="unbounded"`, so a
+* repeat is valid markup rather than a malformed file with no defined answer,
+* and producers write them: 44 of the 5299 packages in the public corpus hold
+* one, almost all from LibreOffice, and `w:b`, `w:i` and `w:sz` are the names
+* that repeat. 3131 of the 3132 repeats state the same value twice and settle
+* nothing; the one that disagrees is `<w:sz w:val="24"/><w:sz w:val="26"/>` on
+* an Arabic run whose `w:szCs` is 26, so the size that was meant is the later
+* one. That is also the rule folio's style parser already applied, and the two
+* readers now answer alike.
+*
+* The statements the last one beat are not kept. The writer puts a modelled
+* child at its own place in the canonical order, so a kept earlier occurrence
+* would come back *after* the value that beat it and invert what a consumer
+* resolves. Dropping it also settles the ambiguity for everyone downstream:
+* the saved element states the property once, and a reader that takes the
+* first and a reader that takes the last then read the same value.
+*
+* The name comes off the child rather than from the map key, so the guard
+* cannot name a property the handler does not read.
+*/
+const readLastOccurrenceOnly = (rPr) => {
+	const winner = /* @__PURE__ */ new Map();
+	for (const child of getChildElements(rPr)) {
+		const namespace = getNamespaceUri(child);
+		if (namespace !== void 0 && !WORDPROCESSINGML_NAMESPACE_URIS.has(namespace)) continue;
+		winner.set(getLocalName(child.name), child);
 	}
-	return children;
-}
+	return (read) => (child) => winner.get(getLocalName(child.name)) === child ? read(child) : void 0;
+};
 /**
 * `w:vertAlign` `baseline` is the reserved value that means "no vertical
 * offset", not a third offset beside `superscript` and `subscript`. It is
@@ -148,191 +142,283 @@ function collectFirstRunPropertyChildren(rPr) {
 */
 const isBaselineVertAlign = (vertAlign) => vertAlign === "baseline";
 /**
-* Parse run formatting properties (w:rPr)
+* Read `w:rFonts` into `fontFamily`, resolving each theme slot to the font the
+* theme names when the element did not spell one out.
 *
-* Handles ALL rPr properties:
-* - w:b (bold), w:i (italic), w:u (underline with style)
-* - w:strike (strikethrough), w:dstrike (double strike)
-* - w:vertAlign (superscript/subscript)
-* - w:smallCaps, w:caps (capitalization)
-* - w:highlight (text highlight color)
-* - w:shd (character shading)
-* - w:color (text color with theme resolution)
-* - w:sz (font size in half-points)
-* - w:rFonts (font family with theme resolution)
-* - w:spacing (character spacing)
-* - w:effect (text effects)
-* - And more...
+* @returns whether the element stated any font at all.
 */
-function parseRunProperties(rPr, theme, _styles) {
-	if (!rPr) return;
-	const formatting = {};
-	const propertyChildren = collectFirstRunPropertyChildren(rPr);
-	const b = propertyChildren.b;
-	if (b) formatting.bold = parseBooleanElement(b);
-	const bCs = propertyChildren.bCs;
-	if (bCs) formatting.boldCs = parseBooleanElement(bCs);
-	const i = propertyChildren.i;
-	if (i) formatting.italic = parseBooleanElement(i);
-	const iCs = propertyChildren.iCs;
-	if (iCs) formatting.italicCs = parseBooleanElement(iCs);
-	const u = propertyChildren.u;
-	if (u) {
-		const style = narrowEnum(getAttribute(u, "w", "val"), UnderlineStyleSchema);
-		if (style) {
-			formatting.underline = { style };
-			const colorVal = getAttribute(u, "w", "color");
-			const themeColor = getAttribute(u, "w", "themeColor");
-			if (colorVal || themeColor) formatting.underline.color = parseColorValue(colorVal, themeColor, getAttribute(u, "w", "themeTint"), getAttribute(u, "w", "themeShade"));
+const readFontFamily = (rFonts, theme, formatting) => {
+	const fontFamily = {};
+	const ascii = getAttribute(rFonts, "w", "ascii");
+	if (ascii) fontFamily.ascii = ascii;
+	const hAnsi = getAttribute(rFonts, "w", "hAnsi");
+	if (hAnsi) fontFamily.hAnsi = hAnsi;
+	const eastAsia = getAttribute(rFonts, "w", "eastAsia");
+	if (eastAsia) fontFamily.eastAsia = eastAsia;
+	const csFont = getAttribute(rFonts, "w", "cs");
+	if (csFont) fontFamily.cs = csFont;
+	const hint = narrowEnum(getAttribute(rFonts, "w", "hint"), FontHintSchema);
+	if (hint) fontFamily.hint = hint;
+	const asciiTheme = narrowEnum(getAttribute(rFonts, "w", "asciiTheme"), FontThemeSchema);
+	if (asciiTheme) {
+		fontFamily.asciiTheme = asciiTheme;
+		if (theme && !fontFamily.ascii) {
+			const resolved = resolveThemeFontRef(theme, asciiTheme);
+			if (resolved) fontFamily.ascii = resolved;
 		}
 	}
-	const strike = propertyChildren.strike;
-	if (strike) formatting.strike = parseBooleanElement(strike);
-	const dstrike = propertyChildren.dstrike;
-	if (dstrike) formatting.doubleStrike = parseBooleanElement(dstrike);
-	const vertAlign = propertyChildren.vertAlign;
-	if (vertAlign) {
-		const val = getAttribute(vertAlign, "w", "val");
-		if (val === "superscript" || val === "subscript" || val === "baseline") formatting.vertAlign = val;
-	}
-	const smallCaps = propertyChildren.smallCaps;
-	if (smallCaps) formatting.smallCaps = parseBooleanElement(smallCaps);
-	const caps = propertyChildren.caps;
-	if (caps) formatting.allCaps = parseBooleanElement(caps);
-	const vanish = propertyChildren.vanish;
-	if (vanish) formatting.hidden = parseBooleanElement(vanish);
-	const noProof = propertyChildren.noProof;
-	if (noProof) formatting.noProof = parseBooleanElement(noProof);
-	const color = propertyChildren.color;
-	if (color) formatting.color = parseColorValue(getAttribute(color, "w", "val"), getAttribute(color, "w", "themeColor"), getAttribute(color, "w", "themeTint"), getAttribute(color, "w", "themeShade"));
-	const highlight = propertyChildren.highlight;
-	if (highlight) {
-		const val = narrowEnum(getAttribute(highlight, "w", "val"), HighlightColorSchema);
-		if (val) formatting.highlight = val;
-	}
-	const shd = propertyChildren.shd;
-	if (shd) {
-		const shadingResult = parseShading(shd);
-		if (shadingResult) formatting.shading = shadingResult;
-	}
-	const sz = propertyChildren.sz;
-	if (sz) {
-		const val = parseNumericAttribute(sz, "w", "val");
-		if (val !== void 0) formatting.fontSize = val;
-	}
-	const szCs = propertyChildren.szCs;
-	if (szCs) {
-		const val = parseNumericAttribute(szCs, "w", "val");
-		if (val !== void 0) formatting.fontSizeCs = val;
-	}
-	const rFonts = propertyChildren.rFonts;
-	if (rFonts) {
-		const fontFamily = {};
-		const ascii = getAttribute(rFonts, "w", "ascii");
-		if (ascii) fontFamily.ascii = ascii;
-		const hAnsi = getAttribute(rFonts, "w", "hAnsi");
-		if (hAnsi) fontFamily.hAnsi = hAnsi;
-		const eastAsia = getAttribute(rFonts, "w", "eastAsia");
-		if (eastAsia) fontFamily.eastAsia = eastAsia;
-		const csFont = getAttribute(rFonts, "w", "cs");
-		if (csFont) fontFamily.cs = csFont;
-		const hint = narrowEnum(getAttribute(rFonts, "w", "hint"), FontHintSchema);
-		if (hint) fontFamily.hint = hint;
-		const asciiTheme = narrowEnum(getAttribute(rFonts, "w", "asciiTheme"), FontThemeSchema);
-		if (asciiTheme) {
-			fontFamily.asciiTheme = asciiTheme;
-			if (theme && !fontFamily.ascii) {
-				const resolved = resolveThemeFontRef(theme, asciiTheme);
-				if (resolved) fontFamily.ascii = resolved;
-			}
-		}
-		const hAnsiTheme = narrowEnum(getAttribute(rFonts, "w", "hAnsiTheme"), FontThemeSchema);
-		if (hAnsiTheme) {
-			fontFamily.hAnsiTheme = hAnsiTheme;
-			if (theme && !fontFamily.hAnsi) {
-				const resolved = resolveThemeFontRef(theme, hAnsiTheme);
-				if (resolved) fontFamily.hAnsi = resolved;
-			}
+	const hAnsiTheme = narrowEnum(getAttribute(rFonts, "w", "hAnsiTheme"), FontThemeSchema);
+	if (hAnsiTheme) {
+		fontFamily.hAnsiTheme = hAnsiTheme;
+		if (theme && !fontFamily.hAnsi) {
+			const resolved = resolveThemeFontRef(theme, hAnsiTheme);
+			if (resolved) fontFamily.hAnsi = resolved;
 		}
-		const eastAsiaTheme = narrowEnum(getAttribute(rFonts, "w", "eastAsiaTheme"), FontThemeSchema);
-		if (eastAsiaTheme) {
-			fontFamily.eastAsiaTheme = eastAsiaTheme;
-			if (theme && !fontFamily.eastAsia) {
-				const resolved = resolveThemeFontRef(theme, eastAsiaTheme);
-				if (resolved) fontFamily.eastAsia = resolved;
-			}
-		}
-		const csTheme = narrowEnum(getAttribute(rFonts, "w", "cstheme"), FontThemeSchema);
-		if (csTheme) {
-			fontFamily.csTheme = csTheme;
-			if (theme && !fontFamily.cs) {
-				const resolved = resolveThemeFontRef(theme, csTheme);
-				if (resolved) fontFamily.cs = resolved;
-			}
-		}
-		formatting.fontFamily = fontFamily;
 	}
-	const lang = propertyChildren.lang;
-	if (lang) {
-		const val = truncateLanguageTag(getAttribute(lang, "w", "val") || void 0);
-		const eastAsia = truncateLanguageTag(getAttribute(lang, "w", "eastAsia") || void 0);
-		const bidi = truncateLanguageTag(getAttribute(lang, "w", "bidi") || void 0);
-		if (val || eastAsia || bidi) formatting.language = {
-			...val ? { val } : {},
-			...eastAsia ? { eastAsia } : {},
-			...bidi ? { bidi } : {}
-		};
-	}
-	const spacing = propertyChildren.spacing;
-	if (spacing) {
-		const val = parseNumericAttribute(spacing, "w", "val");
-		if (val !== void 0) formatting.spacing = val;
-	}
-	const position = propertyChildren.position;
-	if (position) {
-		const val = parseNumericAttribute(position, "w", "val");
-		if (val !== void 0) formatting.position = val;
-	}
-	const w = propertyChildren.w;
-	if (w) {
-		const val = parseHorizontalScalePercent(getAttribute(w, "w", "val"));
-		if (val !== void 0) formatting.scale = val;
-	}
-	const kern = propertyChildren.kern;
-	if (kern) {
-		const val = parseNumericAttribute(kern, "w", "val");
-		if (val !== void 0) formatting.kerning = val;
-	}
-	const effect = propertyChildren.effect;
-	if (effect) {
-		const val = narrowEnum(getAttribute(effect, "w", "val"), TextEffectSchema);
-		if (val) formatting.effect = val;
-	}
-	const em = propertyChildren.em;
-	if (em) {
-		const val = narrowEnum(getAttribute(em, "w", "val"), EmphasisMarkSchema);
-		if (val) formatting.emphasisMark = val;
+	const eastAsiaTheme = narrowEnum(getAttribute(rFonts, "w", "eastAsiaTheme"), FontThemeSchema);
+	if (eastAsiaTheme) {
+		fontFamily.eastAsiaTheme = eastAsiaTheme;
+		if (theme && !fontFamily.eastAsia) {
+			const resolved = resolveThemeFontRef(theme, eastAsiaTheme);
+			if (resolved) fontFamily.eastAsia = resolved;
+		}
 	}
-	const emboss = propertyChildren.emboss;
-	if (emboss) formatting.emboss = parseBooleanElement(emboss);
-	const imprint = propertyChildren.imprint;
-	if (imprint) formatting.imprint = parseBooleanElement(imprint);
-	const outline = propertyChildren.outline;
-	if (outline) formatting.outline = parseBooleanElement(outline);
-	const shadow = propertyChildren.shadow;
-	if (shadow) formatting.shadow = parseBooleanElement(shadow);
-	const rtl = propertyChildren.rtl;
-	if (rtl) formatting.rtl = parseBooleanElement(rtl);
-	const cs = propertyChildren.cs;
-	if (cs) formatting.cs = parseBooleanElement(cs);
-	const rStyle = propertyChildren.rStyle;
-	if (rStyle) {
-		const val = getAttribute(rStyle, "w", "val");
-		if (val) formatting.styleId = val;
+	const csTheme = narrowEnum(getAttribute(rFonts, "w", "cstheme"), FontThemeSchema);
+	if (csTheme) {
+		fontFamily.csTheme = csTheme;
+		if (theme && !fontFamily.cs) {
+			const resolved = resolveThemeFontRef(theme, csTheme);
+			if (resolved) fontFamily.cs = resolved;
+		}
 	}
-	return Object.keys(formatting).length > 0 ? formatting : void 0;
+	if (Object.keys(fontFamily).length === 0) return false;
+	formatting.fontFamily = fontFamily;
+	return true;
+};
+/** @returns whether `w:u` named an underline style the model admits. */
+const readUnderline = (u, formatting) => {
+	const style = narrowEnum(getAttribute(u, "w", "val"), UnderlineStyleSchema);
+	if (!style) return false;
+	formatting.underline = { style };
+	const colorVal = getAttribute(u, "w", "color");
+	const themeColor = getAttribute(u, "w", "themeColor");
+	if (colorVal || themeColor) formatting.underline.color = parseColorValue({
+		rgb: colorVal,
+		themeColor,
+		themeTint: getAttribute(u, "w", "themeTint"),
+		themeShade: getAttribute(u, "w", "themeShade"),
+		element: u.name ?? "w:u"
+	});
+	return true;
+};
+/** @returns whether `w:lang` named a tag for any of the three scripts. */
+const readLanguage = (lang, formatting) => {
+	const val = truncateLanguageTag(getAttribute(lang, "w", "val") || void 0);
+	const eastAsia = truncateLanguageTag(getAttribute(lang, "w", "eastAsia") || void 0);
+	const bidi = truncateLanguageTag(getAttribute(lang, "w", "bidi") || void 0);
+	if (!val && !eastAsia && !bidi) return false;
+	formatting.language = {
+		...val ? { val } : {},
+		...eastAsia ? { eastAsia } : {},
+		...bidi ? { bidi } : {}
+	};
+	return true;
+};
+/**
+* The one reader of a run property set (`w:rPr`).
+*
+* Every owner reads through here — a run, the paragraph mark, a style, a
+* numbering level, a comment's reference mark and the snapshot inside either
+* kind of `w:rPrChange` — so none of them can grow its own idea of which
+* children exist, which values it admits, or which of two statements of one
+* property wins. The style parser used to keep a copy of this function, and
+* the copies had drifted on all three.
+*
+* Every child the content model declares carries a decision: a handler that
+* reads it into {@link TextFormatting}, `ownedElsewhere` when the owner's
+* sibling record reads it, or `CAPTURE` for markup folio models nothing for.
+* A handler that looked and took nothing answers `CAPTURE` as well — `<w:sz/>`
+* states no size and `<w:highlight w:val="chartreuse"/>` states a value the
+* reader's enumeration does not admit, and neither can be decided by the
+* child's name. What no reader took goes to `TextFormatting.preserved` at its
+* schema ordinal, so a rebuild puts it back between the same two siblings.
+*
+* A property stated twice resolves to the last statement; see
+* {@link readLastOccurrenceOnly} for the evidence and for why the statements
+* it beat are not kept.
+*
+* An element that states nothing at all still yields a record: `undefined` here
+* means the owner carried no `w:rPr`, never that the one it carried was empty.
+*/
+function parseRunProperties(rPr, theme, owner) {
+	if (!rPr) return;
+	const formatting = {};
+	const wins = readLastOccurrenceOnly(rPr);
+	const preserved = dispatchChildren({
+		element: rPr,
+		container: "run-properties",
+		handlers: {
+			ins: CAPTURE,
+			del: CAPTURE,
+			moveFrom: CAPTURE,
+			moveTo: CAPTURE,
+			rStyle: wins((child) => {
+				const val = getAttribute(child, "w", "val");
+				if (val) formatting.styleId = val;
+				return keptUnless(Boolean(val));
+			}),
+			rFonts: wins((child) => keptUnless(readFontFamily(child, theme, formatting))),
+			b: wins((child) => {
+				formatting.bold = parseBooleanElement(child);
+			}),
+			bCs: wins((child) => {
+				formatting.boldCs = parseBooleanElement(child);
+			}),
+			i: wins((child) => {
+				formatting.italic = parseBooleanElement(child);
+			}),
+			iCs: wins((child) => {
+				formatting.italicCs = parseBooleanElement(child);
+			}),
+			caps: wins((child) => {
+				formatting.allCaps = parseBooleanElement(child);
+			}),
+			smallCaps: wins((child) => {
+				formatting.smallCaps = parseBooleanElement(child);
+			}),
+			strike: wins((child) => {
+				formatting.strike = parseBooleanElement(child);
+			}),
+			dstrike: wins((child) => {
+				formatting.doubleStrike = parseBooleanElement(child);
+			}),
+			outline: wins((child) => {
+				formatting.outline = parseBooleanElement(child);
+			}),
+			shadow: wins((child) => {
+				formatting.shadow = parseBooleanElement(child);
+			}),
+			emboss: wins((child) => {
+				formatting.emboss = parseBooleanElement(child);
+			}),
+			imprint: wins((child) => {
+				formatting.imprint = parseBooleanElement(child);
+			}),
+			noProof: wins((child) => {
+				formatting.noProof = parseBooleanElement(child);
+			}),
+			vanish: wins((child) => {
+				formatting.hidden = parseBooleanElement(child);
+			}),
+			rtl: wins((child) => {
+				formatting.rtl = parseBooleanElement(child);
+			}),
+			cs: wins((child) => {
+				formatting.cs = parseBooleanElement(child);
+			}),
+			/** Whether the run follows the section's document grid; no layout slot. */
+			snapToGrid: CAPTURE,
+			/** Web-view-only hiding, distinct from `w:vanish`; nothing reads it. */
+			webHidden: CAPTURE,
+			color: wins((child) => {
+				const color = parseColorValue({
+					rgb: getAttribute(child, "w", "val"),
+					themeColor: getAttribute(child, "w", "themeColor"),
+					themeTint: getAttribute(child, "w", "themeTint"),
+					themeShade: getAttribute(child, "w", "themeShade"),
+					element: child.name ?? "w:color"
+				});
+				if (Object.keys(color).length === 0) return CAPTURE;
+				formatting.color = color;
+			}),
+			spacing: wins((child) => {
+				const val = parseNumericAttribute(child, "w", "val");
+				if (val !== void 0) formatting.spacing = val;
+				return keptUnless(val !== void 0);
+			}),
+			w: wins((child) => {
+				const val = parseHorizontalScalePercent(getAttribute(child, "w", "val"));
+				if (val !== void 0) formatting.scale = val;
+				return keptUnless(val !== void 0);
+			}),
+			kern: wins((child) => {
+				const val = parseNumericAttribute(child, "w", "val");
+				if (val !== void 0) formatting.kerning = val;
+				return keptUnless(val !== void 0);
+			}),
+			position: wins((child) => {
+				const val = parseNumericAttribute(child, "w", "val");
+				if (val !== void 0) formatting.position = val;
+				return keptUnless(val !== void 0);
+			}),
+			sz: wins((child) => {
+				const val = parseNumericAttribute(child, "w", "val");
+				if (val !== void 0) formatting.fontSize = val;
+				return keptUnless(val !== void 0);
+			}),
+			szCs: wins((child) => {
+				const val = parseNumericAttribute(child, "w", "val");
+				if (val !== void 0) formatting.fontSizeCs = val;
+				return keptUnless(val !== void 0);
+			}),
+			highlight: wins((child) => {
+				const val = narrowEnum(getAttribute(child, "w", "val"), HighlightColorSchema);
+				if (val) formatting.highlight = val;
+				return keptUnless(Boolean(val));
+			}),
+			u: wins((child) => keptUnless(readUnderline(child, formatting))),
+			effect: wins((child) => {
+				const val = narrowEnum(getAttribute(child, "w", "val"), TextEffectSchema);
+				if (val) formatting.effect = val;
+				return keptUnless(Boolean(val));
+			}),
+			/** A text border around the run; `BorderSpec` is a paragraph/table slot. */
+			bdr: CAPTURE,
+			shd: wins((child) => {
+				const shading = parseShading(child);
+				if (shading) formatting.shading = shading;
+				return keptUnless(shading !== void 0);
+			}),
+			/** Compress the run's text into a fixed width; no layout slot holds it. */
+			fitText: CAPTURE,
+			vertAlign: wins((child) => {
+				const val = getAttribute(child, "w", "val");
+				if (val === "superscript" || val === "subscript" || val === "baseline") {
+					formatting.vertAlign = val;
+					return;
+				}
+				return CAPTURE;
+			}),
+			em: wins((child) => {
+				const val = narrowEnum(getAttribute(child, "w", "val"), EmphasisMarkSchema);
+				if (val) formatting.emphasisMark = val;
+				return keptUnless(Boolean(val));
+			}),
+			lang: wins((child) => keptUnless(readLanguage(child, formatting))),
+			/** East Asian two-lines-in-one and horizontal-in-vertical typesetting. */
+			eastAsianLayout: CAPTURE,
+			/**
+			* The run-in heading marker. On a paragraph mark the paragraph's record
+			* reads it (`runInWithNext`); under a run the schema declares it and folio
+			* models nothing for it.
+			*/
+			specVanish: owner === RUN_PROPERTY_OWNERS.paragraphMark ? wins(() => void 0) : CAPTURE,
+			/** The run is part of an equation; folio has no run-level maths slot. */
+			oMath: CAPTURE,
+			/**
+			* The tracked property change. A run's record reads it into
+			* `Run.propertyChanges`; a paragraph mark has no such record, so its
+			* snapshot is kept whole rather than dropped with the revision.
+			*/
+			rPrChange: CAPTURE,
+			...OWNED_BY_A_SIBLING_RECORD[owner]
+		},
+		capturePosition: sequencePositions("run-properties", rPr)
+	});
+	if (preserved) formatting.preserved = preserved;
+	return formatting;
 }
-function parseRunPropertyChanges(rPr, theme, styles, currentFormatting) {
+function parseRunPropertyChanges(rPr, theme, currentFormatting) {
 	if (!rPr) return;
 	const changes = findChildren(rPr, "w", "rPrChange").map((changeElement) => {
 		const previousRPr = findChild(changeElement, "w", "rPr");
@@ -340,11 +426,11 @@ function parseRunPropertyChanges(rPr, theme, styles, currentFormatting) {
 			type: "runPropertyChange",
 			info: parsePropertyChangeInfo(changeElement)
 		};
-		const previousFormatting = parseRunProperties(previousRPr, theme, styles ?? void 0);
+		const previousFormatting = parseRunProperties(previousRPr, theme, RUN_PROPERTY_OWNERS.standalone);
 		if (previousFormatting) change.previousFormatting = previousFormatting;
 		if (currentFormatting) change.currentFormatting = currentFormatting;
 		return change;
-	}).filter((change) => change.previousFormatting || change.currentFormatting);
+	});
 	return changes.length > 0 ? changes : void 0;
 }
 /**
@@ -419,17 +505,14 @@ function parseEndnoteReference(element) {
 */
 function parseFieldChar(element) {
 	const fldCharType = getAttribute(element, "w", "fldCharType");
-	const fldLock = parseOnOffAttribute(element, "w", "fldLock") === true;
-	const dirty = parseOnOffAttribute(element, "w", "dirty") === true;
 	let charType = "begin";
 	if (fldCharType === "separate") charType = "separate";
 	else if (fldCharType === "end") charType = "end";
 	const content = {
 		type: "fieldChar",
-		charType
+		charType,
+		...parseFieldState(element)
 	};
-	if (fldLock) content.fldLock = true;
-	if (dirty) content.dirty = true;
 	const numberingChange = findChild(element, "w", "numberingChange");
 	if (numberingChange) {
 		const original = getAttribute(numberingChange, "w", "original");
@@ -576,10 +659,11 @@ function parseRunContents(runElement, rels, media, rootXmlns = {}) {
 		}
 		case "object": {
 			const objectPreview = parseVmlImageContent(child, rels, media, rootXmlns);
-			if (objectPreview) contents.push(objectPreview);
+			contents.push(objectPreview ?? preserveRunChild(child));
 			break;
 		}
 		case "rPr": break;
+		case "commentReference": break;
 		case "lastRenderedPageBreak":
 			contents.push({ type: "renderedPageBreak" });
 			break;
@@ -637,11 +721,9 @@ function parseRunContents(runElement, rels, media, rootXmlns = {}) {
 			if (contents.length === contentsBeforeAlternate && !hasTextBoxBranch) contents.push(preserveOnlyDrawing(captureVerbatimXml(cloneWithXmlnsDeclarations(child, rootXmlns))));
 			break;
 		}
-		case "footnoteRef":
-		case "endnoteRef": break;
-		case "separator":
-		case "continuationSeparator": break;
-		default: break;
+		default:
+			contents.push(preserveRunChild(child));
+			break;
 	}
 	return contents;
 }
@@ -649,25 +731,31 @@ function parseRunContents(runElement, rels, media, rootXmlns = {}) {
 * Parse a run element (w:r)
 *
 * @param node - The w:r XML element
-* @param styles - Style map for resolving style references
+* @param _styles - Unread: a run's properties are parsed as the source wrote
+*   them, and style resolution happens above this parser
 * @param theme - Theme for resolving theme colors/fonts
 * @param rels - Relationship map for resolving image references
 * @param media - Media files map for image data
 * @returns Parsed Run object
 */
-function parseRun(node, styles, theme, rels = null, media = null, rootXmlns = {}) {
+function parseRun(node, _styles, theme, rels = null, media = null, rootXmlns = {}) {
 	const run = {
 		type: "run",
 		content: []
 	};
 	const rPr = findChild(node, "w", "rPr");
 	if (rPr) {
-		const formattingResult = parseRunProperties(rPr, theme, styles ?? void 0);
+		const formattingResult = parseRunProperties(rPr, theme, RUN_PROPERTY_OWNERS.run);
 		if (formattingResult) run.formatting = formattingResult;
-		const propertyChangesResult = parseRunPropertyChanges(rPr, theme, styles, run.formatting);
+		const propertyChangesResult = parseRunPropertyChanges(rPr, theme, run.formatting);
 		if (propertyChangesResult) run.propertyChanges = propertyChangesResult;
 	}
 	run.content = parseRunContents(node, rels, media, mergeXmlnsDeclarations(rootXmlns, node));
+	const remainder = attributeRemainder({
+		element: node,
+		modelled: NO_MODELLED_ATTRIBUTES
+	});
+	if (remainder) run.preservedAttributes = remainder;
 	return run;
 }
 /**
@@ -732,4 +820,4 @@ function getFieldCharType(run) {
 	return run.content.find((c) => c.type === "fieldChar")?.charType ?? null;
 }
 //#endregion
-export { getFieldCharType, getImages, getRunText, hasContent, hasFieldChar, hasImage, isBaselineVertAlign, parseRun, parseRunProperties };
+export { RUN_PROPERTY_OWNERS, getFieldCharType, getImages, getRunText, hasContent, hasFieldChar, hasImage, isBaselineVertAlign, parseRun, parseRunProperties };