reamkit 1.22.0 → 1.23.0

package/dist/esm/pptx/embedded-fonts.d.ts

@@ -0,0 +1,31 @@
+import { Loss } from '../core/ir/index.js';
+import { OpcPackage } from '../core/opc/index.js';
+import { PoNode } from '../core/po-helpers.js';
+import { FontRegistry } from '../core/font/index.js';
+/** What an `fntdata` part turned out to hold. */
+type FaceBytes = {
+    readonly kind: 'font';
+    readonly bytes: Uint8Array;
+} | {
+    readonly kind: 'compressed';
+} | {
+    readonly kind: 'unreadable';
+};
+/**
+ * Read one `fntdata` part: the font itself when the container stores it
+ * plainly, and what stopped it otherwise.
+ *
+ * @param data The part's bytes.
+ */
+export declare function readFntData(data: Uint8Array): FaceBytes;
+/**
+ * §19.2.1.13 — the fonts a deck embeds, by normalized family name.
+ *
+ * @param pkg      The opened `.pptx` package.
+ * @param presPath The presentation part's path (relationships resolve from it).
+ * @param pres     Its parsed `p:presentation` element.
+ * @param onLoss   Where a face that cannot be unpacked records itself.
+ * @returns The families whose faces were readable (empty when none were).
+ */
+export declare function loadPptxEmbeddedFonts(pkg: OpcPackage, presPath: string, pres: PoNode | undefined, onLoss: (loss: Loss) => void): Map<string, FontRegistry>;
+export {};

package/dist/esm/pptx/embedded-fonts.js

@@ -0,0 +1,104 @@
+import { FontRegistry } from "../core/font/font-registry.js";
+import { poAttr, poChildren, poIs } from "../core/po-helpers.js";
+//#region src/pptx/embedded-fonts.ts
+var REL_FONT = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/font";
+/** §19.2.1.13 — the four faces a `p:embeddedFont` may name, by element. */
+var VARIANTS = [
+	["p:regular", "regular"],
+	["p:bold", "bold"],
+	["p:italic", "italic"],
+	["p:boldItalic", "boldItalic"]
+];
+var EOT_VERSIONS = new Set([
+	65536,
+	131073,
+	131074
+]);
+var TTEMBED_TTCOMPRESSED = 4;
+var TTEMBED_XORENCRYPTDATA = 268435456;
+/**
+* Read one `fntdata` part: the font itself when the container stores it
+* plainly, and what stopped it otherwise.
+*
+* @param data The part's bytes.
+*/
+function readFntData(data) {
+	if (isSfnt(data)) return {
+		kind: "font",
+		bytes: data
+	};
+	if (data.length < 82) return { kind: "unreadable" };
+	const v = new DataView(data.buffer, data.byteOffset, data.byteLength);
+	const eotSize = v.getUint32(0, true);
+	const version = v.getUint32(8, true);
+	const flags = v.getUint32(12, true);
+	if (eotSize !== data.length || !EOT_VERSIONS.has(version)) return { kind: "unreadable" };
+	if ((flags & (TTEMBED_TTCOMPRESSED | TTEMBED_XORENCRYPTDATA)) !== 0) return { kind: "compressed" };
+	let at = 82;
+	for (let i = 0; i < 4; i++) {
+		if (at + 2 > data.length) return { kind: "unreadable" };
+		at += 2 + v.getUint16(at, true) + 2;
+	}
+	if (version !== 65536) {
+		if (at + 2 > data.length) return { kind: "unreadable" };
+		at += 2 + v.getUint16(at, true);
+		at = data.length - v.getUint32(4, true);
+	}
+	const bytes = data.subarray(at);
+	return isSfnt(bytes) ? {
+		kind: "font",
+		bytes
+	} : { kind: "unreadable" };
+}
+/**
+* §19.2.1.13 — the fonts a deck embeds, by normalized family name.
+*
+* @param pkg      The opened `.pptx` package.
+* @param presPath The presentation part's path (relationships resolve from it).
+* @param pres     Its parsed `p:presentation` element.
+* @param onLoss   Where a face that cannot be unpacked records itself.
+* @returns The families whose faces were readable (empty when none were).
+*/
+function loadPptxEmbeddedFonts(pkg, presPath, pres, onLoss) {
+	const out = /* @__PURE__ */ new Map();
+	const list = pres ? poChildren(pres).find((c) => poIs(c, "p:embeddedFontLst")) : void 0;
+	if (!list) return out;
+	const relById = new Map(pkg.getPartRelationships(presPath).map((r) => [r.id, r]));
+	for (const font of poChildren(list).filter((c) => poIs(c, "p:embeddedFont"))) {
+		const bytes = {};
+		let compressed = false;
+		for (const [tag, variant] of VARIANTS) {
+			const node = poChildren(font).find((c) => poIs(c, tag));
+			const rId = node ? poAttr(node, "r:id") : void 0;
+			const rel = rId !== void 0 ? relById.get(rId) : void 0;
+			if (!rel || rel.type !== REL_FONT) continue;
+			const part = pkg.resolveRelatedPart(presPath, rel);
+			if (!part) continue;
+			const face = readFntData(part.data);
+			if (face.kind === "compressed") compressed = true;
+			if (face.kind === "font") bytes[variant] = face.bytes;
+		}
+		const typeface = poChildren(font).find((c) => poIs(c, "p:font"));
+		const name = (typeface ? poAttr(typeface, "typeface") : void 0)?.trim() ?? "";
+		if (bytes.regular) try {
+			out.set(name.toLowerCase(), FontRegistry.fromBytes({
+				...bytes,
+				regular: bytes.regular
+			}));
+			continue;
+		} catch {}
+		if (compressed) onLoss({
+			feature: "font",
+			detail: `the deck embeds ${name || "a font"}, packed with MicroType Express (EOT TTEMBED_TTCOMPRESSED); it renders in a substitute`,
+			severity: "substituted"
+		});
+	}
+	return out;
+}
+function isSfnt(data) {
+	if (data.length < 4) return false;
+	const sig = (data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3]) >>> 0;
+	return sig === 65536 || sig === 1330926671 || sig === 1953658213 || sig === 1953784678;
+}
+//#endregion
+export { loadPptxEmbeddedFonts };

package/dist/esm/pptx/placeholder-cascade.d.ts

@@ -1,7 +1,9 @@
 import { ParagraphProperties, RunProperties } from '../core/document-model/index.js';
 import { ColorResolver } from '../core/drawingml/colors.js';
+import { ThemeFonts } from '../core/drawingml/theme-parser.js';
 import { PoNode } from '../core/po-helpers.js';
 import { PlaceholderRef, ShapeBoxEmu } from './sp-helpers.js';
+import { Pt } from '../core/ir/index.js';
 /**
  * The placeholder cascade (PX2): the resolver a slide parser consults whenever a
  * slide placeholder shape (`p:sp` with a `p:ph`) lacks its own geometry or run
@@ -27,17 +29,32 @@ export interface PlaceholderCascade {
      */
     readonly anchorFor: (ph: PlaceholderRef) => 't' | 'ctr' | 'b' | undefined;
     /**
-     * The prototype's own `p:spPr`, for the properties a slide placeholder
-     * inherits rather than states: its fill, its outline, its geometry. The
-     * layout's before the master's.
+     * The prototypes' own `p:spPr`, nearest first — the layout's, then the
+     * master's — for the properties a slide placeholder inherits rather than
+     * states: its fill, its outline, its geometry.
+     *
+     * A CHAIN and not one node, because the inheritance is per property. The
+     * layout's prototype may state a box and nothing else, and the fill then
+     * comes from the master: tdf104015's title is red in every reader and was a
+     * bare outline here, because the layout's `p:spPr` existed and stopped the
+     * search.
      */
-    readonly shapePropsFor: (ph: PlaceholderRef) => PoNode | undefined;
+    readonly shapePropsFor: (ph: PlaceholderRef) => ReadonlyArray<PoNode>;
 }
 /** One level of a text style: how its paragraphs sit and how their runs read. */
 interface LevelStyle {
     readonly run: RunProperties;
     readonly paragraph: ParagraphProperties;
     readonly bullet?: LevelBullet;
+    /**
+     * §21.1.2.2.9/.10 — the space around the paragraph stated as a FRACTION of a
+     * line rather than a distance. A fraction of WHAT is only known once the
+     * levels have merged and the size is settled, so it travels this far raw.
+     */
+    readonly spacingPct?: {
+        readonly before?: number;
+        readonly after?: number;
+    };
 }
 /**
  * §21.1.2.4.4/.5/.6 — the bullet a level declares: none at all, a literal
@@ -78,8 +95,24 @@ export declare function parseBullet(pPr: PoNode | undefined, colors?: ColorResol
  * @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.
+ */
+export declare function buildPlaceholderCascade(layoutTree: ReadonlyArray<PoNode>, masterTree: ReadonlyArray<PoNode> | undefined, colors: ColorResolver, deckDefaults?: ReadonlyArray<LevelStyle>, themeFonts?: ThemeFonts): PlaceholderCascade;
+/**
+ * §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.
  */
-export declare function buildPlaceholderCascade(layoutTree: ReadonlyArray<PoNode>, masterTree: ReadonlyArray<PoNode> | undefined, colors: ColorResolver, deckDefaults?: ReadonlyArray<LevelStyle>): PlaceholderCascade;
+export declare function spacingFromLineFraction(pct: number | undefined, sizePt: number | undefined): Pt | undefined;
 /**
  * `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,
@@ -90,5 +123,39 @@ export declare function buildPlaceholderCascade(layoutTree: ReadonlyArray<PoNode
  * @param prefix The level element prefix: `a:lvl` here, always.
  * @returns The nine levels, or an empty list when there is no such node.
  */
-export declare function parseLevelStyles(list: PoNode | undefined, colors: ColorResolver): Array<LevelStyle>;
+export declare function parseLevelStyles(list: PoNode | undefined, colors: ColorResolver, themeFonts?: ThemeFonts): Array<LevelStyle>;
+/**
+ * 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.
+ */
+export declare function pPrToParagraphProps(lvlPr: PoNode | undefined): ParagraphProperties;
+/**
+ * §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.
+ */
+export declare function lineSpacing(pPr: PoNode | undefined): ParagraphProperties;
+/**
+ * §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.
+ */
+export declare function spacingFractions(pPr: PoNode | undefined): {
+    readonly before?: number;
+    readonly after?: number;
+} | undefined;
 export {};

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,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 {