@stll/folio-core 0.45.0 → 0.46.0

package/dist/docx/paragraphParser.js

@@ -1,22 +1,30 @@
 import { isValidHexId } from "../utils/hexId.js";
+import { attributeRemainder } from "./attributeRemainder.js";
 import { parseBookmarkEnd as parseBookmarkEnd$1, parseBookmarkStart as parseBookmarkStart$1 } from "./bookmarkParser.js";
 import { parseBorderSpec } from "./borderParser.js";
+import { CAPTURE, DROPPED_WITH_ITS_WRAPPER, OWNED_ELSEWHERE, dispatchChildren, transitionalNamespaceOf, withPreservedChildren } from "./containerChildren.js";
 import { parseFieldType } from "./fieldParser.js";
-import { parseHyperlink as parseHyperlink$1, parseHyperlinkChild } from "./hyperlinkParser.js";
+import { fieldStateOf, parseFieldState } from "./fieldState.js";
+import { hyperlinkChildHandlers, parseHyperlink as parseHyperlink$1 } from "./hyperlinkParser.js";
+import { isInlineSdtContent, isTrackedChangeWrapperChild } from "./inlineWrapperContent.js";
 import { parseMarkupRangeMarker, parseMoveBookmarkMarker } from "./markupRangeMarker.js";
 import { markerFormattingFromLevel, numberingLevelHasMarkerSlot } from "./numberingParser.js";
 import { isNumberingReference } from "./numberingReference.js";
+import { paraIdAttribute, textIdAttribute } from "./paraIdAttribute.js";
 import { paraIdInRange } from "./paraIdRangeNormalization.js";
 import { assignParagraphPropertySource } from "./paragraphPropertySource.js";
 import { FrameWrapSchema, FrameXAlignSchema, FrameYAlignSchema, LineSpacingRuleSchema, ParagraphAlignmentSchema, TabLeaderSchema, TabStopAlignmentSchema, narrowEnum } from "./parserEnums.js";
+import { preserveInlineChild, preservedInlineCapture } from "./preservedRunContent.js";
 import { consolidateParagraphContent } from "./runConsolidator.js";
 import { parseRun, parseRunProperties } from "./runParser.js";
 import { parseSdtProperties } from "./sdtProperties.js";
 import { parseSectionProperties } from "./sectionParser.js";
 import { parseShading } from "./shadingParser.js";
+import { scanRunForTextBoxDrawings } from "./textBoxParser.js";
 import { parsePropertyChangeInfo, parseTrackedChangeInfo } from "./trackedChangeInfo.js";
 import { captureVerbatimXml } from "./verbatimCapture.js";
-import { WORDPROCESSINGML_NAMESPACE_URIS, cloneElement, findChild, findChildByNamespaceUri, findChildren, findChildrenByNamespaceUri, getAttribute, getAttributeByNamespaceUri, getChildElements, getLocalName, getNamespaceUri, matchesName, mergeXmlnsDeclarations, parseBooleanElement, parseNumberingLevelAttribute, parseNumericAttribute, parseOnOffAttribute, selectAlternateContentBranch } from "./xmlParser.js";
+import { isVmlPictParsedByRunParser } from "./vmlImageParser.js";
+import { WORDPROCESSINGML_NAMESPACE_URIS, cloneElement, findChild, findChildByNamespaceUri, findChildren, findChildrenByNamespaceUri, getAttribute, getAttributeByNamespaceUri, getChildElements, getLocalName, getNamespaceUri, mergeXmlnsDeclarations, parseBooleanElement, parseNumberingLevelAttribute, parseNumericAttribute, parseOnOffAttribute, selectAlternateContentBranch } from "./xmlParser.js";
 import { panic } from "better-result";
 import { BIDI_CONTROLS, PARAGRAPH_MARK_CHANGE_KINDS, REVIEW_CARRIERS } from "@stll/docx-core/model";
 //#region src/docx/paragraphParser.ts
@@ -480,12 +488,6 @@ function parseParagraphMarkChange(pPr) {
 		};
 	}
 }
-function isTrackedChangeWrapperChild(content) {
-	return content.type === "run" || content.type === "hyperlink" || content.type === "bookmarkStart" || content.type === "bookmarkEnd" || content.type === "simpleField" || content.type === "complexField" || content.type === "mathEquation" || content.type === "insertion" || content.type === "deletion" || content.type === "moveFrom" || content.type === "moveTo";
-}
-function isInlineSdtContent(content) {
-	return content.type === "run" || content.type === "hyperlink" || content.type === "simpleField" || content.type === "complexField" || content.type === "inlineSdt" || content.type === "insertion" || content.type === "deletion" || content.type === "moveFrom" || content.type === "moveTo" || content.type === "mathEquation";
-}
 function pushTrackedChangeWrapper({ contents, type, info, content, preserveEmpty = false }) {
 	if (content.length === 0 && !preserveEmpty) return;
 	if (type === "insertion") {
@@ -590,38 +592,43 @@ function pushInlineSdtSegments({ contents, properties, parsedContent }) {
 function parseHyperlink(node, rels, styles, theme, media, rootXmlns = {}) {
 	return parseHyperlink$1(node, rels, styles, theme, media, rootXmlns);
 }
-/** The revision wrapper a `w:hyperlink` child is, when it is one. */
-const hyperlinkRevisionWrapperType = (node) => {
-	switch (getLocalName(node.name)) {
-		case "ins": return "insertion";
-		case "del": return "deletion";
-		case "moveFrom": return "moveFrom";
-		case "moveTo": return "moveTo";
-		default: return;
-	}
-};
+/**
+* The four `CT_RunTrackChange` wrappers a `w:hyperlink` may hold.
+*
+* What to *do* with each is the dispatcher's handler map; this set only
+* answers whether the link needs segmenting at all, which decides between one
+* link and a sequence of links and revisions.
+*/
+const HYPERLINK_REVISION_WRAPPERS = /* @__PURE__ */ new Set([
+	"del",
+	"ins",
+	"moveFrom",
+	"moveTo"
+]);
 const OMML_NAMESPACE = "http://schemas.openxmlformats.org/officeDocument/2006/math";
 /**
-* A bare OMML element as an inline equation, or nothing when the child is not one.
+* An OMML element as an equation, or nothing when the child is not one.
 *
-* `m:oMath` and `m:oMathPara` have branches of their own. This is for the rest
-* of `m:EG_OMathMathElements` — `m:f`, `m:acc`, `m:rad` and their siblings —
-* which the schema admits wherever `m:oMath` is admitted. They carry no
-* structure the editable model holds, so they travel as the markup they
-* arrived as, exactly like the equations that do have a wrapper.
+* `m:oMathPara` is the display form and `m:oMath` the inline one. The rest of
+* `m:EG_OMathMathElements` — `m:f`, `m:acc`, `m:rad` and their siblings — the
+* schema admits wherever `m:oMath` is admitted, so `<w:ins><m:f/></w:ins>` is
+* a tracked insertion of a fraction with no `m:oMath` around it. None of them
+* carries structure the editable model holds, so all travel as the markup
+* they arrived as.
 */
 const mathContentOf = (child) => {
-	if (getNamespaceUri(child) !== OMML_NAMESPACE) return;
+	const namespace = getNamespaceUri(child);
+	if (namespace === void 0 || transitionalNamespaceOf(namespace) !== OMML_NAMESPACE) return;
 	const equation = {
 		type: "mathEquation",
-		display: "inline",
+		display: getLocalName(child.name) === "oMathPara" ? "block" : "inline",
 		ommlXml: captureVerbatimXml(child)
 	};
 	const plainText = extractMathText(child);
 	if (plainText) equation.plainText = plainText;
 	return equation;
 };
-const isHyperlinkChildContent = (content) => content.type === "run" || content.type === "bookmarkStart" || content.type === "bookmarkEnd";
+const isHyperlinkChildContent = (content) => content.type === "run" || content.type === "bookmarkStart" || content.type === "bookmarkEnd" || content.type === "preservedInline";
 /**
 * A `w:hyperlink` as paragraph content, with any revision wrapper it holds
 * hoisted around it.
@@ -632,31 +639,16 @@ const isHyperlinkChildContent = (content) => content.type === "run" || content.t
 * inverse of what the serializer writes, so a package survives the round trip.
 */
 function parseHyperlinkParagraphContents(node, rels, styles, theme, media, rootXmlns) {
-	const children = getChildElements(node);
-	if (!children.some((child) => hyperlinkRevisionWrapperType(child) !== void 0)) return [parseHyperlink(node, rels, styles, theme, media, rootXmlns)];
+	if (!getChildElements(node).some((child) => HYPERLINK_REVISION_WRAPPERS.has(getLocalName(child.name)))) return [parseHyperlink(node, rels, styles, theme, media, rootXmlns)];
 	const inScopeXmlns = mergeXmlnsDeclarations(rootXmlns, node);
 	const shell = parseHyperlink(node, rels, styles, theme, media, rootXmlns);
 	const linkOver = (linkChildren) => ({
 		...shell,
 		children: [...linkChildren]
 	});
-	const contents = [];
-	let plain = [];
-	const flushPlain = () => {
-		if (plain.length > 0) {
-			contents.push(linkOver(plain));
-			plain = [];
-		}
-	};
-	for (const child of children) {
-		const wrapperType = hyperlinkRevisionWrapperType(child);
-		if (wrapperType === void 0) {
-			const parsed = parseHyperlinkChild(child, styles, theme, rels, media, inScopeXmlns);
-			if (parsed) plain.push(parsed);
-			continue;
-		}
-		flushPlain();
-		const wrapped = parseParagraphContents(child, styles, theme, null, rels, media, wrapperType === "deletion" || wrapperType === "moveFrom" ? "deletion" : "default", inScopeXmlns);
+	const items = [];
+	const hoistRevision = (wrapper) => (child) => {
+		const wrapped = parseParagraphContents(child, styles, theme, null, rels, media, wrapper === "deletion" || wrapper === "moveFrom" ? "deletion" : "default", inScopeXmlns);
 		const content = [];
 		let linked = [];
 		const flushLinked = () => {
@@ -674,11 +666,53 @@ function parseHyperlinkParagraphContents(node, rels, styles, theme, media, rootX
 			if (isTrackedChangeWrapperChild(item)) content.push(item);
 		}
 		flushLinked();
+		items.push({
+			type: "hoistedRevision",
+			wrapper,
+			info: parseTrackedChangeInfo(child),
+			content
+		});
+	};
+	const preserved = dispatchChildren({
+		element: node,
+		container: "w:hyperlink",
+		modelledCount: () => items.length,
+		handlers: {
+			...hyperlinkChildHandlers({
+				push: (child) => {
+					items.push(child);
+				},
+				styles,
+				theme,
+				rels,
+				media,
+				inScopeXmlns
+			}),
+			ins: hoistRevision("insertion"),
+			del: hoistRevision("deletion"),
+			moveFrom: hoistRevision("moveFrom"),
+			moveTo: hoistRevision("moveTo")
+		}
+	});
+	const contents = [];
+	let plain = [];
+	const flushPlain = () => {
+		if (plain.length > 0) {
+			contents.push(linkOver(plain));
+			plain = [];
+		}
+	};
+	for (const item of withPreservedChildren(items, preserved, preservedInlineCapture)) {
+		if (item.type !== "hoistedRevision") {
+			plain.push(item);
+			continue;
+		}
+		flushPlain();
 		pushTrackedChangeWrapper({
 			contents,
-			type: wrapperType,
-			info: parseTrackedChangeInfo(child),
-			content,
+			type: item.wrapper,
+			info: item.info,
+			content: item.content,
 			preserveEmpty: true
 		});
 	}
@@ -708,22 +742,69 @@ function parseSimpleField(node, styles, theme, rels, media, rootXmlns = {}) {
 		type: "simpleField",
 		instruction,
 		fieldType: parseFieldType(instruction),
-		content: []
+		content: [],
+		...parseFieldState(node)
 	};
-	if (parseOnOffAttribute(node, "w", "fldLock") === true) field.fldLock = true;
-	if (parseOnOffAttribute(node, "w", "dirty") === true) field.dirty = true;
 	const inScopeXmlns = mergeXmlnsDeclarations(rootXmlns, node);
-	const children = getChildElements(node);
-	for (const child of children) {
-		const localName = getLocalName(child.name);
-		if (localName === "r") field.content.push(parseRun(child, styles, theme, rels, media, inScopeXmlns));
-		else if (localName === "hyperlink") field.content.push(parseHyperlink(child, rels, styles, theme, media, inScopeXmlns));
-	}
+	const content = [];
+	field.content = withPreservedChildren(content, dispatchChildren({
+		element: node,
+		container: "w:fldSimple",
+		modelledCount: () => content.length,
+		handlers: {
+			r: (child) => {
+				content.push(parseRun(child, styles, theme, rels, media, inScopeXmlns));
+			},
+			hyperlink: (child) => {
+				content.push(parseHyperlink(child, rels, styles, theme, media, inScopeXmlns));
+			},
+			customXml: (child) => {
+				content.push(preserveInlineChild(child));
+			},
+			smartTag: (child) => {
+				content.push(preserveInlineChild(child));
+			},
+			bdo: CAPTURE,
+			bookmarkEnd: CAPTURE,
+			bookmarkStart: CAPTURE,
+			commentRangeEnd: CAPTURE,
+			commentRangeStart: CAPTURE,
+			customXmlDelRangeEnd: CAPTURE,
+			customXmlDelRangeStart: CAPTURE,
+			customXmlInsRangeEnd: CAPTURE,
+			customXmlInsRangeStart: CAPTURE,
+			customXmlMoveFromRangeEnd: CAPTURE,
+			customXmlMoveFromRangeStart: CAPTURE,
+			customXmlMoveToRangeEnd: CAPTURE,
+			customXmlMoveToRangeStart: CAPTURE,
+			del: CAPTURE,
+			dir: CAPTURE,
+			fldData: CAPTURE,
+			fldSimple: CAPTURE,
+			ins: CAPTURE,
+			moveFrom: CAPTURE,
+			moveFromRangeEnd: CAPTURE,
+			moveFromRangeStart: CAPTURE,
+			moveTo: CAPTURE,
+			moveToRangeEnd: CAPTURE,
+			moveToRangeStart: CAPTURE,
+			permEnd: CAPTURE,
+			permStart: CAPTURE,
+			proofErr: CAPTURE,
+			sdt: CAPTURE,
+			subDoc: CAPTURE
+		}
+	}), preservedInlineCapture);
 	return field;
 }
-function hasRunPayloadElement(runElement) {
-	return getChildElements(runElement).some((child) => !matchesName(child, "w", "rPr"));
-}
+const hasRunPayload = ({ run, runElement, rels, media }) => {
+	if (run.content.length > 0) return true;
+	const { textBoxDrawings, vmlTextBoxes } = scanRunForTextBoxDrawings({
+		xmlRun: runElement,
+		claimedByRunParser: (pictElement) => isVmlPictParsedByRunParser(pictElement, rels, media)
+	});
+	return textBoxDrawings.length > 0 || vmlTextBoxes.length > 0;
+};
 const LEGACY_FORM_CHECKBOX_GLYPHS = {
 	checked: "☒",
 	unchecked: "☐"
@@ -772,27 +853,45 @@ function isLegacyFormCheckboxInstruction(instruction) {
 */
 function parseParagraphContents(paraElement, styles, theme, _numbering, rels, media, trackedContext = "default", rootXmlns = {}) {
 	const contents = [];
-	const children = getChildElements(paraElement);
 	const inScopeXmlns = mergeXmlnsDeclarations(rootXmlns, paraElement);
 	let inComplexField = false;
 	let complexFieldInstr = "";
 	let complexFieldCodeRuns = [];
 	let complexFieldResultRuns = [];
 	let afterSeparator = false;
-	let complexFieldLock = false;
-	let complexFieldDirty = false;
+	let complexFieldState = {};
 	let complexFieldFallbackDisplay;
 	let complexFieldFormatting;
-	for (const child of children) {
-		const localName = getLocalName(child.name);
-		switch (localName) {
-			case "r": {
+	const parseBidiWrapper = (child, control) => {
+		const wrapper = {
+			type: "inlineWrapper",
+			kind: "bidi",
+			control,
+			content: parseParagraphContents(child, styles, theme, null, rels, media, trackedContext, inScopeXmlns)
+		};
+		const direction = getAttribute(child, "w", "val");
+		if (direction === "ltr" || direction === "rtl") wrapper.direction = direction;
+		return wrapper;
+	};
+	const preserved = dispatchChildren({
+		element: paraElement,
+		container: "run-level-content",
+		modelledCount: () => contents.length,
+		undeclared: { AlternateContent: (child) => {
+			const selectedBranch = selectAlternateContentBranch(child);
+			if (selectedBranch) contents.push(...parseParagraphContents(selectedBranch, styles, theme, null, rels, media, trackedContext, mergeXmlnsDeclarations(inScopeXmlns, child)));
+		} },
+		undeclaredNamespaces: { [OMML_NAMESPACE]: (child) => {
+			const equation = mathContentOf(child);
+			if (equation !== void 0) contents.push(equation);
+		} },
+		handlers: {
+			r: (child) => {
 				const runElement = trackedContext === "deletion" ? normalizeDeletionContentElement(child) : child;
 				const run = parseRun(runElement, styles, theme, rels, media, inScopeXmlns);
 				const commentReferenceId = getCommentReferenceId(runElement);
 				let hasFieldBegin = false;
-				let beginFldLock = false;
-				let beginDirty = false;
+				let beginFieldState = {};
 				const beginFallbackDisplay = getLegacyFormCheckboxDisplay(runElement);
 				let hasFieldSeparate = false;
 				let hasFieldEnd = false;
@@ -800,8 +899,7 @@ function parseParagraphContents(paraElement, styles, theme, _numbering, rels, me
 				let instrText = "";
 				for (const content of run.content) if (content.type === "fieldChar") if (content.charType === "begin") {
 					hasFieldBegin = true;
-					beginFldLock = content.fldLock === true;
-					beginDirty = content.dirty === true;
+					beginFieldState = fieldStateOf(content);
 				} else if (content.charType === "separate") hasFieldSeparate = true;
 				else {
 					hasFieldEnd = true;
@@ -818,8 +916,7 @@ function parseParagraphContents(paraElement, styles, theme, _numbering, rels, me
 					complexFieldInstr = "";
 					complexFieldCodeRuns = [];
 					complexFieldResultRuns = [];
-					complexFieldLock = beginFldLock;
-					complexFieldDirty = beginDirty;
+					complexFieldState = beginFieldState;
 					complexFieldFallbackDisplay = beginFallbackDisplay;
 					complexFieldFormatting = run.formatting;
 				}
@@ -858,10 +955,9 @@ function parseParagraphContents(paraElement, styles, theme, _numbering, rels, me
 							instruction: complexFieldInstr,
 							fieldType: parseFieldType(complexFieldInstr),
 							fieldCode: complexFieldCodeRuns,
-							fieldResult: resultRuns
+							fieldResult: resultRuns,
+							...complexFieldState
 						};
-						if (complexFieldLock) complexField.fldLock = true;
-						if (complexFieldDirty) complexField.dirty = true;
 						if (complexFieldFormatting) complexField.formatting = complexFieldFormatting;
 						contents.push(complexField);
 						if (commentReferenceId !== null) contents.push({
@@ -876,153 +972,146 @@ function parseParagraphContents(paraElement, styles, theme, _numbering, rels, me
 						type: "commentReference",
 						id: commentReferenceId
 					});
-				} else if (run.content.length > 0 || hasRunPayloadElement(runElement)) contents.push(run);
-				break;
-			}
-			case "AlternateContent": {
-				const selectedBranch = selectAlternateContentBranch(child);
-				if (selectedBranch) contents.push(...parseParagraphContents(selectedBranch, styles, theme, null, rels, media, trackedContext, mergeXmlnsDeclarations(inScopeXmlns, child)));
-				break;
-			}
-			case "hyperlink":
+				} else if (hasRunPayload({
+					run,
+					runElement,
+					rels,
+					media
+				})) contents.push(run);
+			},
+			hyperlink: (child) => {
 				contents.push(...parseHyperlinkParagraphContents(child, rels, styles, theme, media, inScopeXmlns));
-				break;
-			case "bookmarkStart":
+			},
+			bookmarkStart: (child) => {
 				contents.push(parseBookmarkStart(child));
-				break;
-			case "bookmarkEnd":
+			},
+			bookmarkEnd: (child) => {
 				contents.push(parseBookmarkEnd(child));
-				break;
-			case "fldSimple":
+			},
+			fldSimple: (child) => {
 				contents.push(parseSimpleField(child, styles, theme, rels, media, inScopeXmlns));
-				break;
-			case "pPr": break;
-			case "proofErr":
-			case "permStart":
-			case "permEnd":
-			case "customXml": break;
-			case "sdt": {
+			},
+			pPr: OWNED_ELSEWHERE,
+			customXml: (child) => {
+				contents.push(preserveInlineChild(child));
+			},
+			proofErr: CAPTURE,
+			permStart: CAPTURE,
+			permEnd: CAPTURE,
+			subDoc: CAPTURE,
+			customXmlDelRangeEnd: CAPTURE,
+			customXmlDelRangeStart: CAPTURE,
+			customXmlInsRangeEnd: CAPTURE,
+			customXmlInsRangeStart: CAPTURE,
+			customXmlMoveFromRangeEnd: CAPTURE,
+			customXmlMoveFromRangeStart: CAPTURE,
+			customXmlMoveToRangeEnd: CAPTURE,
+			customXmlMoveToRangeStart: CAPTURE,
+			smartTagPr: DROPPED_WITH_ITS_WRAPPER,
+			sdt: (child) => {
 				const sdtPr = findChild(child, "w", "sdtPr");
 				const sdtEndPr = findChild(child, "w", "sdtEndPr");
 				const sdtContentEl = findChild(child, "w", "sdtContent");
 				if (sdtContentEl) {
 					const sdtParsed = parseParagraphContents(sdtContentEl, styles, theme, null, rels, media, trackedContext, mergeXmlnsDeclarations(inScopeXmlns, child));
+					const properties = parseSdtProperties(sdtPr, sdtEndPr);
 					pushInlineSdtSegments({
 						contents,
-						properties: parseSdtProperties(sdtPr, sdtEndPr),
+						properties,
 						parsedContent: sdtParsed
 					});
 				}
-				break;
-			}
-			case "ins":
+			},
+			ins: (child) => {
+				const insInfo = parseTrackedChangeInfo(child);
+				const insContent = parseParagraphContents(child, styles, theme, null, rels, media, "default", inScopeXmlns);
 				pushTrackedChangeSegments({
 					contents,
 					type: "insertion",
-					info: parseTrackedChangeInfo(child),
-					parsedContent: parseParagraphContents(child, styles, theme, null, rels, media, "default", inScopeXmlns)
+					info: insInfo,
+					parsedContent: insContent
 				});
-				break;
-			case "del":
+			},
+			del: (child) => {
+				const delInfo = parseTrackedChangeInfo(child);
+				const delContent = parseParagraphContents(child, styles, theme, null, rels, media, "deletion", inScopeXmlns);
 				pushTrackedChangeSegments({
 					contents,
 					type: "deletion",
-					info: parseTrackedChangeInfo(child),
-					parsedContent: parseParagraphContents(child, styles, theme, null, rels, media, "deletion", inScopeXmlns)
+					info: delInfo,
+					parsedContent: delContent
 				});
-				break;
-			case "moveFrom":
+			},
+			moveFrom: (child) => {
+				const moveFromInfo = parseTrackedChangeInfo(child);
+				const moveFromContent = parseParagraphContents(child, styles, theme, null, rels, media, "deletion", inScopeXmlns);
 				pushTrackedChangeSegments({
 					contents,
 					type: "moveFrom",
-					info: parseTrackedChangeInfo(child),
-					parsedContent: parseParagraphContents(child, styles, theme, null, rels, media, "deletion", inScopeXmlns)
+					info: moveFromInfo,
+					parsedContent: moveFromContent
 				});
-				break;
-			case "moveTo":
+			},
+			moveTo: (child) => {
+				const moveToInfo = parseTrackedChangeInfo(child);
+				const moveToContent = parseParagraphContents(child, styles, theme, null, rels, media, "default", inScopeXmlns);
 				pushTrackedChangeSegments({
 					contents,
 					type: "moveTo",
-					info: parseTrackedChangeInfo(child),
-					parsedContent: parseParagraphContents(child, styles, theme, null, rels, media, "default", inScopeXmlns)
+					info: moveToInfo,
+					parsedContent: moveToContent
 				});
-				break;
-			case "smartTag": {
+			},
+			smartTag: (child) => {
 				const inner = parseParagraphContents(child, styles, theme, null, rels, media, trackedContext, mergeXmlnsDeclarations(inScopeXmlns, child));
 				contents.push(...inner);
-				break;
-			}
-			case "moveFromRangeStart":
+			},
+			moveFromRangeStart: (child) => {
 				contents.push({
 					type: "moveFromRangeStart",
 					...parseMoveBookmarkMarker(child)
 				});
-				break;
-			case "moveFromRangeEnd":
+			},
+			moveFromRangeEnd: (child) => {
 				contents.push({
 					type: "moveFromRangeEnd",
 					...parseMarkupRangeMarker(child)
 				});
-				break;
-			case "moveToRangeStart":
+			},
+			moveToRangeStart: (child) => {
 				contents.push({
 					type: "moveToRangeStart",
 					...parseMoveBookmarkMarker(child)
 				});
-				break;
-			case "moveToRangeEnd":
+			},
+			moveToRangeEnd: (child) => {
 				contents.push({
 					type: "moveToRangeEnd",
 					...parseMarkupRangeMarker(child)
 				});
-				break;
-			case "commentRangeStart":
+			},
+			commentRangeStart: (child) => {
 				contents.push({
 					type: "commentRangeStart",
 					...parseMarkupRangeMarker(child)
 				});
-				break;
-			case "commentRangeEnd":
+			},
+			commentRangeEnd: (child) => {
 				contents.push({
 					type: "commentRangeEnd",
 					...parseMarkupRangeMarker(child)
 				});
-				break;
-			case "bdo":
-			case "dir": {
-				const direction = getAttribute(child, "w", "val");
-				const wrapper = {
-					type: "bidiWrapper",
-					control: localName === "bdo" ? BIDI_CONTROLS.override : BIDI_CONTROLS.embedding,
-					content: parseParagraphContents(child, styles, theme, null, rels, media, trackedContext, inScopeXmlns)
-				};
-				if (direction === "ltr" || direction === "rtl") wrapper.direction = direction;
-				contents.push(wrapper);
-				break;
-			}
-			case "oMath":
-			case "oMathPara": {
-				const isBlock = localName === "oMathPara";
-				const ommlXml = captureVerbatimXml(child);
-				const plainText = extractMathText(child);
-				const mathEq = {
-					type: "mathEquation",
-					display: isBlock ? "block" : "inline",
-					ommlXml
-				};
-				if (plainText) mathEq.plainText = plainText;
-				contents.push(mathEq);
-				break;
-			}
-			default: {
-				const mathElement = mathContentOf(child);
-				if (mathElement !== void 0) contents.push(mathElement);
-				break;
+			},
+			bdo: (child) => {
+				contents.push(parseBidiWrapper(child, BIDI_CONTROLS.override));
+			},
+			dir: (child) => {
+				contents.push(parseBidiWrapper(child, BIDI_CONTROLS.embedding));
 			}
 		}
-	}
+	});
 	if (inComplexField && afterSeparator) contents.push(...complexFieldResultRuns);
-	return contents;
+	return withPreservedChildren(contents, preserved, preservedInlineCapture);
 }
 function getCommentReferenceId(runElement) {
 	const commentReference = findChild(runElement, "w", "commentReference");
@@ -1031,6 +1120,18 @@ function getCommentReferenceId(runElement) {
 	return Number.isFinite(id) ? id : null;
 }
 /**
+* Attribute local names `w:p` has a model field for.
+*
+* `w14:paraId` and `w14:textId` are read below and written by
+* `serializeParagraph`; `folio:reviewCarrier` is folio's own. Everything else
+* the element carried is the attribute remainder.
+*/
+const PARAGRAPH_ATTRIBUTES = /* @__PURE__ */ new Set([
+	"paraId",
+	"textId",
+	"reviewCarrier"
+]);
+/**
 * Parse a paragraph element (w:p)
 *
 * @param node - The w:p XML element
@@ -1047,10 +1148,15 @@ function parseParagraph(node, styles, theme, numbering, rels = null, media = nul
 		type: "paragraph",
 		content: []
 	};
-	const paraId = getAttribute(node, "w14", "paraId") ?? getAttribute(node, "w", "paraId");
+	const paraId = paraIdAttribute(node);
 	if (paraId && isValidHexId(paraId)) paragraph.paraId = paraIdInRange(paraId);
-	const textId = getAttribute(node, "w14", "textId") ?? getAttribute(node, "w", "textId");
+	const textId = textIdAttribute(node);
 	if (textId && isValidHexId(textId)) paragraph.textId = paraIdInRange(textId);
+	const remainder = attributeRemainder({
+		element: node,
+		modelled: PARAGRAPH_ATTRIBUTES
+	});
+	if (remainder) paragraph.preservedAttributes = remainder;
 	if (getAttributeByNamespaceUri(node, FOLIO_REVIEW_HISTORY_NAMESPACES, "reviewCarrier") === REVIEW_CARRIERS.TERMINAL_TABLE) paragraph.reviewCarrier = REVIEW_CARRIERS.TERMINAL_TABLE;
 	if (!options?.inHeaderFooter && paragraphStartsWithRenderedPageBreak(node)) paragraph.renderedPageBreakBefore = true;
 	const pPr = findChild(node, "w", "pPr");
@@ -1205,6 +1311,7 @@ const getRunContentText = (content) => {
 		case "break": return content.breakType === "page" ? "\f" : "\n";
 		case "noBreakHyphen": return "‑";
 		case "softHyphen": return "­";
+		case "preservedXml": return content.text;
 		case "drawing":
 		case "endnoteRef":
 		case "fieldChar":
@@ -1225,6 +1332,7 @@ const getHyperlinkText = (hyperlink) => hyperlink.children.map((child) => {
 		case "run": return getRunText(child);
 		case "bookmarkStart":
 		case "bookmarkEnd": return "";
+		case "preservedInline": return child.text;
 		default: return panic(`Unsupported hyperlink child in plain-text extraction: ${JSON.stringify(child)}`);
 	}
 }).join("");
@@ -1237,10 +1345,11 @@ const getParagraphContentText = (content) => {
 		case "inlineSdt": return content.content.map(getParagraphContentText).join("");
 		case "insertion":
 		case "moveTo":
-		case "bidiWrapper": return content.content.map(getParagraphContentText).join("");
+		case "inlineWrapper": return content.content.map(getParagraphContentText).join("");
 		case "deletion":
 		case "moveFrom": return "";
 		case "mathEquation": return content.plainText ?? "";
+		case "preservedInline": return content.text;
 		case "bookmarkEnd":
 		case "bookmarkStart":
 		case "commentRangeEnd":