@stll/folio-core 0.46.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,6 +261,8 @@ const invalidTableCellParagraphSourcePayload = (classification, path) => {
 };
 const tableCellBlockTraversalByType = {
 	blockSdt: "blockSdt",
+	bookmarkEnd: "leaf",
+	bookmarkStart: "leaf",
 	paragraph: "paragraph",
 	preservedBlock: "leaf",
 	table: "table"

package/dist/docx/paragraphTextBoxEnrichment.d.ts

@@ -1,9 +1,10 @@
 import { document_d_exports } from "../types/document.js";
 import { NumberingMap } from "./numberingParser.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,5 +1,6 @@
 import { pixelsToEmu } from "../utils/units.js";
 import { parseParagraph } from "./paragraphParser.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";
@@ -120,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),
@@ -129,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) {
@@ -153,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;
@@ -174,7 +178,8 @@ const enrichTextBoxRuns = ({ content, xmlChildren, styles, theme, numbering, rel
 				numbering,
 				rels,
 				media,
-				parseTable
+				parseTable,
+				context
 			});
 			parsedIndex = lastSegmentIndex + 1;
 			continue;
@@ -190,8 +195,9 @@ const enrichTextBoxRuns = ({ content, xmlChildren, styles, theme, numbering, rel
 		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) {
@@ -207,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: {
@@ -252,7 +259,7 @@ const enrichTextBoxRuns = ({ content, xmlChildren, styles, theme, numbering, rel
 				parsedIndex += 1;
 			}
 		}
-		if (hasNonTextBoxContent && parsedRun) {
+		if ((hasNonTextBoxContent || fillsEmptyCarrier) && parsedRun) {
 			lastConsumedRun = parsedRun;
 			parsedIndex += 1;
 		}

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 };

package/dist/docx/paragraphTraversal.js

@@ -92,34 +92,49 @@ const visitInlineContentSlots = (paragraph, visit) => {
 	};
 	visitContent(paragraph.content);
 };
+/** What the walk does below a record it has just visited. */
+const BLOCK_TREE_DESCENT = {
+	descend: "descend",
+	prune: "prune"
+};
 /**
-* 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.
 */
-var InlineContentRemovals = class {
-	#byContent = /* @__PURE__ */ new Map();
-	mark({ content, index }) {
-		const indexes = this.#byContent.get(content);
-		if (indexes) {
-			indexes.add(index);
-			return;
-		}
-		this.#byContent.set(content, /* @__PURE__ */ new Set([index]));
-	}
-	/** Applies every marked removal and answers how many items were dropped. */
-	apply() {
-		let removed = 0;
-		for (const [content, indexes] of this.#byContent) {
-			if (indexes.size === 0) continue;
-			const next = content.filter((_, index) => !indexes.has(index));
-			removed += content.length - next.length;
-			content.length = 0;
-			content.push(...next);
+const visitBlockTreeRecords = (blocks, visit) => {
+	const visitParagraph = (paragraph) => {
+		if (visit(paragraph) === BLOCK_TREE_DESCENT.prune) return;
+		visitParagraphRuns(paragraph, (run) => {
+			for (const content of run.content) if (content.type === "shape" && content.shape.textBody) visitBlocks(content.shape.textBody.content);
+		});
+	};
+	const visitBlocks = (nested) => {
+		for (const block of nested) switch (block.type) {
+			case "paragraph":
+				visitParagraph(block);
+				break;
+			case "table":
+				if (visit(block) === BLOCK_TREE_DESCENT.prune) break;
+				for (const row of block.rows) {
+					if (visit(row) === BLOCK_TREE_DESCENT.prune) continue;
+					for (const cell of row.cells) visitBlocks(cell.content);
+				}
+				break;
+			case "blockSdt":
+				visitBlocks(block.content);
+				break;
+			case "preservedBlock":
+			case "bookmarkStart":
+			case "bookmarkEnd": break;
+			default: panic(`Unsupported block content: ${JSON.stringify(block)}`);
 		}
-		return removed;
-	}
+	};
+	visitBlocks(blocks);
 };
 const visitDocxParagraphs = ({ documentBody, headers, footers, footnotes, endnotes }, visit) => {
 	const seenParagraphs = /* @__PURE__ */ new WeakSet();
@@ -127,31 +142,14 @@ const visitDocxParagraphs = ({ documentBody, headers, footers, footnotes, endnot
 		if (seenParagraphs.has(paragraph)) return;
 		seenParagraphs.add(paragraph);
 		visit(paragraph);
-		visitParagraphRuns(paragraph, visitRun);
-	};
-	const visitRun = (run) => {
-		for (const content of run.content) {
-			if (content.type !== "shape" || !content.shape.textBody) continue;
-			for (const block of content.shape.textBody.content) visitBlock(block);
-		}
-	};
-	const visitTable = (table) => {
-		for (const row of table.rows) for (const cell of row.cells) visitBlocks(cell.content);
-	};
-	const visitBlock = (block) => {
-		if (block.type === "paragraph") {
-			visitParagraph(block);
-			return;
-		}
-		if (block.type === "table") {
-			visitTable(block);
-			return;
-		}
-		if (block.type === "preservedBlock") return;
-		visitBlocks(block.content);
 	};
 	const visitBlocks = (blocks) => {
-		for (const block of blocks) visitBlock(block);
+		visitBlockTreeRecords(blocks, (record) => {
+			if (record.type !== "paragraph") return BLOCK_TREE_DESCENT.descend;
+			if (seenParagraphs.has(record)) return BLOCK_TREE_DESCENT.prune;
+			visitParagraph(record);
+			return BLOCK_TREE_DESCENT.descend;
+		});
 	};
 	visitBlocks(documentBody.content);
 	for (const section of documentBody.sections ?? []) visitBlocks(section.content);
@@ -159,7 +157,7 @@ const visitDocxParagraphs = ({ documentBody, headers, footers, footnotes, endnot
 	for (const footer of footers?.values() ?? []) visitBlocks(footer.content);
 	for (const footnote of footnotes ?? []) visitBlocks(footnote.content);
 	for (const endnote of endnotes ?? []) visitBlocks(endnote.content);
-	for (const comment of documentBody.comments ?? []) for (const paragraph of comment.content) visitParagraph(paragraph);
+	for (const comment of documentBody.comments ?? []) visitBlocks(comment.content);
 };
 //#endregion
-export { InlineContentRemovals, visitDocxParagraphs, visitInlineContentSlots, visitParagraphRuns };
+export { BLOCK_TREE_DESCENT, visitBlockTreeRecords, visitDocxParagraphs, visitInlineContentSlots, visitParagraphRuns };

package/dist/docx/parseWarningMessage.js

@@ -34,7 +34,10 @@ const PARSE_WARNING_MESSAGES = {
 	[PARSE_WARNING_CODES.unbalancedMoveRange]: (warning) => `Removed ${plural(warning.count, "unbalanced tracked move range marker")}.`,
 	[PARSE_WARNING_CODES.headerFooterTypeOutsideEnum]: (warning) => `Read header/footer type${quoted(warning.value)} as "default"${where(warning)}; ST_HdrFtr is even, default or first.`,
 	[PARSE_WARNING_CODES.unrecognisedOnOffValue]: (warning) => `Ignored on/off value${quoted(warning.value)}${where(warning)}; ST_OnOff is 1, 0, true, false, on or off.`,
+	[PARSE_WARNING_CODES.unrecognisedThemeColor]: (warning) => `Kept theme colour${quoted(warning.value)}${where(warning)} without painting it; ST_ThemeColor does not enumerate it.`,
 	[PARSE_WARNING_CODES.borderWithoutValue]: (warning) => `Read a border with no w:val${where(warning)} as having no border style.`,
+	[PARSE_WARNING_CODES.borderStyleOutsideEnum]: (warning) => `Kept border style${quoted(warning.value)} verbatim${where(warning)}; ST_Border does not declare it.`,
+	[PARSE_WARNING_CODES.outlineDashOutsideEnum]: (warning) => `Kept outline dash${quoted(warning.value)} verbatim${where(warning)}; ST_PresetLineDashVal does not declare it.`,
 	[PARSE_WARNING_CODES.styleSetDuplicateStyleId]: (warning) => `Dropped a style repeating the id${quoted(warning.value)} another style in the set already defines.`,
 	[PARSE_WARNING_CODES.styleSetInitialStyleMissing]: (warning) => `The style set names initial paragraph style${quoted(warning.value)}, which it does not contain; used the set's default instead${where(warning)}.`,
 	[PARSE_WARNING_CODES.pageBreakProjectionApproximated]: (warning) => `${warning.detail ?? "An explicit page break is laid out approximately"}${where(warning)}.`