reamkit 1.22.0 → 1.24.0

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

@@ -55,11 +55,13 @@ 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, deckDefaults = []) {
-	const layoutPhs = collectPlaceholders(layoutTree, "p:sldLayout", colors);
-	const masterPhs = masterTree ? collectPlaceholders(masterTree, "p:sldMaster", colors) : [];
-	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: []
@@ -67,7 +69,8 @@ function buildPlaceholderCascade(layoutTree, masterTree, colors, deckDefaults =
 	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));
-		return layers.reduce(mergeLevels, EMPTY_LEVEL);
+		const merged = layers.reduce(mergeLevels, EMPTY_LEVEL);
+		return merged.spacingPct === void 0 ? merged : withResolvedSpacing(merged);
 	};
 	return {
 		geometryFor(ph) {
@@ -86,7 +89,7 @@ function buildPlaceholderCascade(layoutTree, masterTree, colors, deckDefaults =
 			return matchPlaceholder(layoutPhs, ph)?.anchor ?? matchPlaceholder(masterPhs, ph)?.anchor;
 		},
 		shapePropsFor(ph) {
-			return matchPlaceholder(layoutPhs, ph)?.spPr ?? matchPlaceholder(masterPhs, ph)?.spPr;
+			return [matchPlaceholder(layoutPhs, ph)?.spPr, matchPlaceholder(masterPhs, ph)?.spPr].filter((n) => n !== void 0);
 		}
 	};
 }
@@ -94,6 +97,39 @@ 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 } : {}
+		}
+	};
+}
 /** 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;
@@ -105,6 +141,10 @@ function mergeLevels(base, next) {
 		...base.bullet,
 		...next.bullet
 	} : void 0;
+	const spacingPct = base.spacingPct || next.spacingPct ? {
+		...base.spacingPct,
+		...next.spacingPct
+	} : void 0;
 	return {
 		run: {
 			...base.run,
@@ -114,7 +154,8 @@ function mergeLevels(base, next) {
 			...base.paragraph,
 			...next.paragraph
 		},
-		...bullet ? { bullet } : {}
+		...bullet ? { bullet } : {},
+		...spacingPct ? { spacingPct } : {}
 	};
 }
 /**
@@ -127,17 +168,19 @@ function mergeLevels(base, next) {
 * @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) {
+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),
+			run: rPrToRunProps(defRPr, colors, themeFonts),
 			paragraph: pPrToParagraphProps(lvlPr),
-			...bullet ? { bullet } : {}
+			...bullet ? { bullet } : {},
+			...spacingPct ? { spacingPct } : {}
 		});
 	}
 	return out;
@@ -151,8 +194,12 @@ var ALGN = {
 };
 /**
 * A level's paragraph shape — §21.1.2.2.7 `@algn`, `@marL`/`@indent`, and the
-* space around it. `a:spcPct` is a fraction of the line rather than a distance,
-* which this model has no room for, so only the stated POINTS are read.
+* 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 {};
@@ -164,7 +211,56 @@ function pPrToParagraphProps(lvlPr) {
 		...marL !== void 0 ? { indentLeft: emuToPt(marL) } : {},
 		...indent !== void 0 ? { indentFirstLine: emuToPt(indent) } : {},
 		...spacingPt(lvlPr, "a:spcBef", "spacingBefore"),
-		...spacingPt(lvlPr, "a:spcAft", "spacingAfter")
+		...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) {
@@ -173,7 +269,7 @@ function spacingPt(lvlPr, tag, key) {
 	const val = pts ? poIntAttr(pts, "val") : void 0;
 	return val === void 0 ? {} : { [key]: pt(val / 100) };
 }
-function collectPlaceholders(tree, root, colors) {
+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;
@@ -194,7 +290,7 @@ function collectPlaceholders(tree, root, colors) {
 			ref,
 			...box ? { box } : {},
 			...spPr ? { spPr } : {},
-			levels: parseLevelStyles(lstStyle, colors),
+			levels: parseLevelStyles(lstStyle, colors, themeFonts),
 			...anchor ? { anchor } : {}
 		});
 	}
@@ -210,10 +306,10 @@ 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);
+	const family = (tag) => parseLevelStyles(txStyles ? poChildren(txStyles).find((c) => poIs(c, tag)) : void 0, colors, themeFonts);
 	return {
 		title: family("p:titleStyle"),
 		body: family("p:bodyStyle"),
@@ -221,4 +317,4 @@ function collectTxStyles(masterTree, colors) {
 	};
 }
 //#endregion
-export { buildPlaceholderCascade, parseBullet, parseLevelStyles };
+export { buildPlaceholderCascade, lineSpacing, parseBullet, parseLevelStyles, spacingFractions, spacingFromLineFraction };

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

@@ -1,6 +1,9 @@
 import { pt } from "../../core/ir/units.js";
 import { ResourceStore } from "../../core/ir/resources.js";
 import { FEATURES } from "../../core/ir/features.js";
+import { knockOutColor } from "../../core/images.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 +51,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 +73,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 +129,78 @@ 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 ?? {};
+	const gap = hangs(para) ? "	" : " ";
+	return [{
+		text: `${para.bullet}${gap}`,
+		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,
+			tileFromCentre: true
+		} : {}
+	};
+	if (bg.gradient) {
+		const stops = gradientStops(bg.gradient);
+		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 +214,7 @@ function floatAt(rect) {
 		}
 	};
 }
-function positionedTextShape(rect, paragraphs) {
+function positionedTextShape(rect, paragraphs, centred = false) {
 	return {
 		kind: "shape",
 		shape: {
@@ -154,21 +229,22 @@ 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: {
 			float: floatAt(rect),
-			resource: resources.put(image.bytes),
+			resource: resources.put(drawnBytes(image)),
 			width: pt(rect.w),
 			height: pt(rect.h),
+			...image.crop ? { crop: image.crop } : {},
 			paragraphProperties: {}
 		}
 	};
@@ -214,9 +290,74 @@ function toCustomGeometry(g) {
 		commands
 	};
 }
-function positionedAutoShape(rect, auto) {
+/**
+* §2.3.7.6 `fillFocus` — the stops a shaded fill's two colours make.
+*
+* A focus of zero is the plain ramp everyone expects: the first colour at one
+* end, the second at the other. Any other value means the sweep runs OUT from
+* one of them — a focus of 50 puts the first colour halfway along with the
+* second at BOTH ends, which is what 23884's every slide asks for and why its
+* background read as a flat wash into violet where the reference is blue
+* across the middle and dark only at the corners.
+*
+* @param g The gradient as the `.ppt` states it.
+* @returns The stops, in order.
+*/
+function gradientStops(g) {
+	const focus = g.focusPct ?? 0;
+	if (focus === 0) return [{
+		offset: 0,
+		colorHex: g.fromHex
+	}, {
+		offset: 1,
+		colorHex: g.toHex
+	}];
+	if (Math.abs(focus) >= 100) return [{
+		offset: 0,
+		colorHex: g.toHex
+	}, {
+		offset: 1,
+		colorHex: g.fromHex
+	}];
+	const peak = focus > 0 ? g.fromHex : g.toHex;
+	const ends = focus > 0 ? g.toHex : g.fromHex;
+	const at = focus > 0 ? focus / 100 : 1 + focus / 100;
+	return [
+		{
+			offset: 0,
+			colorHex: ends
+		},
+		{
+			offset: at,
+			colorHex: peak
+		},
+		{
+			offset: 1,
+			colorHex: ends
+		}
+	];
+}
+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,
+			tileFromCentre: true
+		} : {},
+		...auto.tileSizePt ? { tileSizePt: auto.tileSizePt } : {}
+	} : auto.gradient ? {
+		kind: "gradient",
+		gradient: auto.gradient.radial ? {
+			kind: "radial",
+			stops: gradientStops(auto.gradient)
+		} : {
+			kind: "linear",
+			angle: auto.gradient.angleDeg,
+			stops: gradientStops(auto.gradient)
+		}
+	} : auto.fillColorHex ? {
 		kind: "solid",
 		colorHex: auto.fillColorHex
 	} : { kind: "none" };
@@ -250,13 +391,33 @@ function inFlowImage(image, resources) {
 	return {
 		kind: "image",
 		image: {
-			resource: resources.put(image.bytes),
+			resource: resources.put(drawnBytes(image)),
 			width: pt(size.w * .75),
 			height: pt(size.h * .75),
+			...image.crop ? { crop: image.crop } : {},
 			paragraphProperties: {}
 		}
 	};
 }
+/**
+* The bytes a picture is actually DRAWN from.
+*
+* §2.3.23 `pictureTransparent` names a colour the picture is drawn without, and
+* a raster carries no alpha channel to say so — so the knock-out is baked into
+* bytes of its own. The resource store hashes content, so two shapes knocking
+* different colours out of the same blip stay two resources by themselves, and
+* one that knocks out nothing keeps the bytes it arrived with.
+*
+* @param image The picture as the shape states it.
+* @returns The bytes to store, knocked out where the shape asks for it.
+*/
+function drawnBytes(image) {
+	if (image.transparentHex === void 0 || isMetafile(image.bytes)) return image.bytes;
+	return knockOutColor(image.bytes, image.transparentHex) ?? image.bytes;
+}
+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 +459,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 {
@@ -308,12 +473,25 @@ function toRun(r) {
 function toParaProperties(p, breakBefore) {
 	const alignment = p.align !== void 0 ? alignmentFrom(p.align) : void 0;
 	const level = p.level ?? 0;
+	const leftPt = p.leftMarginPt ?? (level > 0 ? level * LEVEL_INDENT_PT : void 0);
+	const firstPt = p.indentPt !== void 0 ? p.indentPt - (leftPt ?? 0) : void 0;
 	return {
 		...breakBefore ? { pageBreakBefore: true } : {},
 		...alignment ? { alignment } : {},
-		...level > 0 ? { indentLeft: pt(level * LEVEL_INDENT_PT) } : {}
+		...leftPt !== void 0 ? { indentLeft: pt(leftPt) } : {},
+		...firstPt !== void 0 && firstPt !== 0 ? { indentFirstLine: pt(firstPt) } : {},
+		...p.spaceBeforePt !== void 0 ? { spacingBefore: pt(p.spaceBeforePt) } : {},
+		...p.spaceAfterPt !== void 0 ? { spacingAfter: pt(p.spaceAfterPt) } : {},
+		...p.lineSpacing !== void 0 && p.lineSpacing > 0 ? {
+			spacingLineRule: "auto",
+			spacingLine: pt(p.lineSpacing / 100 * 12)
+		} : {}
 	};
 }
+/** Whether the paragraph's first line starts LEFT of its body — a hanging bullet. */
+function hangs(p) {
+	return p.indentPt !== void 0 && p.leftMarginPt !== void 0 && p.indentPt < p.leftMarginPt;
+}
 function alignmentFrom(a) {
 	switch (a) {
 		case 1: return "center";

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,24 @@ 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;
+    /**
+     * §2.9.20 `leftMargin` — where the paragraph's BODY sits, in points from the
+     * text box's own left edge.
+     */
+    readonly leftMarginPt?: number;
+    /** §2.9.20 `indent` — where its FIRST line starts. Left of the body ⇒ hanging. */
+    readonly indentPt?: number;
+    /** §2.9.32 `lineSpacing`, as a PERCENTAGE of the line's height — 100 is single. */
+    readonly lineSpacing?: number;
+    /** §2.9.32 `spaceBefore` / `spaceAfter`, in points. */
+    readonly spaceBeforePt?: number;
+    readonly spaceAfterPt?: number;
 }
 /**
  * An embedded picture referenced by a slide shape — the raw image bytes pulled
@@ -27,6 +47,22 @@ export interface PptParagraph {
  */
 export interface PptImage {
     readonly bytes: Uint8Array;
+    /**
+     * §2.3.23 `cropFrom*` — the fraction of each edge of the SOURCE cut away
+     * before it is fitted to the shape's box. Absent ⇒ the whole picture.
+     */
+    readonly crop?: {
+        readonly left: number;
+        readonly top: number;
+        readonly right: number;
+        readonly bottom: number;
+    };
+    /**
+     * §2.3.23 `pictureTransparent` — the colour the picture is drawn WITHOUT,
+     * 6-hex and no leading `#`. Clip art of this age states its ground here
+     * rather than carrying an alpha channel.
+     */
+    readonly transparentHex?: string;
 }
 /** A shape's rectangle on the slide, in points (from the OfficeArtClientAnchor). */
 export interface PptRect {
@@ -80,6 +116,41 @@ 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.6 `fillFocus` — where along the sweep the FIRST colour peaks, as a
+         * percentage. Zero is a plain ramp; 50 puts it in the middle with the
+         * second colour at both ends, which is a different picture entirely.
+         */
+        readonly focusPct?: number;
+    };
+    /**
+     * §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 +160,48 @@ 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;
+    /**
+     * §2.9.51 `OEPlaceholderAtom.placeholderId` — WHICH placeholder it is. The
+     * three a master keeps for the slide's furniture — 7 the date, 8 the slide
+     * number, 9 the footer — are the only ones whose text does not live in the
+     * shape at all (§2.4.15).
+     */
+    readonly placeholderId?: number;
     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 {