@stll/folio-core 0.45.0 → 0.47.0

package/dist/docx/paragraphProperties.d.ts

@@ -0,0 +1,23 @@
+import { document_d_exports } from "../types/document.js";
+import { XmlElement } from "./xmlParser.js";
+//#region src/docx/paragraphProperties.d.ts
+/**
+ * Read `w:pPr` into {@link ParagraphFormatting}, every declared child carrying
+ * a decision.
+ *
+ * One reader serves all four owners of the set — a paragraph's own properties,
+ * the `CT_PPrGeneral` a style carries, a numbering level's, and the
+ * `CT_PPrBase` snapshot inside `w:pPrChange` — so a property is read the same
+ * way wherever it was authored, and the handler map is total over the content
+ * model rather than over whichever names a `switch` happened to list.
+ *
+ * Three children belong to other readers and are neither modelled nor captured
+ * here, because capturing one as well would write it twice: `w:sectPr` is read
+ * by the section parser off the paragraph, `w:pPrChange` by the
+ * property-change parser, and `w:rPr` is the paragraph mark's own property
+ * set, read below off the element for the same reason a run's is read off the
+ * run.
+ */
+declare function parseParagraphProperties(pPr: XmlElement | null, theme: document_d_exports.Theme | null): document_d_exports.ParagraphFormatting | undefined;
+//#endregion
+export { parseParagraphProperties };

package/dist/docx/paragraphProperties.js

@@ -0,0 +1,279 @@
+import { readAttributeBag } from "./attributeRemainder.js";
+import { parseBorderSpec } from "./borderParser.js";
+import { CAPTURE, dispatchChildren, ownedElsewhere, sequencePositions } from "./containerChildren.js";
+import { readParagraphNumbering } from "./numberingReference.js";
+import { FrameWrapSchema, FrameXAlignSchema, FrameYAlignSchema, LineSpacingRuleSchema, ParagraphAlignmentSchema, TabLeaderSchema, TabStopAlignmentSchema, narrowEnum } from "./parserEnums.js";
+import { FRAME_ATTRIBUTES, INDENTATION_ATTRIBUTES, SPACING_ATTRIBUTES, TAB_STOP_ATTRIBUTES } from "./propertyElementAttributes.js";
+import { RUN_PROPERTY_OWNERS, parseRunProperties } from "./runParser.js";
+import { parseShading } from "./shadingParser.js";
+import { numericAttributeAnySpelling } from "./strictNames.js";
+import { captureVerbatimXml } from "./verbatimCapture.js";
+import { findChild, findChildren, getAttribute, parseBooleanElement, parseNumericAttribute, parseOnOffAttribute, parseOnOffChild } from "./xmlParser.js";
+import { outlineLevelFromStatedValue } from "@stll/docx-core/model";
+//#region src/docx/paragraphProperties.ts
+/**
+* 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;
+			const preservedAttributes = readAttributeBag(tab, TAB_STOP_ATTRIBUTES);
+			if (preservedAttributes) tabStop.preservedAttributes = preservedAttributes;
+			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;
+	if (Object.keys(frame).length === 0) return;
+	const preservedAttributes = readAttributeBag(framePr, FRAME_ATTRIBUTES);
+	if (preservedAttributes) frame.preservedAttributes = preservedAttributes;
+	return frame;
+}
+/**
+* Read `w:pPr` into {@link ParagraphFormatting}, every declared child carrying
+* a decision.
+*
+* One reader serves all four owners of the set — a paragraph's own properties,
+* the `CT_PPrGeneral` a style carries, a numbering level's, and the
+* `CT_PPrBase` snapshot inside `w:pPrChange` — so a property is read the same
+* way wherever it was authored, and the handler map is total over the content
+* model rather than over whichever names a `switch` happened to list.
+*
+* Three children belong to other readers and are neither modelled nor captured
+* here, because capturing one as well would write it twice: `w:sectPr` is read
+* by the section parser off the paragraph, `w:pPrChange` by the
+* property-change parser, and `w:rPr` is the paragraph mark's own property
+* set, read below off the element for the same reason a run's is read off the
+* run.
+*/
+function parseParagraphProperties(pPr, theme) {
+	if (!pPr) return;
+	const formatting = {};
+	const taken = /* @__PURE__ */ new Set();
+	const once = (name, read) => (child) => {
+		if (taken.has(name) || !read(child)) return CAPTURE;
+		taken.add(name);
+	};
+	const toggle = (name, field) => once(name, (child) => {
+		formatting[field] = parseBooleanElement(child);
+		return true;
+	});
+	const preserved = dispatchChildren({
+		element: pPr,
+		container: "paragraph-properties",
+		capturePosition: sequencePositions("paragraph-properties", pPr),
+		handlers: {
+			pStyle: once("pStyle", (child) => {
+				const val = getAttribute(child, "w", "val");
+				if (!val) return false;
+				formatting.styleId = val;
+				return true;
+			}),
+			keepNext: toggle("keepNext", "keepNext"),
+			keepLines: toggle("keepLines", "keepLines"),
+			pageBreakBefore: toggle("pageBreakBefore", "pageBreakBefore"),
+			framePr: once("framePr", (child) => {
+				const frame = parseFrameProperties(child);
+				if (frame === void 0) return false;
+				formatting.frame = frame;
+				return true;
+			}),
+			widowControl: toggle("widowControl", "widowControl"),
+			numPr: once("numPr", (child) => {
+				const stated = readParagraphNumbering(child);
+				if (stated !== void 0) formatting.numPr = stated;
+				const numberingChange = findChild(child, "w", "numberingChange");
+				if (numberingChange) formatting.numberingChangeXml = captureVerbatimXml(numberingChange);
+				const statedLevel = parseNumericAttribute(findChild(child, "w", "ilvl"), "w", "val");
+				return stated !== void 0 || numberingChange !== null || statedLevel === -1;
+			}),
+			suppressLineNumbers: toggle("suppressLineNumbers", "suppressLineNumbers"),
+			pBdr: once("pBdr", (child) => {
+				const borders = {};
+				for (const side of PARAGRAPH_BORDER_SIDES) {
+					const border = parseBorderSpec(findChild(child, "w", side));
+					if (border) borders[side] = border;
+				}
+				if (Object.keys(borders).length === 0) return false;
+				formatting.borders = borders;
+				return true;
+			}),
+			shd: once("shd", (child) => {
+				const shading = parseShading(child);
+				if (shading === void 0) return false;
+				formatting.shading = shading;
+				return true;
+			}),
+			tabs: once("tabs", (child) => {
+				const tabs = parseTabStops(child);
+				if (tabs === void 0) return false;
+				formatting.tabs = tabs;
+				return true;
+			}),
+			suppressAutoHyphens: toggle("suppressAutoHyphens", "suppressAutoHyphens"),
+			kinsoku: toggle("kinsoku", "kinsoku"),
+			wordWrap: CAPTURE,
+			overflowPunct: toggle("overflowPunct", "overflowPunctuation"),
+			topLinePunct: CAPTURE,
+			autoSpaceDE: CAPTURE,
+			autoSpaceDN: CAPTURE,
+			bidi: toggle("bidi", "bidi"),
+			adjustRightInd: CAPTURE,
+			snapToGrid: toggle("snapToGrid", "snapToGrid"),
+			spacing: once("spacing", (child) => readParagraphSpacing(child, formatting)),
+			ind: once("ind", (child) => readParagraphIndentation(child, formatting)),
+			contextualSpacing: toggle("contextualSpacing", "contextualSpacing"),
+			mirrorIndents: CAPTURE,
+			suppressOverlap: CAPTURE,
+			jc: once("jc", (child) => {
+				const val = narrowEnum(getAttribute(child, "w", "val"), ParagraphAlignmentSchema);
+				if (!val) return false;
+				formatting.alignment = val;
+				return true;
+			}),
+			textDirection: CAPTURE,
+			textAlignment: CAPTURE,
+			textboxTightWrap: CAPTURE,
+			outlineLvl: once("outlineLvl", (child) => {
+				const val = parseNumericAttribute(child, "w", "val");
+				const level = val === void 0 ? void 0 : outlineLevelFromStatedValue(val);
+				if (level === void 0) return val === -1;
+				formatting.outlineLevel = level;
+				return true;
+			}),
+			divId: CAPTURE,
+			cnfStyle: CAPTURE,
+			rPr: ownedElsewhere({
+				container: "paragraph-properties",
+				child: "rPr",
+				reader: "paragraphProperties#parseParagraphProperties"
+			}),
+			sectPr: ownedElsewhere({
+				container: "paragraph-properties",
+				child: "sectPr",
+				reader: "sectionParser#parseSectionProperties"
+			}),
+			pPrChange: ownedElsewhere({
+				container: "paragraph-properties",
+				child: "pPrChange",
+				reader: "paragraphParser#parseParagraphPropertyChanges"
+			})
+		}
+	});
+	const rPr = findChild(pPr, "w", "rPr");
+	if (rPr) {
+		const runPropsResult = parseRunProperties(rPr, theme, RUN_PROPERTY_OWNERS.paragraphMark);
+		if (runPropsResult !== void 0) formatting.runProperties = runPropsResult;
+		const specVanish = parseOnOffChild(rPr, "w", "specVanish");
+		if (specVanish !== void 0) formatting.runInWithNext = specVanish;
+	}
+	if (preserved) formatting.preserved = preserved;
+	return Object.keys(formatting).length > 0 ? formatting : void 0;
+}
+/** `w:pBdr`'s sides, in the order `CT_PBdr` declares them. */
+const PARAGRAPH_BORDER_SIDES = [
+	"top",
+	"left",
+	"bottom",
+	"right",
+	"between",
+	"bar"
+];
+/**
+* `w:spacing`, which states up to six independent values.
+*
+* @returns whether any of them was taken; an element that states none keeps
+*   its bytes instead, because a `<w:spacing/>` the model cannot rebuild is
+*   markup the author wrote.
+*/
+const readParagraphSpacing = (spacing, formatting) => {
+	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;
+	if (!(before !== void 0 || after !== void 0 || line !== void 0 || lineRule !== void 0 || beforeAutospacing !== void 0 || afterAutospacing !== void 0)) return false;
+	const preservedAttributes = readAttributeBag(spacing, SPACING_ATTRIBUTES);
+	if (preservedAttributes) formatting.spacingPreservedAttributes = preservedAttributes;
+	return true;
+};
+/**
+* `w:ind`. `w:start`/`w:end` are the Strict spellings of `w:left`/`w:right`,
+* so they fill the same fields when the Transitional pair is absent.
+*
+* @returns whether any indent was taken.
+*/
+const readParagraphIndentation = (ind, formatting) => {
+	const left = numericAttributeAnySpelling(ind, "CT_Ind @left");
+	if (left !== void 0) formatting.indentLeft = left;
+	const right = numericAttributeAnySpelling(ind, "CT_Ind @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;
+	}
+	if (!(left !== void 0 || right !== void 0 || firstLine !== void 0 || hanging !== void 0)) return false;
+	const preservedAttributes = readAttributeBag(ind, INDENTATION_ATTRIBUTES);
+	if (preservedAttributes) formatting.indentPreservedAttributes = preservedAttributes;
+	return true;
+};
+//#endregion
+export { parseParagraphProperties };

package/dist/docx/paragraphPropertySource.js

@@ -261,11 +261,14 @@ const invalidTableCellParagraphSourcePayload = (classification, path) => {
 };
 const tableCellBlockTraversalByType = {
 	blockSdt: "blockSdt",
+	bookmarkEnd: "leaf",
+	bookmarkStart: "leaf",
 	paragraph: "paragraph",
+	preservedBlock: "leaf",
 	table: "table"
 };
 const tableCellParagraphContentTraversalByType = {
-	bidiWrapper: "content",
+	inlineWrapper: "content",
 	bookmarkEnd: "leaf",
 	bookmarkStart: "leaf",
 	commentRangeEnd: "leaf",
@@ -283,6 +286,7 @@ const tableCellParagraphContentTraversalByType = {
 	moveTo: "content",
 	moveToRangeEnd: "leaf",
 	moveToRangeStart: "leaf",
+	preservedInline: "leaf",
 	run: "run",
 	simpleField: "content"
 };
@@ -294,6 +298,7 @@ const tableCellRunContentTraversalByType = {
 	footnoteRef: "leaf",
 	instrText: "leaf",
 	noBreakHyphen: "leaf",
+	preservedXml: "leaf",
 	renderedPageBreak: "leaf",
 	shape: "shape",
 	softHyphen: "leaf",
@@ -453,6 +458,7 @@ function visitDecodedTableCellBlock(value, path, context) {
 			for (const [index, child] of content.entries()) visitDecodedTableCellBlock(child, `${path}.content[${index}]`, context);
 			return;
 		}
+		case "leaf": return;
 		default: return traversal;
 	}
 }

package/dist/docx/paragraphTextBoxEnrichment.d.ts

@@ -1,9 +1,10 @@
 import { document_d_exports } from "../types/document.js";
 import { NumberingMap } from "./numberingParser.js";
-import { StyleMap } from "./styleParser.js";
+import { ParseContext } from "./parseContext.js";
 import { XmlElement } from "./xmlParser.js";
+import { StyleMap } from "./styleParser.js";
 import { TableParserFn } from "./textBoxParser.js";
 //#region src/docx/paragraphTextBoxEnrichment.d.ts
-declare const enrichParagraphTextBoxes: (paragraph: document_d_exports.Paragraph, paraXml: XmlElement, styles: StyleMap | null, theme: document_d_exports.Theme | null, numbering: NumberingMap | null, rels: document_d_exports.RelationshipMap | null, media: Map<string, document_d_exports.MediaFile> | null, parseTable: TableParserFn) => void;
+declare const enrichParagraphTextBoxes: (paragraph: document_d_exports.Paragraph, paraXml: XmlElement, styles: StyleMap | null, theme: document_d_exports.Theme | null, numbering: NumberingMap | null, rels: document_d_exports.RelationshipMap | null, media: Map<string, document_d_exports.MediaFile> | null, parseTable: TableParserFn, context?: ParseContext) => void;
 //#endregion
 export { enrichParagraphTextBoxes };

package/dist/docx/paragraphTextBoxEnrichment.js

@@ -1,6 +1,8 @@
 import { pixelsToEmu } from "../utils/units.js";
 import { parseParagraph } from "./paragraphParser.js";
-import { getTextBoxContentElement, isTextBoxDrawing, parseTextBox, parseTextBoxContent } from "./textBoxParser.js";
+import { consolidateParagraphContent } from "./runConsolidator.js";
+import { getTextBoxContentElement, parseTextBox, parseTextBoxContent, scanRunForTextBoxDrawings } from "./textBoxParser.js";
+import { isVmlPictParsedByRunParser } from "./vmlImageParser.js";
 import { findDeep, getAttribute, getChildElements, getLocalName } from "./xmlParser.js";
 //#region src/docx/paragraphTextBoxEnrichment.ts
 const VML_HORIZONTAL_RELATIVES = /* @__PURE__ */ new Set([
@@ -119,7 +121,7 @@ const vmlWrapType = (positioned, zIndex) => {
 	if (Number.isFinite(zIndex) && zIndex < 0) return "behind";
 	return "inFront";
 };
-const enrichParagraphTextBoxes = (paragraph, paraXml, styles, theme, numbering, rels, media, parseTable) => {
+const enrichParagraphTextBoxes = (paragraph, paraXml, styles, theme, numbering, rels, media, parseTable, context) => {
 	enrichTextBoxRuns({
 		content: paragraph.content,
 		xmlChildren: getChildElements(paraXml),
@@ -128,15 +130,17 @@ const enrichParagraphTextBoxes = (paragraph, paraXml, styles, theme, numbering,
 		numbering,
 		rels,
 		media,
-		parseTable
+		parseTable,
+		context
 	});
+	paragraph.content = consolidateParagraphContent(paragraph.content);
 };
 const trackedChangeTypeFromXml = (localName) => {
 	if (localName === "ins") return "insertion";
 	if (localName === "del") return "deletion";
 	if (localName === "moveFrom" || localName === "moveTo") return localName;
 };
-const enrichTextBoxRuns = ({ content, xmlChildren, styles, theme, numbering, rels, media, parseTable }) => {
+const enrichTextBoxRuns = ({ content, xmlChildren, styles, theme, numbering, rels, media, parseTable, context }) => {
 	let parsedIndex = 0;
 	let lastConsumedRun;
 	for (const xmlChild of xmlChildren) {
@@ -152,7 +156,8 @@ const enrichTextBoxRuns = ({ content, xmlChildren, styles, theme, numbering, rel
 			numbering,
 			rels,
 			media,
-			parseTable
+			parseTable,
+			context
 		});
 		if (localName === "sdt" && parsedContent?.type === "inlineSdt") {
 			const properties = parsedContent.properties;
@@ -173,7 +178,8 @@ const enrichTextBoxRuns = ({ content, xmlChildren, styles, theme, numbering, rel
 				numbering,
 				rels,
 				media,
-				parseTable
+				parseTable,
+				context
 			});
 			parsedIndex = lastSegmentIndex + 1;
 			continue;
@@ -182,12 +188,16 @@ const enrichTextBoxRuns = ({ content, xmlChildren, styles, theme, numbering, rel
 			if (parsedIndex < content.length && parsedContent?.type !== "run") parsedIndex += 1;
 			continue;
 		}
-		const { textBoxDrawings, vmlTextBoxes, hasNonTextBoxContent } = scanRunForTextBoxDrawings(xmlChild);
+		const { textBoxDrawings, vmlTextBoxes, hasNonTextBoxContent } = scanRunForTextBoxDrawings({
+			xmlRun: xmlChild,
+			claimedByRunParser: (pictElement) => isVmlPictParsedByRunParser(pictElement, rels, media)
+		});
 		const parsedRun = parsedContent?.type === "run" ? parsedContent : void 0;
 		const targetRun = parsedRun ?? (hasNonTextBoxContent ? lastConsumedRun : void 0);
 		const targetRunMatchesXml = targetRun !== void 0 && (hasNonTextBoxContent || parsedRun?.content.length === 0);
+		const fillsEmptyCarrier = targetRunMatchesXml && !hasNonTextBoxContent && parsedRun !== void 0;
 		for (const runEl of textBoxDrawings) {
-			const textBox = parseTextBox(runEl);
+			const textBox = parseTextBox(runEl, context);
 			if (!textBox) continue;
 			const wsp = findDeep(runEl, "wps", "wsp");
 			if (wsp) {
@@ -203,6 +213,7 @@ const enrichTextBoxRuns = ({ content, xmlChildren, styles, theme, numbering, rel
 				...textBox.title !== void 0 ? { title: textBox.title } : {},
 				...textBox.position !== void 0 ? { position: textBox.position } : {},
 				...textBox.wrap !== void 0 ? { wrap: textBox.wrap } : {},
+				...textBox.anchor !== void 0 ? { anchor: textBox.anchor } : {},
 				...textBox.fill !== void 0 ? { fill: textBox.fill } : {},
 				...textBox.outline !== void 0 ? { outline: textBox.outline } : {},
 				textBody: {
@@ -248,62 +259,12 @@ const enrichTextBoxRuns = ({ content, xmlChildren, styles, theme, numbering, rel
 				parsedIndex += 1;
 			}
 		}
-		if (hasNonTextBoxContent && parsedRun) {
+		if ((hasNonTextBoxContent || fillsEmptyCarrier) && parsedRun) {
 			lastConsumedRun = parsedRun;
 			parsedIndex += 1;
 		}
 	}
 };
-const scanRunForTextBoxDrawings = (xmlRun) => {
-	const textBoxDrawings = [];
-	const vmlTextBoxes = [];
-	let hasNonTextBoxContent = false;
-	const visitDrawing = (drawingEl) => {
-		if (isTextBoxDrawing(drawingEl)) {
-			textBoxDrawings.push(drawingEl);
-			return;
-		}
-		hasNonTextBoxContent = true;
-	};
-	for (const el of getChildElements(xmlRun)) {
-		const name = getLocalName(el.name ?? "");
-		if (name === "rPr") continue;
-		if (name === "drawing") {
-			visitDrawing(el);
-			continue;
-		}
-		if (name === "pict") {
-			if (findDeep(el, "v", "textbox")) if (findDeep(el, "v", "imagedata")) hasNonTextBoxContent = true;
-			else vmlTextBoxes.push(el);
-			else hasNonTextBoxContent = true;
-			continue;
-		}
-		if (name === "AlternateContent") {
-			const branches = getChildElements(el);
-			const choice = branches.find((branch) => getLocalName(branch.name ?? "") === "Choice");
-			const fallback = branches.find((branch) => getLocalName(branch.name ?? "") === "Fallback");
-			const tryBranch = (branch) => {
-				if (!branch) return false;
-				let found = false;
-				for (const innerEl of getChildElements(branch)) if (getLocalName(innerEl.name ?? "") === "drawing") {
-					visitDrawing(innerEl);
-					found = true;
-				}
-				return found;
-			};
-			let foundInBranch = tryBranch(choice);
-			if (!foundInBranch) foundInBranch = tryBranch(fallback);
-			if (!foundInBranch) hasNonTextBoxContent = true;
-			continue;
-		}
-		hasNonTextBoxContent = true;
-	}
-	return {
-		textBoxDrawings,
-		vmlTextBoxes,
-		hasNonTextBoxContent
-	};
-};
 const parseVmlTextBoxShape = (pictEl, styles, theme, numbering, rels, media, parseTable) => {
 	const shapeEl = findDeep(pictEl, "v", "shape");
 	const textBoxEl = shapeEl ? findDeep(shapeEl, "v", "textbox") : null;

package/dist/docx/paragraphTraversal.d.ts

@@ -33,18 +33,22 @@ type InlineContentSlot = {
  * only, and a run is not a marker position.
  */
 declare const visitInlineContentSlots: (paragraph: document_d_exports.Paragraph, visit: (slot: InlineContentSlot) => void) => void;
+/** What the walk does below a record it has just visited. */
+declare const BLOCK_TREE_DESCENT: {
+  readonly descend: "descend";
+  readonly prune: "prune";
+};
+type BlockTreeDescent = (typeof BLOCK_TREE_DESCENT)[keyof typeof BLOCK_TREE_DESCENT];
 /**
- * Positions marked for removal, per inline-content array.
+ * Every record a block tree owns in document order: a paragraph, table, and
+ * table row. These are the records that carry authored state by identity.
  *
- * Removal shifts every later index in that array, so a normaliser records the
- * positions while it reads and drops them once, after it has finished reading.
+ * A block container is not always reached through a block. `w:txbxContent`
+ * hangs off a shape inside a run, so a walk that recurses on block children
+ * alone enters the body, a cell and an `w:sdt` and never enters a text box:
+ * every record inside one is then invisible to whatever the walk is deciding.
  */
-declare class InlineContentRemovals {
-  #private;
-  mark({ content, index }: Pick<InlineContentSlot, "content" | "index">): void;
-  /** Applies every marked removal and answers how many items were dropped. */
-  apply(): number;
-}
+declare const visitBlockTreeRecords: (blocks: readonly document_d_exports.BlockContent[], visit: (record: document_d_exports.Paragraph | document_d_exports.Table | document_d_exports.TableRow) => BlockTreeDescent) => void;
 declare const visitDocxParagraphs: ({ documentBody, headers, footers, footnotes, endnotes }: DocxParagraphSurfaces, visit: (paragraph: document_d_exports.Paragraph) => void) => void;
 //#endregion
-export { DocxParagraphSurfaces, InlineContentRemovals, InlineContentSlot, visitDocxParagraphs, visitInlineContentSlots, visitParagraphRuns };
+export { BLOCK_TREE_DESCENT, BlockTreeDescent, DocxParagraphSurfaces, InlineContentSlot, visitBlockTreeRecords, visitDocxParagraphs, visitInlineContentSlots, visitParagraphRuns };