reamkit 1.15.4 → 1.17.0

package/dist/esm/pdf/vector-graphics.js

@@ -10,12 +10,84 @@ import "../core/vector.js";
 * @param patternName When set, the fill is this named shading pattern from the
 *   page's `/Pattern` resources (a gradient, EP16b) rather than a solid colour;
 *   only used if the shape actually carries a `fillGradient`.
+* @param alphaStateName When set, the shape's shadow is drawn first, under this
+*   named `/ExtGState` (its constant alpha) from the page's resources.
 * @returns The content-stream operator lines.
 */
-function emitVectorShape(shape, patternName) {
+/**
+* §20.1.8.40 `blurRad` — how a blurred shadow is drawn: as `count` copies of
+* the silhouette, each at `alpha` transparency, growing through the blur's
+* width. Shared with the emitter that registers the /ExtGState for it, so the
+* alpha it registers is the one the layers are drawn at.
+*
+* @param shadow The shadow (its `blurPt` and `alpha` are read).
+* @returns The number of layers and the transparency of each.
+*/
+function shadowBlurLayers(shadow) {
+	if (!(shadow.blurPt > 0)) return {
+		count: 1,
+		alpha: shadow.alpha
+	};
+	const count = Math.min(8, Math.max(2, Math.round(shadow.blurPt / 2)));
+	return {
+		count,
+		alpha: shadow.alpha / count
+	};
+}
+function shadowBbox(shape) {
+	let minX = Infinity;
+	let minY = Infinity;
+	let maxX = -Infinity;
+	let maxY = -Infinity;
+	for (const path of shape.paths) for (const seg of path.segments) {
+		if (seg.op === "close") continue;
+		minX = Math.min(minX, seg.x);
+		minY = Math.min(minY, seg.y);
+		maxX = Math.max(maxX, seg.x);
+		maxY = Math.max(maxY, seg.y);
+	}
+	return Number.isFinite(minX) && maxX > minX && maxY > minY ? {
+		minX,
+		minY,
+		maxX,
+		maxY
+	} : void 0;
+}
+function emitVectorShape(shape, patternName, alphaStateName) {
 	const out = [];
-	out.push("q");
 	const [a, b, c, d, e, f] = shape.transform;
+	const shadow = shape.shadow;
+	if (shadow) {
+		const [sr, sg, sb] = hexToRgb01(shadow.colorHex);
+		const bbox = shadowBbox(shape);
+		const scale = Math.sqrt(Math.abs(a * d - b * c)) || 1;
+		const { count } = shadowBlurLayers(shadow);
+		for (let i = 0; i < count; i++) {
+			out.push("q");
+			if (alphaStateName !== void 0) out.push(`/${alphaStateName} gs`);
+			out.push(`${num(a)} ${num(b)} ${num(c)} ${num(d)} ${num(e + shadow.dxPt)} ${num(f - shadow.dyPt)} cm`);
+			if (count > 1 && bbox) {
+				const local = shadow.blurPt / scale;
+				const grow = -local / 2 + (i + .5) * local / count;
+				const halfW = Math.max((bbox.maxX - bbox.minX) / 2, 1e-6);
+				const halfH = Math.max((bbox.maxY - bbox.minY) / 2, 1e-6);
+				const cx = (bbox.minX + bbox.maxX) / 2;
+				const cy = (bbox.minY + bbox.maxY) / 2;
+				const sx = Math.max((halfW + grow) / halfW, 0);
+				const sy = Math.max((halfH + grow) / halfH, 0);
+				out.push(`${num(sx)} 0 0 ${num(sy)} ${num(cx * (1 - sx))} ${num(cy * (1 - sy))} cm`);
+			}
+			out.push(`${num(sr)} ${num(sg)} ${num(sb)} rg`);
+			let shadowEvenodd = false;
+			for (const path of shape.paths) {
+				if (path.fillRule === "evenodd") shadowEvenodd = true;
+				for (const seg of path.segments) out.push(emitSegment(seg));
+			}
+			out.push(shadowEvenodd ? "f*" : "f");
+			out.push("Q");
+		}
+	}
+	out.push("q");
 	out.push(`${num(a)} ${num(b)} ${num(c)} ${num(d)} ${num(e)} ${num(f)} cm`);
 	const stroke = shape.stroke;
 	if (stroke) {
@@ -41,6 +113,34 @@ function emitVectorShape(shape, patternName) {
 	out.push("Q");
 	return out;
 }
+/**
+* The operators that make `paths` the current CLIP, under `transform` — the
+* same local→y-up-page matrix {@link emitVectorShape} takes. Emitted inside the
+* caller's own `q`…`Q`, and followed by the inverse matrix so what comes after
+* is back in page coordinates.
+*
+* @param paths     The clip outline, in the shape's local frame.
+* @param transform The local→page matrix.
+* @returns The operators: `cm`, the path, `W n`, and the inverse `cm`.
+*/
+function emitClipPath(paths, transform) {
+	const [a, b, c, d, e, f] = transform;
+	const det = a * d - b * c;
+	if (det === 0) return [];
+	const out = [`${num(a)} ${num(b)} ${num(c)} ${num(d)} ${num(e)} ${num(f)} cm`];
+	let evenodd = false;
+	for (const path of paths) {
+		if (path.fillRule === "evenodd") evenodd = true;
+		for (const seg of path.segments) out.push(emitSegment(seg));
+	}
+	out.push(evenodd ? "W* n" : "W n");
+	const ia = d / det;
+	const ib = -b / det;
+	const ic = -c / det;
+	const id = a / det;
+	out.push(`${num(ia)} ${num(ib)} ${num(ic)} ${num(id)} ${num(-(e * ia + f * ic))} ${num(-(e * ib + f * id))} cm`);
+	return out;
+}
 function emitSegment(seg) {
 	switch (seg.op) {
 		case "move": return `${num(seg.x)} ${num(seg.y)} m`;
@@ -70,4 +170,4 @@ function hexToRgb01(hex) {
 	];
 }
 //#endregion
-export { emitVectorShape };
+export { emitClipPath, emitVectorShape, shadowBlurLayers };

package/dist/esm/pptx/pptx-reader.js

@@ -19,8 +19,10 @@ var DEFAULT_CX = 9144e3;
 var DEFAULT_CY = 6858e3;
 var decoder = new TextDecoder();
 var parser = new XMLParser({
+	htmlEntities: true,
 	ignoreAttributes: false,
 	attributeNamePrefix: "@_",
+	maxNestedTags: 1e3,
 	preserveOrder: true,
 	parseAttributeValue: false,
 	parseTagValue: false,

package/dist/esm/pptx/slide-parser.d.ts

@@ -73,16 +73,33 @@ export declare function diagramTransform(spTree: PoNode, frame: ShapeBoxEmu): Gr
  * @param where Optional location tag for the loss report (e.g. `slide 3`).
  */
 export declare function noDiagramOverrideLoss(where?: string): Loss;
+/** One SmartArt node: the box it occupies in the target space, and its shape. */
+export interface DiagramNode {
+    readonly box: ShapeBoxEmu;
+    readonly shape: ShapeBlock;
+}
 /**
- * Render a SmartArt drawing override (a `dsp:spTree`) into floating shapes. The
- * `dsp:` wrapper holds an ordinary `a:` `spPr`/`txBody`, so the shared DrawingML
+ * Read a SmartArt drawing override (a `dsp:spTree`) into its nodes. The `dsp:`
+ * wrapper holds an ordinary `a:` `spPr`/`txBody`, so the shared DrawingML
  * readers apply unchanged. Shared by pptx and docx (E-SMARTART); diagrams carry
  * no placeholder cascade.
  *
+ * @param spTree       The diagram drawing's `dsp:spTree`.
+ * @param transform    Maps each shape's diagram-space box to the target space.
+ * @param colors       The colour resolver for the shapes' fills/strokes/text.
+ * @param resolveLink  A run hyperlink resolver, or `undefined`.
+ * @param resolveImage Resolves a picture fill's `r:embed` against the DRAWING
+ *                     part's own relationships, or `undefined`.
+ * @returns The diagram's visible nodes, in drawing order.
+ */
+export declare function parseDiagramNodes(spTree: PoNode, transform: GroupTransform, colors: ColorResolver, resolveLink: LinkResolver, resolveImage?: (relId: string) => ResourceId | undefined): Array<DiagramNode>;
+/**
+ * The same nodes as free-standing floating shapes — what a slide wants, where
+ * every shape is anchored to the page.
+ *
  * @param spTree      The diagram drawing's `dsp:spTree`.
  * @param transform   Maps each shape's diagram-space box to the target space.
- * @param makeFloat   Anchors a box — page-relative for a slide, column/paragraph-
- *                    relative for an inline docx diagram.
+ * @param makeFloat   Anchors a node's box.
  * @param colors      The colour resolver for the shapes' fills/strokes/text.
  * @param resolveLink A run hyperlink resolver, or `undefined`.
  * @returns The diagram's visible shapes as positioned {@link ShapeBlock}s.

package/dist/esm/pptx/slide-parser.js

@@ -1,9 +1,9 @@
-import { emuToPt } from "../core/ir/units.js";
+import { emuToPt, pt } from "../core/ir/units.js";
 import { FEATURES } from "../core/ir/features.js";
-import { poAttr, poChildren, poFindDescendant, poIntAttr, poIs, poText } from "../core/po-helpers.js";
+import { poAttr, poChildren, poFindDescendant, poIntAttr, poIs, poTag, poText } from "../core/po-helpers.js";
 import { defaultColorResolver, resolveColorNode } from "../core/drawingml/colors.js";
 import { boxFromXfrm, parsePh, parseXfrmBox, rPrToRunProps } from "./sp-helpers.js";
-import { parseCustGeom, parseFill, parseLine, parsePrstGeom } from "../word/drawing-parser.js";
+import { parseCustGeom, parseFill, parseLine, parsePrstGeom, parseShadow, parseXfrm } from "../word/drawing-parser.js";
 //#region src/pptx/slide-parser.ts
 var CHART_URI = "http://schemas.openxmlformats.org/drawingml/2006/chart";
 var TABLE_URI = "http://schemas.openxmlformats.org/drawingml/2006/table";
@@ -206,20 +206,20 @@ function noDiagramOverrideLoss(where) {
 	};
 }
 /**
-* Render a SmartArt drawing override (a `dsp:spTree`) into floating shapes. The
-* `dsp:` wrapper holds an ordinary `a:` `spPr`/`txBody`, so the shared DrawingML
+* Read a SmartArt drawing override (a `dsp:spTree`) into its nodes. The `dsp:`
+* wrapper holds an ordinary `a:` `spPr`/`txBody`, so the shared DrawingML
 * readers apply unchanged. Shared by pptx and docx (E-SMARTART); diagrams carry
 * no placeholder cascade.
 *
-* @param spTree      The diagram drawing's `dsp:spTree`.
-* @param transform   Maps each shape's diagram-space box to the target space.
-* @param makeFloat   Anchors a box — page-relative for a slide, column/paragraph-
-*                    relative for an inline docx diagram.
-* @param colors      The colour resolver for the shapes' fills/strokes/text.
-* @param resolveLink A run hyperlink resolver, or `undefined`.
-* @returns The diagram's visible shapes as positioned {@link ShapeBlock}s.
+* @param spTree       The diagram drawing's `dsp:spTree`.
+* @param transform    Maps each shape's diagram-space box to the target space.
+* @param colors       The colour resolver for the shapes' fills/strokes/text.
+* @param resolveLink  A run hyperlink resolver, or `undefined`.
+* @param resolveImage Resolves a picture fill's `r:embed` against the DRAWING
+*                     part's own relationships, or `undefined`.
+* @returns The diagram's visible nodes, in drawing order.
 */
-function parseDiagramDrawing(spTree, transform, makeFloat, colors, resolveLink) {
+function parseDiagramNodes(spTree, transform, colors, resolveLink, resolveImage) {
 	const out = [];
 	for (const sp of poChildren(spTree)) {
 		if (!poIs(sp, "dsp:sp")) continue;
@@ -228,26 +228,89 @@ function parseDiagramDrawing(spTree, transform, makeFloat, colors, resolveLink)
 		if (!own) continue;
 		const box = transform(own);
 		const txBody = poChildren(sp).find((c) => poIs(c, "dsp:txBody"));
-		const text = txBody ? parseTxBody(txBody, void 0, void 0, colors, resolveLink) : void 0;
+		const parsed = txBody ? parseTxBody(txBody, void 0, void 0, colors, resolveLink) : void 0;
+		const text = parsed ? withDiagramFontColor(parsed, sp, colors) : void 0;
 		const geometry = parseGeometry(spPr);
-		const fill = spPr ? parseFill(spPr, colors) : { kind: "none" };
+		const fill = spPr ? parseFill(spPr, colors, resolveImage) : { kind: "none" };
 		const line = spPr ? parseLine(spPr, colors) : void 0;
+		const shadow = spPr ? parseShadow(spPr, colors) : void 0;
 		const visibleLine = line !== void 0 && line.fill !== "none";
 		if (!text && fill.kind === "none" && !visibleLine) continue;
+		const xfrm = spPr ? poChildren(spPr).find((c) => poIs(c, "a:xfrm")) : void 0;
+		const spin = xfrm ? parseXfrm(xfrm) : void 0;
+		const txBox = (spin?.rotation60k ?? 0) % 216e5 !== 0 ? boxFromXfrm(poChildren(sp).find((c) => poIs(c, "dsp:txXfrm"))) : void 0;
 		out.push({
-			float: makeFloat(box),
-			width: emuToPt(box.cx),
-			height: emuToPt(box.cy),
-			geometry,
-			fill,
-			...line ? { line } : {},
-			...text ? { text } : {},
-			paragraphProperties: {}
+			box,
+			shape: {
+				width: emuToPt(box.cx),
+				height: emuToPt(box.cy),
+				geometry,
+				fill,
+				...line ? { line } : {},
+				...text && !txBox ? { text } : {},
+				...spin && Object.keys(spin).length > 0 ? { transform: spin } : {},
+				...shadow ? { shadow } : {},
+				paragraphProperties: {}
+			}
 		});
+		if (text && txBox) {
+			const placed = transform(txBox);
+			out.push({
+				box: placed,
+				shape: {
+					width: emuToPt(placed.cx),
+					height: emuToPt(placed.cy),
+					geometry: RECT_GEOMETRY,
+					fill: { kind: "none" },
+					text,
+					paragraphProperties: {}
+				}
+			});
+		}
 	}
 	return out;
 }
 /**
+* The same nodes as free-standing floating shapes — what a slide wants, where
+* every shape is anchored to the page.
+*
+* @param spTree      The diagram drawing's `dsp:spTree`.
+* @param transform   Maps each shape's diagram-space box to the target space.
+* @param makeFloat   Anchors a node's box.
+* @param colors      The colour resolver for the shapes' fills/strokes/text.
+* @param resolveLink A run hyperlink resolver, or `undefined`.
+* @returns The diagram's visible shapes as positioned {@link ShapeBlock}s.
+*/
+function parseDiagramDrawing(spTree, transform, makeFloat, colors, resolveLink) {
+	return parseDiagramNodes(spTree, transform, colors, resolveLink).map(({ box, shape }) => ({
+		...shape,
+		float: makeFloat(box)
+	}));
+}
+function withDiagramFontColor(text, sp, colors) {
+	const style = poChildren(sp).find((c) => poIs(c, "dsp:style"));
+	const ref = style ? poChildren(style).find((c) => poIs(c, "a:fontRef")) : void 0;
+	const child = ref ? poChildren(ref).find((c) => poTag(c) !== void 0) : void 0;
+	const colorHex = child ? resolveColorNode(child, colors) : void 0;
+	if (colorHex === void 0) return text;
+	return {
+		...text,
+		content: text.content.map((block) => block.kind === "paragraph" ? {
+			...block,
+			paragraph: {
+				...block.paragraph,
+				runs: block.paragraph.runs.map((run) => run.properties.colorHex === void 0 ? {
+					...run,
+					properties: {
+						...run.properties,
+						colorHex
+					}
+				} : run)
+			}
+		} : block)
+	};
+}
+/**
 * `p:bg` → the background fill, or `undefined` when none/unsupported. `p:bgPr`
 * carries the fill directly (`a:solidFill`/`a:gradFill` — the same children
 * `parseFill` reads; a picture background is not yet supported); `p:bgRef` (a
@@ -400,6 +463,17 @@ function parseSlideParagraph(aP, ph, cascade, colors, resolveLink, counters) {
 		const run = parseSlideRun(child, defaults, colors, resolveLink);
 		if (run) runs.push(run);
 	}
+	if (runs.length === 0) {
+		const endRPr = poChildren(aP).find((c) => poIs(c, "a:endParaRPr"));
+		const sz = endRPr ? poIntAttr(endRPr, "sz") : void 0;
+		if (sz !== void 0 && sz > 0) runs.push({
+			text: "",
+			properties: {
+				...defaults,
+				fontSizePt: pt(sz / 100)
+			}
+		});
+	}
 	const marL = pPr ? poIntAttr(pPr, "marL") : void 0;
 	const indent = pPr ? poIntAttr(pPr, "indent") : void 0;
 	const indentLeft = marL !== void 0 ? emuToPt(marL) : level > 0 ? emuToPt(level * 457200) : void 0;
@@ -502,4 +576,4 @@ function cellFillHex(tcPr, colors) {
 	}
 }
 //#endregion
-export { backdropElement, diagramTransform, noDiagramOverrideLoss, parseBackgroundFill, parseDiagramDrawing, parseGeometry, parseSlideShapes, parseTxBody };
+export { backdropElement, diagramTransform, noDiagramOverrideLoss, parseBackgroundFill, parseDiagramNodes, parseGeometry, parseSlideShapes, parseTxBody };

package/dist/esm/svg/svg-writer.js

@@ -87,14 +87,20 @@ function emitPage(out, page, laid, losses, idc) {
 			x2,
 			yBottom
 		];
-		out.push(`<line x1="${fmt(ax)}" y1="${fmt(ay)}" x2="${fmt(bx)}" y2="${fmt(by)}" stroke="#${b.borderColorHex}" stroke-width="${fmt(b.borderSizePt)}"/>`);
+		out.push(`<line x1="${fmt(ax)}" y1="${fmt(ay)}" x2="${fmt(bx)}" y2="${fmt(by)}" stroke="#${b.borderColorHex}" stroke-width="${fmt(b.borderSizePt)}"${b.borderStyle === "dashed" ? " stroke-dasharray=\"8 2.5\"" : b.borderStyle === "dashSmallGap" ? " stroke-dasharray=\"3 1\"" : b.borderStyle === "dotted" ? " stroke-dasharray=\"0.5 1\"" : ""}/>`);
 	}
 	for (const sh of plan.shapes) emitShape(out, sh.shape, idc);
-	for (const t of plan.lines) emitTextLine(out, t, losses);
+	for (const t of plan.lines) emitTextLine(out, t, losses, idc);
 }
-function emitTextLine(out, item, losses) {
+function emitTextLine(out, item, losses, idc) {
+	const clip = item.clip;
+	if (clip) {
+		const id = `clip${idc.n++}`;
+		out.push(`<clipPath id="${id}"><rect x="${fmt(clip.x)}" y="${fmt(clip.y)}" width="${fmt(clip.width)}" height="${fmt(clip.height)}"/></clipPath>`, `<g clip-path="url(#${id})">`);
+	}
 	const y = item.baselineY;
 	let x = item.originX;
+	const rot = item.rotationDeg ? ` transform="rotate(${fmt(-item.rotationDeg)} ${fmt(item.originX)} ${fmt(item.baselineY)})"` : "";
 	for (const tok of item.line.tokens) {
 		if (tok.kind === "image") {
 			x += tok.widthPt;
@@ -109,9 +115,10 @@ function emitTextLine(out, item, losses) {
 			x += tok.widthPt;
 			continue;
 		}
-		if (tok.text.trim().length > 0) out.push(`<text x="${fmt(x)}" y="${fmt(y)}" font-family="sans-serif" font-size="${fmt(tok.fontSizePt)}" fill="#${tok.resolvedRun.colorHex}">${escapeXml(tok.text)}</text>`);
+		if (tok.text.trim().length > 0) out.push(`<text x="${fmt(x)}" y="${fmt(y)}"${rot} font-family="sans-serif" font-size="${fmt(tok.fontSizePt)}" fill="#${tok.resolvedRun.colorHex}">${escapeXml(tok.text)}</text>`);
 		x += tok.widthPt;
 	}
+	if (clip) out.push("</g>");
 }
 function emitShape(out, shape, idc) {
 	const [a, b, c, d, e, f] = shape.transform;
@@ -123,6 +130,18 @@ function emitShape(out, shape, idc) {
 		fill = `url(#${id})`;
 	} else fill = shape.fillColorHex ? `#${shape.fillColorHex}` : "none";
 	const stroke = shape.stroke ? ` stroke="#${shape.stroke.colorHex}" stroke-width="${fmt(shape.stroke.widthPt)}"` : "";
+	const shadow = shape.shadow;
+	if (shadow) {
+		const id = `shadow${idc.n++}`;
+		if (shadow.blurPt > 0) out.push(`<filter id="${id}" x="-50%" y="-50%" width="200%" height="200%"><feGaussianBlur stdDeviation="${fmt(shadow.blurPt / 2)}"/></filter>`);
+		const shTransform = `matrix(${fmt(a)} ${fmt(b)} ${fmt(c)} ${fmt(d)} ${fmt(e + shadow.dxPt)} ${fmt(f + shadow.dyPt)})`;
+		out.push(`<g opacity="${fmt(shadow.alpha)}"${shadow.blurPt > 0 ? ` filter="url(#${id})"` : ""}>`);
+		for (const path of shape.paths) {
+			const rule = path.fillRule === "evenodd" ? " fill-rule=\"evenodd\"" : "";
+			out.push(`<path d="${pathData(path.segments)}" fill="#${shadow.colorHex}"${rule} transform="${shTransform}"/>`);
+		}
+		out.push("</g>");
+	}
 	for (const path of shape.paths) {
 		const d2 = pathData(path.segments);
 		const rule = path.fillRule === "evenodd" ? " fill-rule=\"evenodd\"" : "";

package/dist/esm/word/document-parser.d.ts

@@ -1,7 +1,8 @@
-import { BodyElement, Comment, Section, SectionProperties } from '../core/document-model/index.js';
+import { BodyElement, Comment, RunProperties, Section, SectionProperties, ShapeFill } from '../core/document-model/index.js';
 import { ColorResolver } from '../core/drawingml/colors.js';
 import { Loss, ResourceId } from '../core/ir/index.js';
 import { PoNode } from '../core/po-helpers.js';
+import { ThemeStyles } from './drawing-parser.js';
 /**
  * Resolves a drawing relationship id to a content-addressed `ResourceId` —
  * supplied by the converter (which owns the OPC package and the `ResourceStore`).
@@ -9,6 +10,15 @@ import { PoNode } from '../core/po-helpers.js';
 export type ImageResolver = (relId: string) => ResourceId | undefined;
 /** Resolves a `w:hyperlink` `r:id` to its external target URL. */
 export type HyperlinkResolver = (relId: string) => string | undefined;
+/**
+ * A SmartArt diagram's pre-rendered drawing override: its `dsp:spTree`, plus a
+ * resolver for the picture fills its nodes name — those relationships belong to
+ * the drawing part, not to the part that references the diagram.
+ */
+export interface ResolvedDiagram {
+    readonly spTree: PoNode;
+    readonly resolveImage?: ImageResolver;
+}
 /**
  * Document-wide resolvers every nested parser needs — one context object instead
  * of threading a parameter pair through ten signatures (oop-design §8).
@@ -25,10 +35,28 @@ export interface ParseContext {
     readonly resolveHyperlink?: HyperlinkResolver;
     /**
      * SmartArt: a data relationship id (`dgm:relIds` `@r:dm`) → the diagram's
-     * pre-rendered drawing override (its `dsp:spTree`), or `undefined` when the file
-     * ships none (E-SMARTART SA2).
+     * pre-rendered drawing override, or `undefined` when the file ships none
+     * (E-SMARTART SA2).
+     */
+    readonly resolveDiagram?: (relId: string) => ResolvedDiagram | undefined;
+    /**
+     * §21.2 a `c:chart` `@r:id` → the chart part's path, the key the reader files
+     * parsed charts under. Relationship ids are scoped to their owning part, so a
+     * footer's `rId1` and the body's `rId1` are different charts. Absent ⇒ the
+     * raw rel id is kept.
+     */
+    readonly resolveChartPart?: (relId: string) => string | undefined;
+    /**
+     * §20.1.4.2.19 — the theme's `a:lnStyleLst` widths in points, which a
+     * gallery-styled shape's `a:lnRef idx` indexes for its outline weight.
      */
-    readonly resolveDiagram?: (relId: string) => PoNode | undefined;
+    readonly themeLineWidths?: ReadonlyArray<number>;
+    /**
+     * §20.1.4.1.14/§20.1.4.1.15 — the theme's format scheme: the fill, background
+     * fill and effect styles a `<wps:style>` reference indexes for the fill and
+     * the shadow a gallery-drawn shape wears.
+     */
+    readonly themeStyles?: ThemeStyles;
     /**
      * Sink for graceful-degradation notices (E-SMARTART SA3): a SmartArt with no
      * drawing override records a dropped-feature {@link Loss} rather than vanishing.
@@ -41,6 +69,12 @@ export interface ParseContext {
      * reference is readonly; its contents mutate during the walk (CM2c).
      */
     readonly openCommentRanges?: Set<string>;
+    /**
+     * §17.3.1.1/§17.3.1.3 — what `w:beforeAutospacing`/`w:afterAutospacing`
+     * resolve to for THIS document: 14pt when it states no compatibility mode,
+     * and nothing (the default) for every Word 2007-or-later one.
+     */
+    readonly autoSpacingPt?: number;
 }
 /** The default {@link ParseContext} — just the default colour resolver. */
 export declare const DEFAULT_PARSE_CONTEXT: ParseContext;
@@ -53,8 +87,55 @@ export declare const DEFAULT_PARSE_CONTEXT: ParseContext;
  * @param ctx         The document-wide parse context.
  * @returns The body elements; empty when the `w:body` is absent.
  */
-export declare function parseDocument(documentXml: Uint8Array, ctx?: ParseContext): Array<BodyElement>;
-/** The empty {@link SectionProperties} fallback (no headers/footers). */
+export declare function parseDocument(documentXml: Uint8Array, ctx?: ParseContext, blocks?: BlockCounter): Array<BodyElement>;
+/**
+ * §17.2.1 `w:background` — the colour the whole page is painted, as a six-digit
+ * hex. Read from `@w:color` (Word's own attribute), falling back to the VML
+ * `v:background @fillcolor` beside it. `auto` and a gradient-only background
+ * (which carries no flat colour of its own) both come back undefined.
+ *
+ * @param documentXml The raw `document.xml` bytes.
+ * @returns The colour, or undefined when the document names none.
+ */
+export declare function parseBackgroundColor(documentXml: Uint8Array): string | undefined;
+/**
+ * §17.2.1 — the page background as the FILL it is. `@w:color` is only the flat
+ * fallback: the `v:background` beside it carries the gradient or the picture
+ * Word actually paints, and both references draw those. fill.docx runs a
+ * five-stop radial sweep where we painted its fallback navy, and
+ * tdf126533_pageBitmap.docx papers the page with an image.
+ *
+ * @param documentXml  The raw `document.xml` bytes.
+ * @param resolveImage Resolver for a picture background's `r:id`.
+ * @returns The fill, or undefined when the document names no background.
+ */
+export declare function parseBackgroundFill(documentXml: Uint8Array, resolveImage?: (relId: string) => ResourceId | undefined): ShapeFill | undefined;
+/**
+ * Lines a parsed body up with anything counted in SOURCE blocks. `index[i]` is
+ * the ordinal of the `w:p`/`w:tbl` that produced body element `i`; `next` is the
+ * running count. A paragraph carrying anchored drawings produces several
+ * elements, so the two counts diverge — and {@link parseSections} counts blocks.
+ */
+export interface BlockCounter {
+    readonly index: Array<number>;
+    next: number;
+}
+/** A fresh {@link BlockCounter}. */
+export declare function newBlockCounter(): BlockCounter;
+/**
+ * Translate a section boundary counted in source blocks into one counted in body
+ * elements: the number of elements that came from a block before `blockEnd`.
+ *
+ * @param blocks   The counter filled while parsing the body.
+ * @param blockEnd The section's `endIndex`, in source blocks.
+ * @returns The matching body-element index.
+ */
+export declare function bodyIndexForBlock(blocks: BlockCounter, blockEnd: number): number;
+/**
+ * The empty {@link SectionProperties} fallback (no headers/footers). §17.6.13 —
+ * on the page a document with no `w:sectPr` of its own is made on, which is the
+ * same US Letter a section with no `w:pgSz` gets.
+ */
 export declare const EMPTY_SECTION: SectionProperties;
 /**
  * Parse the document's final section properties (ECMA-376 Part 1 §17.6.17 — the
@@ -96,7 +177,15 @@ export declare function parseHeaderFooter(xml: Uint8Array, ctx?: ParseContext):
  * @param ctx      The document-wide parse context.
  * @returns The parsed body elements.
  */
-export declare function parseBodyElements(children: ReadonlyArray<PoNode>, ctx?: ParseContext): Array<BodyElement>;
+export declare function parseBodyElements(children: ReadonlyArray<PoNode>, ctx?: ParseContext, blocks?: BlockCounter, sdtRunProps?: RunProperties): Array<BodyElement>;
+/**
+ * §17.5.2.28 `w:sdt/w:sdtPr/w:rPr` — the run properties a content control
+ * lends what it holds, when it states any.
+ *
+ * @param sdt The `w:sdt` element.
+ * @returns The properties, or `undefined` when the control states none.
+ */
+export declare function sdtRunProperties(sdt: PoNode): RunProperties | undefined;
 /**
  * Parse `footnotes.xml` / `endnotes.xml` (§17.11) into note content by id. The
  * separator / continuationSeparator / continuationNotice stubs (negative ids or