reamkit 1.21.0 → 1.23.0

package/dist/esm/pptx/placeholder-cascade.js

@@ -1,6 +1,46 @@
-import { poChildren, poIs } from "../core/po-helpers.js";
+import { emuToPt, pt } from "../core/ir/units.js";
+import { fromSymbolFont } from "../core/metafile/symbol-fonts.js";
+import { poAttr, poChildren, poIntAttr, poIs } from "../core/po-helpers.js";
+import { resolveColorNode } from "../core/drawingml/colors.js";
 import { parsePh, parseXfrmBox, rPrToRunProps } from "./sp-helpers.js";
 //#region src/pptx/placeholder-cascade.ts
+/**
+* What an `a:pPr` (or an `a:lvlNpPr`, the same vocabulary) says about its
+* bullet — each part on its own, because a paragraph may restate the SIZE and
+* leave the character to its level.
+*
+* @param pPr    The paragraph-properties node.
+* @param colors The colour resolver, for `a:buClr`.
+* @returns What it states, or `undefined` when it says nothing about bullets.
+*/
+function parseBullet(pPr, colors) {
+	if (!pPr) return void 0;
+	const child = (tag) => poChildren(pPr).find((c) => poIs(c, tag));
+	const pct = poIntAttr(child("a:buSzPct"), "val");
+	const pts = poIntAttr(child("a:buSzPts"), "val");
+	const clr = child("a:buClr");
+	const colorHex = clr && colors ? poChildren(clr).map((c) => resolveColorNode(c, colors)).find((hex) => hex !== void 0) : void 0;
+	const size = {
+		...pct !== void 0 ? { sizePct: pct / 1e5 } : {},
+		...pts !== void 0 ? { sizePts: pts / 100 } : {},
+		...colorHex !== void 0 ? { colorHex } : {}
+	};
+	const buChar = child("a:buChar");
+	const buAuto = child("a:buAutoNum");
+	const kind = poChildren(pPr).some((c) => poIs(c, "a:buNone")) ? { kind: "none" } : buChar ? {
+		kind: "char",
+		char: fromSymbolFont(poAttr(buChar, "char") ?? "•", poAttr(child("a:buFont"), "typeface"))
+	} : buAuto ? {
+		kind: "autoNum",
+		type: poAttr(buAuto, "type") ?? "arabicPeriod",
+		startAt: poIntAttr(buAuto, "startAt") ?? 1
+	} : void 0;
+	const out = {
+		...size,
+		...kind
+	};
+	return Object.keys(out).length > 0 ? out : void 0;
+}
 function categoryOf(type) {
 	if (type === "title" || type === "ctrTitle") return "title";
 	if (type === void 0 || type === "body" || type === "subTitle" || type === "obj") return "body";
@@ -15,27 +55,221 @@ function categoryOf(type) {
 * @param layoutTree The parsed `p:sldLayout` part.
 * @param masterTree The parsed `p:sldMaster` part, when present.
 * @param colors     The deck's colour resolver, for scheme colours in the text styles.
+* @param deckDefaults The presentation's own default text style, as the floor.
+* @param themeFonts The theme's font scheme, for the `+mn-lt` tokens.
 */
-function buildPlaceholderCascade(layoutTree, masterTree, colors) {
-	const layoutPhs = collectPlaceholders(layoutTree, "p:sldLayout");
-	const masterPhs = masterTree ? collectPlaceholders(masterTree, "p:sldMaster") : [];
-	const txStyles = masterTree ? collectTxStyles(masterTree, colors) : {
+function buildPlaceholderCascade(layoutTree, masterTree, colors, deckDefaults = [], themeFonts) {
+	const layoutPhs = collectPlaceholders(layoutTree, "p:sldLayout", colors, themeFonts);
+	const masterPhs = masterTree ? collectPlaceholders(masterTree, "p:sldMaster", colors, themeFonts) : [];
+	const txStyles = masterTree ? collectTxStyles(masterTree, colors, themeFonts) : {
 		title: [],
 		body: [],
 		other: []
 	};
+	const styleAt = (ph, level) => {
+		const layers = [at(deckDefaults, level)];
+		if (ph) layers.push(at(txStyles[categoryOf(ph.type)], level), at(matchPlaceholder(masterPhs, ph)?.levels ?? [], level), at(matchPlaceholder(layoutPhs, ph)?.levels ?? [], level));
+		const merged = layers.reduce(mergeLevels, EMPTY_LEVEL);
+		return merged.spacingPct === void 0 ? merged : withResolvedSpacing(merged);
+	};
 	return {
 		geometryFor(ph) {
 			return matchPlaceholder(layoutPhs, ph)?.box ?? matchPlaceholder(masterPhs, ph)?.box;
 		},
 		defaultsFor(ph, level) {
-			const levels = txStyles[categoryOf(ph.type)];
-			if (levels.length === 0) return {};
-			return levels[Math.min(Math.max(level, 0), levels.length - 1)] ?? {};
+			return styleAt(ph, level).run;
+		},
+		paragraphDefaultsFor(ph, level) {
+			return styleAt(ph, level).paragraph;
+		},
+		bulletFor(ph, level) {
+			return styleAt(ph, level).bullet;
+		},
+		anchorFor(ph) {
+			return matchPlaceholder(layoutPhs, ph)?.anchor ?? matchPlaceholder(masterPhs, ph)?.anchor;
+		},
+		shapePropsFor(ph) {
+			return [matchPlaceholder(layoutPhs, ph)?.spPr, matchPlaceholder(masterPhs, ph)?.spPr].filter((n) => n !== void 0);
+		}
+	};
+}
+var EMPTY_LEVEL = {
+	run: {},
+	paragraph: {}
+};
+/**
+* §21.1.2.2.9/.10 — the space a paragraph states as a FRACTION of a line, in
+* points.
+*
+* A "line" here is the paragraph's own text at its natural height, which is the
+* size times the same 1.2 the layout gives an unstated line. A level that
+* states the fraction and leaves the size to another level is resolved once
+* they have merged, which is why this is not read where the fraction is.
+*
+* @param pct      The fraction, `0..n` (20% arrives as 0.2).
+* @param sizePt   The paragraph's resolved font size.
+* @returns The distance, or `undefined` when the size is not known.
+*/
+function spacingFromLineFraction(pct, sizePt) {
+	if (pct === void 0 || sizePt === void 0) return void 0;
+	return pt(pct * sizePt * NATURAL_LINE);
+}
+/** What the layout gives a line of text with nothing said about its height. */
+var NATURAL_LINE = 1.2;
+function withResolvedSpacing(level) {
+	const size = level.run.fontSizePt;
+	const before = spacingFromLineFraction(level.spacingPct?.before, size);
+	const after = spacingFromLineFraction(level.spacingPct?.after, size);
+	if (before === void 0 && after === void 0) return level;
+	return {
+		...level,
+		paragraph: {
+			...level.paragraph,
+			...before !== void 0 ? { spacingBefore: before } : {},
+			...after !== void 0 ? { spacingAfter: after } : {}
 		}
 	};
 }
-function collectPlaceholders(tree, root) {
+/** The style at `level`, clamped to the list — a deeper level keeps the last. */
+function at(levels, level) {
+	if (levels.length === 0) return EMPTY_LEVEL;
+	return levels[Math.min(Math.max(level, 0), levels.length - 1)] ?? EMPTY_LEVEL;
+}
+/** `next` over `base` — a layer states only what it changes. */
+function mergeLevels(base, next) {
+	const bullet = base.bullet || next.bullet ? {
+		...base.bullet,
+		...next.bullet
+	} : void 0;
+	const spacingPct = base.spacingPct || next.spacingPct ? {
+		...base.spacingPct,
+		...next.spacingPct
+	} : void 0;
+	return {
+		run: {
+			...base.run,
+			...next.run
+		},
+		paragraph: {
+			...base.paragraph,
+			...next.paragraph
+		},
+		...bullet ? { bullet } : {},
+		...spacingPct ? { spacingPct } : {}
+	};
+}
+/**
+* `a:lstStyle` (or a `p:txStyles` family) → its nine levels. Shared by the
+* deck's default text style, the master's families and a prototype's own list,
+* which are the same vocabulary written in different places.
+*
+* @param list   The `a:lstStyle` / `p:titleStyle` / … node.
+* @param colors The deck's colour resolver.
+* @param prefix The level element prefix: `a:lvl` here, always.
+* @returns The nine levels, or an empty list when there is no such node.
+*/
+function parseLevelStyles(list, colors, themeFonts) {
+	if (!list) return [];
+	const out = [];
+	for (let lvl = 1; lvl <= 9; lvl++) {
+		const lvlPr = poChildren(list).find((c) => poIs(c, `a:lvl${String(lvl)}pPr`));
+		const defRPr = lvlPr ? poChildren(lvlPr).find((c) => poIs(c, "a:defRPr")) : void 0;
+		const bullet = parseBullet(lvlPr, colors);
+		const spacingPct = spacingFractions(lvlPr);
+		out.push({
+			run: rPrToRunProps(defRPr, colors, themeFonts),
+			paragraph: pPrToParagraphProps(lvlPr),
+			...bullet ? { bullet } : {},
+			...spacingPct ? { spacingPct } : {}
+		});
+	}
+	return out;
+}
+var ALGN = {
+	l: "left",
+	ctr: "center",
+	r: "right",
+	just: "both",
+	dist: "distribute"
+};
+/**
+* A level's paragraph shape — §21.1.2.2.7 `@algn`, `@marL`/`@indent`, and the
+* space around and between its lines.
+*
+* Both spacings come in two spellings: `a:spcPts` is a distance (hundredths of
+* a point) and `a:spcPct` a FRACTION of a line (thousandths of a percent). Only
+* the distance was read, so a deck that spaces its bullets the usual way — by
+* fraction — set them solid.
+*/
+function pPrToParagraphProps(lvlPr) {
+	if (!lvlPr) return {};
+	const algn = poAttr(lvlPr, "algn");
+	const marL = poIntAttr(lvlPr, "marL");
+	const indent = poIntAttr(lvlPr, "indent");
+	return {
+		...algn !== void 0 && ALGN[algn] ? { alignment: ALGN[algn] } : {},
+		...marL !== void 0 ? { indentLeft: emuToPt(marL) } : {},
+		...indent !== void 0 ? { indentFirstLine: emuToPt(indent) } : {},
+		...spacingPt(lvlPr, "a:spcBef", "spacingBefore"),
+		...spacingPt(lvlPr, "a:spcAft", "spacingAfter"),
+		...lineSpacing(lvlPr)
+	};
+}
+/**
+* §21.1.2.2.5 `a:lnSpc` — the height of each line: a fraction of the natural
+* one (`a:spcPct`) or a distance (`a:spcPts`).
+*
+* The model states a multiple the way §17.3.1.33 does — 12pt under the `auto`
+* rule IS single — so a fraction needs no font size to express, which is why
+* this resolves here and the paragraph SPACING has to wait for the size.
+*
+* @param pPr The paragraph properties (a level's or a paragraph's own).
+* @returns The line spacing, or nothing when the node states none.
+*/
+function lineSpacing(pPr) {
+	const holder = pPr ? poChildren(pPr).find((c) => poIs(c, "a:lnSpc")) : void 0;
+	if (!holder) return {};
+	const pctVal = poIntAttr(poChildren(holder).find((c) => poIs(c, "a:spcPct")), "val");
+	if (pctVal !== void 0 && pctVal > 0) return {
+		spacingLine: pt(pctVal / 1e5 * 12),
+		spacingLineRule: "auto"
+	};
+	const ptsVal = poIntAttr(poChildren(holder).find((c) => poIs(c, "a:spcPts")), "val");
+	if (ptsVal !== void 0 && ptsVal > 0) return {
+		spacingLine: pt(ptsVal / 100),
+		spacingLineRule: "exact"
+	};
+	return {};
+}
+/**
+* §21.1.2.2.9/.10 — the fraction of a line a paragraph puts before and after
+* itself, when it states one. The distance form is read beside it; this is what
+* the caller must still resolve against the size.
+*
+* @param pPr The paragraph properties.
+* @returns The two fractions (`0..n`), each present only when stated.
+*/
+function spacingFractions(pPr) {
+	const frac = (tag) => {
+		const holder = pPr ? poChildren(pPr).find((c) => poIs(c, tag)) : void 0;
+		const pctNode = holder ? poChildren(holder).find((c) => poIs(c, "a:spcPct")) : void 0;
+		const val = pctNode ? poIntAttr(pctNode, "val") : void 0;
+		return val === void 0 || val < 0 ? void 0 : val / 1e5;
+	};
+	const [before, after] = [frac("a:spcBef"), frac("a:spcAft")];
+	if (before === void 0 && after === void 0) return void 0;
+	return {
+		...before !== void 0 ? { before } : {},
+		...after !== void 0 ? { after } : {}
+	};
+}
+function spacingPt(lvlPr, tag, key) {
+	const holder = poChildren(lvlPr).find((c) => poIs(c, tag));
+	const pts = holder ? poChildren(holder).find((c) => poIs(c, "a:spcPts")) : void 0;
+	const val = pts ? poIntAttr(pts, "val") : void 0;
+	return val === void 0 ? {} : { [key]: pt(val / 100) };
+}
+function collectPlaceholders(tree, root, colors, themeFonts) {
 	const sld = tree.find((n) => poIs(n, root));
 	const cSld = sld ? poChildren(sld).find((c) => poIs(c, "p:cSld")) : void 0;
 	const spTree = cSld ? poChildren(cSld).find((c) => poIs(c, "p:spTree")) : void 0;
@@ -45,10 +279,19 @@ function collectPlaceholders(tree, root) {
 		if (!poIs(sp, "p:sp")) continue;
 		const ref = parsePh(sp);
 		if (!ref) continue;
-		const box = parseXfrmBox(poChildren(sp).find((c) => poIs(c, "p:spPr")));
+		const spPr = poChildren(sp).find((c) => poIs(c, "p:spPr"));
+		const box = parseXfrmBox(spPr);
+		const txBody = poChildren(sp).find((c) => poIs(c, "p:txBody"));
+		const lstStyle = txBody ? poChildren(txBody).find((c) => poIs(c, "a:lstStyle")) : void 0;
+		const bodyPr = txBody ? poChildren(txBody).find((c) => poIs(c, "a:bodyPr")) : void 0;
+		const a = bodyPr ? poAttr(bodyPr, "anchor") : void 0;
+		const anchor = a === "ctr" || a === "b" || a === "t" ? a : void 0;
 		out.push({
 			ref,
-			...box ? { box } : {}
+			...box ? { box } : {},
+			...spPr ? { spPr } : {},
+			levels: parseLevelStyles(lstStyle, colors, themeFonts),
+			...anchor ? { anchor } : {}
 		});
 	}
 	return out;
@@ -63,25 +306,15 @@ function matchPlaceholder(list, ph) {
 	const cat = categoryOf(ph.type);
 	return list.find((p) => categoryOf(p.ref.type) === cat);
 }
-function collectTxStyles(masterTree, colors) {
+function collectTxStyles(masterTree, colors, themeFonts) {
 	const sld = masterTree.find((n) => poIs(n, "p:sldMaster"));
 	const txStyles = sld ? poChildren(sld).find((c) => poIs(c, "p:txStyles")) : void 0;
+	const family = (tag) => parseLevelStyles(txStyles ? poChildren(txStyles).find((c) => poIs(c, tag)) : void 0, colors, themeFonts);
 	return {
-		title: levelStyles(txStyles, "p:titleStyle", colors),
-		body: levelStyles(txStyles, "p:bodyStyle", colors),
-		other: levelStyles(txStyles, "p:otherStyle", colors)
+		title: family("p:titleStyle"),
+		body: family("p:bodyStyle"),
+		other: family("p:otherStyle")
 	};
 }
-function levelStyles(txStyles, tag, colors) {
-	const style = txStyles ? poChildren(txStyles).find((c) => poIs(c, tag)) : void 0;
-	if (!style) return [];
-	const out = [];
-	for (let lvl = 1; lvl <= 9; lvl++) {
-		const lvlPr = poChildren(style).find((c) => poIs(c, `a:lvl${lvl}pPr`));
-		const defRPr = lvlPr ? poChildren(lvlPr).find((c) => poIs(c, "a:defRPr")) : void 0;
-		out.push(rPrToRunProps(defRPr, colors));
-	}
-	return out;
-}
 //#endregion
-export { buildPlaceholderCascade };
+export { buildPlaceholderCascade, lineSpacing, parseBullet, parseLevelStyles, spacingFractions, spacingFromLineFraction };

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

@@ -1,6 +1,8 @@
 import { pt } from "../../core/ir/units.js";
 import { ResourceStore } from "../../core/ir/resources.js";
 import { FEATURES } from "../../core/ir/features.js";
+import { isEmf } from "../../core/metafile/emf.js";
+import { isWmf } from "../../core/metafile/wmf.js";
 import { EMPTY_STYLE_SHEET, resolveBodyStyles } from "../../core/style-cascade/resolver.js";
 import "../../core/style-cascade/index.js";
 import { isCfb, openCfb } from "../../core/ole/cfb.js";
@@ -48,7 +50,7 @@ function readPpt(bytes) {
 	return {
 		doc: {
 			kind: "flow",
-			body: resolveBodyStyles(buildBody(content, resources), EMPTY_STYLE_SHEET),
+			body: resolveBodyStyles(buildBody(content, resources, width, height), EMPTY_STYLE_SHEET),
 			sections: [],
 			section: {
 				pageSize: {
@@ -70,19 +72,23 @@ function readPpt(bytes) {
 		losses: [content.encrypted ? PPT_ENCRYPTED_LOSS : PPT_TEXT_LOSS]
 	};
 }
-function buildBody(content, resources) {
+function buildBody(content, resources, pageW, pageH) {
 	const body = [];
 	content.slides.forEach((slide, slideIndex) => {
 		const inFlowParas = [];
 		const inFlowImages = [];
 		const floats = [];
+		if (slide.background) {
+			const backdrop = slideBackdrop(slide.background, resources, pageW, pageH);
+			if (backdrop) floats.push(backdrop);
+		}
 		for (const shape of slide.shapes) if (shape.rectPt) {
-			if (shape.paragraphs?.some((p) => paragraphText(p).length > 0)) floats.push(positionedTextShape(shape.rectPt, shape.paragraphs));
+			if (shape.autoShape) floats.push(positionedAutoShape(shape.rectPt, shape.autoShape, resources));
 			if (shape.image) {
 				const block = positionedImage(shape.rectPt, shape.image, resources);
 				if (block) floats.push(block);
 			}
-			if (shape.autoShape) floats.push(positionedAutoShape(shape.rectPt, shape.autoShape));
+			if (shape.paragraphs?.some((p) => paragraphText(p).length > 0)) floats.push(positionedTextShape(shape.rectPt, shape.paragraphs, shape.wordArt === true));
 		} else {
 			for (const para of shape.paragraphs ?? []) if (paragraphText(para).length > 0) inFlowParas.push(flowParagraph(para));
 			if (shape.image) {
@@ -122,10 +128,80 @@ function flowParagraph(para) {
 		kind: "paragraph",
 		paragraph: {
 			properties: toParaProperties(para, false),
-			runs: para.runs.map(toRun)
+			runs: bulletedRuns(para)
 		}
 	};
 }
+function bulletedRuns(para) {
+	const runs = para.runs.map(toRun);
+	if (para.bullet === void 0) return runs;
+	const { bold: _b, italic: _i, ...rest } = runs[0]?.properties ?? {};
+	return [{
+		text: `${para.bullet} `,
+		properties: rest
+	}, ...runs];
+}
+function slideBackdrop(bg, resources, pageW, pageH) {
+	const fill = backdropFill(bg, resources);
+	if (!fill) return void 0;
+	return {
+		kind: "shape",
+		shape: {
+			float: {
+				wrap: "none",
+				behind: true,
+				posH: {
+					relativeFrom: "page",
+					offsetPt: pt(0)
+				},
+				posV: {
+					relativeFrom: "page",
+					offsetPt: pt(0)
+				}
+			},
+			width: pageW,
+			height: pageH,
+			geometry: {
+				kind: "preset",
+				preset: "rect",
+				adjust: /* @__PURE__ */ new Map()
+			},
+			fill,
+			paragraphProperties: {}
+		}
+	};
+}
+function backdropFill(bg, resources) {
+	if (bg.image) return {
+		kind: "picture",
+		imageResource: resources.put(bg.image.bytes),
+		...bg.imageTiled ? { tiled: true } : {}
+	};
+	if (bg.gradient) {
+		const stops = [{
+			offset: 0,
+			colorHex: bg.gradient.fromHex
+		}, {
+			offset: 1,
+			colorHex: bg.gradient.toHex
+		}];
+		return {
+			kind: "gradient",
+			gradient: bg.gradient.radial ? {
+				kind: "radial",
+				stops
+			} : {
+				kind: "linear",
+				angle: bg.gradient.angleDeg,
+				stops
+			}
+		};
+	}
+	return bg.fillColorHex ? {
+		kind: "solid",
+		colorHex: bg.fillColorHex
+	} : void 0;
+}
 function floatAt(rect) {
 	return {
 		wrap: "none",
@@ -139,7 +215,7 @@ function floatAt(rect) {
 		}
 	};
 }
-function positionedTextShape(rect, paragraphs) {
+function positionedTextShape(rect, paragraphs, centred = false) {
 	return {
 		kind: "shape",
 		shape: {
@@ -154,14 +230,14 @@ function positionedTextShape(rect, paragraphs) {
 			fill: { kind: "none" },
 			text: {
 				content: paragraphs.filter((p) => paragraphText(p).length > 0).map(flowParagraph),
-				anchor: "t"
+				anchor: centred ? "ctr" : "t"
 			},
 			paragraphProperties: {}
 		}
 	};
 }
 function positionedImage(rect, image, resources) {
-	if (!imagePixelSize(image.bytes)) return void 0;
+	if (!isMetafile(image.bytes) && !imagePixelSize(image.bytes)) return void 0;
 	return {
 		kind: "image",
 		image: {
@@ -214,9 +290,36 @@ function toCustomGeometry(g) {
 		commands
 	};
 }
-function positionedAutoShape(rect, auto) {
+function positionedAutoShape(rect, auto, resources) {
 	const line = isLineShape(auto.shapeType);
-	const fill = auto.fillColorHex && !line ? {
+	const fill = line ? { kind: "none" } : auto.image ? {
+		kind: "picture",
+		imageResource: resources.put(auto.image.bytes),
+		...auto.imageTiled ? { tiled: true } : {},
+		...auto.tileSizePt ? { tileSizePt: auto.tileSizePt } : {}
+	} : auto.gradient ? {
+		kind: "gradient",
+		gradient: auto.gradient.radial ? {
+			kind: "radial",
+			stops: [{
+				offset: 0,
+				colorHex: auto.gradient.fromHex
+			}, {
+				offset: 1,
+				colorHex: auto.gradient.toHex
+			}]
+		} : {
+			kind: "linear",
+			angle: auto.gradient.angleDeg,
+			stops: [{
+				offset: 0,
+				colorHex: auto.gradient.fromHex
+			}, {
+				offset: 1,
+				colorHex: auto.gradient.toHex
+			}]
+		}
+	} : auto.fillColorHex ? {
 		kind: "solid",
 		colorHex: auto.fillColorHex
 	} : { kind: "none" };
@@ -257,6 +360,9 @@ function inFlowImage(image, resources) {
 		}
 	};
 }
+function isMetafile(d) {
+	return isEmf(d) || isWmf(d);
+}
 function imagePixelSize(d) {
 	if (d.length >= 24 && d[0] === 137 && d[1] === 80 && d[2] === 78 && d[3] === 71) {
 		const w = u32be(d, 16);
@@ -298,6 +404,10 @@ function toRun(r) {
 		...r.italic ? { italic: true } : {},
 		...underline ? { underline } : {},
 		...r.sizePt ? { fontSizePt: pt(r.sizePt) } : {},
+		...r.fontFamily ? { fontFamily: {
+			ascii: r.fontFamily,
+			hAnsi: r.fontFamily
+		} } : {},
 		...r.colorHex ? { colorHex: r.colorHex } : {}
 	};
 	return {

package/dist/esm/pptx/ppt/ppt-text.d.ts

@@ -1,6 +1,8 @@
 /** A run of uniformly-formatted text within a paragraph (PPT-2). */
 export interface PptRun {
     readonly text: string;
+    /** The typeface the run names, resolved through the deck's font collection. */
+    readonly fontFamily?: string;
     readonly bold?: boolean;
     readonly italic?: boolean;
     readonly underline?: boolean;
@@ -20,6 +22,12 @@ export interface PptParagraph {
     readonly align?: number;
     /** The 0-based outline/indent level. */
     readonly level?: number;
+    /**
+     * §2.9.20 — the bullet character this paragraph is marked with, already
+     * translated out of whatever symbol font stated it. Absent when the paragraph
+     * carries none.
+     */
+    readonly bullet?: string;
 }
 /**
  * An embedded picture referenced by a slide shape — the raw image bytes pulled
@@ -80,6 +88,35 @@ export interface PptAutoShape {
     readonly fillColorHex?: string;
     /** The resolved line colour as 6-hex RGB, when present. */
     readonly lineColorHex?: string;
+    /**
+     * MS-ODRAW §2.3.7.1 — the two-colour sweep a `fillType` of 4..8 asks for.
+     * `fillColor` is one end and `fillBackColor` the other; `fillAngle` is where
+     * it runs. Read as its fillColor alone, 41246-2's title slide came out a flat
+     * teal where every reader fades it to white.
+     */
+    readonly gradient?: {
+        readonly fromHex: string;
+        readonly toHex: string;
+        readonly angleDeg: number;
+        readonly radial: boolean;
+    };
+    /**
+     * §2.3.7.1 MSOFILLTYPE 3 — a picture stretched over the shape, its blip named
+     * by `fillBlip`. A `.ppt` table is a group of cell rectangles, and a cell with
+     * a picture background states it exactly this way.
+     */
+    readonly image?: PptImage;
+    /** §2.3.7.1 MSOFILLTYPE 2 — the picture REPEATS at its own size, not stretched. */
+    readonly imageTiled?: boolean;
+    /**
+     * §2.3.7.11/.12 `fillWidth` / `fillHeight` — the size one copy occupies, in
+     * points, when the shape states it rather than leaving the tile at the
+     * picture's own size.
+     */
+    readonly tileSizePt?: {
+        readonly widthPt: number;
+        readonly heightPt: number;
+    };
     readonly geometry?: PptCustomGeometry;
 }
 /**
@@ -89,13 +126,41 @@ export interface PptAutoShape {
  */
 export interface PptShape {
     readonly rectPt?: PptRect;
+    /**
+     * §2.3.22 — the shape IS a piece of WordArt: its text is the shape, centred
+     * in its box rather than flowed from the top. Drawn as an autoshape it was a
+     * coloured rectangle where the reference has a word.
+     */
+    readonly wordArt?: boolean;
+    /**
+     * Whether the shape is a placeholder (§2.9.24). On a MASTER that means it is
+     * a prototype, not decoration: drawn on the slides that follow it, every one
+     * of them would carry "Click to edit Master title style".
+     */
+    readonly placeholder?: boolean;
     readonly paragraphs?: ReadonlyArray<PptParagraph>;
     readonly image?: PptImage;
     readonly autoShape?: PptAutoShape;
 }
-/** One slide: its shapes in document order. */
+/**
+ * A slide's background (PPT-12) — the fill on the shape MS-ODRAW marks with
+ * `fBackground`. A `.ppt` states it as a shape like any other; drawn as one it
+ * would be a rectangle among the content, and dropped it leaves a black slide
+ * white.
+ */
+export interface PptBackground {
+    /** A solid fill's colour, as 6-hex RGB. */
+    readonly fillColorHex?: string;
+    /** A shaded fill, in the same terms an autoshape's is (PPT-9). */
+    readonly gradient?: PptAutoShape['gradient'];
+    /** A picture fill, stretched over the slide (or tiled across it). */
+    readonly image?: PptImage;
+    readonly imageTiled?: boolean;
+}
+/** One slide: its shapes in document order, over its background. */
 export interface PptSlide {
     readonly shapes: ReadonlyArray<PptShape>;
+    readonly background?: PptBackground;
 }
 /** The extracted content of a `.ppt`: its slides, deck page size and encryption flag. */
 export interface PptContent {