reamkit 1.20.0 → 1.22.0

package/dist/esm/pptx/ole-preview.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Shape id → the relationship id of its `v:imagedata`, for every shape in a
+ * legacy VML drawing part that has one.
+ *
+ * @param data The raw `vmlDrawing#.vml` bytes.
+ * @returns The map, keyed by shape id with the `_x0000_s` prefix stripped.
+ */
+export declare function parseVmlImageRels(data: Uint8Array): Map<string, string>;
+/** Strip the `_x0000_s` prefix a VML shape id carries, so both spellings meet. */
+export declare function normalizeSpid(id: string): string;

package/dist/esm/pptx/ole-preview.js

@@ -0,0 +1,52 @@
+import { XMLParser } from "fast-xml-parser";
+//#region src/pptx/ole-preview.ts
+var decoder = new TextDecoder("utf-8");
+var parser = new XMLParser({
+	ignoreAttributes: false,
+	attributeNamePrefix: "@_",
+	parseAttributeValue: false,
+	parseTagValue: false,
+	removeNSPrefix: true
+});
+var SPID_PREFIX = /^_x0000_s/u;
+/**
+* Shape id → the relationship id of its `v:imagedata`, for every shape in a
+* legacy VML drawing part that has one.
+*
+* @param data The raw `vmlDrawing#.vml` bytes.
+* @returns The map, keyed by shape id with the `_x0000_s` prefix stripped.
+*/
+function parseVmlImageRels(data) {
+	const out = /* @__PURE__ */ new Map();
+	walk(parser.parse(decoder.decode(data)), out);
+	return out;
+}
+/** Strip the `_x0000_s` prefix a VML shape id carries, so both spellings meet. */
+function normalizeSpid(id) {
+	return id.replace(SPID_PREFIX, "");
+}
+function walk(node, out) {
+	if (node === null || typeof node !== "object") return;
+	if (Array.isArray(node)) {
+		for (const item of node) walk(item, out);
+		return;
+	}
+	const rec = node;
+	const shape = rec["shape"];
+	if (shape !== void 0) for (const s of Array.isArray(shape) ? shape : [shape]) collect(s, out);
+	for (const value of Object.values(rec)) walk(value, out);
+}
+function collect(shape, out) {
+	if (shape === null || typeof shape !== "object") return;
+	const rec = shape;
+	const id = rec["@_id"];
+	const imagedata = rec["imagedata"];
+	if (typeof id !== "string" || imagedata === void 0) return;
+	const first = Array.isArray(imagedata) ? imagedata[0] : imagedata;
+	if (first === null || typeof first !== "object") return;
+	const img = first;
+	const rel = img["@_relid"] ?? img["@_id"];
+	if (typeof rel === "string") out.set(normalizeSpid(id), rel);
+}
+//#endregion
+export { normalizeSpid, parseVmlImageRels };

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

@@ -1,4 +1,4 @@
-import { RunProperties } from '../core/document-model/index.js';
+import { ParagraphProperties, RunProperties } from '../core/document-model/index.js';
 import { ColorResolver } from '../core/drawingml/colors.js';
 import { PoNode } from '../core/po-helpers.js';
 import { PlaceholderRef, ShapeBoxEmu } from './sp-helpers.js';
@@ -12,11 +12,63 @@ export interface PlaceholderCascade {
     /** The inherited EMU box for a slide placeholder without its own `a:xfrm`. */
     readonly geometryFor: (ph: PlaceholderRef) => ShapeBoxEmu | undefined;
     /**
-     * The master's default run formatting for a placeholder's paragraph at the
-     * given 0-based outline level (empty when no master text styles apply).
+     * The inherited run formatting for a paragraph at the given 0-based outline
+     * level. Without a placeholder this is the presentation's default text style
+     * — what an ordinary text box on a slide is written in.
      */
-    readonly defaultsFor: (ph: PlaceholderRef, level: number) => RunProperties;
+    readonly defaultsFor: (ph: PlaceholderRef | undefined, level: number) => RunProperties;
+    /** The inherited paragraph shape at that level: alignment, indent, spacing. */
+    readonly paragraphDefaultsFor: (ph: PlaceholderRef | undefined, level: number) => ParagraphProperties;
+    /** The bullet that level inherits, which a paragraph states only to change. */
+    readonly bulletFor: (ph: PlaceholderRef | undefined, level: number) => LevelBullet | undefined;
+    /**
+     * The vertical anchor the placeholder's prototype states (`a:bodyPr@anchor`),
+     * the layout's before the master's, for a shape that states none itself.
+     */
+    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.
+     */
+    readonly shapePropsFor: (ph: PlaceholderRef) => PoNode | undefined;
+}
+/** 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.4.4/.5/.6 — the bullet a level declares: none at all, a literal
+ * character, or a number that counts. A slide paragraph states one only where
+ * it differs from this: themes.pptx's second slide writes one bare line, and
+ * the dot in front of it is the master's body style, nine levels up.
+ */
+export interface LevelBullet {
+    /** What it draws: nothing at all, a character, or a number that counts. */
+    readonly kind?: 'none' | 'char' | 'autoNum';
+    /** `a:buChar` — the character, already read out of the face that states it. */
+    readonly char?: string;
+    /** `a:buAutoNum @type`/`@startAt` — the numbering and where it starts. */
+    readonly type?: string;
+    readonly startAt?: number;
+    /** §21.1.2.4.2/.3 — its size, as a fraction of the text or in points. */
+    readonly sizePct?: number;
+    readonly sizePts?: number;
+    /** §21.1.2.4.1 `a:buClr` — the colour it is drawn in, when it has its own. */
+    readonly colorHex?: string;
 }
+/**
+ * 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.
+ */
+export declare function parseBullet(pPr: PoNode | undefined, colors?: ColorResolver): LevelBullet | undefined;
 /**
  * Build a {@link PlaceholderCascade} from a slide's already-parsed layout and
  * master trees: it resolves a placeholder's inherited geometry (the layout's
@@ -27,4 +79,16 @@ export interface PlaceholderCascade {
  * @param masterTree The parsed `p:sldMaster` part, when present.
  * @param colors     The deck's colour resolver, for scheme colours in the text styles.
  */
-export declare function buildPlaceholderCascade(layoutTree: ReadonlyArray<PoNode>, masterTree: ReadonlyArray<PoNode> | undefined, colors: ColorResolver): PlaceholderCascade;
+export declare function buildPlaceholderCascade(layoutTree: ReadonlyArray<PoNode>, masterTree: ReadonlyArray<PoNode> | undefined, colors: ColorResolver, deckDefaults?: ReadonlyArray<LevelStyle>): PlaceholderCascade;
+/**
+ * `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.
+ */
+export declare function parseLevelStyles(list: PoNode | undefined, colors: ColorResolver): Array<LevelStyle>;
+export {};

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";
@@ -16,26 +56,124 @@ function categoryOf(type) {
 * @param masterTree The parsed `p:sldMaster` part, when present.
 * @param colors     The deck's colour resolver, for scheme colours in the text styles.
 */
-function buildPlaceholderCascade(layoutTree, masterTree, colors) {
-	const layoutPhs = collectPlaceholders(layoutTree, "p:sldLayout");
-	const masterPhs = masterTree ? collectPlaceholders(masterTree, "p:sldMaster") : [];
+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) : {
 		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));
+		return layers.reduce(mergeLevels, EMPTY_LEVEL);
+	};
 	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;
 		}
 	};
 }
-function collectPlaceholders(tree, root) {
+var EMPTY_LEVEL = {
+	run: {},
+	paragraph: {}
+};
+/** 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;
+	return {
+		run: {
+			...base.run,
+			...next.run
+		},
+		paragraph: {
+			...base.paragraph,
+			...next.paragraph
+		},
+		...bullet ? { bullet } : {}
+	};
+}
+/**
+* `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) {
+	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);
+		out.push({
+			run: rPrToRunProps(defRPr, colors),
+			paragraph: pPrToParagraphProps(lvlPr),
+			...bullet ? { bullet } : {}
+		});
+	}
+	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 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.
+*/
+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")
+	};
+}
+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) {
 	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 +183,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),
+			...anchor ? { anchor } : {}
 		});
 	}
 	return out;
@@ -66,22 +213,12 @@ function matchPlaceholder(list, ph) {
 function collectTxStyles(masterTree, colors) {
 	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);
 	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, parseBullet, parseLevelStyles };