@stll/folio-core 0.46.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.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/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/headerFooterReferenceNormalization.js

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

package/dist/docx/hyperlinkParser.d.ts

@@ -1,7 +1,6 @@
 import { document_d_exports } from "../types/document.js";
 import { XmlElement } from "./xmlParser.js";
 import { StyleMap } from "./styleParser.js";
-import { ChildHandlers } from "./containerChildren.js";
 //#region src/docx/hyperlinkParser.d.ts
 /**
  * Parse a hyperlink element (w:hyperlink)
@@ -35,14 +34,49 @@ type HyperlinkChildContext = {
  * 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`.
  *
- * Two callers read this one map: {@link parseHyperlink}, and the paragraph
+ * 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. Everything else is
- * decided here once, so a child one caller starts recognising is recognised
- * by both rather than by whichever list somebody remembered to update.
+ * 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 const hyperlinkChildHandlers: ({ push, styles, theme, rels, media, inScopeXmlns }: HyperlinkChildContext) => ChildHandlers<"w:hyperlink">;
+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
  *
@@ -85,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

package/dist/docx/hyperlinkParser.js

@@ -1,8 +1,10 @@
 import { sanitizeExternalUrl } from "../utils/urlSecurity.js";
-import { CAPTURE, dispatchChildren, withPreservedChildren } from "./containerChildren.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 { runHoldsPayload } from "./runPayload.js";
 import { getAttribute, mergeXmlnsDeclarations, parseNumericAttribute, parseOnOffAttribute } from "./xmlParser.js";
 //#region src/docx/hyperlinkParser.ts
 /**
@@ -66,7 +68,8 @@ 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);
@@ -74,7 +77,7 @@ function parseHyperlink(node, rels, styles = null, theme = null, media = null, r
 	hyperlink.children = withPreservedChildren(children, dispatchChildren({
 		element: node,
 		container: "w:hyperlink",
-		modelledCount: () => children.length,
+		capturePosition: () => children.length,
 		handlers: hyperlinkChildHandlers({
 			push: (child) => {
 				children.push(child);
@@ -96,58 +99,111 @@ function parseHyperlink(node, rels, styles = null, theme = null, media = null, r
 * 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`.
 *
-* Two callers read this one map: {@link parseHyperlink}, and the paragraph
+* 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. Everything else is
-* decided here once, so a child one caller starts recognising is recognised
-* by both rather than by whichever list somebody remembered to update.
+* 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.
 */
-const hyperlinkChildHandlers = ({ push, styles, theme, rels, media, inScopeXmlns }) => ({
-	r: (child) => {
-		push(parseRun(child, styles, theme, rels, media, inScopeXmlns));
-	},
-	bookmarkStart: (child) => {
-		push(parseBookmarkStart(child));
-	},
-	bookmarkEnd: (child) => {
-		push(parseBookmarkEnd(child));
-	},
-	customXml: (child) => {
-		push(preserveInlineChild(child));
-	},
-	smartTag: (child) => {
-		push(preserveInlineChild(child));
-	},
-	del: CAPTURE,
-	ins: CAPTURE,
-	moveFrom: CAPTURE,
-	moveTo: CAPTURE,
-	bdo: CAPTURE,
-	commentRangeEnd: CAPTURE,
-	commentRangeStart: CAPTURE,
-	customXmlDelRangeEnd: CAPTURE,
-	customXmlDelRangeStart: CAPTURE,
-	customXmlInsRangeEnd: CAPTURE,
-	customXmlInsRangeStart: CAPTURE,
-	customXmlMoveFromRangeEnd: CAPTURE,
-	customXmlMoveFromRangeStart: CAPTURE,
-	customXmlMoveToRangeEnd: CAPTURE,
-	customXmlMoveToRangeStart: CAPTURE,
-	dir: CAPTURE,
-	fldSimple: CAPTURE,
-	hyperlink: CAPTURE,
-	moveFromRangeEnd: CAPTURE,
-	moveFromRangeStart: CAPTURE,
-	moveToRangeEnd: CAPTURE,
-	moveToRangeStart: CAPTURE,
-	permEnd: CAPTURE,
-	permStart: CAPTURE,
-	proofErr: CAPTURE,
-	sdt: CAPTURE,
-	subDoc: CAPTURE
+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
 *
 * Concatenates text from all child runs.
@@ -157,10 +213,8 @@ const hyperlinkChildHandlers = ({ push, 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;
 }
 /**
@@ -202,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