@stll/folio-core 0.45.0 → 0.47.0

package/dist/docx/fontTableParser.js

@@ -1,4 +1,6 @@
-import { findChild, findChildren, getAttribute, parseXmlDocument } from "./xmlParser.js";
+import { DERIVED_PART_ROOT_ATTRIBUTES, attributeRemainder } from "./attributeRemainder.js";
+import { CAPTURE, dispatchChildren } from "./containerChildren.js";
+import { getAttribute, parseXmlDocument } from "./xmlParser.js";
 //#region src/docx/fontTableParser.ts
 const FONT_FAMILIES = [
 	"decorative",
@@ -13,60 +15,119 @@ const FONT_PITCHES = [
 	"fixed",
 	"variable"
 ];
+/** `w:font` reads its name; everything else it carries is the remainder's. */
+const MODELLED_FONT_ATTRIBUTES = /* @__PURE__ */ new Set(["name"]);
 const parseFontTable = (xml) => {
 	if (!xml) return;
 	const root = parseXmlDocument(xml);
 	if (!root) return;
 	const fonts = [];
-	for (const element of findChildren(root, "w", "font")) {
-		const font = parseFont(element);
-		if (font) fonts.push(font);
-	}
-	return fonts.length > 0 ? { fonts } : void 0;
+	const preserved = dispatchChildren({
+		element: root,
+		container: "w:fonts",
+		capturePosition: () => fonts.length,
+		handlers: { font: (element) => {
+			const font = parseFont(element);
+			if (font) fonts.push(font);
+		} }
+	});
+	const preservedAttributes = attributeRemainder({
+		element: root,
+		modelled: DERIVED_PART_ROOT_ATTRIBUTES
+	});
+	if (fonts.length === 0 && preserved === void 0 && preservedAttributes === void 0) return;
+	return {
+		fonts,
+		...preserved === void 0 ? {} : { preserved },
+		...preservedAttributes === void 0 ? {} : { preservedAttributes }
+	};
 };
 const parseFont = (element) => {
 	const name = getAttribute(element, "w", "name");
 	if (!name) return;
 	const font = { name };
-	assignValue(font, "altName", childValue(element, "altName"));
-	assignValue(font, "panose1", childValue(element, "panose1"));
-	assignValue(font, "charset", childValue(element, "charset"));
-	const family = childValue(element, "family");
-	if (family && isFontFamily(family)) font.family = family;
-	const pitch = childValue(element, "pitch");
-	if (pitch && isFontPitch(pitch)) font.pitch = pitch;
-	const sig = findChild(element, "w", "sig");
-	if (sig) {
-		const parsed = {};
-		assignSignatureValue(parsed, "usb0", getAttribute(sig, "w", "usb0") ?? void 0);
-		assignSignatureValue(parsed, "usb1", getAttribute(sig, "w", "usb1") ?? void 0);
-		assignSignatureValue(parsed, "usb2", getAttribute(sig, "w", "usb2") ?? void 0);
-		assignSignatureValue(parsed, "usb3", getAttribute(sig, "w", "usb3") ?? void 0);
-		assignSignatureValue(parsed, "csb0", getAttribute(sig, "w", "csb0") ?? void 0);
-		assignSignatureValue(parsed, "csb1", getAttribute(sig, "w", "csb1") ?? void 0);
-		if (Object.values(parsed).some((value) => value !== void 0)) font.sig = parsed;
-	}
-	assignValue(font, "embedRegular", relationshipId(element, "embedRegular"));
-	assignValue(font, "embedBold", relationshipId(element, "embedBold"));
-	assignValue(font, "embedItalic", relationshipId(element, "embedItalic"));
-	assignValue(font, "embedBoldItalic", relationshipId(element, "embedBoldItalic"));
+	let modelled = 0;
+	const read = (key, value) => {
+		if (value === void 0) return;
+		font[key] = value;
+		modelled += 1;
+	};
+	const preserved = dispatchChildren({
+		element,
+		container: "w:font",
+		capturePosition: () => modelled,
+		handlers: {
+			altName: (child) => read("altName", value(child)),
+			panose1: (child) => read("panose1", value(child)),
+			charset: (child) => read("charset", charsetOf(child)),
+			family: (child) => read("family", narrow(value(child), FONT_FAMILIES)),
+			notTrueType: CAPTURE,
+			pitch: (child) => read("pitch", narrow(value(child), FONT_PITCHES)),
+			sig: (child) => read("sig", signatureOf(child)),
+			embedRegular: (child) => read("embedRegular", embedOf(child)),
+			embedBold: (child) => read("embedBold", embedOf(child)),
+			embedItalic: (child) => read("embedItalic", embedOf(child)),
+			embedBoldItalic: (child) => read("embedBoldItalic", embedOf(child))
+		}
+	});
+	if (preserved !== void 0) font.preserved = preserved;
+	const preservedAttributes = attributeRemainder({
+		element,
+		modelled: MODELLED_FONT_ATTRIBUTES
+	});
+	if (preservedAttributes !== void 0) font.preservedAttributes = preservedAttributes;
 	return font;
 };
-const childValue = (element, name) => {
-	const child = findChild(element, "w", name);
-	return child ? getAttribute(child, "w", "val") ?? void 0 : void 0;
-};
-const relationshipId = (element, name) => {
-	const child = findChild(element, "w", name);
-	return child ? getAttribute(child, "r", "id") ?? void 0 : void 0;
+const value = (element) => getAttribute(element, "w", "val") ?? void 0;
+/**
+* An empty `w:charset` is not an absent one.
+*
+* Both of `CT_Charset`'s attributes are optional, so a bare `<w:charset/>` is
+* legal and says the font uses the default code page. Reading it as nothing
+* would write it as nothing, and the document would come back saying something
+* else: the record is what carries the element's presence.
+*/
+const charsetOf = (element) => {
+	const val = value(element);
+	const characterSet = getAttribute(element, "w", "characterSet") ?? void 0;
+	return {
+		...val === void 0 ? {} : { val },
+		...characterSet === void 0 ? {} : { characterSet }
+	};
 };
-const assignValue = (font, key, value) => {
-	if (value !== void 0) font[key] = value;
+/**
+* An embedded face with no relationship points at no binary.
+*
+* Writing the element back without one would declare a face nothing can
+* resolve, so the reference is only a reference when it has an `r:id`.
+*/
+const embedOf = (element) => {
+	const id = getAttribute(element, "r", "id");
+	if (!id) return;
+	const fontKey = getAttribute(element, "w", "fontKey") ?? void 0;
+	const subsetted = getAttribute(element, "w", "subsetted");
+	return {
+		id,
+		...fontKey === void 0 ? {} : { fontKey },
+		...subsetted === null || subsetted === void 0 ? {} : { subsetted: subsetted === "true" || subsetted === "1" || subsetted === "on" }
+	};
 };
-const assignSignatureValue = (signature, key, value) => {
-	if (value !== void 0) signature[key] = value;
+const SIGNATURE_ATTRIBUTES = [
+	"usb0",
+	"usb1",
+	"usb2",
+	"usb3",
+	"csb0",
+	"csb1"
+];
+const signatureOf = (element) => {
+	const signature = {};
+	for (const attribute of SIGNATURE_ATTRIBUTES) {
+		const carried = getAttribute(element, "w", attribute);
+		if (carried !== null && carried !== void 0) signature[attribute] = carried;
+	}
+	return Object.keys(signature).length === 0 ? void 0 : signature;
 };
-const isFontFamily = (value) => FONT_FAMILIES.some((family) => family === value);
-const isFontPitch = (value) => FONT_PITCHES.some((pitch) => pitch === value);
+const narrow = (carried, members) => members.find((member) => member === carried);
 //#endregion
 export { parseFontTable };

package/dist/docx/footnoteParser.d.ts

@@ -1,7 +1,7 @@
 import { document_d_exports } from "../types/document.js";
 import { NumberingMap } from "./numberingParser.js";
-import { StyleMap } from "./styleParser.js";
 import { ParseContext } from "./parseContext.js";
+import { StyleMap } from "./styleParser.js";
 import { parseEndnoteProperties, parseFootnoteProperties } from "./notePropertiesParser.js";
 //#region src/docx/footnoteParser.d.ts
 /**

package/dist/docx/footnoteParser.js

@@ -1,9 +1,9 @@
 import { blockPlainText } from "./blockPlainText.js";
 import { parseEndnoteProperties, parseFootnoteProperties } from "./notePropertiesParser.js";
 import { parseParagraph } from "./paragraphParser.js";
-import { parseSdtProperties } from "./sdtProperties.js";
+import { captureSdtSiblingMarkers, parseSdtProperties } from "./sdtProperties.js";
 import { parseTable } from "./tableParser.js";
-import { findChild, findChildren, getAttributes, getChildElements, getLocalName, parseXml } from "./xmlParser.js";
+import { findChildren, findWordprocessingChild, getAttributes, getChildElements, getLocalName, parseXml } from "./xmlParser.js";
 import { PARSE_WARNING_CODES } from "@stll/docx-core/model";
 //#region src/docx/footnoteParser.ts
 /**
@@ -36,12 +36,16 @@ function parseNoteBlockContent(element, styles, theme, numbering, rels, media) {
 			const table = parseTable(child, styles, theme, numbering, rels, media);
 			if (table) blocks.push(table);
 		} else if (localName === "sdt") {
-			const sdtPr = findChild(child, "w", "sdtPr");
-			const sdtEndPr = findChild(child, "w", "sdtEndPr");
-			const sdtContent = findChild(child, "w", "sdtContent");
+			const sdtPr = findWordprocessingChild(child, "sdtPr");
+			const sdtEndPr = findWordprocessingChild(child, "sdtEndPr");
+			const sdtContent = findWordprocessingChild(child, "sdtContent");
+			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;
 			blocks.push({
 				type: "blockSdt",
-				properties: parseSdtProperties(sdtPr, sdtEndPr),
+				properties,
 				content: sdtContent ? parseNoteBlockContent(sdtContent, styles, theme, numbering, rels, media) : []
 			});
 		}

package/dist/docx/graphicFrameLocks.d.ts

@@ -12,11 +12,23 @@ declare const GRAPHIC_FRAME_LOCK_KEYS: ("noGrp" | "noDrilldown" | "noSelect" | "
  */
 declare const parseGraphicFrameLocks: (parent: XmlElement) => document_d_exports.ImageFrameLocks | undefined;
 /**
- * Emit the whole `wp:cNvGraphicFramePr` element for regenerated DrawingML.
+ * The locks folio gives a picture it creates itself, at the insert that creates
+ * it: Word writes `noChangeAspect="1"` on a picture inserted through its own
+ * UI, and an inserted picture should behave the same in both.
  *
- * Absent locks mean no authored frame was ever parsed (a Folio-created
- * picture), which keeps the historical `noChangeAspect="1"`.
+ * It lives here because it is a fact about this element, and it is applied at
+ * construction rather than at serialization, where "the author wrote no frame"
+ * and "folio made this picture" are the same `undefined`.
+ */
+declare const FOLIO_INSERTED_PICTURE_FRAME_LOCKS: document_d_exports.ImageFrameLocks;
+/**
+ * Emit `wp:cNvGraphicFramePr` for regenerated DrawingML, or nothing.
+ *
+ * Absent locks are the author's silence, and silence is written back as
+ * silence: a frame the source never carried is not invented on the rebuild
+ * path, where it would appear on every edited document and on none of the
+ * replayed ones.
  */
 declare const serializeGraphicFrameLocks: (locks: document_d_exports.ImageFrameLocks | undefined) => string;
 //#endregion
-export { GRAPHIC_FRAME_LOCK_KEYS, parseGraphicFrameLocks, serializeGraphicFrameLocks };
+export { FOLIO_INSERTED_PICTURE_FRAME_LOCKS, GRAPHIC_FRAME_LOCK_KEYS, parseGraphicFrameLocks, serializeGraphicFrameLocks };

package/dist/docx/graphicFrameLocks.js

@@ -38,18 +38,31 @@ const parseGraphicFrameLocks = (parent) => {
 	return present ? locks : void 0;
 };
 /**
-* Emit the whole `wp:cNvGraphicFramePr` element for regenerated DrawingML.
+* The locks folio gives a picture it creates itself, at the insert that creates
+* it: Word writes `noChangeAspect="1"` on a picture inserted through its own
+* UI, and an inserted picture should behave the same in both.
 *
-* Absent locks mean no authored frame was ever parsed (a Folio-created
-* picture), which keeps the historical `noChangeAspect="1"`.
+* It lives here because it is a fact about this element, and it is applied at
+* construction rather than at serialization, where "the author wrote no frame"
+* and "folio made this picture" are the same `undefined`.
+*/
+const FOLIO_INSERTED_PICTURE_FRAME_LOCKS = { noChangeAspect: true };
+/**
+* Emit `wp:cNvGraphicFramePr` for regenerated DrawingML, or nothing.
+*
+* Absent locks are the author's silence, and silence is written back as
+* silence: a frame the source never carried is not invented on the rebuild
+* path, where it would appear on every edited document and on none of the
+* replayed ones.
 */
 const serializeGraphicFrameLocks = (locks) => {
-	const attrs = locks ? GRAPHIC_FRAME_LOCK_KEYS.flatMap((key) => {
+	if (!locks) return "";
+	const attrs = GRAPHIC_FRAME_LOCK_KEYS.flatMap((key) => {
 		const value = locks[key];
 		return value === void 0 ? [] : [`${GRAPHIC_FRAME_LOCK_ATTRIBUTES[key]}="${value ? "1" : "0"}"`];
-	}) : ["noChangeAspect=\"1\""];
+	});
 	const attrList = attrs.length > 0 ? ` ${attrs.join(" ")}` : "";
 	return `<wp:cNvGraphicFramePr><a:graphicFrameLocks ${DRAWINGML_NAMESPACE}${attrList}/></wp:cNvGraphicFramePr>`;
 };
 //#endregion
-export { GRAPHIC_FRAME_LOCK_KEYS, parseGraphicFrameLocks, serializeGraphicFrameLocks };
+export { FOLIO_INSERTED_PICTURE_FRAME_LOCKS, GRAPHIC_FRAME_LOCK_KEYS, parseGraphicFrameLocks, serializeGraphicFrameLocks };

package/dist/docx/groupDrawingParser.js

@@ -1,5 +1,6 @@
 import { emuToPixels } from "../utils/units.js";
 import { parseImage, resolveImageData } from "./imageParser.js";
+import { PREVIEW_KINDS } from "./previewBudget.js";
 import { findAllDeep, findChildByLocalName, findChildrenByLocalName, getAttribute, getChildElements, getLocalName, getTextContent, parseNumericAttribute } from "./xmlParser.js";
 import { escapeXmlAttribute, escapeXmlText } from "@stll/docx-core";
 //#region src/docx/groupDrawingParser.ts
@@ -182,9 +183,9 @@ const parseGroupDrawing = (drawing, rels, media) => {
 	if (!image || image.size.width <= 0 || image.size.height <= 0) return null;
 	const svg = createSvg(group, image.size.width, image.size.height, rels, media);
 	if (!svg || svg.length > MAX_SVG_CHARACTERS) return null;
-	image.src = `data:image/svg+xml;charset=utf-8,${encodeURIComponent(svg)}`;
-	image.mimeType = "image/svg+xml";
-	image.filename = "wordprocessing-group.svg";
+	image.src = `${PREVIEW_KINDS.wpGroup.srcPrefix}${encodeURIComponent(svg)}`;
+	image.mimeType = PREVIEW_KINDS.wpGroup.mimeType;
+	image.filename = PREVIEW_KINDS.wpGroup.filename;
 	return image;
 };
 //#endregion

package/dist/docx/headerFooterParser.js

@@ -155,7 +155,7 @@ function getHeaderFooterText(hf) {
 function isEmptyHeaderFooter(hf) {
 	if (hf.content.length === 0) return true;
 	for (const item of hf.content) {
-		if (item.type === "table") return false;
+		if (item.type !== "paragraph") return false;
 		if (item.content.length > 0) for (const content of item.content) {
 			if (content.type !== "run") return false;
 			for (const rc of content.content) {

package/dist/docx/headerFooterReferenceNormalization.js

@@ -38,6 +38,7 @@ const normalizeHeaderFooterReferences = ({ documentBody, headers, footers }) =>
 			normalizeTable(block);
 			return;
 		}
+		if (block.type !== "blockSdt") return;
 		normalizeBlocks(block.content);
 	};
 	const normalizeBlocks = (blocks) => {

package/dist/docx/hyperlinkParser.d.ts

@@ -1,6 +1,6 @@
 import { document_d_exports } from "../types/document.js";
-import { StyleMap } from "./styleParser.js";
 import { XmlElement } from "./xmlParser.js";
+import { StyleMap } from "./styleParser.js";
 //#region src/docx/hyperlinkParser.d.ts
 /**
  * Parse a hyperlink element (w:hyperlink)
@@ -16,14 +16,67 @@ import { XmlElement } from "./xmlParser.js";
  * @returns Parsed Hyperlink object
  */
 declare function parseHyperlink(node: XmlElement, rels: document_d_exports.RelationshipMap | null, styles?: StyleMap | null, theme?: document_d_exports.Theme | null, media?: Map<string, document_d_exports.MediaFile> | null, rootXmlns?: Record<string, string>): document_d_exports.Hyperlink;
+/** What {@link hyperlinkChildHandlers} needs to read one child of a link. */
+type HyperlinkChildContext = {
+  /** Where a parsed or captured child lands, in source order. */
+  push: (child: document_d_exports.Hyperlink["children"][number]) => void;
+  styles: StyleMap | null;
+  theme: document_d_exports.Theme | null;
+  rels: document_d_exports.RelationshipMap | null;
+  media: Map<string, document_d_exports.MediaFile> | null;
+  inScopeXmlns: Record<string, string>;
+};
 /**
- * One `w:hyperlink` child, or `null` for markup the model does not carry.
- *
- * Exposed so a caller that has to segment a hyperlink — one holding revision
- * wrappers, which the model nests the other way round — parses its plain
- * children exactly as {@link parseHyperlink} does.
+ * What a `w:hyperlink` does with every child its content model declares.
+ *
+ * `CT_Hyperlink` is `EG_PContent`, so a link may hold a permission range, a
+ * proofing error, a nested field or one of the eight custom-XML revision
+ * ranges between its runs; folio models three of the thirty-two names and
+ * used to drop the other twenty-nine off the end of a `switch`.
+ *
+ * Three callers read this one map: {@link parseHyperlink}, the paragraph
+ * parser's revision-segmenting walk, which overrides the four
+ * `CT_RunTrackChange` wrappers because OOXML nests a revision inside a link
+ * and the model nests the link inside the revision, and
+ * {@link parseLinkedInlineWrapper}, which walks a transparent wrapper the link
+ * holds. Everything else is decided here once, so a child one caller starts
+ * recognising is recognised by all of them rather than by whichever list
+ * somebody remembered to update.
  */
-declare function parseHyperlinkChild(node: XmlElement, styles: StyleMap | null, theme: document_d_exports.Theme | null, rels: document_d_exports.RelationshipMap | null, media: Map<string, document_d_exports.MediaFile> | null, inScopeXmlns: Record<string, string>): document_d_exports.Hyperlink["children"][number] | null;
+declare const hyperlinkChildHandlers: (context: HyperlinkChildContext) => {
+  r: (child: XmlElement) => void;
+  bookmarkStart: (child: XmlElement) => void;
+  bookmarkEnd: (child: XmlElement) => void;
+  bdo: (child: XmlElement) => void;
+  dir: (child: XmlElement) => void;
+  customXml: (child: XmlElement) => void;
+  smartTag: (child: XmlElement) => void;
+  del: "capture";
+  ins: "capture";
+  moveFrom: "capture";
+  moveTo: "capture";
+  commentRangeEnd: "capture";
+  commentRangeStart: "capture";
+  customXmlDelRangeEnd: "capture";
+  customXmlDelRangeStart: "capture";
+  customXmlInsRangeEnd: "capture";
+  customXmlInsRangeStart: "capture";
+  customXmlMoveFromRangeEnd: "capture";
+  customXmlMoveFromRangeStart: "capture";
+  customXmlMoveToRangeEnd: "capture";
+  customXmlMoveToRangeStart: "capture";
+  fldSimple: (child: XmlElement) => void;
+  hyperlink: (child: XmlElement) => void;
+  moveFromRangeEnd: "capture";
+  moveFromRangeStart: "capture";
+  moveToRangeEnd: "capture";
+  moveToRangeStart: "capture";
+  permEnd: "capture";
+  permStart: "capture";
+  proofErr: "capture";
+  sdt: "capture";
+  subDoc: "capture";
+};
 /**
  * Get the display text of a hyperlink
  *
@@ -66,7 +119,11 @@ declare function getHyperlinkUrl(hyperlink: document_d_exports.Hyperlink): strin
  */
 declare function hasContent(hyperlink: document_d_exports.Hyperlink): boolean;
 /**
- * Get all runs from a hyperlink
+ * Get all runs from a hyperlink, including those inside a transparent wrapper
+ *
+ * A `w:bdo`, `w:dir`, `w:smartTag` or run-level `w:customXml` says how the
+ * linked text is laid out or what it is tagged as, never that it is not the
+ * link's text, so the walk goes through it.
  *
  * @param hyperlink - Parsed Hyperlink object
  * @returns Array of Run objects
@@ -112,4 +169,4 @@ declare function createExternalHyperlink(url: string, children: document_d_expor
   target?: string;
 }): document_d_exports.Hyperlink;
 //#endregion
-export { createExternalHyperlink, createInternalHyperlink, getHyperlinkRuns, getHyperlinkText, getHyperlinkUrl, hasContent, isExternalLink, isInternalLink, parseHyperlink, parseHyperlinkChild, resolveHyperlinkUrl };
+export { HyperlinkChildContext, createExternalHyperlink, createInternalHyperlink, getHyperlinkRuns, getHyperlinkText, getHyperlinkUrl, hasContent, hyperlinkChildHandlers, isExternalLink, isInternalLink, parseHyperlink, resolveHyperlinkUrl };

package/dist/docx/hyperlinkParser.js

@@ -1,7 +1,11 @@
 import { sanitizeExternalUrl } from "../utils/urlSecurity.js";
+import { CAPTURE, dispatchChildren, ownedElsewhere, withPreservedChildren } from "./containerChildren.js";
+import { inlineWrapperOf } from "./inlineWrapperParser.js";
+import { preserveInlineChild, preservedInlineCapture } from "./preservedRunContent.js";
 import { RELATIONSHIP_TYPES, resolveRelationshipIdOfType } from "./relsParser.js";
 import { parseRun } from "./runParser.js";
-import { getAttribute, getChildElements, getLocalName, mergeXmlnsDeclarations, parseNumericAttribute, parseOnOffAttribute } from "./xmlParser.js";
+import { runHoldsPayload } from "./runPayload.js";
+import { getAttribute, mergeXmlnsDeclarations, parseNumericAttribute, parseOnOffAttribute } from "./xmlParser.js";
 //#region src/docx/hyperlinkParser.ts
 /**
 * Parse bookmark start (w:bookmarkStart)
@@ -64,31 +68,141 @@ function parseHyperlink(node, rels, styles = null, theme = null, media = null, r
 	if (tooltip) hyperlink.tooltip = tooltip;
 	const tgtFrame = getAttribute(node, "w", "tgtFrame");
 	if (tgtFrame) hyperlink.target = tgtFrame;
-	if (parseOnOffAttribute(node, "w", "history") === true) hyperlink.history = true;
+	const history = parseOnOffAttribute(node, "w", "history");
+	if (history !== void 0) hyperlink.history = history;
 	const docLocation = getAttribute(node, "w", "docLocation");
 	if (docLocation) hyperlink.docLocation = docLocation;
 	const inScopeXmlns = mergeXmlnsDeclarations(rootXmlns, node);
-	for (const child of getChildElements(node)) {
-		const parsed = parseHyperlinkChild(child, styles, theme, rels, media, inScopeXmlns);
-		if (parsed) hyperlink.children.push(parsed);
-	}
+	const children = [];
+	hyperlink.children = withPreservedChildren(children, dispatchChildren({
+		element: node,
+		container: "w:hyperlink",
+		capturePosition: () => children.length,
+		handlers: hyperlinkChildHandlers({
+			push: (child) => {
+				children.push(child);
+			},
+			styles,
+			theme,
+			rels,
+			media,
+			inScopeXmlns
+		})
+	}), preservedInlineCapture);
 	return hyperlink;
 }
 /**
-* One `w:hyperlink` child, or `null` for markup the model does not carry.
+* What a `w:hyperlink` does with every child its content model declares.
+*
+* `CT_Hyperlink` is `EG_PContent`, so a link may hold a permission range, a
+* proofing error, a nested field or one of the eight custom-XML revision
+* ranges between its runs; folio models three of the thirty-two names and
+* used to drop the other twenty-nine off the end of a `switch`.
 *
-* Exposed so a caller that has to segment a hyperlink — one holding revision
-* wrappers, which the model nests the other way round — parses its plain
-* children exactly as {@link parseHyperlink} does.
+* Three callers read this one map: {@link parseHyperlink}, the paragraph
+* parser's revision-segmenting walk, which overrides the four
+* `CT_RunTrackChange` wrappers because OOXML nests a revision inside a link
+* and the model nests the link inside the revision, and
+* {@link parseLinkedInlineWrapper}, which walks a transparent wrapper the link
+* holds. Everything else is decided here once, so a child one caller starts
+* recognising is recognised by all of them rather than by whichever list
+* somebody remembered to update.
 */
-function parseHyperlinkChild(node, styles, theme, rels, media, inScopeXmlns) {
-	switch (getLocalName(node.name)) {
-		case "r": return parseRun(node, styles, theme, rels, media, inScopeXmlns);
-		case "bookmarkStart": return parseBookmarkStart(node);
-		case "bookmarkEnd": return parseBookmarkEnd(node);
-		default: return null;
-	}
-}
+const hyperlinkChildHandlers = (context) => {
+	const { push, styles, theme, rels, media, inScopeXmlns } = context;
+	const wrapper = (element) => (child) => {
+		push(parseLinkedInlineWrapper(element, child, context));
+	};
+	return {
+		r: (child) => {
+			const run = parseRun(child, styles, theme, rels, media, inScopeXmlns);
+			if (runHoldsPayload(run)) push(run);
+		},
+		bookmarkStart: (child) => {
+			push(parseBookmarkStart(child));
+		},
+		bookmarkEnd: (child) => {
+			push(parseBookmarkEnd(child));
+		},
+		bdo: wrapper("bdo"),
+		dir: wrapper("dir"),
+		customXml: wrapper("customXml"),
+		smartTag: wrapper("smartTag"),
+		del: CAPTURE,
+		ins: CAPTURE,
+		moveFrom: CAPTURE,
+		moveTo: CAPTURE,
+		commentRangeEnd: CAPTURE,
+		commentRangeStart: CAPTURE,
+		customXmlDelRangeEnd: CAPTURE,
+		customXmlDelRangeStart: CAPTURE,
+		customXmlInsRangeEnd: CAPTURE,
+		customXmlInsRangeStart: CAPTURE,
+		customXmlMoveFromRangeEnd: CAPTURE,
+		customXmlMoveFromRangeStart: CAPTURE,
+		customXmlMoveToRangeEnd: CAPTURE,
+		customXmlMoveToRangeStart: CAPTURE,
+		fldSimple: (child) => {
+			push(preserveInlineChild(child));
+		},
+		hyperlink: (child) => {
+			push(preserveInlineChild(child));
+		},
+		moveFromRangeEnd: CAPTURE,
+		moveFromRangeStart: CAPTURE,
+		moveToRangeEnd: CAPTURE,
+		moveToRangeStart: CAPTURE,
+		permEnd: CAPTURE,
+		permStart: CAPTURE,
+		proofErr: CAPTURE,
+		sdt: CAPTURE,
+		subDoc: CAPTURE
+	};
+};
+const LINKED_SMART_TAG_PROPERTIES_OWNER = ownedElsewhere({
+	container: "run-level-content",
+	child: "smartTagPr",
+	reader: "inlineWrapperParser#inlineWrapperOf"
+});
+const LINKED_CUSTOM_XML_PROPERTIES_OWNER = ownedElsewhere({
+	container: "run-level-content",
+	child: "customXmlPr",
+	reader: "inlineWrapperParser#inlineWrapperOf"
+});
+/**
+* A transparent wrapper a link holds, with the content the link would hold.
+*
+* `CT_BdoContentRun` and its three siblings are `EG_PContent`, the group
+* `CT_Hyperlink` is, so the wrapper's declared children are run-level content
+* and the decision per child is the link's own map. That is what keeps the two
+* from drifting: a `w:ins` inside a `w:bdo` inside a link is captured for the
+* same reason a `w:ins` directly inside the link is.
+*
+* The wrapper's own `w:smartTagPr` / `w:customXmlPr` is read by
+* {@link inlineWrapperOf}, so it is declared owned here rather than captured a
+* second time by the sink.
+*/
+const parseLinkedInlineWrapper = (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: {
+			...hyperlinkChildHandlers({
+				...context,
+				inScopeXmlns,
+				push: (child) => {
+					content.push(child);
+				}
+			}),
+			customXmlPr: LINKED_CUSTOM_XML_PROPERTIES_OWNER,
+			smartTagPr: LINKED_SMART_TAG_PROPERTIES_OWNER,
+			pPr: CAPTURE
+		}
+	}), preservedInlineCapture));
+};
 /**
 * Get the display text of a hyperlink
 *
@@ -99,10 +213,8 @@ function parseHyperlinkChild(node, styles, theme, rels, media, inScopeXmlns) {
 */
 function getHyperlinkText(hyperlink) {
 	let text = "";
-	for (const child of hyperlink.children) if (child.type === "run") {
-		for (const content of child.content) if (content.type === "text") text += content.text;
-		else if (content.type === "tab") text += "	";
-	}
+	for (const run of getHyperlinkRuns(hyperlink)) for (const content of run.content) if (content.type === "text") text += content.text;
+	else if (content.type === "tab") text += "	";
 	return text;
 }
 /**
@@ -144,16 +256,31 @@ function getHyperlinkUrl(hyperlink) {
 * @returns true if hyperlink has child runs
 */
 function hasContent(hyperlink) {
-	return hyperlink.children.some((child) => child.type === "run");
+	return getHyperlinkRuns(hyperlink).length > 0;
 }
 /**
-* Get all runs from a hyperlink
+* Get all runs from a hyperlink, including those inside a transparent wrapper
+*
+* A `w:bdo`, `w:dir`, `w:smartTag` or run-level `w:customXml` says how the
+* linked text is laid out or what it is tagged as, never that it is not the
+* link's text, so the walk goes through it.
 *
 * @param hyperlink - Parsed Hyperlink object
 * @returns Array of Run objects
 */
 function getHyperlinkRuns(hyperlink) {
-	return hyperlink.children.filter((child) => child.type === "run");
+	const runs = [];
+	const collect = (items) => {
+		for (const item of items) {
+			if (item.type === "run") {
+				runs.push(item);
+				continue;
+			}
+			if (item.type === "inlineWrapper") collect(item.content);
+		}
+	};
+	collect(hyperlink.children);
+	return runs;
 }
 /**
 * Resolve a hyperlink's rId to a URL using a relationship map
@@ -219,4 +346,4 @@ function createExternalHyperlink(url, children, options) {
 	};
 }
 //#endregion
-export { createExternalHyperlink, createInternalHyperlink, getHyperlinkRuns, getHyperlinkText, getHyperlinkUrl, hasContent, isExternalLink, isInternalLink, parseHyperlink, parseHyperlinkChild, resolveHyperlinkUrl };
+export { createExternalHyperlink, createInternalHyperlink, getHyperlinkRuns, getHyperlinkText, getHyperlinkUrl, hasContent, hyperlinkChildHandlers, isExternalLink, isInternalLink, parseHyperlink, resolveHyperlinkUrl };