@stll/folio-core 0.45.0 → 0.47.0

package/dist/docx/paragraphParser.js

@@ -1,24 +1,33 @@
 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, dispatchChildren, ownedElsewhere, 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 { isHyperlinkContent, isInlineSdtContent, isTrackedChangeWrapperChild } from "./inlineWrapperContent.js";
+import { inlineWrapperOf } from "./inlineWrapperParser.js";
 import { parseMarkupRangeMarker, parseMoveBookmarkMarker } from "./markupRangeMarker.js";
-import { markerFormattingFromLevel, numberingLevelHasMarkerSlot } from "./numberingParser.js";
-import { isNumberingReference } from "./numberingReference.js";
+import { counterFormatOf, markerAlignmentForLevel, markerFormattingFromLevel, numberingLevelHasMarkerSlot } from "./numberingParser.js";
+import { mergeParagraphNumbering as mergeParagraphNumbering$1, paragraphNumberingReferenceId as paragraphNumberingReferenceId$1, resolveParagraphNumbering as resolveParagraphNumbering$1 } from "./numberingReference.js";
+import { paraIdAttribute, textIdAttribute } from "./paraIdAttribute.js";
 import { paraIdInRange } from "./paraIdRangeNormalization.js";
+import { parseParagraphProperties } from "./paragraphProperties.js";
 import { assignParagraphPropertySource } from "./paragraphPropertySource.js";
-import { FrameWrapSchema, FrameXAlignSchema, FrameYAlignSchema, LineSpacingRuleSchema, ParagraphAlignmentSchema, TabLeaderSchema, TabStopAlignmentSchema, narrowEnum } from "./parserEnums.js";
+import { preserveInlineChild, preserveRunChild, preservedInlineCapture } from "./preservedRunContent.js";
 import { consolidateParagraphContent } from "./runConsolidator.js";
-import { parseRun, parseRunProperties } from "./runParser.js";
-import { parseSdtProperties } from "./sdtProperties.js";
+import { parseRun } from "./runParser.js";
+import { runHoldsPayload } from "./runPayload.js";
+import { captureSdtSiblingMarkers, parseSdtProperties } from "./sdtProperties.js";
 import { parseSectionProperties } from "./sectionParser.js";
-import { parseShading } from "./shadingParser.js";
+import { hasAttributeAnySpelling } from "./strictNames.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, findChildrenByNamespaceUri, findWordprocessingChild, getAttribute, getAttributeByNamespaceUri, getChildElements, getLocalName, getNamespaceUri, mergeXmlnsDeclarations, parseBooleanElement, parseNumericAttribute, selectAlternateContentBranch } from "./xmlParser.js";
 import { panic } from "better-result";
-import { BIDI_CONTROLS, PARAGRAPH_MARK_CHANGE_KINDS, REVIEW_CARRIERS } from "@stll/docx-core/model";
+import { PARAGRAPH_MARK_CHANGE_KINDS, REVIEW_CARRIERS } from "@stll/docx-core/model";
 //#region src/docx/paragraphParser.ts
 const FOLIO_REVIEW_HISTORY_NAMESPACES = /* @__PURE__ */ new Set(["urn:stella:folio:review-history:1"]);
 /**
@@ -38,293 +47,6 @@ function extractMathText(el) {
 	return text;
 }
 /**
-* Parse tab stops (w:tabs)
-*/
-function parseTabStops(tabs) {
-	if (!tabs) return;
-	const tabElements = findChildren(tabs, "w", "tab");
-	if (tabElements.length === 0) return;
-	const result = [];
-	for (const tab of tabElements) {
-		const pos = parseNumericAttribute(tab, "w", "pos");
-		const alignment = narrowEnum(getAttribute(tab, "w", "val"), TabStopAlignmentSchema);
-		if (pos !== void 0 && alignment) {
-			const tabStop = {
-				position: pos,
-				alignment
-			};
-			const leader = narrowEnum(getAttribute(tab, "w", "leader"), TabLeaderSchema);
-			if (leader && leader !== "none") tabStop.leader = leader;
-			result.push(tabStop);
-		}
-	}
-	return result.length > 0 ? result : void 0;
-}
-/**
-* Parse frame properties (w:framePr)
-*/
-function parseFrameProperties(framePr) {
-	if (!framePr) return;
-	const frame = {};
-	const dropCap = getAttribute(framePr, "w", "dropCap");
-	if (dropCap === "none" || dropCap === "drop" || dropCap === "margin") frame.dropCap = dropCap;
-	const lines = parseNumericAttribute(framePr, "w", "lines");
-	if (lines !== void 0) frame.lines = lines;
-	const w = parseNumericAttribute(framePr, "w", "w");
-	if (w !== void 0) frame.width = w;
-	const h = parseNumericAttribute(framePr, "w", "h");
-	if (h !== void 0) frame.height = h;
-	const hSpace = parseNumericAttribute(framePr, "w", "hSpace");
-	if (hSpace !== void 0) frame.hSpace = hSpace;
-	const vSpace = parseNumericAttribute(framePr, "w", "vSpace");
-	if (vSpace !== void 0) frame.vSpace = vSpace;
-	const hAnchor = getAttribute(framePr, "w", "hAnchor");
-	if (hAnchor === "text" || hAnchor === "margin" || hAnchor === "page") frame.hAnchor = hAnchor;
-	const vAnchor = getAttribute(framePr, "w", "vAnchor");
-	if (vAnchor === "text" || vAnchor === "margin" || vAnchor === "page") frame.vAnchor = vAnchor;
-	const x = parseNumericAttribute(framePr, "w", "x");
-	if (x !== void 0) frame.x = x;
-	const y = parseNumericAttribute(framePr, "w", "y");
-	if (y !== void 0) frame.y = y;
-	const xAlign = narrowEnum(getAttribute(framePr, "w", "xAlign"), FrameXAlignSchema);
-	if (xAlign) frame.xAlign = xAlign;
-	const yAlign = narrowEnum(getAttribute(framePr, "w", "yAlign"), FrameYAlignSchema);
-	if (yAlign) frame.yAlign = yAlign;
-	const wrap = narrowEnum(getAttribute(framePr, "w", "wrap"), FrameWrapSchema);
-	if (wrap) frame.wrap = wrap;
-	return Object.keys(frame).length > 0 ? frame : void 0;
-}
-function collectFirstParagraphPropertyChildren(pPr) {
-	const children = {};
-	for (const child of pPr.elements ?? []) {
-		if (child.type !== "element") continue;
-		switch (getLocalName(child.name)) {
-			case "bidi":
-				children.bidi ??= child;
-				break;
-			case "contextualSpacing":
-				children.contextualSpacing ??= child;
-				break;
-			case "framePr":
-				children.framePr ??= child;
-				break;
-			case "ind":
-				children.ind ??= child;
-				break;
-			case "jc":
-				children.jc ??= child;
-				break;
-			case "keepLines":
-				children.keepLines ??= child;
-				break;
-			case "keepNext":
-				children.keepNext ??= child;
-				break;
-			case "kinsoku":
-				children.kinsoku ??= child;
-				break;
-			case "numPr":
-				children.numPr ??= child;
-				break;
-			case "outlineLvl":
-				children.outlineLvl ??= child;
-				break;
-			case "overflowPunct":
-				children.overflowPunct ??= child;
-				break;
-			case "pageBreakBefore":
-				children.pageBreakBefore ??= child;
-				break;
-			case "pBdr":
-				children.pBdr ??= child;
-				break;
-			case "pStyle":
-				children.pStyle ??= child;
-				break;
-			case "rPr":
-				children.rPr ??= child;
-				break;
-			case "shd":
-				children.shd ??= child;
-				break;
-			case "snapToGrid":
-				children.snapToGrid ??= child;
-				break;
-			case "spacing":
-				children.spacing ??= child;
-				break;
-			case "suppressAutoHyphens":
-				children.suppressAutoHyphens ??= child;
-				break;
-			case "suppressLineNumbers":
-				children.suppressLineNumbers ??= child;
-				break;
-			case "tabs":
-				children.tabs ??= child;
-				break;
-			case "widowControl":
-				children.widowControl ??= child;
-				break;
-		}
-	}
-	return children;
-}
-/**
-* Parse paragraph formatting properties (w:pPr)
-*
-* Handles ALL pPr properties:
-* - w:jc (alignment: left, center, right, both/justify)
-* - w:spacing (before, after, line, lineRule)
-* - w:ind (left, right, firstLine, hanging)
-* - w:pBdr (paragraph borders: top, bottom, left, right, between)
-* - w:shd (paragraph shading/background)
-* - w:tabs (tab stops with positions and types)
-* - w:keepNext, w:keepLines, w:widowControl, w:pageBreakBefore
-* - w:bidi (right-to-left)
-* - w:numPr (list info)
-* - w:pStyle (style reference)
-* - w:outlineLvl (outline level)
-* - w:framePr (frame properties)
-* - w:rPr (default run properties)
-*/
-function parseParagraphProperties(pPr, theme, styles) {
-	if (!pPr) return;
-	const formatting = {};
-	const propertyChildren = collectFirstParagraphPropertyChildren(pPr);
-	const kinsoku = propertyChildren.kinsoku;
-	if (kinsoku) formatting.kinsoku = parseBooleanElement(kinsoku);
-	const overflowPunct = propertyChildren.overflowPunct;
-	if (overflowPunct) formatting.overflowPunctuation = parseBooleanElement(overflowPunct);
-	const jc = propertyChildren.jc;
-	if (jc) {
-		const val = narrowEnum(getAttribute(jc, "w", "val"), ParagraphAlignmentSchema);
-		if (val) formatting.alignment = val;
-	}
-	const bidi = propertyChildren.bidi;
-	if (bidi) formatting.bidi = parseBooleanElement(bidi);
-	const snapToGrid = propertyChildren.snapToGrid;
-	if (snapToGrid) formatting.snapToGrid = parseBooleanElement(snapToGrid);
-	const spacing = propertyChildren.spacing;
-	if (spacing) {
-		const before = parseNumericAttribute(spacing, "w", "before");
-		if (before !== void 0) formatting.spaceBefore = before;
-		const after = parseNumericAttribute(spacing, "w", "after");
-		if (after !== void 0) formatting.spaceAfter = after;
-		const line = parseNumericAttribute(spacing, "w", "line");
-		if (line !== void 0) formatting.lineSpacing = line;
-		const spacingExplicit = {};
-		if (before !== void 0) spacingExplicit.before = true;
-		if (after !== void 0) spacingExplicit.after = true;
-		if (spacingExplicit.before || spacingExplicit.after) formatting.spacingExplicit = spacingExplicit;
-		const lineRule = narrowEnum(getAttribute(spacing, "w", "lineRule"), LineSpacingRuleSchema);
-		if (lineRule) formatting.lineSpacingRule = lineRule;
-		const beforeAutospacing = parseOnOffAttribute(spacing, "w", "beforeAutospacing");
-		if (beforeAutospacing !== void 0) formatting.beforeAutospacing = beforeAutospacing;
-		const afterAutospacing = parseOnOffAttribute(spacing, "w", "afterAutospacing");
-		if (afterAutospacing !== void 0) formatting.afterAutospacing = afterAutospacing;
-	}
-	const ind = propertyChildren.ind;
-	if (ind) {
-		const left = parseNumericAttribute(ind, "w", "left");
-		if (left !== void 0) formatting.indentLeft = left;
-		const right = parseNumericAttribute(ind, "w", "right");
-		if (right !== void 0) formatting.indentRight = right;
-		const firstLine = parseNumericAttribute(ind, "w", "firstLine");
-		if (firstLine !== void 0) formatting.indentFirstLine = firstLine;
-		const hanging = parseNumericAttribute(ind, "w", "hanging");
-		if (hanging !== void 0) {
-			formatting.indentFirstLine = -hanging;
-			formatting.hangingIndent = true;
-		}
-		const start = parseNumericAttribute(ind, "w", "start");
-		if (start !== void 0 && formatting.indentLeft === void 0) formatting.indentLeft = start;
-		const end = parseNumericAttribute(ind, "w", "end");
-		if (end !== void 0 && formatting.indentRight === void 0) formatting.indentRight = end;
-	}
-	const pBdr = propertyChildren.pBdr;
-	if (pBdr) {
-		const borders = {};
-		const top = parseBorderSpec(findChild(pBdr, "w", "top"));
-		if (top) borders.top = top;
-		const bottom = parseBorderSpec(findChild(pBdr, "w", "bottom"));
-		if (bottom) borders.bottom = bottom;
-		const left = parseBorderSpec(findChild(pBdr, "w", "left"));
-		if (left) borders.left = left;
-		const right = parseBorderSpec(findChild(pBdr, "w", "right"));
-		if (right) borders.right = right;
-		const between = parseBorderSpec(findChild(pBdr, "w", "between"));
-		if (between) borders.between = between;
-		const bar = parseBorderSpec(findChild(pBdr, "w", "bar"));
-		if (bar) borders.bar = bar;
-		if (Object.keys(borders).length > 0) formatting.borders = borders;
-	}
-	const shd = propertyChildren.shd;
-	if (shd) {
-		const shadingResult = parseShading(shd);
-		if (shadingResult !== void 0) formatting.shading = shadingResult;
-	}
-	const tabs = propertyChildren.tabs;
-	if (tabs) {
-		const tabsResult = parseTabStops(tabs);
-		if (tabsResult !== void 0) formatting.tabs = tabsResult;
-	}
-	const keepNext = propertyChildren.keepNext;
-	if (keepNext) formatting.keepNext = parseBooleanElement(keepNext);
-	const keepLines = propertyChildren.keepLines;
-	if (keepLines) formatting.keepLines = parseBooleanElement(keepLines);
-	const widowControl = propertyChildren.widowControl;
-	if (widowControl) formatting.widowControl = parseBooleanElement(widowControl);
-	const pageBreakBefore = propertyChildren.pageBreakBefore;
-	if (pageBreakBefore) formatting.pageBreakBefore = parseBooleanElement(pageBreakBefore);
-	const contextualSpacing = propertyChildren.contextualSpacing;
-	if (contextualSpacing) formatting.contextualSpacing = parseBooleanElement(contextualSpacing);
-	const numPr = propertyChildren.numPr;
-	if (numPr) {
-		const numIdEl = findChild(numPr, "w", "numId");
-		const ilvlEl = findChild(numPr, "w", "ilvl");
-		if (numIdEl || ilvlEl) {
-			formatting.numPr = {};
-			if (numIdEl) {
-				const val = parseNumericAttribute(numIdEl, "w", "val");
-				if (val !== void 0) formatting.numPr.numId = val;
-			}
-			if (ilvlEl) {
-				const val = parseNumberingLevelAttribute(ilvlEl);
-				if (val !== void 0) formatting.numPr.ilvl = val;
-			}
-		}
-		const numberingChange = findChild(numPr, "w", "numberingChange");
-		if (numberingChange) formatting.numberingChangeXml = captureVerbatimXml(numberingChange);
-	}
-	const outlineLvl = propertyChildren.outlineLvl;
-	if (outlineLvl) {
-		const val = parseNumericAttribute(outlineLvl, "w", "val");
-		if (val !== void 0) formatting.outlineLevel = val;
-	}
-	const pStyle = propertyChildren.pStyle;
-	if (pStyle) {
-		const val = getAttribute(pStyle, "w", "val");
-		if (val) formatting.styleId = val;
-	}
-	const framePr = propertyChildren.framePr;
-	if (framePr) {
-		const frameResult = parseFrameProperties(framePr);
-		if (frameResult !== void 0) formatting.frame = frameResult;
-	}
-	const suppressLineNumbers = propertyChildren.suppressLineNumbers;
-	if (suppressLineNumbers) formatting.suppressLineNumbers = parseBooleanElement(suppressLineNumbers);
-	const suppressAutoHyphens = propertyChildren.suppressAutoHyphens;
-	if (suppressAutoHyphens) formatting.suppressAutoHyphens = parseBooleanElement(suppressAutoHyphens);
-	const rPr = propertyChildren.rPr;
-	if (rPr) {
-		const runPropsResult = parseRunProperties(rPr, theme, styles);
-		if (runPropsResult !== void 0) formatting.runProperties = runPropsResult;
-		const specVanish = findChild(rPr, "w", "specVanish");
-		if (specVanish && parseBooleanElement(specVanish)) formatting.runInWithNext = true;
-	}
-	return Object.keys(formatting).length > 0 ? formatting : void 0;
-}
-/**
 * Capture the authored paragraph properties separately from structural and
 * revision children, which have their own model fields and lifecycles.
 */
@@ -448,10 +170,10 @@ function normalizeDeletionContentElement(node) {
 		...node.elements ? { elements: node.elements.map(normalizeDeletionContentElement) } : {}
 	});
 }
-function parseParagraphPropertyChanges(pPr, theme, styles, currentFormatting) {
+function parseParagraphPropertyChanges(pPr, theme, currentFormatting) {
 	if (!pPr) return;
 	const changes = findChildrenByNamespaceUri(pPr, WORDPROCESSINGML_NAMESPACE_URIS, "pPrChange").map((changeElement) => {
-		const previousFormatting = parseParagraphProperties(findChildByNamespaceUri(changeElement, WORDPROCESSINGML_NAMESPACE_URIS, "pPr"), theme, styles ?? void 0);
+		const previousFormatting = parseParagraphProperties(findChildByNamespaceUri(changeElement, WORDPROCESSINGML_NAMESPACE_URIS, "pPr"), theme);
 		const change = {
 			type: "paragraphPropertyChange",
 			info: parsePropertyChangeInfo(changeElement)
@@ -459,7 +181,7 @@ function parseParagraphPropertyChanges(pPr, theme, styles, currentFormatting) {
 		if (previousFormatting !== void 0) change.previousFormatting = previousFormatting;
 		if (currentFormatting !== void 0) change.currentFormatting = currentFormatting;
 		return change;
-	}).filter((change) => change.previousFormatting || change.currentFormatting);
+	});
 	return changes.length > 0 ? changes : void 0;
 }
 /**
@@ -480,12 +202,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 +306,42 @@ 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";
 /**
 * A `w:hyperlink` as paragraph content, with any revision wrapper it holds
 * hoisted around it.
@@ -632,31 +352,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 = () => {
@@ -666,7 +371,7 @@ function parseHyperlinkParagraphContents(node, rels, styles, theme, media, rootX
 			}
 		};
 		for (const item of wrapped) {
-			if (isHyperlinkChildContent(item)) {
+			if (isHyperlinkContent(item)) {
 				linked.push(item);
 				continue;
 			}
@@ -674,11 +379,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",
+		capturePosition: () => 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 +455,154 @@ 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",
+		capturePosition: () => content.length,
+		handlers: simpleFieldChildHandlers({
+			push: (child) => {
+				content.push(child);
+			},
+			styles,
+			theme,
+			rels,
+			media,
+			inScopeXmlns
+		})
+	}), preservedInlineCapture);
 	return field;
 }
-function hasRunPayloadElement(runElement) {
-	return getChildElements(runElement).some((child) => !matchesName(child, "w", "rPr"));
-}
+/**
+* What a `w:fldSimple` does with every child its content model declares.
+*
+* Two callers read this one map: {@link parseSimpleField}, and
+* {@link parseFieldInlineWrapper} for a transparent wrapper the field holds —
+* `CT_BdoContentRun` and its three siblings are the same `EG_PContent` the
+* field is, so the decision per child is the field's own.
+*/
+const simpleFieldChildHandlers = (context) => {
+	const { push, styles, theme, rels, media, inScopeXmlns } = context;
+	const wrapper = (element) => (child) => {
+		push(parseFieldInlineWrapper(element, child, context));
+	};
+	return {
+		r: (child) => {
+			push(parseRun(child, styles, theme, rels, media, inScopeXmlns));
+		},
+		hyperlink: (child) => {
+			push(parseHyperlink(child, rels, styles, theme, media, inScopeXmlns));
+		},
+		bdo: wrapper("bdo"),
+		dir: wrapper("dir"),
+		customXml: wrapper("customXml"),
+		smartTag: wrapper("smartTag"),
+		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,
+		fldData: CAPTURE,
+		fldSimple: (child) => {
+			push(preserveInlineChild(child));
+		},
+		ins: CAPTURE,
+		moveFrom: CAPTURE,
+		moveFromRangeEnd: CAPTURE,
+		moveFromRangeStart: CAPTURE,
+		moveTo: CAPTURE,
+		moveToRangeEnd: CAPTURE,
+		moveToRangeStart: CAPTURE,
+		permEnd: CAPTURE,
+		permStart: CAPTURE,
+		proofErr: CAPTURE,
+		sdt: CAPTURE,
+		subDoc: CAPTURE
+	};
+};
+/**
+* A transparent wrapper a simple field holds, with the content the field holds.
+*
+* The mirror of `parseLinkedInlineWrapper`: the wrapper's declared children are
+* run-level content, the decision per child is the container's own map, and the
+* wrapper's properties bag is read by `inlineWrapperOf` rather than captured a
+* second time by the sink.
+*/
+const parseFieldInlineWrapper = (element, node, context) => {
+	const inScopeXmlns = mergeXmlnsDeclarations(context.inScopeXmlns, node);
+	const content = [];
+	return inlineWrapperOf(element, node, withPreservedChildren(content, dispatchChildren({
+		element: node,
+		container: "run-level-content",
+		capturePosition: () => content.length,
+		handlers: {
+			...simpleFieldChildHandlers({
+				...context,
+				inScopeXmlns,
+				push: (child) => {
+					content.push(child);
+				}
+			}),
+			customXmlPr: CUSTOM_XML_PROPERTIES_OWNER,
+			smartTagPr: SMART_TAG_PROPERTIES_OWNER,
+			pPr: CAPTURE
+		}
+	}), preservedInlineCapture));
+};
+const hasRunPayload = ({ run, runElement, rels, media }) => {
+	if (runHoldsPayload(run)) return true;
+	const { textBoxDrawings, vmlTextBoxes } = scanRunForTextBoxDrawings({
+		xmlRun: runElement,
+		claimedByRunParser: (pictElement) => isVmlPictParsedByRunParser(pictElement, rels, media)
+	});
+	return textBoxDrawings.length > 0 || vmlTextBoxes.length > 0;
+};
+/**
+* A field character that belongs to no field, kept as the markup it was.
+*
+* `FieldCharContent` is half of a `ComplexField`: `convertField` reads it off
+* the assembled field, and one that reaches the editor's inline converter on
+* its own is dropped. So a `w:fldChar` whose field this paragraph never closed,
+* or one with no `begin` before it, loses the editor round trip — and the
+* model holds nothing of its `w:ffData` either, so the save loses a legacy form
+* field's name, macros, help text and checkbox state as well.
+*
+* `preservedXml` is the run's own capture member: the editor carries it as an
+* opaque atom and the serializer replays the source bytes, `w:ffData` included.
+* The two lists line up because `parseRunContents` walks the source children in
+* order, so the nth `w:fldChar` child is the nth `fieldChar` content.
+*
+* `w:instrText` is left alone. It is fully modelled and fully serialized; what
+* the editor does with an orphan is a separate question from what the container
+* contract asks here, and answering it with bytes would trade a model for one.
+*/
+const withOrphanFieldCharsPreserved = (run, runElement) => {
+	const captured = getChildElements(runElement).filter((child) => getLocalName(child.name) === "fldChar").map(preserveRunChild);
+	if (captured.length === 0) return run;
+	let next = 0;
+	const content = run.content.map((item) => {
+		if (item.type !== "fieldChar") return item;
+		const replacement = captured[next];
+		next += 1;
+		return replacement ?? item;
+	});
+	return {
+		...run,
+		content
+	};
+};
 const LEGACY_FORM_CHECKBOX_GLYPHS = {
 	checked: "☒",
 	unchecked: "☐"
@@ -766,33 +645,64 @@ function isLegacyFormCheckboxInstruction(instruction) {
 	return instruction.trim().split(/\s+/u).at(0)?.toUpperCase() === LEGACY_FORM_CHECKBOX_INSTRUCTION;
 }
 /**
+* The paragraph's own properties, read from the element by `parseParagraph`.
+*
+* The entry is in the inline handler map because the map covers every inline
+* container, not because this walk reads it. Declared at module scope so the
+* claim is registered when the module loads.
+*/
+const PARAGRAPH_PROPERTIES_OWNER = ownedElsewhere({
+	container: "run-level-content",
+	child: "pPr",
+	reader: "paragraphProperties#parseParagraphProperties"
+});
+const SMART_TAG_PROPERTIES_OWNER = ownedElsewhere({
+	container: "run-level-content",
+	child: "smartTagPr",
+	reader: "inlineWrapperParser#inlineWrapperOf"
+});
+const CUSTOM_XML_PROPERTIES_OWNER = ownedElsewhere({
+	container: "run-level-content",
+	child: "customXmlPr",
+	reader: "inlineWrapperParser#inlineWrapperOf"
+});
+/**
 * Parse all content within a paragraph
 *
 * Returns the parsed content and any complex fields that span multiple runs
 */
 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 complexFieldOpenRuns = [];
 	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 parseInlineWrapper = (child, element) => inlineWrapperOf(element, child, parseParagraphContents(child, styles, theme, null, rels, media, trackedContext, mergeXmlnsDeclarations(inScopeXmlns, child)));
+	const preserved = dispatchChildren({
+		element: paraElement,
+		container: "run-level-content",
+		capturePosition: () => 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 +710,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,12 +727,13 @@ function parseParagraphContents(paraElement, styles, theme, _numbering, rels, me
 					complexFieldInstr = "";
 					complexFieldCodeRuns = [];
 					complexFieldResultRuns = [];
-					complexFieldLock = beginFldLock;
-					complexFieldDirty = beginDirty;
+					complexFieldOpenRuns = [];
+					complexFieldState = beginFieldState;
 					complexFieldFallbackDisplay = beginFallbackDisplay;
 					complexFieldFormatting = run.formatting;
 				}
 				if (inComplexField) {
+					complexFieldOpenRuns.push(withOrphanFieldCharsPreserved(run, runElement));
 					if (instrText) complexFieldInstr += instrText;
 					if ((!complexFieldFormatting || Object.keys(complexFieldFormatting).length === 0) && run.formatting && Object.keys(run.formatting).length > 0) complexFieldFormatting = run.formatting;
 					let inFieldCodeRegion = !hasFieldBegin && !afterSeparator;
@@ -858,10 +768,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({
@@ -871,158 +780,154 @@ function parseParagraphContents(paraElement, styles, theme, _numbering, rels, me
 						inComplexField = false;
 					}
 				} else if (commentReferenceId !== null) {
-					if (run.content.length > 0) contents.push(run);
+					if (runHoldsPayload(run)) contents.push(withOrphanFieldCharsPreserved(run, runElement));
 					contents.push({
 						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(withOrphanFieldCharsPreserved(run, runElement));
+			},
+			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": {
-				const sdtPr = findChild(child, "w", "sdtPr");
-				const sdtEndPr = findChild(child, "w", "sdtEndPr");
-				const sdtContentEl = findChild(child, "w", "sdtContent");
+			},
+			pPr: PARAGRAPH_PROPERTIES_OWNER,
+			customXml: (child) => {
+				contents.push(parseInlineWrapper(child, "customXml"));
+			},
+			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: SMART_TAG_PROPERTIES_OWNER,
+			customXmlPr: CUSTOM_XML_PROPERTIES_OWNER,
+			sdt: (child) => {
+				const sdtPr = findWordprocessingChild(child, "sdtPr");
+				const sdtEndPr = findWordprocessingChild(child, "sdtEndPr");
+				const sdtContentEl = findWordprocessingChild(child, "sdtContent");
 				if (sdtContentEl) {
 					const sdtParsed = parseParagraphContents(sdtContentEl, styles, theme, null, rels, media, trackedContext, mergeXmlnsDeclarations(inScopeXmlns, child));
+					const properties = parseSdtProperties(sdtPr, sdtEndPr);
+					const captured = captureSdtSiblingMarkers(child);
+					if (captured.before.length > 0) properties.rawSdtChildrenBeforeContent = captured.before;
+					if (captured.after.length > 0) properties.rawSdtChildrenAfterContent = captured.after;
 					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": {
-				const inner = parseParagraphContents(child, styles, theme, null, rels, media, trackedContext, mergeXmlnsDeclarations(inScopeXmlns, child));
-				contents.push(...inner);
-				break;
-			}
-			case "moveFromRangeStart":
+			},
+			smartTag: (child) => {
+				contents.push(parseInlineWrapper(child, "smartTag"));
+			},
+			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(parseInlineWrapper(child, "bdo"));
+			},
+			dir: (child) => {
+				contents.push(parseInlineWrapper(child, "dir"));
 			}
 		}
-	}
-	if (inComplexField && afterSeparator) contents.push(...complexFieldResultRuns);
-	return contents;
+	});
+	if (inComplexField) contents.push(...complexFieldOpenRuns);
+	return withPreservedChildren(contents, preserved, preservedInlineCapture);
 }
 function getCommentReferenceId(runElement) {
 	const commentReference = findChild(runElement, "w", "commentReference");
@@ -1031,6 +936,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,48 +964,51 @@ 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");
 	if (pPr) {
-		const formattingResult = parseParagraphProperties(pPr, theme, styles ?? void 0);
+		const formattingResult = parseParagraphProperties(pPr, theme);
 		if (formattingResult !== void 0) paragraph.formatting = formattingResult;
-		const propertyChangesResult = parseParagraphPropertyChanges(pPr, theme, styles, paragraph.formatting);
+		const propertyChangesResult = parseParagraphPropertyChanges(pPr, theme, paragraph.formatting);
 		if (propertyChangesResult !== void 0) paragraph.propertyChanges = propertyChangesResult;
 		const pPrMarkResult = parseParagraphMarkChange(pPr);
 		if (pPrMarkResult !== void 0) paragraph.pPrMark = pPrMarkResult;
 		const sectPr = findChild(pPr, "w", "sectPr");
 		if (sectPr) paragraph.sectionProperties = parseSectionProperties(sectPr);
 	}
-	paragraph.content = consolidateParagraphContent(parseParagraphContents(node, styles, theme, numbering, rels, media, "default", options?.rootXmlns ?? {}));
+	const rawContent = parseParagraphContents(node, styles, theme, numbering, rels, media, "default", options?.rootXmlns ?? {});
+	paragraph.content = options?.runConsolidation === "deferred" ? rawContent : consolidateParagraphContent(rawContent);
 	const paragraphFormatting = paragraph.formatting;
 	const directNumPr = paragraphFormatting?.numPr;
 	const styleNumPr = paragraphFormatting?.styleId && styles ? styles.get(paragraphFormatting.styleId)?.pPr?.numPr : void 0;
+	const numPrFromStyle = styleNumPr !== void 0 && (directNumPr === void 0 || directNumPr.kind === "levelOnly");
 	let effectiveNumPr = directNumPr;
-	let numPrFromStyle = false;
-	if (paragraphFormatting && styleNumPr && directNumPr?.numId === void 0) {
-		effectiveNumPr = {
-			...styleNumPr,
-			...directNumPr
-		};
-		numPrFromStyle = true;
-		paragraphFormatting.numPr = effectiveNumPr;
+	if (paragraphFormatting && numPrFromStyle) {
+		effectiveNumPr = mergeParagraphNumbering$1(styleNumPr, directNumPr);
+		if (effectiveNumPr !== void 0) paragraphFormatting.numPr = effectiveNumPr;
 		paragraphFormatting.numPrFromStyle = styleNumPr;
 	}
-	if (effectiveNumPr && numbering) {
-		const { numId, ilvl = 0 } = effectiveNumPr;
-		if (isNumberingReference(numId)) {
+	const resolvedNumbering = resolveParagraphNumbering$1(effectiveNumPr);
+	if (numbering) {
+		if (resolvedNumbering.kind === "reference") {
+			const { numId, ilvl } = resolvedNumbering;
 			const level = numbering.getLevel(numId, ilvl);
 			if (level) {
 				const levelNumFmts = [];
 				const levelStarts = [];
 				for (let levelIndex = 0; levelIndex <= ilvl; levelIndex += 1) {
 					const listLevel = numbering.getLevel(numId, levelIndex);
-					levelNumFmts.push(level.isLgl ? "decimal" : listLevel?.numFmt ?? "decimal");
+					levelNumFmts.push(level.isLgl || !listLevel ? "decimal" : counterFormatOf(listLevel));
 					levelStarts.push(listLevel?.start ?? 1);
 				}
 				const listRendering = {
@@ -1105,12 +1025,13 @@ function parseParagraph(node, styles, theme, numbering, rels = null, media = nul
 				if (instance?.abstractNumId !== void 0) listRendering.abstractNumId = instance.abstractNumId;
 				if (overrideForLevel?.startOverride !== void 0) listRendering.startOverride = overrideForLevel.startOverride;
 				if (level.isLgl) listRendering.isLegal = true;
-				listRendering.numFmt = level.isLgl ? "decimal" : level.numFmt;
+				listRendering.numFmt = level.isLgl ? "decimal" : counterFormatOf(level);
 				if (level.rPr?.hidden) listRendering.markerHidden = true;
 				const markerFormatting = markerFormattingFromLevel(level.rPr);
 				if (markerFormatting) listRendering.markerFormatting = markerFormatting;
 				if (level.rPr?.allCaps) listRendering.markerAllCaps = true;
-				if (level.lvlJc) listRendering.markerAlignment = level.lvlJc;
+				const markerAlignment = markerAlignmentForLevel(level.lvlJc);
+				if (markerAlignment !== void 0) listRendering.markerAlignment = markerAlignment;
 				if (level.suffix) listRendering.markerSuffix = level.suffix;
 				let implicitChildLevelAdvances = 0;
 				const foldedMarkerSuffix = [];
@@ -1155,7 +1076,7 @@ function parseParagraph(node, styles, theme, numbering, rels = null, media = nul
 				if (level.pPr) {
 					if (!paragraph.formatting) paragraph.formatting = {};
 					const directInd = pPr ? findChild(pPr, "w", "ind") : null;
-					const hasDirectLeft = directInd !== null && (getAttribute(directInd, "w", "left") !== null || getAttribute(directInd, "w", "start") !== null);
+					const hasDirectLeft = hasAttributeAnySpelling(directInd, "CT_Ind @left");
 					const directFirstLine = directInd ? parseNumericAttribute(directInd, "w", "firstLine") : void 0;
 					const directHanging = directInd ? parseNumericAttribute(directInd, "w", "hanging") : void 0;
 					const hasDirectFirstLineOrHanging = directFirstLine !== void 0 && directFirstLine !== 0 || directHanging !== void 0 && directHanging !== 0;
@@ -1205,6 +1126,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 +1147,8 @@ const getHyperlinkText = (hyperlink) => hyperlink.children.map((child) => {
 		case "run": return getRunText(child);
 		case "bookmarkStart":
 		case "bookmarkEnd": return "";
+		case "preservedInline": return child.text;
+		case "inlineWrapper": return child.content.map(getParagraphContentText).join("");
 		default: return panic(`Unsupported hyperlink child in plain-text extraction: ${JSON.stringify(child)}`);
 	}
 }).join("");
@@ -1237,10 +1161,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":
@@ -1278,7 +1203,7 @@ function isEmptyParagraph(paragraph) {
 * @returns true if paragraph has numbering properties
 */
 function isListItem(paragraph) {
-	return isNumberingReference(paragraph.formatting?.numPr?.numId);
+	return paragraphNumberingReferenceId$1(paragraph.formatting?.numPr) !== void 0;
 }
 /**
 * Get the list level of a paragraph (0-8)
@@ -1287,8 +1212,8 @@ function isListItem(paragraph) {
 * @returns List level or undefined if not a list item
 */
 function getListLevel(paragraph) {
-	if (!isListItem(paragraph)) return;
-	return paragraph.formatting?.numPr?.ilvl ?? 0;
+	const resolved = resolveParagraphNumbering$1(paragraph.formatting?.numPr);
+	return resolved.kind === "reference" ? resolved.ilvl : void 0;
 }
 /**
 * Check if paragraph has a specific style
@@ -1315,4 +1240,4 @@ function getTemplateVariable(paragraph) {
 	return text.slice(start + 2, end);
 }
 //#endregion
-export { getListLevel, getParagraphText, getTemplateVariable, hasStyle, isEmptyParagraph, isListItem, parseParagraph, parseParagraphProperties };
+export { getListLevel, getParagraphText, getTemplateVariable, hasStyle, isEmptyParagraph, isListItem, parseParagraph, parseParagraphPropertyChanges };