reamkit 1.21.0 → 1.22.0

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

@@ -4,14 +4,15 @@ import { FEATURES } from "../core/ir/features.js";
 import { EMPTY_STYLE_SHEET, resolveBodyStyles } from "../core/style-cascade/resolver.js";
 import "../core/style-cascade/index.js";
 import { poAttr, poChildren, poFindDescendant, poIntAttr, poIs } from "../core/po-helpers.js";
-import { bytesIncludePartName } from "../core/bytes.js";
-import { DEFAULT_THEME_PALETTE, defaultColorResolver, makeColorResolver } from "../core/drawingml/colors.js";
+import { packageHasPart } from "../core/bytes.js";
+import { DEFAULT_SCHEME_ALIAS, DEFAULT_THEME_PALETTE, defaultColorResolver, makeColorResolver } from "../core/drawingml/colors.js";
 import { parseChart, withChartColorStyle } from "../core/drawingml/chart-parser.js";
-import { parseTheme } from "../core/drawingml/theme-parser.js";
+import { parseTheme, parseThemeBgFillStyles, parseThemeFillStyles, parseThemeLineWidths } from "../core/drawingml/theme-parser.js";
 import { OpcPackage } from "../core/opc/package.js";
 import "../core/opc/index.js";
-import { buildPlaceholderCascade } from "./placeholder-cascade.js";
-import { backdropElement, parseBackgroundFill, parseSlideShapes } from "./slide-parser.js";
+import { buildPlaceholderCascade, parseLevelStyles } from "./placeholder-cascade.js";
+import { normalizeSpid, parseVmlImageRels } from "./ole-preview.js";
+import { asBackdrop, backdropElement, parseBackgroundFill, parseSlideShapes } from "./slide-parser.js";
 import { XMLParser } from "fast-xml-parser";
 //#region src/pptx/pptx-reader.ts
 var EMU_PER_PT = 12700;
@@ -47,15 +48,18 @@ function readPptx(bytes) {
 	const losses = [];
 	const pkg = OpcPackage.open(bytes);
 	const presPath = pkg.getMainDocumentPath();
+	const tableStyles = makeTableStyleResolver(pkg, presPath);
 	const presData = pkg.getPart(presPath);
 	const resources = new ResourceStore();
 	const charts = /* @__PURE__ */ new Map();
 	let cx = DEFAULT_CX;
 	let cy = DEFAULT_CY;
+	let defaultTextStyle;
 	const slideParts = [];
 	if (presData) {
 		const pres = parser.parse(decoder.decode(presData)).find((n) => poIs(n, "p:presentation"));
 		const kids = pres ? poChildren(pres) : [];
+		defaultTextStyle = kids.find((c) => poIs(c, "p:defaultTextStyle"));
 		const sldSz = kids.find((c) => poIs(c, "p:sldSz"));
 		cx = (sldSz ? poIntAttr(sldSz, "cx") : void 0) || DEFAULT_CX;
 		cy = (sldSz ? poIntAttr(sldSz, "cy") : void 0) || DEFAULT_CY;
@@ -103,20 +107,37 @@ function readPptx(bytes) {
 		});
 		const part = slideParts[i];
 		if (part) {
-			const styles = slideStylesFor(pkg, part.path, stylesByLayout);
+			const slideTree = parseXml(part.data);
+			const styles = slideStylesFor(pkg, part.path, stylesByLayout, resources, charts, (loss) => losses.push(loss.where ? loss : {
+				...loss,
+				where: `slide ${i + 1}`
+			}), defaultTextStyle, {
+				widthPt: pageW,
+				heightPt: pageH
+			}, overrideAlias(slideTree, "p:sld"));
 			const ctx = {
 				...styles.cascade ? { cascade: styles.cascade } : {},
 				colors: styles.colors,
+				...styles.background ? { backgroundFill: styles.background } : {},
+				slideSize: {
+					widthPt: pageW,
+					heightPt: pageH
+				},
+				...styles.themeFills ? { themeFills: styles.themeFills } : {},
+				...styles.themeLineWidths ? { themeLineWidths: styles.themeLineWidths } : {},
 				resolveImage: makeSlideImageResolver(pkg, part.path, resources),
-				resolveChart: makeSlideChartResolver(pkg, part.path, charts, styles.colors),
+				resolveChart: makeSlideChartResolver(pkg, part.path, charts, styles.colors, resources),
 				resolveHyperlink: makeHyperlinkResolver(pkg, part.path),
 				resolveDiagram: makeSlideDiagramResolver(pkg, part.path),
+				resolveOlePreview: makeOlePreviewResolver(pkg, part.path, resources),
+				resolveTableStyle: tableStyles,
 				onLoss: (loss) => losses.push(loss.where ? loss : {
 					...loss,
 					where: `slide ${i + 1}`
 				})
 			};
-			body.push(...parseSlide(part.data, ctx, styles.background, pageW, pageH));
+			const inherited = showMasterShapes(slideTree, "p:sld") ? styles.inheritedShapes ?? [] : [];
+			body.push(...parseSlide(slideTree, ctx, styles.background, pageW, pageH, inherited));
 		}
 	}
 	const section = {
@@ -154,23 +175,29 @@ function readPptx(bytes) {
 function parseXml(data) {
 	return parser.parse(decoder.decode(data));
 }
-function parseSlide(data, ctx, inheritedBg, pageW, pageH) {
-	const sld = parseXml(data).find((n) => poIs(n, "p:sld"));
+function parseSlide(tree, ctx, inheritedBg, pageW, pageH, inheritedShapes = []) {
+	const sld = tree.find((n) => poIs(n, "p:sld"));
 	const cSld = sld ? poChildren(sld).find((c) => poIs(c, "p:cSld")) : void 0;
 	const colors = ctx.colors ?? defaultColorResolver;
 	const bgNode = cSld ? poChildren(cSld).find((c) => poIs(c, "p:bg")) : void 0;
-	const bg = (bgNode ? parseBackgroundFill(bgNode, colors) : void 0) ?? inheritedBg;
+	const own = bgNode ? parseBackgroundFill(bgNode, colors, ctx.resolveImage, ctx.themeFills) : void 0;
+	const bg = own ?? inheritedBg;
 	const spTree = cSld ? poChildren(cSld).find((c) => poIs(c, "p:spTree")) : void 0;
+	const shapeCtx = own ? {
+		...ctx,
+		backgroundFill: own
+	} : ctx;
 	const out = [];
 	if (bg) out.push(backdropElement(bg, pageW, pageH));
-	if (spTree) out.push(...parseSlideShapes(spTree, ctx));
+	out.push(...inheritedShapes.map(asBackdrop));
+	if (spTree) out.push(...parseSlideShapes(spTree, shapeCtx));
 	return out;
 }
-function partBackground(tree, root, colors) {
+function partBackground(tree, root, colors, resolveImage, themeFills) {
 	const sld = tree.find((n) => poIs(n, root));
 	const cSld = sld ? poChildren(sld).find((c) => poIs(c, "p:cSld")) : void 0;
 	const bg = cSld ? poChildren(cSld).find((c) => poIs(c, "p:bg")) : void 0;
-	return bg ? parseBackgroundFill(bg, colors) : void 0;
+	return bg ? parseBackgroundFill(bg, colors, resolveImage, themeFills) : void 0;
 }
 function makeSlideImageResolver(pkg, slidePath, resources) {
 	const cache = /* @__PURE__ */ new Map();
@@ -183,19 +210,77 @@ function makeSlideImageResolver(pkg, slidePath, resources) {
 		return id;
 	};
 }
+/**
+* The preview picture resolver for one slide's embedded objects: a `p:oleObj`
+* `@spid` → the media the slide's legacy VML drawing hangs off that shape.
+*
+* Two relationship hops, and neither is the slide's own: the slide names the
+* VML part, and the VML part names the picture. The whole part is read once,
+* lazily — most slides have no embedded object at all.
+*/
+function makeOlePreviewResolver(pkg, slidePath, resources) {
+	let byShape;
+	let vmlPath;
+	const cache = /* @__PURE__ */ new Map();
+	return (spid) => {
+		const key = normalizeSpid(spid);
+		if (cache.has(key)) return cache.get(key);
+		if (byShape === void 0) {
+			const rel = pkg.getPartRelationships(slidePath).find((r) => r.type.endsWith("/vmlDrawing") || r.type.endsWith("/legacyDrawing"));
+			const part = rel ? pkg.resolveRelatedPart(slidePath, rel) : void 0;
+			byShape = part ? parseVmlImageRels(part.data) : /* @__PURE__ */ new Map();
+			vmlPath = part?.path;
+		}
+		const relId = byShape.get(key);
+		const imgRel = relId !== void 0 && vmlPath !== void 0 ? pkg.getPartRelationships(vmlPath).find((r) => r.id === relId) : void 0;
+		const media = imgRel && vmlPath !== void 0 ? pkg.resolveRelatedPart(vmlPath, imgRel) : void 0;
+		const id = media ? resources.put(media.data) : void 0;
+		cache.set(key, id);
+		return id;
+	};
+}
+/**
+* §20.1.4.2.24 — the deck's table styles, by the GUID a table names.
+*
+* The list's own `@def` is NOT a fallback: it is the style PowerPoint applies
+* when a table is INSERTED, and the table then records that GUID itself. A
+* table that names none wears none — table-with-no-theme's two rows are bare
+* text in a plain frame, not the blue banding `@def` points at.
+*
+* The part is read once, on the first table in the deck.
+*/
+function makeTableStyleResolver(pkg, presPath) {
+	let byId;
+	return (styleId) => {
+		if (byId === void 0) {
+			byId = /* @__PURE__ */ new Map();
+			const rel = pkg.getPartRelationships(presPath).find((r) => r.type.endsWith("/tableStyles"));
+			const part = rel ? pkg.resolveRelatedPart(presPath, rel) : void 0;
+			for (const root of part ? parseXml(part.data) : []) {
+				const list = poIs(root, "a:tblStyleLst") ? root : poFindDescendant(root, "a:tblStyleLst");
+				if (!list) continue;
+				for (const style of poChildren(list)) {
+					const id = poIs(style, "a:tblStyle") ? poAttr(style, "styleId") : void 0;
+					if (id !== void 0) byId.set(id, style);
+				}
+			}
+		}
+		return styleId === void 0 ? void 0 : byId.get(styleId);
+	};
+}
 function makeHyperlinkResolver(pkg, slidePath) {
 	return (relId) => {
 		const rel = pkg.getPartRelationships(slidePath).find((r) => r.id === relId);
 		return rel && rel.targetMode === "External" ? rel.target : void 0;
 	};
 }
-function makeSlideChartResolver(pkg, slidePath, charts, colors) {
+function makeSlideChartResolver(pkg, slidePath, charts, colors, resources) {
 	const cache = /* @__PURE__ */ new Map();
 	return (relId) => {
 		if (cache.has(relId)) return cache.get(relId);
 		const rel = pkg.getPartRelationships(slidePath).find((r) => r.id === relId);
 		const resolved = rel ? pkg.resolveRelatedPart(slidePath, rel) : void 0;
-		const chart = resolved ? parseChart(resolved.data, colors) : null;
+		const chart = resolved ? parseChart(resolved.data, colors, makeSlideImageResolver(pkg, resolved.path, resources)) : null;
 		let key;
 		if (chart && resolved) {
 			key = `${slidePath}!${relId}`;
@@ -212,49 +297,172 @@ function makeSlideDiagramResolver(pkg, slidePath) {
 		let spTree;
 		const dataRel = pkg.getPartRelationships(slidePath).find((r) => r.id === relId);
 		const data = dataRel ? pkg.resolveRelatedPart(slidePath, dataRel) : void 0;
-		if (data) {
-			const drawRel = pkg.getPartRelationships(data.path).find((r) => r.type.endsWith("/diagramDrawing"));
-			const draw = drawRel ? pkg.resolveRelatedPart(data.path, drawRel) : void 0;
-			if (draw) for (const root of parseXml(draw.data)) {
-				const found = poFindDescendant(root, "dsp:spTree");
-				if (found) {
-					spTree = found;
-					break;
-				}
+		const draw = data ? drawingPart(pkg, slidePath, data) : void 0;
+		if (draw) for (const root of parseXml(draw.data)) {
+			const found = poFindDescendant(root, "dsp:spTree");
+			if (found) {
+				spTree = found;
+				break;
 			}
 		}
 		cache.set(relId, spTree);
 		return spTree;
 	};
 }
-function slideStylesFor(pkg, slidePath, cache) {
+/**
+* The pre-rendered drawing a diagram's data part points at.
+*
+* PowerPoint names it from INSIDE the data: `<dsp:dataModelExt relId>` in the
+* data's extension list, and that id is a relationship of the SLIDE, not of the
+* data part. Looked for on the data part alone — where some producers do put it
+* — two corpus decks with a `drawing1.xml` sitting right there reported having
+* no drawing at all and rendered nothing (smartart-missing-bullet,
+* tdf145528_SmartArt_Matrix).
+*
+* @param pkg       The package.
+* @param slidePath The slide the diagram is on.
+* @param data      The resolved `dgm:relIds@r:dm` data part.
+* @returns The drawing part, or undefined when the deck ships none.
+*/
+function drawingPart(pkg, slidePath, data) {
+	const extRelId = parseXml(data.data).map((root) => poFindDescendant(root, "dsp:dataModelExt")).map((ext) => ext ? poAttr(ext, "relId") : void 0).find((id) => id !== void 0);
+	const bySlide = extRelId !== void 0 ? pkg.getPartRelationships(slidePath).find((r) => r.id === extRelId) : void 0;
+	if (bySlide) {
+		const part = pkg.resolveRelatedPart(slidePath, bySlide);
+		if (part) return part;
+	}
+	const own = pkg.getPartRelationships(data.path).find((r) => r.type.endsWith("/diagramDrawing"));
+	if (own) return pkg.resolveRelatedPart(data.path, own);
+	const onSlide = pkg.getPartRelationships(slidePath).filter((r) => r.type.endsWith("/diagramDrawing"));
+	return onSlide.length === 1 && onSlide[0] ? pkg.resolveRelatedPart(slidePath, onSlide[0]) : void 0;
+}
+function slideStylesFor(pkg, slidePath, cache, resources, charts, onLoss, deckDefaultTextStyle, slideSize, slideAlias) {
 	const layoutRel = pkg.getPartRelationships(slidePath).find((r) => r.type.endsWith("/slideLayout"));
 	const layout = layoutRel ? pkg.resolveRelatedPart(slidePath, layoutRel) : void 0;
 	if (!layout) return { colors: defaultColorResolver };
-	const cached = cache.get(layout.path);
+	const key = slideAlias ? `${layout.path}|${aliasKey(slideAlias)}` : layout.path;
+	const cached = cache.get(key);
 	if (cached) return cached;
 	const masterRel = pkg.getPartRelationships(layout.path).find((r) => r.type.endsWith("/slideMaster"));
 	const master = masterRel ? pkg.resolveRelatedPart(layout.path, masterRel) : void 0;
-	const colors = master ? deckColorResolver(pkg, master.path) : defaultColorResolver;
 	const layoutTree = parseXml(layout.data);
 	const masterTree = master ? parseXml(master.data) : void 0;
-	const cascade = buildPlaceholderCascade(layoutTree, masterTree, colors);
-	const background = partBackground(layoutTree, "p:sldLayout", colors) ?? (masterTree ? partBackground(masterTree, "p:sldMaster", colors) : void 0);
+	const inheritedAlias = overrideAlias(layoutTree, "p:sldLayout") ?? (masterTree ? masterAlias(masterTree) : void 0);
+	const alias = slideAlias ?? inheritedAlias;
+	const theme = master ? themePart(pkg, master.path) : void 0;
+	const colors = master ? deckColorResolver(theme?.data, alias) : defaultColorResolver;
+	const inheritedColors = slideAlias === void 0 || !master ? colors : deckColorResolver(theme?.data, inheritedAlias);
+	const themeFills = theme ? {
+		fills: parseThemeFillStyles(theme.data),
+		backgrounds: parseThemeBgFillStyles(theme.data),
+		resolveImage: makeSlideImageResolver(pkg, theme.path, resources)
+	} : void 0;
+	const themeLineWidths = theme ? parseThemeLineWidths(theme.data) : void 0;
+	const cascade = buildPlaceholderCascade(layoutTree, masterTree, colors, parseLevelStyles(deckDefaultTextStyle, colors));
+	const background = partBackground(layoutTree, "p:sldLayout", inheritedColors, makeSlideImageResolver(pkg, layout.path, resources), themeFills) ?? (masterTree && master ? partBackground(masterTree, "p:sldMaster", inheritedColors, makeSlideImageResolver(pkg, master.path, resources), themeFills) : void 0);
+	const deps = {
+		colors: inheritedColors,
+		resources,
+		charts,
+		onLoss,
+		slideSize,
+		...themeFills ? { themeFills } : {},
+		...themeLineWidths && themeLineWidths.length > 0 ? { themeLineWidths } : {},
+		...background ? { background } : {}
+	};
+	const inheritedShapes = [];
+	if (masterTree && master && showMasterShapes(layoutTree, "p:sldLayout")) inheritedShapes.push(...partShapes(pkg, master.path, masterTree, "p:sldMaster", deps));
+	inheritedShapes.push(...partShapes(pkg, layout.path, layoutTree, "p:sldLayout", deps));
 	const styles = {
 		cascade,
 		colors,
-		...background ? { background } : {}
+		...themeFills ? { themeFills } : {},
+		...themeLineWidths && themeLineWidths.length > 0 ? { themeLineWidths } : {},
+		...background ? { background } : {},
+		...inheritedShapes.length > 0 ? { inheritedShapes } : {}
 	};
-	cache.set(layout.path, styles);
+	cache.set(key, styles);
 	return styles;
 }
-function deckColorResolver(pkg, masterPath) {
-	const themeRel = pkg.getPartRelationships(masterPath).find((r) => r.type.endsWith("/theme"));
-	const theme = themeRel ? pkg.resolveRelatedPart(masterPath, themeRel) : void 0;
-	if (!theme) return defaultColorResolver;
+/**
+* A master's or layout's own drawn shapes — everything in its `p:spTree` that
+* is not a placeholder, read with resolvers bound to THAT part: a logo's image
+* relationship, a chart's, a hyperlink's are all scoped to the part that names
+* them.
+*/
+function partShapes(pkg, path, tree, root, deps) {
+	const part = tree.find((n) => poIs(n, root));
+	const cSld = part ? poChildren(part).find((c) => poIs(c, "p:cSld")) : void 0;
+	const spTree = cSld ? poChildren(cSld).find((c) => poIs(c, "p:spTree")) : void 0;
+	if (!spTree) return [];
+	return parseSlideShapes(spTree, {
+		colors: deps.colors,
+		...deps.themeFills ? { themeFills: deps.themeFills } : {},
+		...deps.themeLineWidths ? { themeLineWidths: deps.themeLineWidths } : {},
+		...deps.background ? { backgroundFill: deps.background } : {},
+		slideSize: deps.slideSize,
+		resolveImage: makeSlideImageResolver(pkg, path, deps.resources),
+		resolveChart: makeSlideChartResolver(pkg, path, deps.charts, deps.colors, deps.resources),
+		resolveHyperlink: makeHyperlinkResolver(pkg, path),
+		resolveDiagram: makeSlideDiagramResolver(pkg, path),
+		onLoss: deps.onLoss
+	}, void 0, true);
+}
+/**
+* §19.3.1.38/§19.3.1.39 `@showMasterSp` — whether this part draws the shapes it
+* inherits. Absent, it does.
+*/
+function showMasterShapes(tree, root) {
+	const part = tree.find((n) => poIs(n, root));
+	return part === void 0 || poAttr(part, "showMasterSp") !== "0";
+}
+/** The master's `p:clrMap` (§19.3.1.6) as a scheme-alias table. */
+function masterAlias(masterTree) {
+	const master = masterTree.find((n) => poIs(n, "p:sldMaster"));
+	const map = master ? poChildren(master).find((c) => poIs(c, "p:clrMap")) : void 0;
+	return map ? aliasFromAttrs(map) : void 0;
+}
+/**
+* A layout's or slide's `p:clrMapOvr` (§19.3.1.7) as a scheme-alias table, or
+* `undefined` when it holds `a:masterClrMapping` — which says "the master's",
+* i.e. nothing of its own.
+*/
+function overrideAlias(tree, root) {
+	const part = tree.find((n) => poIs(n, root));
+	const ovr = part ? poChildren(part).find((c) => poIs(c, "p:clrMapOvr")) : void 0;
+	const own = ovr ? poChildren(ovr).find((c) => poIs(c, "a:overrideClrMapping")) : void 0;
+	return own ? aliasFromAttrs(own) : void 0;
+}
+function aliasFromAttrs(node) {
+	const alias = {};
+	for (const name of [
+		"bg1",
+		"tx1",
+		"bg2",
+		"tx2"
+	]) {
+		const slot = poAttr(node, name);
+		if (slot !== void 0) alias[name] = slot;
+	}
+	return alias;
+}
+/** A stable key for an alias table, so the per-layout cache can include it. */
+function aliasKey(alias) {
+	return Object.entries(alias).sort(([a], [b]) => a < b ? -1 : 1).map(([k, v]) => `${k}=${v}`).join(",");
+}
+function deckColorResolver(theme, alias) {
 	const palette = new Map(DEFAULT_THEME_PALETTE);
-	for (const [slot, hex] of parseTheme(theme.data)) palette.set(slot, hex);
-	return makeColorResolver(palette);
+	if (theme) for (const [slot, hex] of parseTheme(theme)) palette.set(slot, hex);
+	if (!theme && !alias) return defaultColorResolver;
+	return makeColorResolver(palette, {
+		...DEFAULT_SCHEME_ALIAS,
+		...alias
+	});
+}
+/** The master's theme part, if it has one — its path names its own pictures. */
+function themePart(pkg, masterPath) {
+	const rel = pkg.getPartRelationships(masterPath).find((r) => r.type.endsWith("/theme"));
+	return rel ? pkg.resolveRelatedPart(masterPath, rel) : void 0;
 }
 /**
 * The {@link DocumentReader} for PresentationML (`.pptx`): sniffs the OPC ZIP for
@@ -271,7 +479,7 @@ var pptxReader = {
 		FEATURES.charts,
 		FEATURES.tables
 	]),
-	sniff: (bytes) => bytes[0] === 80 && bytes[1] === 75 && bytesIncludePartName(bytes, "ppt/presentation.xml"),
+	sniff: (bytes) => bytes[0] === 80 && bytes[1] === 75 && packageHasPart(bytes, "ppt/presentation.xml"),
 	read: (bytes) => readPptx(bytes)
 };
 //#endregion

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

@@ -15,6 +15,30 @@ export interface SlideContext {
     readonly cascade?: PlaceholderCascade;
     /** A slide-scoped blip relationship id (`a:blip @r:embed`) → a stored resource (PX3a). */
     readonly resolveImage?: (relId: string) => ResourceId | undefined;
+    /** The deck theme's fill style lists, for a `p:bgRef` on this slide. */
+    readonly themeFills?: ThemeFillStyles;
+    /** §20.1.4.1.21 `a:lnStyleLst` — the widths an `a:lnRef` indexes, in points. */
+    readonly themeLineWidths?: ReadonlyArray<number>;
+    /**
+     * §19.3.1.43 — the slide's own background fill, which a shape marked
+     * `useBgFill` is painted with.
+     */
+    readonly backgroundFill?: ShapeFill;
+    /** The slide's size, which says WHERE that background lies under a shape. */
+    readonly slideSize?: {
+        readonly widthPt: Pt;
+        readonly heightPt: Pt;
+    };
+    /**
+     * §19.3.2.4 — the picture an embedded object shows, by the `@spid` of its
+     * shape in the slide's legacy VML drawing.
+     */
+    readonly resolveOlePreview?: (spid: string) => ResourceId | undefined;
+    /**
+     * §20.1.4.2.24 — the `a:tblStyle` a table names by GUID, from the deck's
+     * `tableStyles.xml`. A table that names none wears none.
+     */
+    readonly resolveTableStyle?: (styleId: string | undefined) => PoNode | undefined;
     /** A chart relationship id (`c:chart @r:id`) → its document-unique key (PX4a). */
     readonly resolveChart?: (relId: string) => string | undefined;
     /**
@@ -50,7 +74,7 @@ type GroupTransform = (box: ShapeBoxEmu) => ShapeBoxEmu;
  * @param transform Maps child-space boxes to the slide (identity at the top level).
  * @returns The container's shapes as positioned {@link BodyElement}s.
  */
-export declare function parseSlideShapes(container: PoNode, ctx?: SlideContext, transform?: GroupTransform): Array<BodyElement>;
+export declare function parseSlideShapes(container: PoNode, ctx?: SlideContext, transform?: GroupTransform, skipPlaceholders?: boolean): Array<BodyElement>;
 /**
  * The diagram's child shapes live in the spTree's own coordinate space
  * (`dsp:grpSpPr/a:xfrm` `chOff`/`chExt`); map that onto a target box (the frame on
@@ -106,13 +130,43 @@ export declare function parseDiagramNodes(spTree: PoNode, transform: GroupTransf
  */
 export declare function parseDiagramDrawing(spTree: PoNode, transform: GroupTransform, makeFloat: (box: ShapeBoxEmu) => FloatAnchor, colors: ColorResolver, resolveLink: LinkResolver): Array<ShapeBlock>;
 /**
- * `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
- * theme fill-style index) is approximated by its colour child as a solid fill.
+ * The theme fill styles a `p:bgRef` indexes into (§19.3.1.2), as the raw nodes
+ * the fill readers take.
+ */
+export interface ThemeFillStyles {
+    /** `a:fillStyleLst` — what an index of 1…999 names. */
+    readonly fills: ReadonlyArray<PoNode>;
+    /** `a:bgFillStyleLst` — what an index past 1000 names, 1001 being the first. */
+    readonly backgrounds: ReadonlyArray<PoNode>;
+    /**
+     * A picture named inside a style belongs to the THEME part: the Office
+     * "Berlin" background is a photograph the theme carries and its `r:embed`
+     * means nothing in the master's relationships (corpus: tdf123684, where it
+     * resolved to a different image entirely).
+     */
+    readonly resolveImage?: (relId: string) => ResourceId | undefined;
+}
+/**
+ * `p:bg` → the background fill, or `undefined` when it declares none.
+ *
+ * Two spellings. `p:bgPr` carries the fill itself — solid, gradient, or a
+ * PICTURE, which needs the owning part's image resolver since the blip's
+ * relationship is scoped to the part the background is written in. `p:bgRef`
+ * (§19.3.1.2) carries no fill at all: an index into the theme's style lists and
+ * the colour to put wherever that style says `phClr`. Read as its colour alone
+ * — which is all this did — a deck whose theme opens with a black-to-grey
+ * gradient came out flat, and one whose first background slot is a picture came
+ * out a single colour.
+ *
  * Used for the slide's own background and the inherited layout/master one (PX5b).
+ *
+ * @param bg           The `p:bg` node.
+ * @param colors       The deck's colour resolver.
+ * @param resolveImage Resolver for a picture background's relationship, scoped
+ *                     to the part this `p:bg` is written in.
+ * @param theme        The theme's fill style lists, for a `p:bgRef`.
  */
-export declare function parseBackgroundFill(bg: PoNode, colors: ColorResolver): ShapeFill | undefined;
+export declare function parseBackgroundFill(bg: PoNode, colors: ColorResolver, resolveImage?: (relId: string) => ResourceId | undefined, theme?: ThemeFillStyles): ShapeFill | undefined;
 /**
  * A full-slide backdrop element for a background fill: a rectangle covering the
  * page, anchored behind the content (PX5b).
@@ -123,10 +177,18 @@ export declare function parseBackgroundFill(bg: PoNode, colors: ColorResolver):
  */
 export declare function backdropElement(fill: ShapeFill, widthPt: Pt, heightPt: Pt): BodyElement;
 /**
- * `p:spPr` geometry: `a:prstGeom` (preset) or `a:custGeom` (custom path), default
- * rect. Exported for sheet shapes (E-SHEET W2), whose `xdr:spPr` carries the same
- * `a:` children.
+ * The same element, painted BEHIND the slide's own content.
+ *
+ * §19.3.1 — a slide's shape tree is drawn over its layout's, and that over the
+ * master's; nothing a deck states once can bury what a slide puts on it. Our
+ * page paints by KIND (every image, then every shape), so without this a
+ * layout's white card landed on top of the photograph the slide is made of —
+ * themes.pptx's fifth slide is one picture and it vanished under the card.
+ *
+ * @param el The inherited element.
+ * @returns The element with its float sunk to the backdrop layer.
  */
+export declare function asBackdrop(el: BodyElement): BodyElement;
 export declare function parseGeometry(spPr: PoNode | undefined): ShapeGeometry;
 /**
  * `p:txBody` → {@link ShapeTextBody}. `a:bodyPr` carries the insets and the
@@ -141,5 +203,5 @@ export declare function parseGeometry(spPr: PoNode | undefined): ShapeGeometry;
  * @param resolveLink A run hyperlink resolver, or `undefined`.
  * @returns The text body, or `undefined` when it holds no paragraphs.
  */
-export declare function parseTxBody(txBody: PoNode, ph: PlaceholderRef | undefined, cascade: PlaceholderCascade | undefined, colors: ColorResolver, resolveLink: LinkResolver): ShapeTextBody | undefined;
+export declare function parseTxBody(txBody: PoNode, ph: PlaceholderRef | undefined, cascade: PlaceholderCascade | undefined, colors: ColorResolver, resolveLink: LinkResolver, styleColor?: string): ShapeTextBody | undefined;
 export {};