@pptx-studio/model 0.1.0

package/dist/index.js

@@ -0,0 +1,3042 @@
+import { COLOR_TRANSFORM_OPS, MAPPED_COLOR_NAMES, PaintError, SCHEME_SLOTS, WHOLE_RECT, parseAngle, parsePercentage, resolveColor, transformShape } from "@pptx-studio/paint";
+import { attributeValue, childElements, firstChild, parseXml, textContent } from "@pptx-studio/xml";
+import { custGeom } from "@pptx-studio/geometry";
+import { REL_TYPE } from "@pptx-studio/opc";
+//#region src/errors.ts
+var ModelError = class extends Error {
+	name = "ModelError";
+	code;
+	/** The part the failure is about, when there is one. */
+	partName;
+	/** Whatever detail names the failure: an attribute value, a rel id, a slot. */
+	detail;
+	constructor(code, message, partName = null, detail = null) {
+		super(message);
+		this.code = code;
+		this.partName = partName;
+		this.detail = detail;
+	}
+};
+function isModelError(value) {
+	return value instanceof ModelError;
+}
+const MODEL_ERROR_CODES = [
+	"MODEL_PART_MISSING",
+	"MODEL_PART_KIND",
+	"MODEL_NO_PRESENTATION",
+	"MODEL_NO_PARENT",
+	"MODEL_NO_THEME",
+	"MODEL_CLRMAP_INCOMPLETE",
+	"MODEL_CLRMAP_SLOT",
+	"MODEL_PLACEHOLDER_IDX",
+	"MODEL_XFRM_NUMBER",
+	"MODEL_GEOMETRY",
+	"MODEL_STYLE_IDX",
+	"MODEL_FONT_COLLECTION",
+	"MODEL_NO_STYLE_MATRIX",
+	"MODEL_STYLE_LIST_EMPTY",
+	"MODEL_SHEET_CYCLE",
+	"MODEL_FOREIGN_SHEET",
+	"MODEL_TEXT_ATTR",
+	"MODEL_TEXT_FIELD",
+	"MODEL_TEXT_LEVEL",
+	"MODEL_TEXT_TYPEFACE"
+];
+//#endregion
+//#region src/types.ts
+const PLACEHOLDER_TYPES = [
+	"title",
+	"body",
+	"ctrTitle",
+	"subTitle",
+	"obj",
+	"chart",
+	"tbl",
+	"clipArt",
+	"dgm",
+	"media",
+	"sldImg",
+	"pic",
+	"sldNum",
+	"hdr",
+	"ftr",
+	"dt"
+];
+/** The six a slide master may carry. Measured; see `PlaceholderType`. */
+const MASTER_PLACEHOLDER_TYPES = [
+	"title",
+	"body",
+	"dt",
+	"ftr",
+	"sldNum",
+	"hdr"
+];
+//#endregion
+//#region src/parse/paint.ts
+/**
+* DrawingML markup into the types `@pptx-studio/paint` defines.
+*
+* Paint depends on nothing but arithmetic - it has never seen an `XElement` and
+* must not, or it would inherit the XML layer's whole surface for the sake of
+* six element names. So the crossing lives here, at layer 2, which is the first
+* place that knows about both.
+*
+* Every function returns `undefined` when the element is absent, and `undefined`
+* is load-bearing: "this shape declares no fill" and "this shape declares
+* `a:noFill`" are different files with different resolutions, and only the first
+* one inherits.
+*/
+const COLOR_ELEMENTS = /* @__PURE__ */ new Set([
+	"a:srgbClr",
+	"a:scrgbClr",
+	"a:hslClr",
+	"a:schemeClr",
+	"a:sysClr",
+	"a:prstClr"
+]);
+const FILL_ELEMENTS = /* @__PURE__ */ new Set([
+	"a:noFill",
+	"a:solidFill",
+	"a:gradFill",
+	"a:blipFill",
+	"a:pattFill",
+	"a:grpFill"
+]);
+/** An integer attribute, or `fallback` when absent. Throws on a non-integer. */
+function intAttr(element, name, fallback, what) {
+	const raw = attributeValue(element, name);
+	if (raw === void 0) return fallback;
+	const value = Number(raw);
+	if (!Number.isInteger(value)) throw new ModelError("MODEL_XFRM_NUMBER", `${what}/@${name} is "${raw}"`, null, raw);
+	return value;
+}
+/**
+* `ST_Percentage`, which may legally be written `"40000"` or `"40%"`.
+*
+* The second spelling is Strict's and a Transitional part accepts it anyway -
+* measured in 2.6. `parseInt` on `"40%"` yields 40, which is 0.04%, and that is
+* how a line-spacing of 150% becomes a collapsed slide.
+*/
+function percentAttr(element, name, fallback) {
+	const raw = attributeValue(element, name);
+	if (raw === void 0) return fallback;
+	return parsePercentage(raw);
+}
+function boolAttr(element, name, fallback) {
+	const raw = attributeValue(element, name);
+	if (raw === void 0) return fallback;
+	return raw === "1" || raw === "true";
+}
+function parseTransforms(element) {
+	const out = [];
+	for (const child of childElements(element)) {
+		const local = child.qname.startsWith("a:") ? child.qname.slice(2) : child.qname;
+		const shape = transformShape(local);
+		if (shape === null) continue;
+		const op = local;
+		const raw = attributeValue(child, "val");
+		if (shape === "flag") {
+			out.push({ op });
+			continue;
+		}
+		if (raw === void 0) throw new PaintError("COLOR_NUMBER", `a:${local} has no @val`, local);
+		const val = shape === "angle" ? parseAngle(raw) : parsePercentage(raw);
+		out.push({
+			op,
+			val
+		});
+	}
+	return out;
+}
+/** One of the six `EG_ColorChoice` members. */
+function parseColorElement(element) {
+	const transforms = parseTransforms(element);
+	switch (element.qname) {
+		case "a:srgbClr": return {
+			space: "srgb",
+			hex: attributeValue(element, "val") ?? "",
+			transforms
+		};
+		case "a:scrgbClr": return {
+			space: "scrgb",
+			r: percentAttr(element, "r", 0),
+			g: percentAttr(element, "g", 0),
+			b: percentAttr(element, "b", 0),
+			transforms
+		};
+		case "a:hslClr": return {
+			space: "hsl",
+			hue: Number(attributeValue(element, "hue") ?? "0"),
+			sat: percentAttr(element, "sat", 0),
+			lum: percentAttr(element, "lum", 0),
+			transforms
+		};
+		case "a:schemeClr": return {
+			space: "scheme",
+			name: attributeValue(element, "val") ?? "",
+			transforms
+		};
+		case "a:sysClr": return {
+			space: "sys",
+			name: attributeValue(element, "val") ?? "",
+			lastClr: attributeValue(element, "lastClr") ?? null,
+			transforms
+		};
+		case "a:prstClr": return {
+			space: "prst",
+			name: attributeValue(element, "val") ?? "",
+			transforms
+		};
+		default: throw new PaintError("COLOR_SCHEME_NAME", `${element.qname} is not a colour element`, element.qname);
+	}
+}
+/** The first colour child of a wrapper such as `a:solidFill` or `a:fillRef`. */
+function parseColorChild(parent) {
+	if (parent === void 0) return null;
+	for (const child of childElements(parent)) if (COLOR_ELEMENTS.has(child.qname)) return parseColorElement(child);
+	return null;
+}
+function parseRelativeRect(element) {
+	if (element === void 0) return WHOLE_RECT;
+	return {
+		l: percentAttr(element, "l", 0),
+		t: percentAttr(element, "t", 0),
+		r: percentAttr(element, "r", 0),
+		b: percentAttr(element, "b", 0)
+	};
+}
+function parseGradientShade(element) {
+	const lin = firstChild(element, "a:lin");
+	if (lin !== void 0) return {
+		kind: "linear",
+		ang: Number(attributeValue(lin, "ang") ?? "0"),
+		scaled: boolAttr(lin, "scaled", false)
+	};
+	const path = firstChild(element, "a:path");
+	if (path === void 0) return null;
+	const raw = attributeValue(path, "path") ?? "rect";
+	const kind = raw === "circle" || raw === "rect" ? raw : "shape";
+	const rect = firstChild(path, "a:fillToRect");
+	return {
+		kind: "path",
+		path: kind,
+		fillToRect: rect === void 0 ? null : parseRelativeRect(rect)
+	};
+}
+const TILE_ALIGNS = /* @__PURE__ */ new Set([
+	"tl",
+	"t",
+	"tr",
+	"l",
+	"ctr",
+	"r",
+	"bl",
+	"b",
+	"br"
+]);
+const TILE_FLIPS = /* @__PURE__ */ new Set([
+	"none",
+	"x",
+	"y",
+	"xy"
+]);
+/** `a:blip`'s colour effects, in document order, which is the order they apply. */
+/** The `{96DAC541-...}` extension PowerPoint writes on a blip with an SVG original. */
+const SVG_BLIP_EXT = "{96DAC541-7B7A-43D3-8B79-37D633B846F1}";
+/** `a:blip/a:extLst/a:ext[@uri=SVG_BLIP_EXT]/asvg:svgBlip/@r:embed`, or `null`. */
+function svgBlipEmbed(blip) {
+	const extLst = firstChild(blip, "a:extLst");
+	if (extLst === void 0) return null;
+	for (const ext of childElements(extLst)) {
+		if (ext.qname !== "a:ext" || attributeValue(ext, "uri") !== SVG_BLIP_EXT) continue;
+		for (const child of childElements(ext)) {
+			if (child.qname.split(":").pop() !== "svgBlip") continue;
+			const embed = attributeValue(child, "r:embed");
+			if (embed !== void 0) return embed;
+		}
+	}
+	return null;
+}
+function parseBlipEffects(blip) {
+	const effects = [];
+	for (const child of childElements(blip)) switch (child.qname) {
+		case "a:grayscl":
+			effects.push({ kind: "grayscale" });
+			break;
+		case "a:biLevel":
+			effects.push({
+				kind: "biLevel",
+				thresh: percentAttr(child, "thresh", 0)
+			});
+			break;
+		case "a:lum":
+			effects.push({
+				kind: "lum",
+				bright: percentAttr(child, "bright", 0),
+				contrast: percentAttr(child, "contrast", 0)
+			});
+			break;
+		case "a:duotone": {
+			const [from, to] = childElements(child).filter((c) => COLOR_ELEMENTS.has(c.qname)).map(parseColorElement);
+			if (from === void 0 || to === void 0) throw new ModelError("BLIP_DUOTONE", "a:duotone needs two colours", "a:duotone");
+			effects.push({
+				kind: "duotone",
+				from,
+				to
+			});
+			break;
+		}
+		case "a:alphaModFix":
+			effects.push({
+				kind: "alphaModFix",
+				amt: percentAttr(child, "amt", 1e5)
+			});
+			break;
+		case "a:clrChange": {
+			const from = parseColorChild(firstChild(child, "a:clrFrom"));
+			const to = parseColorChild(firstChild(child, "a:clrTo"));
+			if (from === null || to === null) throw new ModelError("BLIP_CLR_CHANGE", "a:clrChange needs both colours", "a:clrChange");
+			effects.push({
+				kind: "clrChange",
+				from,
+				to,
+				useAlpha: boolAttr(child, "useA", true)
+			});
+			break;
+		}
+	}
+	return effects;
+}
+/**
+* `a:blipFill`.
+*
+* The relationship id is carried, never resolved: a fill in a layout resolves
+* against the layout's rels and the same markup inherited onto a slide still
+* means the layout's image. Same contract as `a:buBlip`.
+*/
+function parseBlipFill(element, partName) {
+	const blip = firstChild(element, "a:blip");
+	if (blip === void 0) throw new ModelError("BLIP_NO_EMBED", "a:blipFill has no a:blip", "a:blipFill");
+	const embed = attributeValue(blip, "r:embed") ?? null;
+	const svgEmbed = svgBlipEmbed(blip);
+	if (embed === null && svgEmbed === null) throw new ModelError("BLIP_NO_EMBED", "a:blip names no image to resolve", "a:blip");
+	const tile = firstChild(element, "a:tile");
+	const stretch = firstChild(element, "a:stretch");
+	let mode;
+	if (tile !== void 0) {
+		const algn = attributeValue(tile, "algn") ?? "tl";
+		const flip = attributeValue(tile, "flip") ?? "none";
+		if (!TILE_ALIGNS.has(algn)) throw new ModelError("BLIP_TILE_ALIGN", `a:tile/@algn is "${algn}"`, "a:tile");
+		if (!TILE_FLIPS.has(flip)) throw new ModelError("BLIP_TILE_FLIP", `a:tile/@flip is "${flip}"`, "a:tile");
+		mode = {
+			kind: "tile",
+			tx: intAttr(tile, "tx", 0, "a:tile"),
+			ty: intAttr(tile, "ty", 0, "a:tile"),
+			sx: percentAttr(tile, "sx", 1e5),
+			sy: percentAttr(tile, "sy", 1e5),
+			flip,
+			algn
+		};
+	} else mode = {
+		kind: "stretch",
+		fillRect: parseRelativeRect(stretch === void 0 ? void 0 : firstChild(stretch, "a:fillRect"))
+	};
+	return {
+		type: "blip",
+		embed,
+		svgEmbed,
+		part: partName,
+		srcRect: parseRelativeRect(firstChild(element, "a:srcRect")),
+		mode,
+		effects: parseBlipEffects(blip),
+		dpi: intAttr(element, "dpi", 0, "a:blipFill"),
+		rotWithShape: boolAttr(element, "rotWithShape", true)
+	};
+}
+/**
+* `p:pic/p:blipFill` - the image a picture shape draws.
+*
+* `CT_Picture` is `nvPicPr, blipFill, spPr`, so the image sits *beside*
+* `p:spPr` rather than inside it, and in PresentationML. ADR 0037.
+*/
+function parsePictureFill(pic, partName) {
+	const blipFill = firstChild(pic, "p:blipFill");
+	return blipFill === void 0 ? void 0 : parseBlipFill(blipFill, partName);
+}
+/** One member of `EG_FillProperties`. */
+function parseFillElement(element, partName) {
+	switch (element.qname) {
+		case "a:noFill": return { type: "none" };
+		case "a:grpFill": return { type: "group" };
+		case "a:blipFill": return parseBlipFill(element, partName);
+		case "a:solidFill": {
+			const color = parseColorChild(element);
+			if (color === null) throw new PaintError("COLOR_SCHEME_NAME", "a:solidFill has no colour child", "a:solidFill");
+			return {
+				type: "solid",
+				color
+			};
+		}
+		case "a:pattFill": return {
+			type: "pattern",
+			prst: attributeValue(element, "prst") ?? "",
+			fg: parseColorChild(firstChild(element, "a:fgClr")),
+			bg: parseColorChild(firstChild(element, "a:bgClr"))
+		};
+		case "a:gradFill": {
+			const stops = [];
+			const list = firstChild(element, "a:gsLst");
+			if (list !== void 0) for (const gs of childElements(list)) {
+				if (gs.qname !== "a:gs") continue;
+				const color = parseColorChild(gs);
+				if (color === null) continue;
+				stops.push({
+					pos: percentAttr(gs, "pos", 0),
+					color
+				});
+			}
+			const flip = attributeValue(element, "flip") ?? "none";
+			return {
+				type: "gradient",
+				stops,
+				shade: parseGradientShade(element),
+				tileRect: firstChild(element, "a:tileRect") === void 0 ? null : parseRelativeRect(firstChild(element, "a:tileRect")),
+				flip,
+				rotWithShape: boolAttr(element, "rotWithShape", true)
+			};
+		}
+		default: throw new PaintError("FILL_PATTERN_UNKNOWN", `${element.qname} is not a fill element`, element.qname);
+	}
+}
+/** The fill a container declares, or `undefined` when it declares none. */
+function parseFill(parent, partName) {
+	for (const child of childElements(parent)) if (FILL_ELEMENTS.has(child.qname)) return parseFillElement(child, partName);
+}
+const JOIN_KINDS = {
+	"a:round": "round",
+	"a:bevel": "bevel",
+	"a:miter": "miter"
+};
+function parseLineEnd(element) {
+	if (element === void 0) return null;
+	const size = (name) => {
+		const raw = attributeValue(element, name);
+		return raw === "sm" || raw === "med" || raw === "lg" ? raw : "med";
+	};
+	return {
+		type: attributeValue(element, "type") ?? "none",
+		w: size("w"),
+		len: size("len")
+	};
+}
+function parseDash(element) {
+	const preset = firstChild(element, "a:prstDash");
+	if (preset !== void 0) return {
+		kind: "preset",
+		val: attributeValue(preset, "val") ?? "solid"
+	};
+	const custom = firstChild(element, "a:custDash");
+	if (custom === void 0) return null;
+	const stops = [];
+	for (const ds of childElements(custom)) {
+		if (ds.qname !== "a:ds") continue;
+		stops.push({
+			d: percentAttr(ds, "d", 0) / 1e5,
+			sp: percentAttr(ds, "sp", 0) / 1e5
+		});
+	}
+	return {
+		kind: "custom",
+		stops
+	};
+}
+/** `a:ln`, lazily: every field is `null` when the attribute was absent. */
+function parseLineElement(element, partName) {
+	let join = null;
+	for (const child of childElements(element)) {
+		const kind = JOIN_KINDS[child.qname];
+		if (kind === void 0) continue;
+		const lim = attributeValue(child, "lim");
+		join = {
+			kind,
+			limit: lim === void 0 ? null : parsePercentage(lim) / 1e5
+		};
+		break;
+	}
+	const cap = attributeValue(element, "cap");
+	const algn = attributeValue(element, "algn");
+	return {
+		w: attributeValue(element, "w") === void 0 ? null : intAttr(element, "w", 0, "a:ln"),
+		cap: cap === "flat" || cap === "sq" || cap === "rnd" ? cap : null,
+		cmpd: attributeValue(element, "cmpd") ?? null,
+		algn: algn === "ctr" || algn === "in" ? algn : null,
+		fill: parseFill(element, partName) ?? null,
+		dash: parseDash(element),
+		join,
+		headEnd: parseLineEnd(firstChild(element, "a:headEnd")),
+		tailEnd: parseLineEnd(firstChild(element, "a:tailEnd"))
+	};
+}
+function parseLine(parent, partName) {
+	const element = firstChild(parent, "a:ln");
+	return element === void 0 ? void 0 : parseLineElement(element, partName);
+}
+const RECT_ALIGNMENTS = /* @__PURE__ */ new Set([
+	"tl",
+	"t",
+	"tr",
+	"l",
+	"ctr",
+	"r",
+	"bl",
+	"b",
+	"br"
+]);
+function alignAttr(element, fallback) {
+	const raw = attributeValue(element, "algn");
+	return raw !== void 0 && RECT_ALIGNMENTS.has(raw) ? raw : fallback;
+}
+function shadowGeometry(element) {
+	return {
+		blurRad: intAttr(element, "blurRad", 0, element.qname),
+		dist: intAttr(element, "dist", 0, element.qname),
+		dir: intAttr(element, "dir", 0, element.qname),
+		sx: percentAttr(element, "sx", 1e5),
+		sy: percentAttr(element, "sy", 1e5),
+		kx: intAttr(element, "kx", 0, element.qname),
+		ky: intAttr(element, "ky", 0, element.qname),
+		algn: alignAttr(element, "b"),
+		rotWithShape: boolAttr(element, "rotWithShape", true)
+	};
+}
+function requireColor(element) {
+	const color = parseColorChild(element);
+	if (color === null) throw new PaintError("COLOR_SCHEME_NAME", `${element.qname} has no colour child`, element.qname);
+	return color;
+}
+/** One member of `a:effectLst`, or `null` for an element this does not model. */
+function parseEffectElement(element) {
+	switch (element.qname) {
+		case "a:outerShdw": return {
+			kind: "outerShdw",
+			color: requireColor(element),
+			...shadowGeometry(element)
+		};
+		case "a:innerShdw": return {
+			kind: "innerShdw",
+			color: requireColor(element),
+			...shadowGeometry(element)
+		};
+		case "a:prstShdw": return {
+			kind: "prstShdw",
+			prst: attributeValue(element, "prst") ?? "",
+			dist: intAttr(element, "dist", 0, "a:prstShdw"),
+			dir: intAttr(element, "dir", 0, "a:prstShdw"),
+			color: requireColor(element)
+		};
+		case "a:glow": return {
+			kind: "glow",
+			rad: intAttr(element, "rad", 0, "a:glow"),
+			color: requireColor(element)
+		};
+		case "a:softEdge": return {
+			kind: "softEdge",
+			rad: intAttr(element, "rad", 0, "a:softEdge")
+		};
+		case "a:blur": return {
+			kind: "blur",
+			rad: intAttr(element, "rad", 0, "a:blur"),
+			grow: boolAttr(element, "grow", true)
+		};
+		case "a:reflection": return {
+			kind: "reflection",
+			blurRad: intAttr(element, "blurRad", 0, "a:reflection"),
+			stA: percentAttr(element, "stA", 1e5),
+			stPos: percentAttr(element, "stPos", 0),
+			endA: percentAttr(element, "endA", 0),
+			endPos: percentAttr(element, "endPos", 1e5),
+			dist: intAttr(element, "dist", 0, "a:reflection"),
+			dir: intAttr(element, "dir", 0, "a:reflection"),
+			fadeDir: intAttr(element, "fadeDir", 54e5, "a:reflection"),
+			sx: percentAttr(element, "sx", 1e5),
+			sy: percentAttr(element, "sy", 1e5),
+			kx: intAttr(element, "kx", 0, "a:reflection"),
+			ky: intAttr(element, "ky", 0, "a:reflection"),
+			algn: alignAttr(element, "b"),
+			rotWithShape: boolAttr(element, "rotWithShape", true)
+		};
+		default: return null;
+	}
+}
+/**
+* `a:effectLst`, in the order the file wrote it.
+*
+* Which is not the order it is painted in: 2.8 measured a glow painting *over*
+* an outer shadow, the reverse of the schema's sequence. `effectFilter` in
+* `paint` owns that, and this owns only the reading.
+*
+* `a:effectDag` is not modelled, so the shape is re-emitted byte for byte
+* rather than approximated. PowerPoint writes none but does render one:
+* measured on `a04-effects-03`, where it composites a glow over the fill.
+*/
+function parseEffects(parent) {
+	const list = firstChild(parent, "a:effectLst");
+	if (list === void 0) return void 0;
+	const out = [];
+	for (const child of childElements(list)) {
+		const effect = parseEffectElement(child);
+		if (effect !== null) out.push(effect);
+	}
+	return out;
+}
+//#endregion
+//#region src/parse/geometry.ts
+/**
+* `a:prstGeom` and `a:custGeom`, into the one type `@pptx-studio/geometry` takes.
+*
+* ## Why this is in the model rather than in the renderer
+*
+* Because geometry inherits. A slide placeholder that states no `a:spPr/a:xfrm`
+* usually states no `a:prstGeom` either, and takes both from its layout - so
+* "which shape is this" is a question for the resolver, and the resolver only
+* works over fields on `Shape`. Reading the geometry off `shape.node` in a
+* renderer would put half of one answer in the model and the other half
+* somewhere that cannot see the chain.
+*
+* 2.9 recorded only the preset's *name*, which is enough to say what a shape is
+* and not enough to draw it: `a:avLst` is where a rounded rectangle's corner
+* radius and a chevron's notch depth live, and a preset drawn with its defaults
+* when the file overrode them is a visibly wrong shape.
+*
+* ## The two are one type, and that is 2.4's finding rather than a convenience
+*
+* `a:custGeom` carries `avLst`, `gdLst`, `ahLst`, `cxnLst`, `rect` and
+* `pathLst`: the same six children with the same meanings as a preset
+* definition, written inline instead of looked up by name. So both parse into
+* `Geometry` and the evaluator has one code path. The only difference is that a
+* preset has a name and a `custGeom` does not.
+*/
+function guides(parent, qname) {
+	const list = parent === void 0 ? void 0 : firstChild(parent, qname);
+	if (list === void 0) return [];
+	const out = [];
+	for (const child of childElements(list)) {
+		if (child.qname !== "a:gd") continue;
+		const name = attributeValue(child, "name");
+		const fmla = attributeValue(child, "fmla");
+		if (name === void 0 || fmla === void 0) continue;
+		out.push({
+			name,
+			fmla: fmla.trim().split(/\s+/)
+		});
+	}
+	return out;
+}
+function point(element, partName) {
+	const x = attributeValue(element, "x");
+	const y = attributeValue(element, "y");
+	if (x === void 0 || y === void 0) throw new ModelError("MODEL_GEOMETRY", `<${element.qname}> has no x or no y`, partName);
+	return {
+		x,
+		y
+	};
+}
+const PATH_FILLS = /* @__PURE__ */ new Set([
+	"none",
+	"norm",
+	"lighten",
+	"lightenLess",
+	"darken",
+	"darkenLess"
+]);
+function pathFill(raw) {
+	return raw !== void 0 && PATH_FILLS.has(raw) ? raw : "norm";
+}
+/** `@w`/`@h` on an `a:path`. Absent means zero, which means no path space. */
+function pathExtent(element, name, partName) {
+	const raw = attributeValue(element, name);
+	if (raw === void 0) return 0;
+	const value = Number(raw);
+	if (!Number.isFinite(value)) throw new ModelError("MODEL_GEOMETRY", `a:path/@${name} is "${raw}"`, partName);
+	return value;
+}
+function commands(path, partName) {
+	const out = [];
+	for (const child of childElements(path)) switch (child.qname) {
+		case "a:moveTo":
+		case "a:lnTo": {
+			const pt = firstChild(child, "a:pt");
+			if (pt === void 0) break;
+			out.push({
+				kind: child.qname === "a:moveTo" ? "moveTo" : "lnTo",
+				to: point(pt, partName)
+			});
+			break;
+		}
+		case "a:quadBezTo": {
+			const pts = childElements(child).filter((c) => c.qname === "a:pt");
+			if (pts.length < 2) break;
+			out.push({
+				kind: "quadBezTo",
+				c1: point(pts[0], partName),
+				to: point(pts[1], partName)
+			});
+			break;
+		}
+		case "a:cubicBezTo": {
+			const pts = childElements(child).filter((c) => c.qname === "a:pt");
+			if (pts.length < 3) break;
+			out.push({
+				kind: "cubicBezTo",
+				c1: point(pts[0], partName),
+				c2: point(pts[1], partName),
+				to: point(pts[2], partName)
+			});
+			break;
+		}
+		case "a:arcTo": {
+			const wR = attributeValue(child, "wR");
+			const hR = attributeValue(child, "hR");
+			const stAng = attributeValue(child, "stAng");
+			const swAng = attributeValue(child, "swAng");
+			if (wR === void 0 || hR === void 0 || stAng === void 0 || swAng === void 0) throw new ModelError("MODEL_GEOMETRY", "a:arcTo is missing an attribute", partName);
+			out.push({
+				kind: "arcTo",
+				wR,
+				hR,
+				stAng,
+				swAng
+			});
+			break;
+		}
+		case "a:close": out.push({ kind: "close" });
+	}
+	return out;
+}
+function paths(parent, partName) {
+	const list = firstChild(parent, "a:pathLst");
+	if (list === void 0) return [];
+	const out = [];
+	for (const child of childElements(list)) {
+		if (child.qname !== "a:path") continue;
+		out.push({
+			w: pathExtent(child, "w", partName),
+			h: pathExtent(child, "h", partName),
+			fill: pathFill(attributeValue(child, "fill")),
+			stroke: attributeValue(child, "stroke") !== "0",
+			extrusionOk: attributeValue(child, "extrusionOk") === "1",
+			commands: commands(child, partName)
+		});
+	}
+	return out;
+}
+function handles(parent, partName) {
+	const list = firstChild(parent, "a:ahLst");
+	if (list === void 0) return [];
+	const out = [];
+	for (const child of childElements(list)) {
+		const pos = firstChild(child, "a:pos");
+		if (pos === void 0) continue;
+		const at = point(pos, partName);
+		if (child.qname === "a:ahXY") out.push({
+			kind: "xy",
+			pos: at,
+			gdRefX: attributeValue(child, "gdRefX") ?? null,
+			minX: attributeValue(child, "minX") ?? null,
+			maxX: attributeValue(child, "maxX") ?? null,
+			gdRefY: attributeValue(child, "gdRefY") ?? null,
+			minY: attributeValue(child, "minY") ?? null,
+			maxY: attributeValue(child, "maxY") ?? null
+		});
+		else if (child.qname === "a:ahPolar") out.push({
+			kind: "polar",
+			pos: at,
+			gdRefAng: attributeValue(child, "gdRefAng") ?? null,
+			minAng: attributeValue(child, "minAng") ?? null,
+			maxAng: attributeValue(child, "maxAng") ?? null,
+			gdRefR: attributeValue(child, "gdRefR") ?? null,
+			minR: attributeValue(child, "minR") ?? null,
+			maxR: attributeValue(child, "maxR") ?? null
+		});
+	}
+	return out;
+}
+function sites(parent, partName) {
+	const list = firstChild(parent, "a:cxnLst");
+	if (list === void 0) return [];
+	const out = [];
+	for (const child of childElements(list)) {
+		if (child.qname !== "a:cxn") continue;
+		const pos = firstChild(child, "a:pos");
+		const ang = attributeValue(child, "ang");
+		if (pos === void 0 || ang === void 0) continue;
+		out.push({
+			ang,
+			pos: point(pos, partName)
+		});
+	}
+	return out;
+}
+function textRect(parent) {
+	const rect = firstChild(parent, "a:rect");
+	if (rect === void 0) return null;
+	const l = attributeValue(rect, "l");
+	const t = attributeValue(rect, "t");
+	const r = attributeValue(rect, "r");
+	const b = attributeValue(rect, "b");
+	return l === void 0 || t === void 0 || r === void 0 || b === void 0 ? null : {
+		l,
+		t,
+		r,
+		b
+	};
+}
+/**
+* The geometry a shape declares, or `undefined` when it declares none.
+*
+* `undefined` is the whole point: a slide placeholder with no `a:prstGeom` has
+* not chosen to be a rectangle, it has said nothing, and `resolve` is what turns
+* that into the layout's answer.
+*/
+function parseGeometry(spPr, partName) {
+	if (spPr === void 0) return void 0;
+	const preset = firstChild(spPr, "a:prstGeom");
+	if (preset !== void 0) {
+		const prst = attributeValue(preset, "prst");
+		if (prst === void 0) throw new ModelError("MODEL_GEOMETRY", "a:prstGeom has no @prst", partName);
+		return {
+			kind: "preset",
+			prst,
+			adjust: guides(preset, "a:avLst")
+		};
+	}
+	const custom = firstChild(spPr, "a:custGeom");
+	if (custom === void 0) return void 0;
+	return {
+		kind: "custom",
+		geometry: custGeom({
+			avLst: guides(custom, "a:avLst"),
+			gdLst: guides(custom, "a:gdLst"),
+			ahLst: handles(custom, partName),
+			cxnLst: sites(custom, partName),
+			rect: textRect(custom),
+			pathLst: paths(custom, partName)
+		})
+	};
+}
+//#endregion
+//#region src/parse/body.ts
+/**
+* `a:bodyPr`: the text frame, as the file states it.
+*
+* Every field is `T | undefined` for the reason the rest of the model is - a
+* frame that states no anchor is not a top-anchored frame, and 3.6 measured that
+* the difference is the whole of the placeholder cascade.
+*/
+const ANCHORS = [
+	"t",
+	"ctr",
+	"b",
+	"just",
+	"dist"
+];
+const VERTICALS = [
+	"horz",
+	"vert",
+	"vert270",
+	"wordArtVert",
+	"eaVert",
+	"mongolianVert",
+	"wordArtVertRtl"
+];
+const WRAPS = ["none", "square"];
+const VERT_OVERFLOWS = [
+	"overflow",
+	"ellipsis",
+	"clip"
+];
+const HORZ_OVERFLOWS = ["overflow", "clip"];
+function attrError(element, name, raw, why, part) {
+	throw new ModelError("MODEL_TEXT_ATTR", `${element.qname}/@${name} is "${raw}", which is not ${why}`, part, name);
+}
+function boolOf$1(element, name, part) {
+	const raw = attributeValue(element, name);
+	if (raw === void 0) return void 0;
+	if (raw === "1" || raw === "true") return true;
+	if (raw === "0" || raw === "false") return false;
+	return attrError(element, name, raw, "a ST_OnOff", part);
+}
+function intOf$2(element, name, part) {
+	const raw = attributeValue(element, name);
+	if (raw === void 0) return void 0;
+	const value = Number(raw);
+	if (!Number.isInteger(value)) return attrError(element, name, raw, "an integer", part);
+	return value;
+}
+function enumOf$1(element, name, allowed, part) {
+	const raw = attributeValue(element, name);
+	if (raw === void 0) return void 0;
+	if (!allowed.includes(raw)) return attrError(element, name, raw, `one of ${allowed.join(", ")}`, part);
+	return raw;
+}
+/**
+* `a:noAutofit` / `a:normAutofit` / `a:spAutoFit`, whichever is present.
+*
+* The scale attributes are `ST_TextFontScalePercentOrPercentString`, which is
+* the same both-spellings grammar as every other percentage here; they are kept
+* as thousandths so `@pptx-studio/text` reads them the way it was measured.
+*/
+function parseAutofit(element, part) {
+	if (firstChild(element, "a:noAutofit") !== void 0) return { kind: "none" };
+	if (firstChild(element, "a:spAutoFit") !== void 0) return { kind: "shape" };
+	const norm = firstChild(element, "a:normAutofit");
+	if (norm === void 0) return void 0;
+	return {
+		kind: "normal",
+		fontScale: percentOf(norm, "fontScale", part),
+		lnSpcReduction: percentOf(norm, "lnSpcReduction", part)
+	};
+}
+/** Thousandths of a percent, accepting both the `92500` and the `92.5%` spellings. */
+function percentOf(element, name, part) {
+	const raw = attributeValue(element, name);
+	if (raw === void 0) return void 0;
+	const value = raw.endsWith("%") ? Number(raw.slice(0, -1)) * 1e3 : Number(raw);
+	if (!Number.isFinite(value)) return attrError(element, name, raw, "a ST_Percentage", part);
+	return value;
+}
+/** Parse an `a:bodyPr`. Lengths stay in EMU and angles in 60000ths of a degree. */
+function parseBodyProps(element, partName) {
+	return {
+		anchor: enumOf$1(element, "anchor", ANCHORS, partName),
+		anchorCtr: boolOf$1(element, "anchorCtr", partName),
+		lIns: intOf$2(element, "lIns", partName),
+		tIns: intOf$2(element, "tIns", partName),
+		rIns: intOf$2(element, "rIns", partName),
+		bIns: intOf$2(element, "bIns", partName),
+		vert: enumOf$1(element, "vert", VERTICALS, partName),
+		wrap: enumOf$1(element, "wrap", WRAPS, partName),
+		vertOverflow: enumOf$1(element, "vertOverflow", VERT_OVERFLOWS, partName),
+		horzOverflow: enumOf$1(element, "horzOverflow", HORZ_OVERFLOWS, partName),
+		rot: intOf$2(element, "rot", partName),
+		upright: boolOf$1(element, "upright", partName),
+		numCol: intOf$2(element, "numCol", partName),
+		spcCol: intOf$2(element, "spcCol", partName),
+		rtlCol: boolOf$1(element, "rtlCol", partName),
+		spcFirstLastPara: boolOf$1(element, "spcFirstLastPara", partName),
+		compatLnSpc: boolOf$1(element, "compatLnSpc", partName),
+		fromWordArt: boolOf$1(element, "fromWordArt", partName),
+		forceAA: boolOf$1(element, "forceAA", partName),
+		autofit: parseAutofit(element, partName),
+		node: element
+	};
+}
+/** The `a:bodyPr` of a `p:txBody`, when it has one. */
+function parseBodyPropsChild(parent, partName) {
+	const element = firstChild(parent, "a:bodyPr");
+	return element === void 0 ? void 0 : parseBodyProps(element, partName);
+}
+//#endregion
+//#region src/text.ts
+const THEME_FONT = /^\+(mj|mn)-(lt|ea|cs)$/;
+/** `+mn-lt` and its five siblings, or `null` for a real typeface name. */
+function themeFontRef(typeface) {
+	const match = THEME_FONT.exec(typeface);
+	if (match === null) return null;
+	const script = match[2];
+	return {
+		collection: match[1] === "mj" ? "major" : "minor",
+		script: script === "lt" ? "latin" : script
+	};
+}
+/** The number of levels a `CT_TextListStyle` holds, and `@lvl`'s range plus one. */
+const LEVELS = 9;
+//#endregion
+//#region src/parse/text.ts
+/**
+* `p:txBody`, `a:lstStyle` and `p:txStyles` into the text model.
+*
+* Nothing here resolves anything and nothing here defaults anything the file
+* could have said. That is the same rule the rest of the parser follows, and in
+* this one corner it is load-bearing rather than tidy: `@marL` and `@indent`
+* have schema defaults of 347663 and -342900, and a parser that materialises
+* them gives every paragraph a 27-point hanging indent it never asked for *and*
+* blocks the value it should have inherited, because a default that has been
+* written down cannot be told from a declaration. Measured in 3.1 - PowerPoint
+* resolves both to 0 when nothing declares them.
+*
+* The one place a value is supplied is `Paragraph.level`, which is 0 when
+* `@lvl` is absent because that is what the attribute means rather than what the
+* schema says, and which is not inherited by anything.
+*/
+/**
+* `ST_OnOff`, which has four lexical forms and not two.
+*
+* `1`/`true` and `0`/`false`. Anything else is a file that says something we do
+* not understand, and guessing is how an explicit `b="0"` becomes bold.
+*/
+function boolOf(element, name, partName) {
+	const raw = attributeValue(element, name);
+	if (raw === void 0) return void 0;
+	if (raw === "1" || raw === "true") return true;
+	if (raw === "0" || raw === "false") return false;
+	throw new ModelError("MODEL_TEXT_ATTR", `${element.qname}/@${name} is "${raw}", which is not a ST_OnOff`, partName, name);
+}
+function intOf$1(element, name, partName) {
+	const raw = attributeValue(element, name);
+	if (raw === void 0) return void 0;
+	const value = Number(raw);
+	if (!Number.isInteger(value)) throw new ModelError("MODEL_TEXT_ATTR", `${element.qname}/@${name} is "${raw}", which is not an integer`, partName, name);
+	return value;
+}
+/**
+* An attribute whose value must be one of a fixed set.
+*
+* A value outside the set throws rather than falling back to the first member.
+* A silent fallback here paints the wrong thing and gives nothing to trace it
+* by, and `ST_TextAlignType` in particular has a member - `just` - whose
+* substitute would be plausible on most slides and wrong on the rest.
+*/
+function enumOf(element, name, allowed, partName) {
+	const raw = attributeValue(element, name);
+	if (raw === void 0) return void 0;
+	if (!allowed.includes(raw)) throw new ModelError("MODEL_TEXT_ATTR", `${element.qname}/@${name} is "${raw}", which is not one of ${allowed.join(", ")}`, partName, name);
+	return raw;
+}
+const ALIGN = [
+	"l",
+	"ctr",
+	"r",
+	"just",
+	"justLow",
+	"dist",
+	"thaiDist"
+];
+const FONT_ALIGN = [
+	"auto",
+	"t",
+	"ctr",
+	"base",
+	"b"
+];
+const STRIKE = [
+	"noStrike",
+	"sngStrike",
+	"dblStrike"
+];
+const CAPS = [
+	"none",
+	"small",
+	"all"
+];
+const UNDERLINE = [
+	"none",
+	"words",
+	"sng",
+	"dbl",
+	"heavy",
+	"dotted",
+	"dottedHeavy",
+	"dash",
+	"dashHeavy",
+	"dashLong",
+	"dashLongHeavy",
+	"dotDash",
+	"dotDashHeavy",
+	"dotDotDash",
+	"dotDotDashHeavy",
+	"wavy",
+	"wavyHeavy",
+	"wavyDbl"
+];
+/**
+* `a:latin` and its three siblings.
+*
+* `@charset` is **signed**: Shift-JIS is written `-128`, and reading it as an
+* unsigned byte turns the one value that identifies Japanese text into 128,
+* which is nothing. `@panose` is kept as the twenty hex characters it is,
+* because it is written back verbatim and nothing here interprets it.
+*/
+function typefaceOf(element, partName) {
+	const typeface = attributeValue(element, "typeface");
+	if (typeface === void 0) throw new ModelError("MODEL_TEXT_ATTR", `${element.qname} has no @typeface`, partName, element.qname);
+	return {
+		typeface,
+		panose: attributeValue(element, "panose"),
+		pitchFamily: intOf$1(element, "pitchFamily", partName),
+		charset: intOf$1(element, "charset", partName)
+	};
+}
+/**
+* A named typeface child.
+*
+* Split from `typefaceOf` because `a:buFont` carries the same attributes on the
+* element itself rather than on a child of a known name, and reading it through
+* a lookup by qname would need the caller to pass its own element as its own
+* parent.
+*/
+function parseTypeface(parent, qname, partName) {
+	const element = firstChild(parent, qname);
+	return element === void 0 ? void 0 : typefaceOf(element, partName);
+}
+/** `a:rPr`, `a:defRPr` or `a:endParaRPr` - one type under three names. */
+function parseRunProps(element, partName) {
+	return {
+		sz: intOf$1(element, "sz", partName),
+		b: boolOf(element, "b", partName),
+		i: boolOf(element, "i", partName),
+		u: enumOf(element, "u", UNDERLINE, partName),
+		strike: enumOf(element, "strike", STRIKE, partName),
+		cap: enumOf(element, "cap", CAPS, partName),
+		spc: intOf$1(element, "spc", partName),
+		kern: intOf$1(element, "kern", partName),
+		baseline: intOf$1(element, "baseline", partName),
+		noProof: boolOf(element, "noProof", partName),
+		lang: attributeValue(element, "lang"),
+		altLang: attributeValue(element, "altLang"),
+		latin: parseTypeface(element, "a:latin", partName),
+		ea: parseTypeface(element, "a:ea", partName),
+		cs: parseTypeface(element, "a:cs", partName),
+		sym: parseTypeface(element, "a:sym", partName),
+		fill: parseFill(element, partName),
+		line: parseLine(element, partName),
+		effects: parseEffects(element),
+		highlight: parseColorChild(firstChild(element, "a:highlight")) ?? void 0,
+		node: element
+	};
+}
+function parseRunPropsChild(parent, qname, partName) {
+	const element = firstChild(parent, qname);
+	return element === void 0 ? void 0 : parseRunProps(element, partName);
+}
+/**
+* `a:lnSpc`, `a:spcBef` or `a:spcAft`.
+*
+* The child's name is the unit. `a:spcPct` is a `ST_TextSpacingPercentOrPercentString`
+* and so accepts both the `150000` and the `150%` spellings - `parsePercentage`
+* handles the second, measured in 2.6 for colour and again in 3.1 here.
+* `a:spcPts` is hundredths of a point and has only one spelling.
+*/
+function parseSpacing(parent, qname, partName) {
+	const element = firstChild(parent, qname);
+	if (element === void 0) return void 0;
+	const pct = firstChild(element, "a:spcPct");
+	if (pct !== void 0) {
+		const raw = attributeValue(pct, "val");
+		if (raw === void 0) throw new ModelError("MODEL_TEXT_ATTR", `${qname}/a:spcPct has no @val`, partName, qname);
+		return {
+			kind: "percent",
+			value: parsePercentage(raw)
+		};
+	}
+	const pts = firstChild(element, "a:spcPts");
+	if (pts !== void 0) {
+		const value = intOf$1(pts, "val", partName);
+		if (value === void 0) throw new ModelError("MODEL_TEXT_ATTR", `${qname}/a:spcPts has no @val`, partName, qname);
+		return {
+			kind: "points",
+			value
+		};
+	}
+}
+/** `a:pPr`, `a:defPPr` or any `a:lvlNpPr` - one type under eleven names. */
+function parseParaProps(element, partName) {
+	return {
+		marL: intOf$1(element, "marL", partName),
+		marR: intOf$1(element, "marR", partName),
+		indent: intOf$1(element, "indent", partName),
+		algn: enumOf(element, "algn", ALIGN, partName),
+		defTabSz: intOf$1(element, "defTabSz", partName),
+		rtl: boolOf(element, "rtl", partName),
+		eaLnBrk: boolOf(element, "eaLnBrk", partName),
+		fontAlgn: enumOf(element, "fontAlgn", FONT_ALIGN, partName),
+		latinLnBrk: boolOf(element, "latinLnBrk", partName),
+		hangingPunct: boolOf(element, "hangingPunct", partName),
+		lnSpc: parseSpacing(element, "a:lnSpc", partName),
+		spcBef: parseSpacing(element, "a:spcBef", partName),
+		spcAft: parseSpacing(element, "a:spcAft", partName),
+		defRPr: parseRunPropsChild(element, "a:defRPr", partName),
+		...parseBullet(element, partName),
+		node: element
+	};
+}
+/** The four bullet elements, of which at most one may appear. */
+const BULLET_KINDS = [
+	["a:buNone", "none"],
+	["a:buChar", "char"],
+	["a:buAutoNum", "autonum"],
+	["a:buBlip", "blip"]
+];
+/**
+* The bullet, as four independent slots plus the exclusive kind.
+*
+* Four rather than one because T5 measured them to merge separately: a level
+* that declares only `a:buFont` re-faces an inherited `a:buChar` and keeps
+* everything else. Folding them into a single value would make that impossible
+* to express, and the fold is what a reader writes first because the schema puts
+* the four kinds in one exclusive group.
+*
+* `a:buFontTx`, `a:buSzTx` and `a:buClrTx` are parsed as *values* rather than as
+* absences, because they are: PowerPoint writes nothing at all to mean "follow
+* the text", so the explicit element only ever appears in order to cancel
+* something a level above declared.
+*/
+function parseBullet(element, partName) {
+	let buKind;
+	for (const [name, kind] of BULLET_KINDS) if (firstChild(element, name) !== void 0) {
+		if (buKind !== void 0) throw new ModelError("MODEL_TEXT_BULLET", `a:pPr declares both ${buKind} and ${kind} bullets, which are exclusive`, partName, "a:pPr");
+		buKind = kind;
+	}
+	const charElement = firstChild(element, "a:buChar");
+	const autoNum = firstChild(element, "a:buAutoNum");
+	const blip = firstChild(element, "a:buBlip");
+	const font = firstChild(element, "a:buFont");
+	const szPct = firstChild(element, "a:buSzPct");
+	const szPts = firstChild(element, "a:buSzPts");
+	const clr = firstChild(element, "a:buClr");
+	let buAutoNum;
+	if (autoNum !== void 0) {
+		const type = attributeValue(autoNum, "type");
+		if (type === void 0) throw new ModelError("MODEL_TEXT_BULLET", "a:buAutoNum has no @type, which the schema requires", partName, "a:buAutoNum");
+		buAutoNum = {
+			type,
+			startAt: intOf$1(autoNum, "startAt", partName)
+		};
+	}
+	let buBlip;
+	if (blip !== void 0) {
+		const embed = firstChild(blip, "a:blip");
+		buBlip = embed === void 0 ? void 0 : attributeValue(embed, "r:embed");
+		if (buBlip === void 0) throw new ModelError("MODEL_TEXT_BULLET", "a:buBlip has no a:blip/@r:embed to resolve", partName, "a:buBlip");
+	}
+	let buFont;
+	if (firstChild(element, "a:buFontTx") !== void 0) buFont = { kind: "text" };
+	else if (font !== void 0) buFont = {
+		kind: "typeface",
+		value: typefaceOf(font, partName)
+	};
+	let buSize;
+	if (firstChild(element, "a:buSzTx") !== void 0) buSize = { kind: "text" };
+	else if (szPct !== void 0) buSize = {
+		kind: "percent",
+		value: requiredPercentage(szPct, partName, "a:buSzPct")
+	};
+	else if (szPts !== void 0) buSize = {
+		kind: "points",
+		value: requiredInt(szPts, partName, "a:buSzPts")
+	};
+	let buColor;
+	if (firstChild(element, "a:buClrTx") !== void 0) buColor = { kind: "text" };
+	else if (clr !== void 0) {
+		const value = parseColorChild(clr);
+		if (value === void 0 || value === null) throw new ModelError("MODEL_TEXT_BULLET", "a:buClr holds no colour", partName, "a:buClr");
+		buColor = {
+			kind: "color",
+			value
+		};
+	}
+	return {
+		buKind,
+		buChar: charElement === void 0 ? void 0 : attributeValue(charElement, "char") ?? "",
+		buAutoNum,
+		buBlip,
+		buFont,
+		buSize,
+		buColor
+	};
+}
+/** `@val` on a `a:buSzPct`, which the schema makes required. */
+function requiredPercentage(element, partName, what) {
+	const raw = attributeValue(element, "val");
+	if (raw === void 0) throw new ModelError("MODEL_TEXT_BULLET", `${what} has no @val`, partName, what);
+	return parsePercentage(raw);
+}
+/** `@val` on a `a:buSzPts`, in hundredths of a point. */
+function requiredInt(element, partName, what) {
+	const value = intOf$1(element, "val", partName);
+	if (value === void 0) throw new ModelError("MODEL_TEXT_BULLET", `${what} has no @val`, partName, what);
+	return value;
+}
+const LEVEL_NAMES = Array.from({ length: 9 }, (_, i) => `a:lvl${String(i + 1)}pPr`);
+/**
+* `a:lstStyle`, or a `p:txStyles` bucket, which is the same type unwrapped.
+*
+* The nine levels are independent: measured in 3.1, a layout placeholder
+* declaring only `a:lvl2pPr` changes the second level and leaves the first and
+* third to the master. So a level nobody declared stays `undefined` rather than
+* falling back to level one, and the resolver asks per level.
+*/
+function parseListStyle(element, partName) {
+	const levels = [];
+	for (const name of LEVEL_NAMES) {
+		const level = firstChild(element, name);
+		levels.push(level === void 0 ? void 0 : parseParaProps(level, partName));
+	}
+	const defPPr = firstChild(element, "a:defPPr");
+	return {
+		levels,
+		defPPr: defPPr === void 0 ? void 0 : parseParaProps(defPPr, partName),
+		node: element
+	};
+}
+function parseListStyleChild(parent, qname, partName) {
+	const element = firstChild(parent, qname);
+	return element === void 0 ? void 0 : parseListStyle(element, partName);
+}
+/** `p:txStyles` on a master. */
+function parseTextStyles(element, partName) {
+	return {
+		title: parseListStyleChild(element, "p:titleStyle", partName),
+		body: parseListStyleChild(element, "p:bodyStyle", partName),
+		other: parseListStyleChild(element, "p:otherStyle", partName),
+		node: element
+	};
+}
+/** `p:defaultTextStyle` on `ppt/presentation.xml`, which is a `CT_TextListStyle`. */
+function parseDefaultTextStyle(presentation, partName) {
+	return parseListStyleChild(presentation, "p:defaultTextStyle", partName);
+}
+/**
+* The paragraph's level, from `a:pPr/@lvl`.
+*
+* `ST_TextIndentLevelType` bounds it at 0..8 and PowerPoint still opens a file
+* outside the bound, so this clamps rather than throws - refusing to render a
+* deck PowerPoint renders is a worse answer than rendering it the way
+* PowerPoint does. A non-integer is a different matter and does throw: that is
+* a file saying something nobody can act on.
+*/
+function levelOf(pPr, partName) {
+	if (pPr === void 0) return 0;
+	const lvl = intOf$1(pPr, "lvl", partName);
+	if (lvl === void 0) return 0;
+	return Math.max(0, Math.min(8, lvl));
+}
+function parseContent(element, partName) {
+	if (element.qname === "a:r") {
+		const t = firstChild(element, "a:t");
+		return {
+			kind: "run",
+			props: parseRunPropsChild(element, "a:rPr", partName),
+			text: t === void 0 ? "" : textContent(t),
+			node: element
+		};
+	}
+	if (element.qname === "a:br") return {
+		kind: "br",
+		props: parseRunPropsChild(element, "a:rPr", partName),
+		node: element
+	};
+	if (element.qname === "a:fld") {
+		const id = attributeValue(element, "id");
+		if (id === void 0) throw new ModelError("MODEL_TEXT_FIELD", "a:fld has no @id", partName, "a:fld");
+		const t = firstChild(element, "a:t");
+		return {
+			kind: "field",
+			id,
+			fieldType: attributeValue(element, "type"),
+			props: parseRunPropsChild(element, "a:rPr", partName),
+			text: t === void 0 ? "" : textContent(t),
+			node: element
+		};
+	}
+	return null;
+}
+function parseParagraph(element, partName) {
+	const pPr = firstChild(element, "a:pPr");
+	const content = [];
+	for (const child of childElements(element)) {
+		const parsed = parseContent(child, partName);
+		if (parsed !== null) content.push(parsed);
+	}
+	return {
+		props: pPr === void 0 ? void 0 : parseParaProps(pPr, partName),
+		level: levelOf(pPr, partName),
+		content,
+		endParaRPr: parseRunPropsChild(element, "a:endParaRPr", partName),
+		node: element
+	};
+}
+/** A `p:txBody` or an `a:txBody`. */
+function parseTextBody(element, partName) {
+	return {
+		bodyPr: parseBodyPropsChild(element, partName),
+		lstStyle: parseListStyleChild(element, "a:lstStyle", partName),
+		paragraphs: childElements(element).filter((child) => child.qname === "a:p").map((child) => parseParagraph(child, partName)),
+		node: element
+	};
+}
+/** The `p:txBody` of a shape, when it has one. */
+function parseTextBodyChild(parent, partName) {
+	const element = firstChild(parent, "p:txBody") ?? firstChild(parent, "a:txBody");
+	return element === void 0 ? void 0 : parseTextBody(element, partName);
+}
+//#endregion
+//#region src/parse/sheet.ts
+/**
+* A slide, layout or master part into a `Sheet`; a theme part into a `Theme`.
+*
+* Nothing here resolves anything and nothing here defaults anything that the
+* file could have said. The one exception is `showMasterShapes`, whose default
+* is `true` and which has no third state to preserve.
+*/
+const SLOT_SET = new Set(SCHEME_SLOTS);
+/**
+* `p:clrMap` or `a:overrideClrMapping`: all twelve attributes, every time.
+*
+* Eleven is a repair prompt, so a map that is missing one is a broken file
+* rather than a partial opinion, and there is nothing sensible to default the
+* missing one to.
+*/
+function parseClrMap(element, partName) {
+	const out = {};
+	for (const name of MAPPED_COLOR_NAMES) {
+		const raw = attributeValue(element, name);
+		if (raw === void 0) throw new ModelError("MODEL_CLRMAP_INCOMPLETE", `${element.qname} has no @${name}`, partName, name);
+		if (!SLOT_SET.has(raw)) throw new ModelError("MODEL_CLRMAP_SLOT", `${element.qname}/@${name} is "${raw}", which is not a clrScheme slot`, partName, raw);
+		out[name] = raw;
+	}
+	return out;
+}
+function parseClrMapOvr(parent, partName) {
+	const element = firstChild(parent, "p:clrMapOvr");
+	if (element === void 0) return void 0;
+	const override = firstChild(element, "a:overrideClrMapping");
+	if (override !== void 0) return {
+		kind: "override",
+		map: parseClrMap(override, partName)
+	};
+	return { kind: "inherit" };
+}
+function intOf(element, name, partName) {
+	const raw = attributeValue(element, name);
+	if (raw === void 0) return 0;
+	const value = Number(raw);
+	if (!Number.isInteger(value)) throw new ModelError("MODEL_XFRM_NUMBER", `${element.qname}/@${name} is "${raw}"`, partName, raw);
+	return value;
+}
+/**
+* The transform, from whichever element holds it.
+*
+* A `p:graphicFrame` keeps its geometry in a **PresentationML** `p:xfrm` and
+* has no `p:spPr` at all - it is a different element in a different namespace
+* from the `a:xfrm` every other shape uses, and looking for the wrong one gives
+* every chart, table, diagram and OLE object a size of zero.
+*/
+function parseXfrm(parent, partName, qname = "a:xfrm") {
+	const element = firstChild(parent, qname);
+	if (element === void 0) return void 0;
+	const off = firstChild(element, "a:off");
+	const ext = firstChild(element, "a:ext");
+	const chOff = firstChild(element, "a:chOff");
+	const chExt = firstChild(element, "a:chExt");
+	return {
+		x: off === void 0 ? 0 : intOf(off, "x", partName),
+		y: off === void 0 ? 0 : intOf(off, "y", partName),
+		cx: ext === void 0 ? 0 : intOf(ext, "cx", partName),
+		cy: ext === void 0 ? 0 : intOf(ext, "cy", partName),
+		rot: intOf(element, "rot", partName),
+		flipH: attributeValue(element, "flipH") === "1",
+		flipV: attributeValue(element, "flipV") === "1",
+		child: chOff === void 0 && chExt === void 0 ? null : {
+			x: chOff === void 0 ? 0 : intOf(chOff, "x", partName),
+			y: chOff === void 0 ? 0 : intOf(chOff, "y", partName),
+			cx: chExt === void 0 ? 0 : intOf(chExt, "cx", partName),
+			cy: chExt === void 0 ? 0 : intOf(chExt, "cy", partName)
+		}
+	};
+}
+const TYPE_SET = new Set(PLACEHOLDER_TYPES);
+const SIZE_SET = /* @__PURE__ */ new Set([
+	"full",
+	"half",
+	"quarter"
+]);
+/** `2^32 - 1`, the top of `xsd:unsignedInt`, which is what `@idx` is. */
+const MAX_IDX = 4294967295;
+function parsePlaceholder(nvPr, partName) {
+	if (nvPr === void 0) return null;
+	const ph = firstChild(nvPr, "p:ph");
+	if (ph === void 0) return null;
+	const rawType = attributeValue(ph, "type");
+	const rawIdx = attributeValue(ph, "idx");
+	let idx = null;
+	if (rawIdx !== void 0) {
+		const value = Number(rawIdx);
+		if (!Number.isInteger(value) || value < 0 || value > MAX_IDX) throw new ModelError("MODEL_PLACEHOLDER_IDX", `p:ph/@idx is "${rawIdx}", which is not an unsignedInt`, partName, rawIdx);
+		idx = value;
+	}
+	const rawSize = attributeValue(ph, "sz");
+	const orient = attributeValue(ph, "orient");
+	return {
+		type: rawType !== void 0 && TYPE_SET.has(rawType) ? rawType : null,
+		idx,
+		size: rawSize !== void 0 && SIZE_SET.has(rawSize) ? rawSize : null,
+		orient: orient === "vert" ? "vert" : orient === "horz" ? "horz" : null,
+		hasCustomPrompt: attributeValue(ph, "hasCustomPrompt") === "1"
+	};
+}
+function parseStyleRef(element, partName) {
+	if (element === void 0) return {
+		idx: 0,
+		color: null
+	};
+	const raw = attributeValue(element, "idx");
+	const idx = raw === void 0 ? 0 : Number(raw);
+	if (!Number.isInteger(idx) || idx < 0) throw new ModelError("MODEL_STYLE_IDX", `${element.qname}/@idx is "${String(raw)}"`, partName, raw ?? "");
+	let color = null;
+	for (const child of childElements(element)) if (child.qname.startsWith("a:") && child.qname.endsWith("Clr")) {
+		color = parseColorElement(child);
+		break;
+	}
+	return {
+		idx,
+		color
+	};
+}
+function parseStyle(parent, partName) {
+	const element = firstChild(parent, "p:style");
+	if (element === void 0) return void 0;
+	const fontRefElement = firstChild(element, "a:fontRef");
+	const rawFont = fontRefElement === void 0 ? void 0 : attributeValue(fontRefElement, "idx");
+	if (rawFont !== void 0 && rawFont !== "major" && rawFont !== "minor" && rawFont !== "none") throw new ModelError("MODEL_FONT_COLLECTION", `a:fontRef/@idx is "${rawFont}", not major, minor or none`, partName, rawFont);
+	let fontColor = null;
+	if (fontRefElement !== void 0) {
+		for (const child of childElements(fontRefElement)) if (child.qname.startsWith("a:") && child.qname.endsWith("Clr")) {
+			fontColor = parseColorElement(child);
+			break;
+		}
+	}
+	return {
+		lnRef: parseStyleRef(firstChild(element, "a:lnRef"), partName),
+		fillRef: parseStyleRef(firstChild(element, "a:fillRef"), partName),
+		effectRef: parseStyleRef(firstChild(element, "a:effectRef"), partName),
+		fontRef: {
+			idx: rawFont ?? "minor",
+			color: fontColor
+		}
+	};
+}
+const SHAPE_KINDS = {
+	"p:sp": "sp",
+	"p:pic": "pic",
+	"p:grpSp": "grpSp",
+	"p:graphicFrame": "graphicFrame",
+	"p:cxnSp": "cxnSp",
+	"p:contentPart": "contentPart"
+};
+/** Where each shape kind keeps its non-visual properties. */
+const NV_CONTAINERS = {
+	sp: "p:nvSpPr",
+	pic: "p:nvPicPr",
+	grpSp: "p:nvGrpSpPr",
+	graphicFrame: "p:nvGraphicFramePr",
+	cxnSp: "p:nvCxnSpPr",
+	contentPart: "p:nvContentPartPr"
+};
+function parseShape(element, kind, partName) {
+	const nv = firstChild(element, NV_CONTAINERS[kind]);
+	const cNvPr = nv === void 0 ? void 0 : firstChild(nv, "p:cNvPr");
+	const spPr = firstChild(element, kind === "grpSp" ? "p:grpSpPr" : "p:spPr");
+	const geometryHost = kind === "graphicFrame" ? element : spPr;
+	const prstGeom = spPr === void 0 ? void 0 : firstChild(spPr, "a:prstGeom");
+	const children = [];
+	if (kind === "grpSp") for (const child of childElements(element)) {
+		const childKind = SHAPE_KINDS[child.qname];
+		if (childKind !== void 0) children.push(parseShape(child, childKind, partName));
+	}
+	const picture = kind === "pic" ? parsePictureFill(element, partName) : void 0;
+	const rawId = cNvPr === void 0 ? void 0 : attributeValue(cNvPr, "id");
+	return {
+		kind,
+		cNvPrId: rawId === void 0 ? 0 : Number(rawId),
+		name: (cNvPr === void 0 ? void 0 : attributeValue(cNvPr, "name")) ?? "",
+		descr: (cNvPr === void 0 ? void 0 : attributeValue(cNvPr, "descr")) ?? null,
+		hidden: cNvPr !== void 0 && attributeValue(cNvPr, "hidden") === "1",
+		placeholder: parsePlaceholder(nv === void 0 ? void 0 : firstChild(nv, "p:nvPr"), partName),
+		xfrm: geometryHost === void 0 ? void 0 : parseXfrm(geometryHost, partName, kind === "graphicFrame" ? "p:xfrm" : "a:xfrm"),
+		fill: picture ?? (spPr === void 0 ? void 0 : parseFill(spPr, partName)),
+		line: spPr === void 0 ? void 0 : parseLine(spPr, partName),
+		effects: spPr === void 0 ? void 0 : parseEffects(spPr),
+		style: parseStyle(element, partName),
+		prstGeom: prstGeom === void 0 ? void 0 : attributeValue(prstGeom, "prst") ?? "",
+		geometry: parseGeometry(spPr, partName),
+		text: parseTextBodyChild(element, partName),
+		children,
+		node: element
+	};
+}
+function parseShapeTree(cSld, partName) {
+	const tree = firstChild(cSld, "p:spTree");
+	if (tree === void 0) return [];
+	const out = [];
+	for (const child of childElements(tree)) {
+		const kind = SHAPE_KINDS[child.qname];
+		if (kind !== void 0) out.push(parseShape(child, kind, partName));
+	}
+	return out;
+}
+function parseBackground(cSld, partName) {
+	const bg = firstChild(cSld, "p:bg");
+	if (bg === void 0) return void 0;
+	const ref = firstChild(bg, "p:bgRef");
+	if (ref !== void 0) return {
+		kind: "ref",
+		ref: parseStyleRef(ref, partName)
+	};
+	const pr = firstChild(bg, "p:bgPr");
+	if (pr === void 0) return void 0;
+	return {
+		kind: "fill",
+		fill: parseFill(pr, partName) ?? { type: "none" },
+		effects: parseEffects(pr)
+	};
+}
+function parseScheme(element, partName) {
+	const out = {};
+	for (const slot of SCHEME_SLOTS) {
+		const child = firstChild(element, `a:${slot}`);
+		if (child === void 0) continue;
+		for (const grandchild of childElements(child)) if (grandchild.qname.startsWith("a:") && grandchild.qname.endsWith("Clr")) {
+			out[slot] = parseColorElement(grandchild);
+			break;
+		}
+	}
+	const missing = SCHEME_SLOTS.filter((slot) => out[slot] === void 0);
+	if (missing.length > 0) throw new ModelError("MODEL_CLRMAP_INCOMPLETE", `a:clrScheme is missing ${missing.join(", ")}`, partName, missing.join(","));
+	return out;
+}
+function parseFontScheme(element) {
+	const collection = (which) => {
+		const font = element === void 0 ? void 0 : firstChild(element, which);
+		const face = (script) => {
+			if (font === void 0) return null;
+			const child = firstChild(font, script);
+			return child === void 0 ? null : attributeValue(child, "typeface") ?? null;
+		};
+		return {
+			latin: face("a:latin"),
+			ea: face("a:ea"),
+			cs: face("a:cs")
+		};
+	};
+	return {
+		name: element === void 0 ? null : attributeValue(element, "name") ?? null,
+		major: collection("a:majorFont"),
+		minor: collection("a:minorFont")
+	};
+}
+function parseFormatScheme(element, partName) {
+	if (element === void 0) return null;
+	const fills = (name) => {
+		const list = firstChild(element, name);
+		if (list === void 0) return [];
+		return childElements(list).map((child) => parseFillElement(child, partName));
+	};
+	const lineList = firstChild(element, "a:lnStyleLst");
+	const lines = lineList === void 0 ? [] : childElements(lineList).filter((child) => child.qname === "a:ln").map((child) => parseLineElement(child, partName));
+	const effectList = firstChild(element, "a:effectStyleLst");
+	const effects = effectList === void 0 ? [] : childElements(effectList).filter((child) => child.qname === "a:effectStyle").map((child) => parseEffects(child) ?? []);
+	return {
+		name: attributeValue(element, "name") ?? null,
+		fillStyles: fills("a:fillStyleLst"),
+		lineStyles: lines,
+		effectStyles: effects,
+		bgFillStyles: fills("a:bgFillStyleLst")
+	};
+}
+function parseTheme(root, partName) {
+	const elements = firstChild(root, "a:themeElements");
+	const scheme = elements === void 0 ? void 0 : firstChild(elements, "a:clrScheme");
+	if (elements === void 0 || scheme === void 0) throw new ModelError("MODEL_PART_KIND", "a theme with no a:clrScheme", partName);
+	return {
+		partName,
+		name: attributeValue(root, "name") ?? null,
+		scheme: parseScheme(scheme, partName),
+		fonts: parseFontScheme(firstChild(elements, "a:fontScheme")),
+		format: parseFormatScheme(firstChild(elements, "a:fmtScheme"), partName),
+		node: root
+	};
+}
+const ROOTS = {
+	"p:sld": "slide",
+	"p:sldLayout": "layout",
+	"p:sldMaster": "master"
+};
+/**
+* One part into one sheet. The parent and the theme are filled in by
+* `document.ts`, which is the only thing that can follow a relationship.
+*/
+function parseSheet(root, partName) {
+	const kind = ROOTS[root.qname];
+	if (kind === void 0) throw new ModelError("MODEL_PART_KIND", `${root.qname} is not a sheet root`, partName);
+	const cSld = firstChild(root, "p:cSld");
+	if (cSld === void 0) throw new ModelError("MODEL_PART_KIND", `${root.qname} has no p:cSld`, partName);
+	const clrMapElement = kind === "master" ? firstChild(root, "p:clrMap") : void 0;
+	const txStylesElement = kind === "master" ? firstChild(root, "p:txStyles") : void 0;
+	return {
+		kind,
+		partName,
+		name: attributeValue(cSld, "name") ?? null,
+		layoutType: kind === "layout" ? attributeValue(root, "type") ?? null : null,
+		matchingName: kind === "layout" ? attributeValue(root, "matchingName") ?? null : null,
+		shapes: parseShapeTree(cSld, partName),
+		background: parseBackground(cSld, partName),
+		clrMap: clrMapElement === void 0 ? void 0 : parseClrMap(clrMapElement, partName),
+		txStyles: txStylesElement === void 0 ? void 0 : parseTextStyles(txStylesElement, partName),
+		clrMapOvr: kind === "master" ? void 0 : parseClrMapOvr(root, partName),
+		showMasterShapes: attributeValue(root, "showMasterSp") !== "0",
+		node: root
+	};
+}
+//#endregion
+//#region src/resolve/placeholder.ts
+/**
+* The type of a `p:ph` that has none.
+*
+* `obj`, measured: a bare `<p:ph/>` on a slide reads back through PowerPoint's
+* object model as `ppPlaceholderObject`. ECMA's own default for the attribute
+* is `body`, and the two behave identically at the first hop because that hop
+* ignores the type - but they differ at the second, where `obj` folds to `body`
+* and `body` is already there. They agree, and it is worth knowing why rather
+* than by luck.
+*/
+const DEFAULT_PLACEHOLDER_TYPE = "obj";
+/** The `@idx` of a `p:ph` that has none. */
+const DEFAULT_PLACEHOLDER_IDX = 0;
+/** Supply the two defaults, so a comparison has something to compare. */
+function normalizePlaceholder(ph) {
+	return {
+		type: ph.type ?? "obj",
+		idx: ph.idx ?? 0
+	};
+}
+/** The four types that fold to `title` or stay as themselves on a master. */
+const MASTER_TITLE = /* @__PURE__ */ new Set(["title", "ctrTitle"]);
+/** The types a master may carry, which are the only targets of the second hop. */
+const MASTER_OWN = /* @__PURE__ */ new Set([
+	"body",
+	"dt",
+	"ftr",
+	"sldNum",
+	"hdr"
+]);
+/**
+* The type a placeholder presents when it asks a master for its parent.
+*
+* `ctrTitle` becomes `title`; everything a master may not carry - `subTitle`,
+* `obj`, `pic`, `chart`, `tbl`, `clipArt`, `dgm`, `media`, `sldImg` - becomes
+* `body`. Measured on `pic`, `obj`, `subTitle` and `ctrTitle`; the rest follow
+* because a master cannot hold them either and `body` is the only remaining
+* content type.
+*/
+function masterPlaceholderType(type) {
+	if (MASTER_TITLE.has(type)) return "title";
+	if (MASTER_OWN.has(type)) return type;
+	return "body";
+}
+/** Every placeholder in a sheet's top-level shape tree, in document order. */
+function placeholders(sheet) {
+	return sheet.shapes.filter((shape) => shape.placeholder !== null);
+}
+/**
+* Slide to layout: the first placeholder whose `@idx` agrees.
+*
+* "First" matters only for a layout that has two placeholders at one index,
+* which PowerPoint accepts without repairing; the first in the shape tree is
+* the one that wins.
+*/
+function matchInLayout(ph, layout) {
+	const want = normalizePlaceholder(ph);
+	for (const shape of layout.shapes) {
+		if (shape.placeholder === null) continue;
+		if (normalizePlaceholder(shape.placeholder).idx === want.idx) return shape;
+	}
+	return null;
+}
+/** Layout to master: the first placeholder of the folded type. */
+function matchInMaster(ph, master) {
+	const want = masterPlaceholderType(normalizePlaceholder(ph).type);
+	for (const shape of master.shapes) {
+		if (shape.placeholder === null) continue;
+		if (masterPlaceholderType(normalizePlaceholder(shape.placeholder).type) === want) return shape;
+	}
+	return null;
+}
+/**
+* The chain a shape inherits along, nearest first.
+*
+* One entry for a non-placeholder, and for a placeholder that matched nothing.
+* Up to three for a slide placeholder that reached the master. Each hop asks
+* with the placeholder of the sheet it is leaving, which is why the layout's
+* `@type` and not the slide's decides the second hop.
+*/
+function inheritanceChain(shape, sheet) {
+	const chain = [{
+		shape,
+		sheet,
+		origin: "shape"
+	}];
+	if (shape.placeholder === null) return chain;
+	let current = shape;
+	let currentSheet = sheet;
+	const seen = /* @__PURE__ */ new Set([sheet.partName]);
+	while (currentSheet.parent !== null && current.placeholder !== null) {
+		const parentSheet = currentSheet.parent;
+		if (seen.has(parentSheet.partName)) break;
+		seen.add(parentSheet.partName);
+		const next = parentSheet.kind === "master" ? matchInMaster(current.placeholder, parentSheet) : matchInLayout(current.placeholder, parentSheet);
+		if (next === null) break;
+		chain.push({
+			shape: next,
+			sheet: parentSheet,
+			origin: parentSheet.kind === "master" ? "masterPh" : "layoutPh"
+		});
+		current = next;
+		currentSheet = parentSheet;
+	}
+	return chain;
+}
+/**
+* A placeholder that reached no parent and states no geometry of its own.
+*
+* PowerPoint renders one at the origin with zero width and height - it does not
+* refuse the file, does not drop the shape, and does not invent a rectangle.
+* Measured on four probes: a title where the layout has none, a body at an index
+* nobody has, and both against a layout with no placeholders at all.
+*/
+const ORPHAN_RECT = {
+	x: 0,
+	y: 0,
+	cx: 0,
+	cy: 0
+};
+//#endregion
+//#region src/resolve/resolve.ts
+/**
+* The first level of the chain that declared something.
+*
+* `pick` must return `undefined` for "this level did not say" and anything else
+* for a value, including `null` - a shape may legitimately declare a `null`, and
+* conflating that with silence is how an explicit `a:noFill` gets overwritten by
+* an inherited colour.
+*/
+function resolve(shape, sheet, pick) {
+	const chain = inheritanceChain(shape, sheet);
+	for (const [index, link] of chain.entries()) {
+		const value = pick(link.shape);
+		if (value === void 0) continue;
+		return {
+			value,
+			origin: link.origin,
+			explicit: index === 0,
+			sheet: link.sheet,
+			shape: link.shape
+		};
+	}
+}
+/**
+* The rectangle a shape occupies, and which sheet stated it.
+*
+* The single most consequential call in the package. A slide placeholder that
+* PowerPoint wrote has **no** `a:xfrm` - not when it was created, not when text
+* was typed into it, only when the user moved or resized it, at which point the
+* whole resolved rectangle is baked in at once. So an absent `xfrm` is the
+* statement "still bound to my layout", and it is what Change Layout reads.
+*/
+function resolveXfrm(shape, sheet) {
+	return resolve(shape, sheet, (s) => s.xfrm);
+}
+/** Every sheet from this one up to its master, nearest first. */
+function sheetChain(sheet) {
+	const chain = [];
+	const seen = /* @__PURE__ */ new Set();
+	let current = sheet;
+	while (current !== null) {
+		if (seen.has(current.partName)) throw new ModelError("MODEL_SHEET_CYCLE", `the sheet chain returns to ${current.partName}`, current.partName);
+		seen.add(current.partName);
+		chain.push(current);
+		current = current.parent;
+	}
+	return chain;
+}
+/** The master at the top of a sheet's chain, or `null` if the chain is broken. */
+function masterOf(sheet) {
+	for (const link of sheetChain(sheet)) if (link.kind === "master") return link;
+	return null;
+}
+/**
+* The theme a sheet resolves against.
+*
+* The master's, reached through this sheet's own chain. **Not** the one
+* `ppt/presentation.xml.rels` names: PowerPoint writes a `theme` relationship
+* there too, it always points at `theme1.xml`, and on a two-master deck every
+* slide on the second master would take the first master's palette. Measured -
+* the two masters resolved `accent1` to two different colours, and each
+* master's background used its own theme's `bgFillStyleLst`.
+*
+* A master must own its theme part outright: two masters pointing at the same
+* one is repaired on open, so a shared theme is a broken file rather than an
+* economy.
+*/
+function themeOf(sheet) {
+	return masterOf(sheet)?.theme ?? null;
+}
+function schemeOf(sheet) {
+	return themeOf(sheet)?.scheme;
+}
+/**
+* The colour map in force on a sheet.
+*
+* `a:masterClrMapping` says "the map already in force", and the surprise is what
+* that means: for a slide it is the **layout's** map, not the master's. Measured
+* - a layout carrying an `a:overrideClrMapping` changed `accent1` on a slide
+* that declared `masterClrMapping`, and a slide with an override of its own beat
+* its layout's. The element is named for the sheet it usually ends at rather
+* than for the one it asks.
+*/
+function colorMapOf(sheet) {
+	for (const link of sheetChain(sheet)) {
+		if (link.kind === "master") return link.clrMap;
+		if (link.clrMapOvr?.kind === "override") return link.clrMapOvr.map;
+	}
+}
+/**
+* Everything `resolveColor` needs, for a colour written on this sheet.
+*
+* `phClr` is supplied by whatever style invocation the colour sits inside, and
+* there is nothing sensible to default it to: `style.ts` passes it in, and a
+* `schemeClr val="phClr"` reached any other way throws rather than painting
+* black.
+*/
+function colorContextOf(sheet, phClr) {
+	const scheme = schemeOf(sheet);
+	const map = colorMapOf(sheet);
+	return {
+		...scheme === void 0 ? {} : { scheme },
+		...map === void 0 ? {} : { map },
+		...phClr === void 0 ? {} : { phClr }
+	};
+}
+//#endregion
+//#region src/style.ts
+/**
+* The style matrix, the 1000-offset, and `phClr`.
+*
+* A `p:style` holds four references into the theme. Each names an entry by
+* index and carries the colour that entry's `schemeClr val="phClr"` is to be
+* resolved with - so an entry such as
+* `<a:solidFill><a:schemeClr val="phClr"><a:lumMod val="60000"/></a:schemeClr></a:solidFill>`
+* is a *function* of a colour, and the reference is the call.
+*
+* Miss `phClr` and every themed shape renders black, which is the failure this
+* whole file exists to prevent.
+*/
+/**
+* The offset that separates the two style lists.
+*
+* `0` and `1000` mean *nothing at all*; `1..999` index the main list; `1001` and
+* up index the background list. Measured on both `a:fillRef` and `p:bgRef`
+* against a theme whose six entries paint six distinguishable colours - all six
+* agreed between the two elements, and `idx="0"` and `idx="1000"` both painted
+* nothing.
+*/
+const STYLE_MATRIX_OFFSET = 1e3;
+/**
+* Where an index points, before anything is fetched.
+*
+* Out of range is not an error. A `fillRef idx="4"` against a three-entry list
+* paints the third entry, and a `bgRef idx="9999"` paints the last background
+* entry: PowerPoint clamps, opens the file without repairing it, and a renderer
+* that throws here refuses a deck PowerPoint shows.
+*/
+function styleMatrixTarget(idx) {
+	if (idx === 0 || idx === 1e3) return { list: "none" };
+	if (idx < 1e3) return {
+		list: "main",
+		at: idx - 1
+	};
+	return {
+		list: "background",
+		at: idx - STYLE_MATRIX_OFFSET - 1
+	};
+}
+function clampInto(entries, at, what, theme) {
+	if (entries.length === 0) throw new ModelError("MODEL_STYLE_LIST_EMPTY", `${what} has no entries`, theme.partName, what);
+	return entries[Math.min(Math.max(at, 0), entries.length - 1)];
+}
+/** The fill a `fillRef`/`bgRef` index names, or `null` for none. */
+function styleMatrixFill(ref, theme) {
+	const target = styleMatrixTarget(ref.idx);
+	if (target.list === "none") return null;
+	const format = theme.format;
+	if (format === null) throw new ModelError("MODEL_NO_STYLE_MATRIX", "the theme has no a:fmtScheme", theme.partName);
+	return target.list === "main" ? clampInto(format.fillStyles, target.at, "a:fillStyleLst", theme) : clampInto(format.bgFillStyles, target.at, "a:bgFillStyleLst", theme);
+}
+/**
+* The line an `lnRef` index names, or `null` for none.
+*
+* `a:lnStyleLst` has no background counterpart, so an index above 1000 clamps
+* into the same list rather than reaching a second one.
+*/
+function styleMatrixLine(ref, theme) {
+	const target = styleMatrixTarget(ref.idx);
+	if (target.list === "none") return null;
+	const format = theme.format;
+	if (format === null) throw new ModelError("MODEL_NO_STYLE_MATRIX", "the theme has no a:fmtScheme", theme.partName);
+	return clampInto(format.lineStyles, target.at, "a:lnStyleLst", theme);
+}
+/** The effects an `effectRef` index names. Empty for none. */
+function styleMatrixEffects(ref, theme) {
+	const target = styleMatrixTarget(ref.idx);
+	if (target.list === "none") return [];
+	const format = theme.format;
+	if (format === null) throw new ModelError("MODEL_NO_STYLE_MATRIX", "the theme has no a:fmtScheme", theme.partName);
+	return clampInto(format.effectStyles, target.at, "a:effectStyleLst", theme);
+}
+/**
+* The colour a style reference invokes its entry with.
+*
+* The reference's own colour child, resolved against the sheet - and it may
+* carry transforms of its own. PowerPoint's shape-style gallery writes
+* `<a:schemeClr val="accent1"><a:shade val="15000"/></a:schemeClr>` on seven of
+* its forty-two entries, so `phClr` is a fully transformed colour and not a
+* theme slot name.
+*/
+function phClrOf(ref, sheet) {
+	if (ref.color === null) return null;
+	return resolveColor(ref.color, colorContextOf(sheet));
+}
+function styleOf(shape, sheet) {
+	return resolve(shape, sheet, (s) => s.style);
+}
+/**
+* What a shape paints, following both routes and in the right order.
+*
+* An explicit `spPr` fill beats the `fillRef`, and an explicit `a:noFill` beats
+* it too - both measured. A shape with neither paints nothing rather than black.
+*
+* The two routes are searched independently: the `spPr` fill is looked for down
+* the whole inheritance chain first, and only if no level declared one does the
+* `p:style` - itself inherited down the same chain - get consulted.
+*/
+function resolveAppearance(shape, sheet) {
+	const theme = themeOf(sheet);
+	const style = styleOf(shape, sheet);
+	const directFill = resolve(shape, sheet, (s) => s.fill);
+	const directLine = resolve(shape, sheet, (s) => s.line);
+	const directEffects = resolve(shape, sheet, (s) => s.effects);
+	let fill = directFill?.value ?? null;
+	let fillOrigin = directFill?.origin ?? null;
+	let fillPhClr = null;
+	if (directFill === void 0 && style !== void 0 && theme !== null) {
+		const ref = style.value?.fillRef;
+		if (ref !== void 0) {
+			fill = styleMatrixFill(ref, theme);
+			fillOrigin = fill === null ? null : "theme";
+			fillPhClr = fill === null ? null : phClrOf(ref, sheet);
+		}
+	}
+	let line = directLine?.value ?? null;
+	let lineOrigin = directLine?.origin ?? null;
+	let linePhClr = null;
+	if (directLine === void 0 && style !== void 0 && theme !== null) {
+		const ref = style.value?.lnRef;
+		if (ref !== void 0) {
+			line = styleMatrixLine(ref, theme);
+			lineOrigin = line === null ? null : "theme";
+			linePhClr = line === null ? null : phClrOf(ref, sheet);
+		}
+	}
+	let effects = directEffects?.value ?? null;
+	if (directEffects === void 0 && style !== void 0 && theme !== null) {
+		const ref = style.value?.effectRef;
+		if (ref !== void 0) effects = styleMatrixEffects(ref, theme);
+	}
+	return {
+		fill,
+		fillOrigin,
+		fillPhClr,
+		line,
+		lineOrigin,
+		linePhClr,
+		effects
+	};
+}
+/**
+* A shape's fill as a single colour, when it is one.
+*
+* A convenience over `resolveAppearance` for the common case, and the shape the
+* ground-truth fixture is in: PowerPoint's object model reports one RGB per
+* shape, so this is what a measurement can be compared against.
+*/
+function resolveSolidFill(shape, sheet) {
+	const appearance = resolveAppearance(shape, sheet);
+	if (appearance.fill === null || appearance.fill.type !== "solid") return null;
+	const phClr = appearance.fillPhClr;
+	return resolveColor(appearance.fill.color, colorContextOf(sheet, phClr === null ? void 0 : phClr));
+}
+/** Resolve any colour written on a sheet, with an optional `phClr` in scope. */
+function resolveOnSheet(color, sheet, phClr) {
+	return resolveColor(color, colorContextOf(sheet, phClr));
+}
+//#endregion
+//#region src/resolve/background.ts
+/**
+* What is behind everything on a slide.
+*
+* Two questions, and they are independent. *Which sheet's* background applies,
+* and *what* that background is.
+*
+* **Which sheet.** The nearest one that declares a `p:bg` at all: the slide,
+* else its layout, else the master. Measured on all three. An absent `p:bg` is
+* the only thing that inherits - a slide declaring `<p:bgPr><a:noFill/>` paints
+* nothing and does *not* fall through, which is the distinction between "I have
+* no opinion" and "my opinion is nothing", and the reason `Background` is a
+* value rather than a nullable fill.
+*
+* **What it is.** `p:bgPr` states a fill outright. `p:bgRef` names an entry of
+* the theme's style matrix and the colour to invoke its `phClr` with, using the
+* same 1000-offset as `a:fillRef` over the same two lists - measured on six
+* indices through both elements, agreeing on all six. PowerPoint's own master
+* writes `<p:bgRef idx="1001"><a:schemeClr val="bg1"/></p:bgRef>`, which is the
+* first entry of `a:bgFillStyleLst` invoked with whatever `bg1` maps to.
+*
+* And `bg1` there is resolved through the colour map in force **on the sheet
+* that owns the shape**, not on the sheet that owns the background: a slide
+* whose `clrMapOvr` remaps `bg1` gets a different background out of the same
+* master. Measured.
+*/
+/** Which sheet's `p:bg` applies, without unpacking it. */
+function backgroundSheet(sheet) {
+	for (const link of sheetChain(sheet)) if (link.background !== void 0) return {
+		sheet: link,
+		background: link.background
+	};
+	return null;
+}
+/**
+* The background of a slide, layout or master.
+*
+* `null` when no sheet in the chain declares one, which is a legal file: a deck
+* whose master has no `p:bg` paints nothing behind its slides.
+*/
+function resolveBackground(sheet) {
+	const found = backgroundSheet(sheet);
+	if (found === null) return null;
+	if (found.background.kind === "fill") return {
+		fill: found.background.fill,
+		sheet: found.sheet,
+		explicit: found.sheet === sheet,
+		form: "bgPr",
+		phClr: null
+	};
+	const theme = themeOf(sheet);
+	if (theme === null) return null;
+	const fill = styleMatrixFill(found.background.ref, theme);
+	if (fill === null) return {
+		fill: { type: "none" },
+		sheet: found.sheet,
+		explicit: found.sheet === sheet,
+		form: "bgRef",
+		phClr: null
+	};
+	return {
+		fill,
+		sheet: found.sheet,
+		explicit: found.sheet === sheet,
+		form: "bgRef",
+		phClr: phClrOf(found.background.ref, sheet)
+	};
+}
+/** The background as one colour, when it is a solid. `null` otherwise. */
+function resolveBackgroundColor(sheet) {
+	const background = resolveBackground(sheet);
+	if (background === null || background.fill.type !== "solid") return null;
+	return resolveColor(background.fill.color, colorContextOf(sheet, background.phClr === null ? void 0 : background.phClr));
+}
+//#endregion
+//#region src/document.ts
+/**
+* The package into sheets, and the sheets into a chain.
+*
+* ## Every binding comes from the part's own `.rels`, and from nothing else
+*
+* A slide part does not name its layout. A layout does not name its master. A
+* master does not name its theme. Each of those bindings lives in exactly one
+* place - `ppt/slides/_rels/slideN.xml.rels`, and its two counterparts - and
+* every other candidate is a trap:
+*
+* - **`p:sldLayoutIdLst` is not the binding.** It gives each layout an id and an
+*   order for the UI. A two-master deck saved by PowerPoint puts all 22 layouts
+*   in one flat `ppt/slideLayouts/` folder, numbered 1 to 22, and which master
+*   owns which is recorded only in the two masters' relationship parts.
+* - **The part number is not the binding.** Same reason.
+* - **`ppt/presentation.xml.rels` has a `theme` relationship**, it always points
+*   at `theme1.xml`, and reading it gives every slide the first master's palette.
+*   On a one-master deck - which is every deck most people ever test with - that
+*   is indistinguishable from correct.
+* - **The order of a `.rels` file is not `rId` order.** PowerPoint writes them
+*   in whatever order it likes; `rId8` routinely comes first. Anything that
+*   reads a relationship part positionally is wrong on the files Office writes.
+*
+* ## A broken binding is not an error
+*
+* A slide with no layout relationship, a layout with no master, a master with no
+* theme: PowerPoint repairs all three rather than refusing them, and after the
+* repair the binding is simply gone. So this loads them with `parent` or `theme`
+* as `null` and records the problem, rather than throwing. Refusing to *write*
+* one is `validate`'s job, and it is a different question.
+*/
+const REL_SLIDE = REL_TYPE.slide;
+const REL_LAYOUT = REL_TYPE.slideLayout;
+const REL_MASTER = REL_TYPE.slideMaster;
+const REL_THEME = REL_TYPE.theme;
+function rootOf(store, partName) {
+	const root = parseXml(store.read(partName)).root;
+	if (root === null) throw new ModelError("MODEL_PART_KIND", `${partName} has no root element`, partName);
+	return root;
+}
+function themeFor(state, masterPartName) {
+	const rels = state.store.relationships(masterPartName);
+	const rel = rels.firstOfType(REL_THEME);
+	if (rel === void 0) {
+		state.problems.push({
+			code: "MODEL_NO_THEME",
+			partName: masterPartName,
+			message: "the master has no theme relationship"
+		});
+		return null;
+	}
+	const target = rels.resolve(rel);
+	const cached = state.themes.get(target);
+	if (cached !== void 0) return cached;
+	if (!state.store.has(target)) {
+		state.problems.push({
+			code: "MODEL_PART_MISSING",
+			partName: target,
+			message: `${masterPartName} names a theme part that is not in the package`
+		});
+		return null;
+	}
+	const theme = parseTheme(rootOf(state.store, target), target);
+	state.themes.set(target, theme);
+	return theme;
+}
+/**
+* Load one sheet and, recursively, its parent.
+*
+* The `loading` set is a cycle guard rather than an optimisation. A layout whose
+* `slideMaster` relationship points back at a layout is a package a hostile
+* input can produce, and following it without a guard is an unbounded recursion
+* in a Web Worker.
+*/
+function loadSheet(state, partName) {
+	const cached = state.sheets.get(partName);
+	if (cached !== void 0) return cached;
+	if (state.loading.has(partName)) {
+		state.problems.push({
+			code: "MODEL_PART_KIND",
+			partName,
+			message: "the sheet chain returns to this part"
+		});
+		return null;
+	}
+	if (!state.store.has(partName)) {
+		state.problems.push({
+			code: "MODEL_PART_MISSING",
+			partName,
+			message: "the part is not in the package"
+		});
+		return null;
+	}
+	state.loading.add(partName);
+	let parsed;
+	try {
+		parsed = parseSheet(rootOf(state.store, partName), partName);
+	} catch (error) {
+		state.loading.delete(partName);
+		if (error instanceof ModelError && error.code === "MODEL_PART_KIND") {
+			state.problems.push({
+				code: "MODEL_PART_KIND",
+				partName,
+				message: error.message
+			});
+			return null;
+		}
+		throw error;
+	}
+	let parent = null;
+	let theme = null;
+	if (parsed.kind === "master") theme = themeFor(state, partName);
+	else {
+		const wantedType = parsed.kind === "slide" ? REL_LAYOUT : REL_MASTER;
+		const rels = state.store.relationships(partName);
+		const rel = rels.firstOfType(wantedType);
+		if (rel === void 0) state.problems.push({
+			code: "MODEL_NO_PARENT",
+			partName,
+			message: `no ${parsed.kind === "slide" ? "slideLayout" : "slideMaster"} relationship`
+		});
+		else {
+			parent = loadSheet(state, rels.resolve(rel));
+			if (parent !== null && parent.kind === parsed.kind) {
+				state.problems.push({
+					code: "MODEL_PART_KIND",
+					partName,
+					message: `the parent of a ${parsed.kind} is another ${parsed.kind}`
+				});
+				parent = null;
+			}
+		}
+	}
+	state.loading.delete(partName);
+	const sheet = {
+		...parsed,
+		parent,
+		theme
+	};
+	state.sheets.set(partName, sheet);
+	return sheet;
+}
+function officeDocumentOf(store) {
+	const rel = store.rootRelationships().firstOfType(REL_TYPE.officeDocument);
+	if (rel === void 0) throw new ModelError("MODEL_NO_PRESENTATION", "the package root names no officeDocument");
+	return store.rootRelationships().resolve(rel);
+}
+function loadDocument(store) {
+	const presentationPartName = officeDocumentOf(store);
+	if (!store.has(presentationPartName)) throw new ModelError("MODEL_NO_PRESENTATION", `${presentationPartName} is not in the package`, presentationPartName);
+	const presentation = rootOf(store, presentationPartName);
+	const state = {
+		problems: [],
+		sheets: /* @__PURE__ */ new Map(),
+		themes: /* @__PURE__ */ new Map(),
+		loading: /* @__PURE__ */ new Set(),
+		store
+	};
+	const rels = store.relationships(presentationPartName);
+	const slides = [];
+	const slideList = presentation.children.find((child) => child.type === "element" && child.qname === "p:sldIdLst");
+	if (slideList !== void 0 && slideList.type === "element") for (const entry of slideList.children) {
+		if (entry.type !== "element" || entry.qname !== "p:sldId") continue;
+		const id = entry.attributes.find((attr) => attr.qname === "r:id")?.value;
+		if (id === void 0) continue;
+		const target = rels.targetOf(id);
+		if (target === void 0) continue;
+		const sheet = loadSheet(state, target);
+		if (sheet !== null) slides.push(sheet);
+	}
+	for (const rel of rels.byType(REL_SLIDE)) {
+		const target = rels.resolve(rel);
+		if (state.sheets.has(target)) continue;
+		const sheet = loadSheet(state, target);
+		if (sheet !== null) slides.push(sheet);
+	}
+	const masters = [];
+	for (const rel of rels.byType(REL_MASTER)) {
+		const sheet = loadSheet(state, rels.resolve(rel));
+		if (sheet !== null) masters.push(sheet);
+	}
+	const layouts = [];
+	for (const master of masters) {
+		const masterRels = store.relationships(master.partName);
+		for (const rel of masterRels.byType(REL_LAYOUT)) {
+			const sheet = loadSheet(state, masterRels.resolve(rel));
+			if (sheet !== null && !layouts.includes(sheet)) layouts.push(sheet);
+		}
+	}
+	const size = presentation.children.find((child) => child.type === "element" && child.qname === "p:sldSz");
+	const dimension = (name) => {
+		if (size === void 0 || size.type !== "element") return 0;
+		const raw = size.attributes.find((attr) => attr.qname === name)?.value;
+		return raw === void 0 ? 0 : Number(raw);
+	};
+	const sheets = state.sheets;
+	return {
+		presentation,
+		presentationPartName,
+		slides,
+		masters,
+		layouts,
+		themes: [...state.themes.values()],
+		problems: state.problems,
+		defaultTextStyle: parseDefaultTextStyle(presentation, presentationPartName),
+		slideSize: {
+			cx: dimension("cx"),
+			cy: dimension("cy")
+		},
+		sheet(partName) {
+			return sheets.get(partName);
+		}
+	};
+}
+//#endregion
+//#region src/builtin-text-styles.ts
+/** The three buckets, nine levels each, level 1 first. */
+const BUILTIN_TEXT_STYLES = {
+	title: [
+		{
+			sz: 4400,
+			marL: 0,
+			indent: 0,
+			bullet: false,
+			typeface: "+mj-lt"
+		},
+		{
+			sz: 1800,
+			marL: 0,
+			indent: 0,
+			bullet: false,
+			typeface: null
+		},
+		{
+			sz: 1800,
+			marL: 0,
+			indent: 0,
+			bullet: false,
+			typeface: null
+		},
+		{
+			sz: 1800,
+			marL: 0,
+			indent: 0,
+			bullet: false,
+			typeface: null
+		},
+		{
+			sz: 1800,
+			marL: 0,
+			indent: 0,
+			bullet: false,
+			typeface: null
+		},
+		{
+			sz: 1800,
+			marL: 0,
+			indent: 0,
+			bullet: false,
+			typeface: null
+		},
+		{
+			sz: 1800,
+			marL: 0,
+			indent: 0,
+			bullet: false,
+			typeface: null
+		},
+		{
+			sz: 1800,
+			marL: 0,
+			indent: 0,
+			bullet: false,
+			typeface: null
+		},
+		{
+			sz: 1800,
+			marL: 0,
+			indent: 0,
+			bullet: false,
+			typeface: null
+		}
+	],
+	body: [
+		{
+			sz: 2800,
+			marL: 228600,
+			indent: -228600,
+			bullet: true,
+			typeface: "+mn-lt"
+		},
+		{
+			sz: 2400,
+			marL: 685800,
+			indent: -228600,
+			bullet: true,
+			typeface: "+mn-lt"
+		},
+		{
+			sz: 2e3,
+			marL: 1143e3,
+			indent: -228600,
+			bullet: true,
+			typeface: "+mn-lt"
+		},
+		{
+			sz: 1800,
+			marL: 1600200,
+			indent: -228600,
+			bullet: true,
+			typeface: "+mn-lt"
+		},
+		{
+			sz: 1800,
+			marL: 2057400,
+			indent: -228600,
+			bullet: true,
+			typeface: "+mn-lt"
+		},
+		{
+			sz: 1800,
+			marL: 2514600,
+			indent: -228600,
+			bullet: true,
+			typeface: "+mn-lt"
+		},
+		{
+			sz: 1800,
+			marL: 2971800,
+			indent: -228600,
+			bullet: true,
+			typeface: "+mn-lt"
+		},
+		{
+			sz: 1800,
+			marL: 3429e3,
+			indent: -228600,
+			bullet: true,
+			typeface: "+mn-lt"
+		},
+		{
+			sz: 1800,
+			marL: 3886200,
+			indent: -228600,
+			bullet: true,
+			typeface: "+mn-lt"
+		}
+	],
+	other: [
+		{
+			sz: 1800,
+			marL: 0,
+			indent: 0,
+			bullet: false,
+			typeface: "+mn-lt"
+		},
+		{
+			sz: 1800,
+			marL: 457200,
+			indent: 0,
+			bullet: false,
+			typeface: "+mn-lt"
+		},
+		{
+			sz: 1800,
+			marL: 914400,
+			indent: 0,
+			bullet: false,
+			typeface: "+mn-lt"
+		},
+		{
+			sz: 1800,
+			marL: 1371600,
+			indent: 0,
+			bullet: false,
+			typeface: "+mn-lt"
+		},
+		{
+			sz: 1800,
+			marL: 1828800,
+			indent: 0,
+			bullet: false,
+			typeface: "+mn-lt"
+		},
+		{
+			sz: 1800,
+			marL: 2286e3,
+			indent: 0,
+			bullet: false,
+			typeface: "+mn-lt"
+		},
+		{
+			sz: 1800,
+			marL: 2743200,
+			indent: 0,
+			bullet: false,
+			typeface: "+mn-lt"
+		},
+		{
+			sz: 1800,
+			marL: 3200400,
+			indent: 0,
+			bullet: false,
+			typeface: "+mn-lt"
+		},
+		{
+			sz: 1800,
+			marL: 3657600,
+			indent: 0,
+			bullet: false,
+			typeface: "+mn-lt"
+		}
+	]
+};
+/**
+* What is left when every source is silent and the master *does* declare
+* `p:txStyles`.
+*
+* Distinct from the table above, and measured separately: a body placeholder
+* whose `p:bodyStyle/a:lvl1pPr` declares only a `marL` came back at
+* 18 points rather than the built-in body style's
+* 28, and with no indent rather than the built-in's
+* hanging one. So the built-in styles are substituted wholesale for an absent
+* `p:txStyles` and are not a per-property backstop underneath a present one.
+*
+* `marL` and `indent` are **0**, not the ECMA-376 schema defaults of 347663 and
+* -342900. Materialising those at parse time gives every paragraph a
+* 27-point hanging indent nothing asked for, and blocks the inherited value on
+* top of it, because a default that has been written down cannot be told from a
+* declaration.
+*
+* The typeface is the minor face on all 6 probes that reach a silent cascade.
+*/
+const TEXT_FLOOR = {
+	sz: 1800,
+	marL: 0,
+	indent: 0,
+	bullet: false,
+	typeface: "+mn-lt"
+};
+//#endregion
+//#region src/resolve/typeface.ts
+/**
+* `+mn-lt` and its five siblings, resolved against a theme's `a:fontScheme`.
+*
+* Measured 8 of 8 against a reading that swaps the two collections, which fits
+* 2. ADR 0033.
+*/
+/**
+* The typeface a slot asks for, with any theme reference followed.
+*
+* `undefined` means the reference resolved to a collection entry the theme
+* leaves empty, which is not the same as the theme naming nothing.
+*/
+function resolveTypeface(typeface, scheme) {
+	const ref = themeFontRef(typeface);
+	if (ref === null) return typeface;
+	const name = (ref.collection === "major" ? scheme.major : scheme.minor)[ref.script];
+	if (name === null || name.length === 0) return void 0;
+	return name;
+}
+/** The same, for a whole `CT_TextFont`. */
+function resolveTypefaceOf(font, scheme) {
+	return resolveTypeface(font.typeface, scheme);
+}
+/**
+* Every distinct typeface a set of runs asks for, theme references followed.
+*
+* This is what `fontReport` is given: a report keyed on `+mn-lt` would name a
+* token no user recognises and would collapse two themes into one row.
+*/
+function requestedTypefaces(fonts, scheme) {
+	const out = [];
+	for (const font of fonts) {
+		if (font === void 0) continue;
+		const name = resolveTypeface(font.typeface, scheme);
+		if (name !== void 0) out.push(name);
+	}
+	return out;
+}
+//#endregion
+//#region src/resolve/text.ts
+/**
+* The text cascade: one walk, two termini, and the origin of every answer.
+*
+* `resolveRun(context, paragraph, run, pick)` returns the first level that
+* declared the property asked for **and which level that was**, exactly as
+* `resolve` does for geometry and fills. The inspector's provenance chips,
+* per-property Reset, and knowing what a theme swap invalidates all fall out of
+* the same field, read by the same function the renderer reads.
+*
+* ## The walk
+*
+* 1. the run's own `a:rPr`
+* 2. the paragraph's `a:pPr/a:defRPr`
+* 3. the shape's `a:lstStyle`, at the paragraph's level
+* 4. each ancestor placeholder's `a:lstStyle`, up the chain 2.9 measured for
+*    geometry: `@idx` alone to the layout, the folded `@type` to the master
+*
+* ## The two termini, which are not one ladder
+*
+* A shape whose chain ends at a type with a bucket - `title` and `ctrTitle` to
+* `p:titleStyle`, the content types to `p:bodyStyle` - reads that bucket and
+* **stops**. A shape with no bucket reads `p:defaultTextStyle` and **stops**.
+*
+* Measured in 3.1, and it is where every implementation this project has read
+* goes wrong. Scored over the eight combinations of the three choices anyone
+* could make, this reading fits 37 of 37 probes and the reading the plan
+* specified - the shape's own `@type` picks the bucket, the header-and-footer
+* trio reads `p:otherStyle`, and so does a shape that is not a placeholder -
+* fits 13. Three of the four disagreements are visible on any deck:
+*
+* - **The `@type` at the end of the chain picks the bucket, not the shape's.**
+*   The first hop matches on `@idx` alone, so a slide `title` at idx 0 really
+*   does land on a layout `body` at idx 0, and when it does it reads
+*   `p:bodyStyle`. Measured both ways round and twice more through a `sldNum`.
+* - **`dt`, `ftr`, `sldNum` and `hdr` reach no bucket at all** and fall through
+*   to `p:defaultTextStyle`, which a body placeholder ignores even when it is
+*   there in the same package.
+* - **Nothing measurable reads `p:otherStyle`** - not those four, not a shape
+*   that is not a placeholder, on the slide, the layout or the master.
+*
+* ## Every level contributes only what it declares
+*
+* The walk is per property, not per level. Measured with five levels declaring
+* one property each: the run came back 24-point bold italic underlined and
+* struck through, where a nearest-level-takes-all reading gives an 18-point run
+* that is only struck through.
+*/
+/** `title` and `ctrTitle`. Everything else with a bucket has the body one. */
+const TITLE_TYPES = /* @__PURE__ */ new Set(["title", "ctrTitle"]);
+/**
+* The four types that reach no bucket.
+*
+* Measured, and against the plan, which assigned all four to `p:otherStyle`. A
+* `sldNum` placeholder in a package declaring `p:otherStyle` at 12 points and
+* `p:defaultTextStyle` at 20 came back at 20.
+*/
+const NO_BUCKET_TYPES = /* @__PURE__ */ new Set([
+	"dt",
+	"ftr",
+	"sldNum",
+	"hdr"
+]);
+/** Which `p:txStyles` bucket a placeholder type reads, or `null` for none. */
+function bucketOf(type) {
+	if (TITLE_TYPES.has(type)) return "title";
+	if (NO_BUCKET_TYPES.has(type)) return null;
+	return "body";
+}
+function terminusOf(context) {
+	const placeholder = inheritanceChain(context.shape, context.sheet).at(-1)?.shape.placeholder ?? null;
+	let master = null;
+	for (let sheet = context.sheet; sheet !== null; sheet = sheet.parent) if (sheet.kind === "master") {
+		master = sheet;
+		break;
+	}
+	return {
+		bucket: placeholder === null ? null : bucketOf(normalizePlaceholder(placeholder).type),
+		master
+	};
+}
+/**
+* The list styles a shape reads, nearest first, ending at whichever terminus it
+* reaches.
+*
+* Exported because it *is* the finding: a caller that wants to show the user
+* where a value could have come from - the inspector's Overrides panel, layout
+* compatibility scoring - needs the same list the resolver walks, not a second
+* opinion about it.
+*/
+function textLevels(context) {
+	const levels = inheritanceChain(context.shape, context.sheet).map((link, index) => ({
+		style: link.shape.text?.lstStyle,
+		origin: index === 0 ? "shape" : link.origin,
+		sheet: link.sheet,
+		shape: link.shape
+	}));
+	const { bucket, master } = terminusOf(context);
+	if (bucket === null) {
+		levels.push({
+			style: context.defaultTextStyle,
+			origin: "defaultTextStyle",
+			sheet: null,
+			shape: null
+		});
+		return levels;
+	}
+	levels.push({
+		style: master?.txStyles?.[bucket],
+		origin: "txStyles",
+		sheet: master,
+		shape: null
+	});
+	return levels;
+}
+/**
+* The values left when every level has been asked and none of them said.
+*
+* Two quite different things, and which applies turns on one question: does the
+* master declare `p:txStyles` at all? If it does not, PowerPoint substitutes its
+* whole built-in set, and a body placeholder is 28 points with a hanging bullet
+* indent. If it does, there is no per-property backstop underneath it and what
+* remains is the floor - 18 points, no margin, no indent. Measured as two
+* separate probes precisely because the two are easy to conflate and differ on
+* every partially-specified master.
+*/
+function floorOf(context, level) {
+	const { bucket, master } = terminusOf(context);
+	if (master?.txStyles !== void 0) return TEXT_FLOOR;
+	return BUILTIN_TEXT_STYLES[bucket ?? "other"][clampLevel(level)] ?? TEXT_FLOOR;
+}
+function clampLevel(level) {
+	if (!Number.isInteger(level)) throw new ModelError("MODEL_TEXT_LEVEL", `paragraph level ${String(level)} is not an integer`);
+	return Math.max(0, Math.min(8, level));
+}
+function resolvedAt(value, level, explicit) {
+	return {
+		value,
+		origin: level.origin,
+		explicit,
+		sheet: level.sheet,
+		shape: level.shape
+	};
+}
+/**
+* A paragraph property, from the paragraph's own `a:pPr` or up the walk.
+*
+* `pick` returns `undefined` for "this level did not say" and anything else for
+* a value, including `null` - the same contract `resolve` uses, and for the same
+* reason: a level may legitimately declare a `null`, and conflating that with
+* silence is how an explicit value gets overwritten by an inherited one.
+*/
+function resolveParagraph(context, paragraph, pick) {
+	if (paragraph.props !== void 0) {
+		const own = pick(paragraph.props);
+		if (own !== void 0) return {
+			value: own,
+			origin: "paragraph",
+			explicit: true,
+			sheet: context.sheet,
+			shape: context.shape
+		};
+	}
+	const level = clampLevel(paragraph.level);
+	for (const entry of textLevels(context)) {
+		const props = entry.style?.levels[level];
+		if (props === void 0) continue;
+		const value = pick(props);
+		if (value !== void 0) return resolvedAt(value, entry, entry.origin === "shape");
+	}
+}
+/**
+* A run property, from the run's own `a:rPr` and then every `a:defRPr` above it.
+*
+* The paragraph's `a:pPr/a:defRPr` is one level, not a special case: it sits
+* between the run and the shape's `a:lstStyle`, which the ladder pinned by
+* declaring a different size at each and reading back which one won.
+*/
+function resolveRun(context, paragraph, run, pick) {
+	if (run?.props !== void 0) {
+		const own = pick(run.props);
+		if (own !== void 0) return {
+			value: own,
+			origin: "run",
+			explicit: true,
+			sheet: context.sheet,
+			shape: context.shape
+		};
+	}
+	if (paragraph.props?.defRPr !== void 0) {
+		const value = pick(paragraph.props.defRPr);
+		if (value !== void 0) return {
+			value,
+			origin: "paragraph",
+			explicit: true,
+			sheet: context.sheet,
+			shape: context.shape
+		};
+	}
+	const level = clampLevel(paragraph.level);
+	for (const entry of textLevels(context)) {
+		const defRPr = entry.style?.levels[level]?.defRPr;
+		if (defRPr === void 0) continue;
+		const value = pick(defRPr);
+		if (value !== void 0) return resolvedAt(value, entry, entry.origin === "shape");
+	}
+}
+/**
+* The font size of a run, in hundredths of a point, always.
+*
+* The only resolver here that cannot return `undefined`: text has to be drawn at
+* some size, and the size when nothing declared one is measured rather than
+* chosen. `origin` is `builtin` when the master declares no `p:txStyles` and
+* `schemaDefault` when it does and the bucket said nothing - two different
+* numbers on the same slide, and the field says which was used.
+*/
+function resolveSize(context, paragraph, run) {
+	const found = resolveRun(context, paragraph, run, (props) => props.sz);
+	if (found !== void 0) return found;
+	return floorResolved(context, paragraph, (level) => level.sz);
+}
+/**
+* The Latin typeface of a run, with any theme reference followed.
+*
+* The second resolver that cannot return `undefined`: a run has to be drawn in
+* some face, and the face when nothing named one is measured rather than
+* chosen - the theme's minor, on all six probes reaching a silent cascade.
+*/
+function resolveLatinTypeface(context, paragraph, run) {
+	const scheme = themeOf(context.sheet)?.fonts ?? null;
+	/** A name a source gave, with a theme reference followed where one can be. */
+	const faceOf = (typeface) => {
+		if (themeFontRef(typeface) === null) return typeface;
+		return scheme === null ? void 0 : resolveTypeface(typeface, scheme);
+	};
+	const named = resolveRun(context, paragraph, run, (props) => props.latin);
+	if (named !== void 0) {
+		const face = faceOf(named.value.typeface);
+		if (face !== void 0) return {
+			...named,
+			value: face
+		};
+	}
+	const floor = floorOf(context, paragraph.level);
+	const reference = floor.typeface ?? TEXT_FLOOR.typeface;
+	const face = reference === null ? void 0 : faceOf(reference);
+	if (face === void 0) throw new ModelError("MODEL_TEXT_TYPEFACE", "no source in the cascade names a typeface, and the theme names none either");
+	return {
+		value: face,
+		origin: floor === TEXT_FLOOR ? "schemaDefault" : "builtin",
+		explicit: false,
+		sheet: null,
+		shape: null
+	};
+}
+/** `@marL` in EMU. Measured to be 0 when nothing declares it, not 347663. */
+function resolveMarginLeft(context, paragraph) {
+	const found = resolveParagraph(context, paragraph, (props) => props.marL);
+	if (found !== void 0) return found;
+	return floorResolved(context, paragraph, (level) => level.marL);
+}
+/** `@indent` in EMU. Measured to be 0 when nothing declares it, not -342900. */
+function resolveIndent(context, paragraph) {
+	const found = resolveParagraph(context, paragraph, (props) => props.indent);
+	if (found !== void 0) return found;
+	return floorResolved(context, paragraph, (level) => level.indent);
+}
+/**
+* The bullet, merged the way T5 measured it: five slots, each on its own.
+*
+* The kind is one slot because the schema makes the four elements exclusive, and
+* the three decorations are three more because PowerPoint merges them
+* separately - a level declaring only `a:buFont` re-faces the character it
+* inherits and keeps its size and colour. Measured on eleven cases twice over,
+* once through a shape's own `a:lstStyle` and once through three hops of the
+* master chain, and the two agree.
+*
+* Every one of these returns `undefined` when nothing in the chain declares the
+* slot, which for the kind is the difference between "no bullet" and "nobody
+* said" - `a:buNone` resolves to `'none'` and an empty chain to `undefined`.
+* Nothing here supplies a default, because a paragraph with no bullet anywhere
+* in its chain genuinely has none.
+*/
+function resolveBulletKind(context, paragraph) {
+	return resolveParagraph(context, paragraph, (props) => props.buKind);
+}
+/** `a:buChar/@char`, as written. The symbol mapping belongs to the renderer. */
+function resolveBulletChar(context, paragraph) {
+	return resolveParagraph(context, paragraph, (props) => props.buChar);
+}
+/** `a:buAutoNum`, type and start value together, since one is meaningless alone. */
+function resolveBulletAutoNum(context, paragraph) {
+	return resolveParagraph(context, paragraph, (props) => props.buAutoNum);
+}
+/** `a:buBlip/a:blip/@r:embed`, which the caller resolves against the part's rels. */
+function resolveBulletBlip(context, paragraph) {
+	return resolveParagraph(context, paragraph, (props) => props.buBlip);
+}
+/**
+* `a:buFont` or `a:buFontTx`.
+*
+* Worth knowing before using it: this is **inert for an autonumber**. PowerPoint
+* draws a number in the first run's face whatever `a:buFont` says - measured on
+* twenty probes, including one where `buFont` named Wingdings and the run named
+* Courier New - and its own UI writes `buFont="+mj-lt"` on every list it
+* numbers. The resolver still reports it, because the file says it and 1.3 has
+* to write it back; the renderer is where it is ignored.
+*/
+function resolveBulletFont(context, paragraph) {
+	return resolveParagraph(context, paragraph, (props) => props.buFont);
+}
+/** `a:buSzPct`, `a:buSzPts` or `a:buSzTx`; a percentage is of the first run's size. */
+function resolveBulletSize(context, paragraph) {
+	return resolveParagraph(context, paragraph, (props) => props.buSize);
+}
+/** `a:buClr` or `a:buClrTx`. Unlike the font, this one *does* reach an autonumber. */
+function resolveBulletColor(context, paragraph) {
+	return resolveParagraph(context, paragraph, (props) => props.buColor);
+}
+function floorResolved(context, paragraph, pick) {
+	const floor = floorOf(context, paragraph.level);
+	return {
+		value: pick(floor),
+		origin: floor === TEXT_FLOOR ? "schemaDefault" : "builtin",
+		explicit: false,
+		sheet: null,
+		shape: null
+	};
+}
+//#endregion
+//#region src/resolve/body.ts
+/**
+* `a:bodyPr`, resolved up the placeholder chain.
+*
+* Every attribute inherits on its own, from any level: a bare `<a:bodyPr/>` on a
+* slide is anchored where its master says, not at the schema default. ADR 0032.
+*/
+const EMU_PER_POINT = 12700;
+/** Points. Asymmetric, and each edge defaults on its own. */
+const DEFAULT_INSETS = {
+	left: 7.2,
+	top: 3.6,
+	right: 7.2,
+	bottom: 3.6
+};
+/**
+* One property of the text frame, from the shape's own `a:bodyPr` or above it.
+*
+* `pick` returns `undefined` for "this level did not say", the same contract the
+* text cascade uses.
+*/
+function resolveBody(shape, sheet, pick) {
+	for (const [index, link] of inheritanceChain(shape, sheet).entries()) {
+		const props = link.shape.text?.bodyPr;
+		if (props === void 0) continue;
+		const value = pick(props);
+		if (value === void 0) continue;
+		return {
+			value,
+			origin: index === 0 ? "shape" : link.origin,
+			explicit: index === 0,
+			sheet: link.sheet,
+			shape: link.shape
+		};
+	}
+}
+function resolveAnchor(shape, sheet) {
+	return resolveBody(shape, sheet, (p) => p.anchor);
+}
+function resolveAnchorCtr(shape, sheet) {
+	return resolveBody(shape, sheet, (p) => p.anchorCtr);
+}
+function resolveVertical(shape, sheet) {
+	return resolveBody(shape, sheet, (p) => p.vert);
+}
+function resolveWrap(shape, sheet) {
+	return resolveBody(shape, sheet, (p) => p.wrap);
+}
+function resolveColumns(shape, sheet) {
+	return resolveBody(shape, sheet, (p) => p.numCol);
+}
+/**
+* The four insets, in points, each falling back on its own.
+*
+* A frame stating only `lIns` still gets 3.6 above and below, so this resolves
+* four times rather than once.
+*/
+function resolveInsets(shape, sheet) {
+	const at = (pick, fallback) => {
+		const found = resolveBody(shape, sheet, pick);
+		return found === void 0 ? fallback : found.value / EMU_PER_POINT;
+	};
+	return {
+		left: at((p) => p.lIns, DEFAULT_INSETS.left),
+		top: at((p) => p.tIns, DEFAULT_INSETS.top),
+		right: at((p) => p.rIns, DEFAULT_INSETS.right),
+		bottom: at((p) => p.bIns, DEFAULT_INSETS.bottom)
+	};
+}
+//#endregion
+export { BUILTIN_TEXT_STYLES, COLOR_TRANSFORM_OPS, DEFAULT_PLACEHOLDER_IDX, DEFAULT_PLACEHOLDER_TYPE, LEVELS, MASTER_PLACEHOLDER_TYPES, MODEL_ERROR_CODES, ModelError, ORPHAN_RECT, PLACEHOLDER_TYPES, STYLE_MATRIX_OFFSET, TEXT_FLOOR, backgroundSheet, bucketOf, colorContextOf, colorMapOf, floorOf, inheritanceChain, isModelError, loadDocument, masterOf, masterPlaceholderType, matchInLayout, matchInMaster, normalizePlaceholder, parseBodyProps, parseBodyPropsChild, parseClrMap, parseColorChild, parseColorElement, parseDefaultTextStyle, parseEffects, parseFill, parseFillElement, parseGeometry, parseLine, parseLineElement, parseListStyle, parseParaProps, parseRunProps, parseSheet, parseTextBody, parseTextBodyChild, parseTextStyles, parseTheme, phClrOf, placeholders, requestedTypefaces, resolve, resolveAnchor, resolveAnchorCtr, resolveAppearance, resolveBackground, resolveBackgroundColor, resolveBody, resolveBulletAutoNum, resolveBulletBlip, resolveBulletChar, resolveBulletColor, resolveBulletFont, resolveBulletKind, resolveBulletSize, resolveColumns, resolveIndent, resolveInsets, resolveLatinTypeface, resolveMarginLeft, resolveOnSheet, resolveParagraph, resolveRun, resolveSize, resolveSolidFill, resolveTypeface, resolveTypefaceOf, resolveVertical, resolveWrap, resolveXfrm, schemeOf, sheetChain, styleMatrixEffects, styleMatrixFill, styleMatrixLine, styleMatrixTarget, textLevels, themeFontRef, themeOf };
+
+//# sourceMappingURL=index.js.map