@shbernal/ts-pptx 3.4.0 → 3.6.0

package/dist/{shapes-Dyw5bxwO.js → shapes-BemroU-z.js}

@@ -1,6 +1,6 @@
-import { r as warn } from "./diagnostics-CPVADSL1.js";
+import { i as EMU_PER_POINT, s as PERCENT_SCALE, t as ANGLE_UNITS_PER_DEGREE, x as warn } from "./units-1kRzYShk.js";
 import { i as PackageReadError, n as InvalidOptionError, o as UnsupportedFeatureError, t as InternalError } from "./errors-Bvln0H-7.js";
-import { A as TEXT_ANCHORS, M as TEXT_VERTICAL, N as checkEnumOrThrow, _ as THEME_REL, a as NOTES_MASTER_REL, b as getImageSizeFromBytes, c as OFFICE_DOCUMENT_REL, f as SLIDE_LAYOUT_REL, j as TEXT_HORZ_OVERFLOW, m as SLIDE_MASTER_REL, r as IMAGE_REL, t as OOXML_NS, v as fitSrcRectPercents } from "./namespaces-Sy_m7Nhd.js";
+import { F as TEXT_VERTICAL, L as checkEnumOrThrow, N as TEXT_ANCHORS, P as TEXT_HORZ_OVERFLOW, a as NOTES_MASTER_REL, c as OFFICE_DOCUMENT_REL, h as SLIDE_MASTER_REL, p as SLIDE_LAYOUT_REL, r as IMAGE_REL, t as OOXML_NS, v as THEME_REL, x as getImageSizeFromBytes, y as fitSrcRectPercents } from "./namespaces-BVnNu7sg.js";
 import { DOMParser, MIME_TYPE, XMLSerializer, onErrorStopParsing } from "@xmldom/xmldom";
 /** Parse an XML string strictly: any well-formedness error throws. */
 function parseXml(xml) {
@@ -458,6 +458,439 @@ function setSolidFill(parent, afterOrder, color) {
 	fill.appendChild(clr);
 }
 //#endregion
+//#region src/read/oxml/color-transform.ts
+/**
+* Apply DrawingML colour-transform modifiers (`lumMod`/`lumOff`/`shade`/`tint`/
+* `satMod`/`alpha`/…) to a base sRGB colour, returning the *effective* colour a
+* renderer would paint.
+*
+* The read model resolves a `schemeClr`/`srgbClr` reference to its **base** hex
+* and carries the transform children verbatim (so the `theme: 'preserve'` flatten
+* path can re-emit them byte-for-byte). This module is the missing step that
+* turns that base hex + transform list into the final rendered hex, so a consumer
+* never hand-computes a tint/shade again.
+*
+* Colour-space model (verified against PowerPoint output — see
+* `test/read/color-transform.test.js`): the working colour is kept canonical as
+* sRGB between transforms; each transform converts into the space its family
+* operates in, applies, and converts back to sRGB. Transforms apply in **document
+* order** (ECMA-376 §20.1.2.3).
+*
+*  - `lumMod` / `lumOff` — luminance (L) in HSL: `L' = L·mod + off`. PowerPoint's
+*    "Lighter/Darker N%" family.
+*  - `satMod` / `satOff` — saturation (S) in HSL.
+*  - `hueMod` / `hueOff` — hue (H) in HSL (`hueMod` scales, `hueOff` offsets by
+*    degrees). Not exercised by any current source; implemented for completeness.
+*  - `shade` — toward black in **linear** RGB: `c' = c·k`.
+*  - `tint` — toward white in **linear** RGB: `c' = c·k + (1−k)`.
+*  - `alpha` / `alphaMod` / `alphaOff` — opacity, returned alongside the hex
+*    (never folded into RGB).
+*  - `comp` / `inv` / `gray` / `gamma` / `invGamma` — pass-through for now (no
+*    current source needs them; add when one does).
+*
+* All DrawingML percentage values are stored in thousandths of a percent
+* (`100%` → `100000`), so a modifier's fraction is `val / PERCENT_SCALE`.
+*/
+/**
+* DrawingML percentage → fraction, or `null` when unparseable.
+*
+* `a:ST_Percentage` is a *union* in the Transitional profile: the fixed-point integer form
+* Office writes (`100%` → `100000`) and a decimal string with a literal `%` (`-?[0-9]+(\.[0-9]+)?%`),
+* which is the only form the Strict profile has. Both are read here — a reader that took only the
+* first dropped a schema-legal value silently, and the two are one `endsWith` apart.
+* @param value - the raw attribute value, or `null` when the attribute is absent
+*/
+function parsePercent(value) {
+	if (value === null || value === "") return null;
+	if (value.endsWith("%")) {
+		const n = Number(value.slice(0, -1));
+		return Number.isFinite(n) ? n / 100 : null;
+	}
+	const n = Number(value);
+	return Number.isFinite(n) ? n / PERCENT_SCALE : null;
+}
+const clamp01 = (n) => n < 0 ? 0 : n > 1 ? 1 : n;
+/** Parse a 6-hex string (`RRGGBB`, optional `#`) into 0–1 sRGB channels, or `null`. */
+function parseHex(hex) {
+	const h = hex.startsWith("#") ? hex.slice(1) : hex;
+	if (!/^[0-9a-fA-F]{6}$/.test(h)) return null;
+	return {
+		r: parseInt(h.slice(0, 2), 16) / 255,
+		g: parseInt(h.slice(2, 4), 16) / 255,
+		b: parseInt(h.slice(4, 6), 16) / 255
+	};
+}
+/** 0–1 sRGB channels → uppercase `RRGGBB`, rounding and clamping each channel. */
+function toHex(c) {
+	const ch = (v) => Math.round(clamp01(v) * 255).toString(16).toUpperCase().padStart(2, "0");
+	return `${ch(c.r)}${ch(c.g)}${ch(c.b)}`;
+}
+/** sRGB channel (0–1) → linear-light (gamma decode). */
+function srgbToLinear(c) {
+	return c <= .04045 ? c / 12.92 : Math.pow((c + .055) / 1.055, 2.4);
+}
+/** Linear-light channel (0–1) → sRGB (gamma encode). */
+function linearToSrgb(c) {
+	return c <= .0031308 ? c * 12.92 : 1.055 * Math.pow(c, 1 / 2.4) - .055;
+}
+/** sRGB (0–1) → HSL with H in degrees [0,360), S/L in [0,1]. */
+function rgbToHsl(c) {
+	const { r, g, b } = c;
+	const max = Math.max(r, g, b);
+	const min = Math.min(r, g, b);
+	const l = (max + min) / 2;
+	const d = max - min;
+	if (d === 0) return {
+		h: 0,
+		s: 0,
+		l
+	};
+	const s = d / (1 - Math.abs(2 * l - 1));
+	let h;
+	if (max === r) h = (g - b) / d % 6;
+	else if (max === g) h = (b - r) / d + 2;
+	else h = (r - g) / d + 4;
+	h *= 60;
+	if (h < 0) h += 360;
+	return {
+		h,
+		s,
+		l
+	};
+}
+/** HSL (H degrees, S/L 0–1) → sRGB (0–1). */
+function hslToRgb({ h, s, l }) {
+	const c = (1 - Math.abs(2 * l - 1)) * s;
+	const hp = (h % 360 + 360) % 360 / 60;
+	const x = c * (1 - Math.abs(hp % 2 - 1));
+	const [r, g, b] = hp < 1 ? [
+		c,
+		x,
+		0
+	] : hp < 2 ? [
+		x,
+		c,
+		0
+	] : hp < 3 ? [
+		0,
+		c,
+		x
+	] : hp < 4 ? [
+		0,
+		x,
+		c
+	] : hp < 5 ? [
+		x,
+		0,
+		c
+	] : [
+		c,
+		0,
+		x
+	];
+	const m = l - c / 2;
+	return {
+		r: r + m,
+		g: g + m,
+		b: b + m
+	};
+}
+/**
+* An `a:hslClr` triple → 6-hex sRGB, or `null` when any of the three is unparseable.
+*
+* The colour space is the one `lumMod`/`satMod` already work in — DrawingML's HSL is sRGB-HSL,
+* which is what the transform family below is verified against — so this shares that conversion
+* rather than introducing a second one. Units are the schema's: `@hue` is
+* `a:ST_PositiveFixedAngle`, i.e. 60,000ths of a degree, and `@sat`/`@lum` are `a:ST_Percentage`
+* (see {@link parsePercent}). Saturation and luminance are clamped to 0–1; hue wraps.
+* @param hue - raw `@hue`
+* @param sat - raw `@sat`
+* @param lum - raw `@lum`
+*/
+function hslClrToHex(hue, sat, lum) {
+	const h = hue === null || hue === "" ? null : Number(hue);
+	const s = parsePercent(sat);
+	const l = parsePercent(lum);
+	if (h === null || !Number.isFinite(h) || s === null || l === null) return null;
+	return toHex(hslToRgb({
+		h: h / ANGLE_UNITS_PER_DEGREE,
+		s: clamp01(s),
+		l: clamp01(l)
+	}));
+}
+/**
+* Apply an ordered list of DrawingML colour transforms to a base sRGB hex,
+* returning the effective sRGB hex (and opacity, when an `alpha*` modifier set
+* it). Pure: no DOM, no theme lookup — the caller has already resolved the base
+* colour and extracted each modifier's `{ name, value }`.
+*
+* An unparseable base hex is returned unchanged (with no transforms applied); an
+* unparseable/`null` modifier value is skipped.
+*/
+function applyColorTransforms(baseHex, transforms) {
+	const parsed = parseHex(baseHex);
+	if (!parsed) return { hex: baseHex };
+	let rgb = parsed;
+	let alpha;
+	for (const { name, value } of transforms) switch (name) {
+		case "lumMod":
+		case "lumOff": {
+			const f = parsePercent(value);
+			if (f === null) break;
+			const hsl = rgbToHsl(rgb);
+			hsl.l = clamp01(name === "lumMod" ? hsl.l * f : hsl.l + f);
+			rgb = hslToRgb(hsl);
+			break;
+		}
+		case "satMod":
+		case "satOff": {
+			const f = parsePercent(value);
+			if (f === null) break;
+			const hsl = rgbToHsl(rgb);
+			hsl.s = clamp01(name === "satMod" ? hsl.s * f : hsl.s + f);
+			rgb = hslToRgb(hsl);
+			break;
+		}
+		case "hueMod":
+		case "hueOff": {
+			const hsl = rgbToHsl(rgb);
+			if (name === "hueMod") {
+				const f = parsePercent(value);
+				if (f === null) break;
+				hsl.h = (hsl.h * f % 360 + 360) % 360;
+			} else {
+				const n = value === null ? NaN : Number(value);
+				if (!Number.isFinite(n)) break;
+				hsl.h = ((hsl.h + n / ANGLE_UNITS_PER_DEGREE) % 360 + 360) % 360;
+			}
+			rgb = hslToRgb(hsl);
+			break;
+		}
+		case "shade":
+		case "tint": {
+			const k = parsePercent(value);
+			if (k === null) break;
+			const lin = {
+				r: srgbToLinear(rgb.r),
+				g: srgbToLinear(rgb.g),
+				b: srgbToLinear(rgb.b)
+			};
+			const apply = (c) => clamp01(name === "shade" ? c * k : c * k + (1 - k));
+			rgb = {
+				r: linearToSrgb(apply(lin.r)),
+				g: linearToSrgb(apply(lin.g)),
+				b: linearToSrgb(apply(lin.b))
+			};
+			break;
+		}
+		case "alpha": {
+			const f = parsePercent(value);
+			if (f !== null) alpha = clamp01(f);
+			break;
+		}
+		case "alphaMod": {
+			const f = parsePercent(value);
+			if (f !== null) alpha = clamp01((alpha ?? 1) * f);
+			break;
+		}
+		case "alphaOff": {
+			const f = parsePercent(value);
+			if (f !== null) alpha = clamp01((alpha ?? 1) + f);
+			break;
+		}
+	}
+	return alpha === void 0 ? { hex: toHex(rgb) } : {
+		hex: toHex(rgb),
+		alpha
+	};
+}
+//#endregion
+//#region src/read/oxml/preset-color.ts
+/**
+* The ECMA-376 preset colour table (`a:prstClr/@val` → literal RGB).
+*
+* `ST_PresetColorVal` (§20.1.10.47) enumerates 190 names, and the standard gives each one an
+* RGB triple. They are the HTML/CSS named colours: every value in the enumeration has the same
+* RGB here as the CSS colour of the same name, and the 190 names collapse to the 140 distinct
+* CSS names below through three mechanical spelling rules the enumeration adds on top —
+*
+*  - abbreviated prefixes: `dk*`/`lt*`/`med*` alongside `dark*`/`light*`/`medium*`
+*    (`dkSlateBlue` is `darkSlateBlue`), and only as a *prefix* — `medium…` is not `mediumium…`;
+*  - both spellings of grey: `dimGrey` is `dimGray`;
+*  - case: the enumeration is camelCase, the table below is folded to lower case.
+*
+* So the table holds one row per colour rather than one per spelling, and {@link presetColorHex}
+* normalizes a name into it. That is the difference between 140 hand-checked constants and 190,
+* and it makes the abbreviation rule something a reader can see rather than something spread
+* across fifty near-duplicate rows.
+*
+* This is spec data, not observed behaviour: the values come from the enumeration's own
+* documentation, and the table is asserted complete against the schema's 190-value list in
+* `test/read/preset-color.test.js` — a name the reader cannot resolve is a hole in the table,
+* and that test is what finds it.
+*/
+/**
+* Canonical (lower-case, unabbreviated, `gray`-spelled) preset colour name → 6-hex RGB.
+* Reach it through {@link presetColorHex}, which does the normalizing.
+*/
+const PRESET_COLOR_HEX = {
+	aliceblue: "F0F8FF",
+	antiquewhite: "FAEBD7",
+	aqua: "00FFFF",
+	aquamarine: "7FFFD4",
+	azure: "F0FFFF",
+	beige: "F5F5DC",
+	bisque: "FFE4C4",
+	black: "000000",
+	blanchedalmond: "FFEBCD",
+	blue: "0000FF",
+	blueviolet: "8A2BE2",
+	brown: "A52A2A",
+	burlywood: "DEB887",
+	cadetblue: "5F9EA0",
+	chartreuse: "7FFF00",
+	chocolate: "D2691E",
+	coral: "FF7F50",
+	cornflowerblue: "6495ED",
+	cornsilk: "FFF8DC",
+	crimson: "DC143C",
+	cyan: "00FFFF",
+	darkblue: "00008B",
+	darkcyan: "008B8B",
+	darkgoldenrod: "B8860B",
+	darkgray: "A9A9A9",
+	darkgreen: "006400",
+	darkkhaki: "BDB76B",
+	darkmagenta: "8B008B",
+	darkolivegreen: "556B2F",
+	darkorange: "FF8C00",
+	darkorchid: "9932CC",
+	darkred: "8B0000",
+	darksalmon: "E9967A",
+	darkseagreen: "8FBC8F",
+	darkslateblue: "483D8B",
+	darkslategray: "2F4F4F",
+	darkturquoise: "00CED1",
+	darkviolet: "9400D3",
+	deeppink: "FF1493",
+	deepskyblue: "00BFFF",
+	dimgray: "696969",
+	dodgerblue: "1E90FF",
+	firebrick: "B22222",
+	floralwhite: "FFFAF0",
+	forestgreen: "228B22",
+	fuchsia: "FF00FF",
+	gainsboro: "DCDCDC",
+	ghostwhite: "F8F8FF",
+	gold: "FFD700",
+	goldenrod: "DAA520",
+	gray: "808080",
+	green: "008000",
+	greenyellow: "ADFF2F",
+	honeydew: "F0FFF0",
+	hotpink: "FF69B4",
+	indianred: "CD5C5C",
+	indigo: "4B0082",
+	ivory: "FFFFF0",
+	khaki: "F0E68C",
+	lavender: "E6E6FA",
+	lavenderblush: "FFF0F5",
+	lawngreen: "7CFC00",
+	lemonchiffon: "FFFACD",
+	lightblue: "ADD8E6",
+	lightcoral: "F08080",
+	lightcyan: "E0FFFF",
+	lightgoldenrodyellow: "FAFAD2",
+	lightgray: "D3D3D3",
+	lightgreen: "90EE90",
+	lightpink: "FFB6C1",
+	lightsalmon: "FFA07A",
+	lightseagreen: "20B2AA",
+	lightskyblue: "87CEFA",
+	lightslategray: "778899",
+	lightsteelblue: "B0C4DE",
+	lightyellow: "FFFFE0",
+	lime: "00FF00",
+	limegreen: "32CD32",
+	linen: "FAF0E6",
+	magenta: "FF00FF",
+	maroon: "800000",
+	mediumaquamarine: "66CDAA",
+	mediumblue: "0000CD",
+	mediumorchid: "BA55D3",
+	mediumpurple: "9370DB",
+	mediumseagreen: "3CB371",
+	mediumslateblue: "7B68EE",
+	mediumspringgreen: "00FA9A",
+	mediumturquoise: "48D1CC",
+	mediumvioletred: "C71585",
+	midnightblue: "191970",
+	mintcream: "F5FFFA",
+	mistyrose: "FFE4E1",
+	moccasin: "FFE4B5",
+	navajowhite: "FFDEAD",
+	navy: "000080",
+	oldlace: "FDF5E6",
+	olive: "808000",
+	olivedrab: "6B8E23",
+	orange: "FFA500",
+	orangered: "FF4500",
+	orchid: "DA70D6",
+	palegoldenrod: "EEE8AA",
+	palegreen: "98FB98",
+	paleturquoise: "AFEEEE",
+	palevioletred: "DB7093",
+	papayawhip: "FFEFD5",
+	peachpuff: "FFDAB9",
+	peru: "CD853F",
+	pink: "FFC0CB",
+	plum: "DDA0DD",
+	powderblue: "B0E0E6",
+	purple: "800080",
+	red: "FF0000",
+	rosybrown: "BC8F8F",
+	royalblue: "4169E1",
+	saddlebrown: "8B4513",
+	salmon: "FA8072",
+	sandybrown: "F4A460",
+	seagreen: "2E8B57",
+	seashell: "FFF5EE",
+	sienna: "A0522D",
+	silver: "C0C0C0",
+	skyblue: "87CEEB",
+	slateblue: "6A5ACD",
+	slategray: "708090",
+	snow: "FFFAFA",
+	springgreen: "00FF7F",
+	steelblue: "4682B4",
+	tan: "D2B48C",
+	teal: "008080",
+	thistle: "D8BFD8",
+	tomato: "FF6347",
+	turquoise: "40E0D0",
+	violet: "EE82EE",
+	wheat: "F5DEB3",
+	white: "FFFFFF",
+	whitesmoke: "F5F5F5",
+	yellow: "FFFF00",
+	yellowgreen: "9ACD32"
+};
+/**
+* Resolve an `a:prstClr/@val` preset colour name to its 6-hex RGB, or `null` when the name is
+* not one of the 190 `ST_PresetColorVal` values.
+*
+* Lenient about case for the same reason the rest of the read path is: the input is a file
+* someone else wrote, and a producer that spelled `Black` has still said which colour it meant.
+* A name that is not in the enumeration at all resolves to `null` rather than to a guess, so the
+* caller reports "no colour" instead of painting an invented one.
+* @param name - the raw attribute value, or `null` when the attribute is absent
+*/
+function presetColorHex(name) {
+	if (!name) return null;
+	const canonical = name.toLowerCase().replace(/grey/g, "gray").replace(/^dk/, "dark").replace(/^lt/, "light").replace(/^med(?!ium)/, "medium");
+	return PRESET_COLOR_HEX[canonical] ?? null;
+}
+//#endregion
 //#region src/read/oxml/theme.ts
 /**
 * Theme colour resolution: turning a DrawingML colour reference or a style-matrix reference into
@@ -551,17 +984,34 @@ function resolveSchemeToken(token, ctx) {
 function isA(el, local) {
 	return !!el && el.namespaceURI === OOXML_NS.a && el.localName === local;
 }
-/** The literal RGB of a colour element (`srgbClr`/`sysClr`), or `null` for others. */
+/**
+* The literal RGB of a *non-scheme* colour element, or `null` for one that needs the theme
+* (`a:schemeClr`) or that this reader does not resolve.
+*
+* Four of `a:EG_ColorChoice`'s six members land here. `a:scrgbClr` is the one deliberately left
+* out: its channels are percentages of a colour space the schema does not pin down, so whether
+* `50%` is linear-light or sRGB-encoded decides the answer and neither the schema nor the
+* transform work in `color-transform.ts` settles it. Guessing would produce a colour that is
+* wrong by a gamma curve and says nothing about it, which is worse than reporting no colour.
+* Closing it needs a render oracle — a deck with an `a:scrgbClr` fill authored in PowerPoint
+* and the painted pixel read back — not a reading of the schema.
+*/
 function colorElementHex(color) {
 	if (!color) return null;
 	if (isA(color, "srgbClr")) return attr(color, "val");
 	if (isA(color, "sysClr")) return attr(color, "lastClr") ?? attr(color, "val");
+	if (isA(color, "prstClr")) return presetColorHex(attr(color, "val"));
+	if (isA(color, "hslClr")) return hslClrToHex(attr(color, "hue"), attr(color, "sat"), attr(color, "lum"));
 	return null;
 }
 /**
 * Resolve a DrawingML colour element to a literal `{ hex, transforms }`, routing
 * `a:schemeClr` through the context. Returns `null` when the base cannot be made
 * literal (unmapped token, or a colour model we do not flatten).
+*
+* Five of `a:EG_ColorChoice`'s six members resolve: `a:srgbClr`, `a:sysClr`, `a:schemeClr`,
+* `a:prstClr` (through the {@link presetColorHex} table) and `a:hslClr`. `a:scrgbClr` does not —
+* see {@link colorElementHex} for why that one is a `null` rather than a guess.
 */
 function resolveColor(color, ctx) {
 	if (!color) return null;
@@ -573,7 +1023,7 @@ function resolveColor(color, ctx) {
 			transforms
 		} : null;
 	}
-	if (isA(color, "sysClr")) {
+	if (isA(color, "sysClr") || isA(color, "prstClr") || isA(color, "hslClr")) {
 		const hex = colorElementHex(color);
 		return hex ? {
 			hex,
@@ -1003,219 +1453,39 @@ function placeholderInheritedXfrm(type, idx, ctx) {
 	return null;
 }
 /**
-* The vertical anchor (`a:bodyPr/@anchor`) a placeholder inherits from the source
-* layout, then master, or `null`. Resolves per-attribute: the first tier whose
-* placeholder `a:bodyPr` actually sets `@anchor` wins, so a layout `a:bodyPr`
-* present but without `@anchor` does not mask the master's. The read-model
-* `TextFrame.resolvedAnchor` sibling of {@link placeholderInheritedXfrm}.
-*/
-function placeholderInheritedAnchor(type, idx, ctx) {
-	for (const root of [ctx.layoutRoot, ctx.masterRoot]) {
-		if (!root) continue;
-		const ph = findPlaceholder(root, type, idx);
-		const txBody = ph && firstChild(ph, "p:txBody");
-		const bodyPr = txBody && firstChild(txBody, "a:bodyPr");
-		const anchor = bodyPr && attr(bodyPr, "anchor");
-		if (anchor) return anchor;
-	}
-	return null;
-}
-/** Whether the *slide itself* already fixes this run's colour (so a rebind cannot change it). */
-function slideDefinesColor(run, pPr, slideLst, level) {
-	const rPr = firstChild(run, "a:rPr");
-	if (rPr && FILL_CHOICES.some((q) => firstChild(rPr, q))) return true;
-	const defRPr = pPr && firstChild(pPr, "a:defRPr");
-	if (defRPr && firstChild(defRPr, "a:solidFill")) return true;
-	return !!lstStyleLevelFill(slideLst, level);
-}
-/** Whether the *slide itself* already fixes a run property (so a rebind cannot change it). */
-function slideDefinesProp(name, run, pPr, slideLst, level) {
-	const rPr = firstChild(run, "a:rPr");
-	if (rPr && attr(rPr, name) != null) return true;
-	const defRPr = pPr && firstChild(pPr, "a:defRPr");
-	if (defRPr && attr(defRPr, name) != null) return true;
-	const slideDefRPr = lstStyleLevelDefRPr(slideLst, level);
-	return !!(slideDefRPr && attr(slideDefRPr, name) != null);
-}
-//#endregion
-//#region src/read/oxml/color-transform.ts
-/** DrawingML percentage (`100%` = `100000`) → fraction, or `null` when unparseable. */
-function pct(value) {
-	if (value === null || value === "") return null;
-	const n = Number(value);
-	return Number.isFinite(n) ? n / 1e5 : null;
-}
-const clamp01 = (n) => n < 0 ? 0 : n > 1 ? 1 : n;
-/** Parse a 6-hex string (`RRGGBB`, optional `#`) into 0–1 sRGB channels, or `null`. */
-function parseHex(hex) {
-	const h = hex.startsWith("#") ? hex.slice(1) : hex;
-	if (!/^[0-9a-fA-F]{6}$/.test(h)) return null;
-	return {
-		r: parseInt(h.slice(0, 2), 16) / 255,
-		g: parseInt(h.slice(2, 4), 16) / 255,
-		b: parseInt(h.slice(4, 6), 16) / 255
-	};
-}
-/** 0–1 sRGB channels → uppercase `RRGGBB`, rounding and clamping each channel. */
-function toHex(c) {
-	const ch = (v) => Math.round(clamp01(v) * 255).toString(16).toUpperCase().padStart(2, "0");
-	return `${ch(c.r)}${ch(c.g)}${ch(c.b)}`;
-}
-/** sRGB channel (0–1) → linear-light (gamma decode). */
-function srgbToLinear(c) {
-	return c <= .04045 ? c / 12.92 : Math.pow((c + .055) / 1.055, 2.4);
-}
-/** Linear-light channel (0–1) → sRGB (gamma encode). */
-function linearToSrgb(c) {
-	return c <= .0031308 ? c * 12.92 : 1.055 * Math.pow(c, 1 / 2.4) - .055;
-}
-/** sRGB (0–1) → HSL with H in degrees [0,360), S/L in [0,1]. */
-function rgbToHsl(c) {
-	const { r, g, b } = c;
-	const max = Math.max(r, g, b);
-	const min = Math.min(r, g, b);
-	const l = (max + min) / 2;
-	const d = max - min;
-	if (d === 0) return {
-		h: 0,
-		s: 0,
-		l
-	};
-	const s = d / (1 - Math.abs(2 * l - 1));
-	let h;
-	if (max === r) h = (g - b) / d % 6;
-	else if (max === g) h = (b - r) / d + 2;
-	else h = (r - g) / d + 4;
-	h *= 60;
-	if (h < 0) h += 360;
-	return {
-		h,
-		s,
-		l
-	};
-}
-/** HSL (H degrees, S/L 0–1) → sRGB (0–1). */
-function hslToRgb({ h, s, l }) {
-	const c = (1 - Math.abs(2 * l - 1)) * s;
-	const hp = (h % 360 + 360) % 360 / 60;
-	const x = c * (1 - Math.abs(hp % 2 - 1));
-	const [r, g, b] = hp < 1 ? [
-		c,
-		x,
-		0
-	] : hp < 2 ? [
-		x,
-		c,
-		0
-	] : hp < 3 ? [
-		0,
-		c,
-		x
-	] : hp < 4 ? [
-		0,
-		x,
-		c
-	] : hp < 5 ? [
-		x,
-		0,
-		c
-	] : [
-		c,
-		0,
-		x
-	];
-	const m = l - c / 2;
-	return {
-		r: r + m,
-		g: g + m,
-		b: b + m
-	};
-}
-/**
-* Apply an ordered list of DrawingML colour transforms to a base sRGB hex,
-* returning the effective sRGB hex (and opacity, when an `alpha*` modifier set
-* it). Pure: no DOM, no theme lookup — the caller has already resolved the base
-* colour and extracted each modifier's `{ name, value }`.
-*
-* An unparseable base hex is returned unchanged (with no transforms applied); an
-* unparseable/`null` modifier value is skipped.
+* The vertical anchor (`a:bodyPr/@anchor`) a placeholder inherits from the source
+* layout, then master, or `null`. Resolves per-attribute: the first tier whose
+* placeholder `a:bodyPr` actually sets `@anchor` wins, so a layout `a:bodyPr`
+* present but without `@anchor` does not mask the master's. The read-model
+* `TextFrame.resolvedAnchor` sibling of {@link placeholderInheritedXfrm}.
 */
-function applyColorTransforms(baseHex, transforms) {
-	const parsed = parseHex(baseHex);
-	if (!parsed) return { hex: baseHex };
-	let rgb = parsed;
-	let alpha;
-	for (const { name, value } of transforms) switch (name) {
-		case "lumMod":
-		case "lumOff": {
-			const f = pct(value);
-			if (f === null) break;
-			const hsl = rgbToHsl(rgb);
-			hsl.l = clamp01(name === "lumMod" ? hsl.l * f : hsl.l + f);
-			rgb = hslToRgb(hsl);
-			break;
-		}
-		case "satMod":
-		case "satOff": {
-			const f = pct(value);
-			if (f === null) break;
-			const hsl = rgbToHsl(rgb);
-			hsl.s = clamp01(name === "satMod" ? hsl.s * f : hsl.s + f);
-			rgb = hslToRgb(hsl);
-			break;
-		}
-		case "hueMod":
-		case "hueOff": {
-			const hsl = rgbToHsl(rgb);
-			if (name === "hueMod") {
-				const f = pct(value);
-				if (f === null) break;
-				hsl.h = (hsl.h * f % 360 + 360) % 360;
-			} else {
-				const n = value === null ? NaN : Number(value);
-				if (!Number.isFinite(n)) break;
-				hsl.h = ((hsl.h + n / 6e4) % 360 + 360) % 360;
-			}
-			rgb = hslToRgb(hsl);
-			break;
-		}
-		case "shade":
-		case "tint": {
-			const k = pct(value);
-			if (k === null) break;
-			const lin = {
-				r: srgbToLinear(rgb.r),
-				g: srgbToLinear(rgb.g),
-				b: srgbToLinear(rgb.b)
-			};
-			const apply = (c) => clamp01(name === "shade" ? c * k : c * k + (1 - k));
-			rgb = {
-				r: linearToSrgb(apply(lin.r)),
-				g: linearToSrgb(apply(lin.g)),
-				b: linearToSrgb(apply(lin.b))
-			};
-			break;
-		}
-		case "alpha": {
-			const f = pct(value);
-			if (f !== null) alpha = clamp01(f);
-			break;
-		}
-		case "alphaMod": {
-			const f = pct(value);
-			if (f !== null) alpha = clamp01((alpha ?? 1) * f);
-			break;
-		}
-		case "alphaOff": {
-			const f = pct(value);
-			if (f !== null) alpha = clamp01((alpha ?? 1) + f);
-			break;
-		}
+function placeholderInheritedAnchor(type, idx, ctx) {
+	for (const root of [ctx.layoutRoot, ctx.masterRoot]) {
+		if (!root) continue;
+		const ph = findPlaceholder(root, type, idx);
+		const txBody = ph && firstChild(ph, "p:txBody");
+		const bodyPr = txBody && firstChild(txBody, "a:bodyPr");
+		const anchor = bodyPr && attr(bodyPr, "anchor");
+		if (anchor) return anchor;
 	}
-	return alpha === void 0 ? { hex: toHex(rgb) } : {
-		hex: toHex(rgb),
-		alpha
-	};
+	return null;
+}
+/** Whether the *slide itself* already fixes this run's colour (so a rebind cannot change it). */
+function slideDefinesColor(run, pPr, slideLst, level) {
+	const rPr = firstChild(run, "a:rPr");
+	if (rPr && FILL_CHOICES.some((q) => firstChild(rPr, q))) return true;
+	const defRPr = pPr && firstChild(pPr, "a:defRPr");
+	if (defRPr && firstChild(defRPr, "a:solidFill")) return true;
+	return !!lstStyleLevelFill(slideLst, level);
+}
+/** Whether the *slide itself* already fixes a run property (so a rebind cannot change it). */
+function slideDefinesProp(name, run, pPr, slideLst, level) {
+	const rPr = firstChild(run, "a:rPr");
+	if (rPr && attr(rPr, name) != null) return true;
+	const defRPr = pPr && firstChild(pPr, "a:defRPr");
+	if (defRPr && attr(defRPr, name) != null) return true;
+	const slideDefRPr = lstStyleLevelDefRPr(slideLst, level);
+	return !!(slideDefRPr && attr(slideDefRPr, name) != null);
 }
 //#endregion
 //#region src/read/api/theme-context.ts
@@ -1459,22 +1729,44 @@ function resolveInheritedRunFontFace(ph, level, pPr, slideLstStyle, ctx) {
 	return null;
 }
 /**
-* Whether a run effectively renders bold when its own `a:rPr` sets no `@b`,
-* walking the same chain as {@link resolveInheritedRunSize}: the first
-* `a:defRPr/@b` (`1`/`true` → `true`, `0`/`false` → `false`) in the paragraph →
+* Whether a run effectively renders with the boolean character property `name`
+* (`b`/`i`) when its own `a:rPr` sets none, walking the same chain as
+* {@link resolveInheritedRunSize}: the first `a:defRPr/@<name>` in the paragraph →
 * slide → (placeholder) layout → master → `p:txStyles` → `p:defaultTextStyle`
-* chain. A non-placeholder run skips the placeholder tiers but still reaches
-* `p:defaultTextStyle` (which sets no `@b` in a PowerPoint-written deck, so bold
-* stays `null` there). `null` when nothing in the chain defines bold.
+* chain. The first tier that *states* the attribute wins, and its value is parsed
+* by {@link boolValue} — the same `xsd:boolean` parser the run's own `bold`/`italic`
+* getters use — so an unparseable value reports `null` rather than being read as
+* `false`. `null` when nothing in the chain states it.
 */
-function resolveInheritedRunBold(ph, level, pPr, slideLstStyle, ctx) {
+function resolveInheritedRunFlag(name, ph, level, pPr, slideLstStyle, ctx) {
 	for (const defRPr of inheritedRunDefRPrs(ph, level, pPr, slideLstStyle, ctx)) {
-		const b = attr(defRPr, "b");
-		if (b !== null) return b === "1" || b === "true";
+		const raw = attr(defRPr, name);
+		if (raw !== null) return boolValue(raw);
 	}
 	return null;
 }
 /**
+* Whether a run effectively renders bold when its own `a:rPr` sets no `@b`: the
+* first `a:defRPr/@b` in the inheritance chain (see {@link resolveInheritedRunFlag}).
+* A non-placeholder run skips the placeholder tiers but still reaches
+* `p:defaultTextStyle` (which sets no `@b` in a PowerPoint-written deck, so bold
+* stays `null` there). `null` when nothing in the chain defines bold.
+*/
+function resolveInheritedRunBold(ph, level, pPr, slideLstStyle, ctx) {
+	return resolveInheritedRunFlag("b", ph, level, pPr, slideLstStyle, ctx);
+}
+/**
+* Whether a run effectively renders italic when its own `a:rPr` sets no `@i`: the
+* first `a:defRPr/@i` in the inheritance chain (see {@link resolveInheritedRunFlag}).
+* `@b` and `@i` are siblings on `CT_TextCharacterProperties` and a master text
+* style states them together, so this is the exact twin of
+* {@link resolveInheritedRunBold} one attribute along. `null` when nothing in the
+* chain defines italic.
+*/
+function resolveInheritedRunItalic(ph, level, pPr, slideLstStyle, ctx) {
+	return resolveInheritedRunFlag("i", ph, level, pPr, slideLstStyle, ctx);
+}
+/**
 * The vertical anchor a placeholder text frame effectively renders when its own
 * `a:bodyPr` sets no `@anchor`: the value inherited from the layout → master
 * placeholder `a:bodyPr` (see {@link placeholderInheritedAnchor}). `null` when the
@@ -1515,8 +1807,9 @@ function resolveInheritedFrame(ph, ctx) {
 	};
 }
 /**
-* Resolve a DrawingML colour *element* (`a:srgbClr`/`a:schemeClr`/`a:sysClr`)
-* against `ctx` into a full {@link ResolvedColor} — base hex, raw transform list,
+* Resolve a DrawingML colour *element* (every `a:EG_ColorChoice` member except
+* `a:scrgbClr` — see `read/oxml/theme.ts`) against `ctx` into a full
+* {@link ResolvedColor} — base hex, raw transform list,
 * and the `effectiveHex`/`alpha` after applying those transforms. `null` when the
 * element cannot be made literal (unmapped token, or a colour model we do not
 * resolve). Shared by the solid-fill and gradient-stop colour reads.
@@ -1616,14 +1909,17 @@ function readGradientStops(container, ctx) {
 	const gsLst = firstChild(grad, "a:gsLst");
 	if (!gsLst) return [];
 	return getElements(gsLst, "a:gs").map((gs) => {
+		const colorEl = firstChildElement(gs);
+		const model = colorEl?.localName ?? null;
 		const pos = intValue(attr(gs, "pos"));
-		const srgb = firstChild(gs, "a:srgbClr");
-		const scheme = firstChild(gs, "a:schemeClr");
-		const resolved = resolveColorElement(srgb ?? scheme ?? null, ctx);
+		const resolved = resolveColorElement(colorEl, ctx);
+		const rawOf = (local) => colorEl && model === local ? attr(colorEl, "val") : null;
 		return {
-			position: pos === null ? null : pos / 1e5,
-			color: srgb ? attr(srgb, "val") : null,
-			schemeColor: scheme ? attr(scheme, "val") : null,
+			position: pos === null ? null : pos / PERCENT_SCALE,
+			color: rawOf("srgbClr"),
+			schemeColor: rawOf("schemeClr"),
+			presetColor: rawOf("prstClr"),
+			resolvedColor: resolved,
 			effectiveHex: resolved ? resolved.effectiveHex : null,
 			...resolved?.alpha !== void 0 ? { alpha: resolved.alpha } : {}
 		};
@@ -1642,7 +1938,7 @@ function readGradientFill(container, ctx) {
 	const ang = lin ? intValue(attr(lin, "ang")) : null;
 	return {
 		kind: lin ? "linear" : path ? "path" : null,
-		angleDeg: ang === null ? null : ang / 6e4,
+		angleDeg: ang === null ? null : ang / ANGLE_UNITS_PER_DEGREE,
 		path: path ? attr(path, "path") ?? null : null,
 		stops: readGradientStops(container, ctx) ?? []
 	};
@@ -1664,7 +1960,7 @@ function readGradientFill(container, ctx) {
 function readRect(rect) {
 	const edge = (name) => {
 		const v = intValue(attr(rect, name));
-		return v === null ? 0 : v / 1e5;
+		return v === null ? 0 : v / PERCENT_SCALE;
 	};
 	return {
 		left: edge("l"),
@@ -1677,7 +1973,7 @@ function readRect(rect) {
 function readTile(tile) {
 	const scale = (name) => {
 		const v = intValue(attr(tile, name));
-		return v === null ? 1 : v / 1e5;
+		return v === null ? 1 : v / PERCENT_SCALE;
 	};
 	return {
 		offsetXEmu: intValue(attr(tile, "tx")) ?? 0,
@@ -1720,7 +2016,7 @@ function readPictureFill(container, rels = null) {
 		srcRect: srcRect ? readRect(srcRect) : null,
 		fillRect: fillRect ? readRect(fillRect) : null,
 		tile: tile ? readTile(tile) : null,
-		alpha: alphaMod ? amt === null ? 1 : amt / 1e5 : null,
+		alpha: alphaMod ? amt === null ? 1 : amt / PERCENT_SCALE : null,
 		dpi: intValue(attr(blipFill, "dpi")),
 		rotWithShape: boolValue(attr(blipFill, "rotWithShape"))
 	};
@@ -1862,8 +2158,8 @@ function readGeometryPath(path) {
 					cmd: "arcTo",
 					wR: intValue(attr(seg, "wR")) ?? 0,
 					hR: intValue(attr(seg, "hR")) ?? 0,
-					stAng: (intValue(attr(seg, "stAng")) ?? 0) / 6e4,
-					swAng: (intValue(attr(seg, "swAng")) ?? 0) / 6e4
+					stAng: (intValue(attr(seg, "stAng")) ?? 0) / ANGLE_UNITS_PER_DEGREE,
+					swAng: (intValue(attr(seg, "swAng")) ?? 0) / ANGLE_UNITS_PER_DEGREE
 				});
 				break;
 			case "close": commands.push({ cmd: "close" });
@@ -1901,7 +2197,7 @@ function readBox(xfrm, offName, extName) {
 }
 function rotationDegrees(xfrm) {
 	const rot = intValue(attr(xfrm, "rot"));
-	return rot === null ? 0 : rot / 6e4;
+	return rot === null ? 0 : rot / ANGLE_UNITS_PER_DEGREE;
 }
 function transformFlipH(xfrm) {
 	return boolValue(attr(xfrm, "flipH")) === true;
@@ -2045,9 +2341,10 @@ var Run = class {
 	inheritedSize;
 	inheritedFace;
 	inheritedBold;
+	inheritedItalic;
 	relationships;
 	fontRef;
-	constructor(element, part, themeContext, inheritedColor, inheritedSize, inheritedFace, inheritedBold, relationships, fontRef) {
+	constructor(element, part, themeContext, inheritedColor, inheritedSize, inheritedFace, inheritedBold, inheritedItalic, relationships, fontRef) {
 		this.element = element;
 		this.part = part;
 		this.themeContext = themeContext;
@@ -2055,6 +2352,7 @@ var Run = class {
 		this.inheritedSize = inheritedSize;
 		this.inheritedFace = inheritedFace;
 		this.inheritedBold = inheritedBold;
+		this.inheritedItalic = inheritedItalic;
 		this.relationships = relationships;
 		this.fontRef = fontRef;
 	}
@@ -2284,6 +2582,19 @@ var Run = class {
 	get resolvedBold() {
 		return this.bold ?? this.inheritedBold?.() ?? null;
 	}
+	/**
+	* Whether this run effectively renders italic. It is the run's own `@i`
+	* ({@link italic}) when set; otherwise, for a run inside a placeholder, the italic
+	* state it inherits from the placeholder/list-style chain (paragraph `a:defRPr` →
+	* slide `a:lstStyle` → layout → master placeholder `a:lstStyle` → master
+	* `p:txStyles`). `null` when the run sets no `@i` and inherits none — the
+	* resolved counterpart of {@link italic}, and the twin of {@link resolvedBold}:
+	* `@b` and `@i` are siblings a master text style states together, so a deck that
+	* can be authored with an inherited italic can be read back with one.
+	*/
+	get resolvedItalic() {
+		return this.italic ?? this.inheritedItalic?.() ?? null;
+	}
 	/** Escape hatch: the underlying `a:r` element. After mutating it call {@link markDirty}, or `save()` writes the original bytes. */
 	get element_() {
 		return this.element;
@@ -2352,8 +2663,9 @@ var Paragraph = class {
 		const inheritedSize = this.#inheritedResolver((ph, level, pPr, slideLst, ctx) => resolveInheritedRunSize(ph, level, pPr, slideLst, ctx));
 		const inheritedFace = this.#inheritedResolver((ph, level, pPr, slideLst, ctx) => resolveInheritedRunFontFace(ph, level, pPr, slideLst, ctx));
 		const inheritedBold = this.#inheritedResolver((ph, level, pPr, slideLst, ctx) => resolveInheritedRunBold(ph, level, pPr, slideLst, ctx));
+		const inheritedItalic = this.#inheritedResolver((ph, level, pPr, slideLst, ctx) => resolveInheritedRunItalic(ph, level, pPr, slideLst, ctx));
 		const fontRef = this.inherit?.placeholder.fontRef ?? null;
-		return getElements(this.element, "a:r").map((element) => new Run(element, this.part, this.themeContext, inheritedColor, inheritedSize, inheritedFace, inheritedBold, this.relationships, fontRef));
+		return getElements(this.element, "a:r").map((element) => new Run(element, this.part, this.themeContext, inheritedColor, inheritedSize, inheritedFace, inheritedBold, inheritedItalic, this.relationships, fontRef));
 	}
 	/**
 	* A memoized thunk resolving the colour every run in this paragraph inherits
@@ -2366,7 +2678,7 @@ var Paragraph = class {
 	}
 	/**
 	* Build a memoized per-paragraph thunk for one inherited run property
-	* (colour/size/face), or `undefined` for non-placeholder paragraphs. All runs in
+	* (colour/size/face/bold/italic), or `undefined` for non-placeholder paragraphs. All runs in
 	* a paragraph share its level and `a:pPr`, so each `resolve` runs at most once
 	* and only when a run actually lacks its own value and asks.
 	*/
@@ -2513,7 +2825,7 @@ var Paragraph = class {
 	#emuAttrPt(name) {
 		const pPr = firstChild(this.element, "a:pPr");
 		const emu = pPr ? intValue(attr(pPr, name)) : null;
-		return emu === null ? null : emu / 12700;
+		return emu === null ? null : emu / EMU_PER_POINT;
 	}
 	/**
 	* The paragraph's text: run (`a:r`) and field (`a:fld`) text concatenated in
@@ -2529,6 +2841,16 @@ var Paragraph = class {
 		}
 		return out;
 	}
+	/**
+	* Replace **this paragraph's** content with a single run, preserving the character
+	* formatting (`a:rPr`) of its first existing run and leaving its `a:pPr` (level,
+	* alignment, bullet) alone. Sibling paragraphs are untouched — the difference from
+	* {@link TextFrame.text}, which collapses the whole body to one paragraph.
+	*/
+	set text(value) {
+		setParagraphText(this.element, value);
+		this.part.markDirty();
+	}
 	/** Escape hatch: the underlying `a:p` element. After mutating it call {@link markDirty}, or `save()` writes the original bytes. */
 	get element_() {
 		return this.element;
@@ -2570,7 +2892,7 @@ var TextFrame = class {
 		const insetsPt = {};
 		const inset = (qn, key) => {
 			const v = intValue(attr(bodyPr, qn));
-			if (v !== null) insetsPt[key] = v / 12700;
+			if (v !== null) insetsPt[key] = v / EMU_PER_POINT;
 		};
 		inset("lIns", "left");
 		inset("rIns", "right");
@@ -2672,8 +2994,6 @@ function setTextBodyText(txBody, value) {
 	const doc = txBody.ownerDocument;
 	if (!doc) throw new InternalError("oxml/node-has-no-document", "Cannot set text: text body has no owner document");
 	const paragraphs = getElements(txBody, "a:p");
-	const firstRun = paragraphs[0] && firstChild(paragraphs[0], "a:r");
-	const rPrTemplate = firstRun && firstChild(firstRun, "a:rPr");
 	for (let i = paragraphs.length - 1; i >= 1; i--) {
 		const extra = paragraphs[i];
 		if (extra) txBody.removeChild(extra);
@@ -2683,6 +3003,21 @@ function setTextBodyText(txBody, value) {
 		p = createElement(doc, "a:p");
 		txBody.appendChild(p);
 	}
+	setParagraphText(p, value);
+}
+/**
+* Replace **one paragraph's** content with a single run, preserving the `a:rPr` of that
+* paragraph's first existing run and leaving its `a:pPr` (level, alignment, bullet) alone.
+* Sibling paragraphs are untouched, which is the whole difference from
+* {@link setTextBodyText} and the reason this exists: a SmartArt drawing cache packs several
+* nodes' text into one `dsp:txBody`, so collapsing the body there would delete the other
+* nodes' strings. Does **not** mark any part dirty — the caller owns the `Part`.
+*/
+function setParagraphText(p, value) {
+	const doc = p.ownerDocument;
+	if (!doc) throw new InternalError("oxml/node-has-no-document", "Cannot set text: paragraph has no owner document");
+	const firstRun = firstChild(p, "a:r");
+	const rPrTemplate = firstRun && firstChild(firstRun, "a:rPr");
 	for (const child of childElements(p)) if (child.localName === "r" || child.localName === "br" || child.localName === "fld") p.removeChild(child);
 	const run = createElement(doc, "a:r");
 	if (rPrTemplate) run.appendChild(rPrTemplate.cloneNode(true));
@@ -3060,7 +3395,7 @@ var Shape = class {
 	get lineWidthPt() {
 		const ln = this.#line();
 		const w = ln ? intValue(attr(ln, "w")) : null;
-		return w === null ? null : w / 12700;
+		return w === null ? null : w / EMU_PER_POINT;
 	}
 	/**
 	* The line/border dash style (`spPr/a:ln/a:prstDash/@val`), e.g. `'dash'`,
@@ -3243,7 +3578,7 @@ var Shape = class {
 		const out = { color: null };
 		this.#applyEffectColor(out, firstChildElement(glow));
 		const rad = intValue(attr(glow, "rad"));
-		if (rad !== null) out.radiusPt = rad / 12700;
+		if (rad !== null) out.radiusPt = rad / EMU_PER_POINT;
 		return out;
 	}
 	/**
@@ -3259,14 +3594,14 @@ var Shape = class {
 			const v = intValue(attr(refl, name));
 			if (v !== null) out[target] = v / div;
 		};
-		put("blurPt", "blurRad", 12700);
-		put("distPt", "dist", 12700);
-		put("angleDeg", "dir", 6e4);
-		put("fadeAngleDeg", "fadeDir", 6e4);
-		put("startAlpha", "stA", 1e5);
-		put("startPos", "stPos", 1e5);
-		put("endAlpha", "endA", 1e5);
-		put("endPos", "endPos", 1e5);
+		put("blurPt", "blurRad", EMU_PER_POINT);
+		put("offsetPt", "dist", EMU_PER_POINT);
+		put("angleDeg", "dir", ANGLE_UNITS_PER_DEGREE);
+		put("fadeAngleDeg", "fadeDir", ANGLE_UNITS_PER_DEGREE);
+		put("startAlpha", "stA", PERCENT_SCALE);
+		put("startPos", "stPos", PERCENT_SCALE);
+		put("endAlpha", "endA", PERCENT_SCALE);
+		put("endPos", "endPos", PERCENT_SCALE);
 		return out;
 	}
 	/**
@@ -3277,7 +3612,7 @@ var Shape = class {
 		const soft = this.#effect("a:softEdge");
 		if (!soft) return null;
 		const rad = intValue(attr(soft, "rad"));
-		return { radiusPt: rad === null ? 0 : rad / 12700 };
+		return { radiusPt: rad === null ? 0 : rad / EMU_PER_POINT };
 	}
 	/**
 	* The shape's pattern (hatch) fill (`spPr/a:pattFill`), or `null` when the fill
@@ -3321,13 +3656,13 @@ var Shape = class {
 	/** Decode a shadow element (`a:outerShdw`/`a:innerShdw` share the fields), resolving its colour. */
 	#readShadow(shdw) {
 		const out = { color: null };
-		this.#applyEffectColor(out, firstChild(shdw, "a:srgbClr") ?? firstChild(shdw, "a:schemeClr"));
+		this.#applyEffectColor(out, firstChildElement(shdw));
 		const blur = intValue(attr(shdw, "blurRad"));
 		const dist = intValue(attr(shdw, "dist"));
 		const dir = intValue(attr(shdw, "dir"));
-		if (blur !== null) out.blurPt = blur / 12700;
-		if (dist !== null) out.offsetPt = dist / 12700;
-		if (dir !== null) out.angleDeg = dir / 6e4;
+		if (blur !== null) out.blurPt = blur / EMU_PER_POINT;
+		if (dist !== null) out.offsetPt = dist / EMU_PER_POINT;
+		if (dir !== null) out.angleDeg = dir / ANGLE_UNITS_PER_DEGREE;
 		return out;
 	}
 	/**
@@ -3633,7 +3968,7 @@ var Picture = class extends Shape {
 		if (!srcRect) return null;
 		const edge = (name) => {
 			const v = intValue(attr(srcRect, name));
-			return v === null ? 0 : v / 1e5;
+			return v === null ? 0 : v / PERCENT_SCALE;
 		};
 		return {
 			left: edge("l"),
@@ -3678,14 +4013,14 @@ var Picture = class extends Shape {
 					const thresh = intValue(attr(child, "thresh"));
 					return {
 						kind: "biLevel",
-						threshold: thresh === null ? null : thresh / 1e5
+						threshold: thresh === null ? null : thresh / PERCENT_SCALE
 					};
 				}
 				case "alphaModFix": {
 					const amt = intValue(attr(child, "amt"));
 					return {
 						kind: "alphaModFix",
-						amount: amt === null ? 1 : amt / 1e5
+						amount: amt === null ? 1 : amt / PERCENT_SCALE
 					};
 				}
 			}
@@ -3821,6 +4156,75 @@ var Connector = class extends Shape {
 	}
 };
 //#endregion
+//#region src/read/oxml/point-cache.ts
+/**
+* The one place a chart point cache is turned into an idx-ordered array.
+*
+* Both chart families cache their category/value data the same way: a run of indexed point
+* elements plus a declared count, which the reader widens back into a dense array so
+* `series.values[3]` means the point at `idx="3"` and a gap reads as `null`. Classic `c:`
+* charts and 2016 `cx:` charts spell it differently — `c:ptCount/@val` and a `c:v` child
+* against `cx:lvl/@ptCount` and the point's own text — and nothing else about the two decodes
+* differs, so the shape parameterizes over exactly those two differences.
+*
+* **Why neither number out of the file is trusted.** `@ptCount` is `xsd:unsignedInt`, so
+* `4294967295` is schema-valid, and `new Array(n).fill(null)` at that size is not a slow path
+* but a process kill: V8 answers `FATAL ERROR: invalid table size` and the host dies with no
+* exception to catch. That was reachable through the public read API — `Presentation.load()`
+* on a deck with an edited `c:ptCount` returned normally and the first `chart.series` access
+* killed the process. A single `<c:pt idx="900000000"/>` does the same thing on its own.
+* Reading a deck is the one part of this library whose input comes from somewhere other than
+* the calling program, so both numbers are bounded here.
+*
+* The array is sized by the points that are really there, not by the declared count. The cost
+* of that is a *trailing* gap: a cache declaring four points but carrying three (the fourth
+* cell blank) reads three long rather than four. No value is lost — the dropped slots are the
+* ones that would have been `null` — and the disagreement is warned about either way.
+*/
+/**
+* The highest point index this reader will honour.
+*
+* A cache references a range in the embedded workbook, and a worksheet has 1,048,576 rows, so
+* a point index at or above that cannot describe data any producer could have charted. Using
+* the sheet bound rather than a round number keeps the ceiling something a reader can check:
+* below it every real cache fits, above it the file is wrong by construction. It also caps the
+* worst-case allocation at about 8 MB of `null` — survivable, and reported — instead of an
+* unbounded one that takes the process with it.
+*/
+const MAX_POINT_INDEX = 1048576;
+/**
+* Read indexed cache points into a dense, idx-ordered array.
+*
+* The result is as long as the highest `@idx` actually present, and holds `null` at every
+* index no point claimed. A declared count that disagrees is warned about and not obeyed; a
+* point indexed past {@link MAX_POINT_INDEX} is warned about and dropped.
+* @param pts - the point elements, in document order
+* @param declaredCount - the cache's own count attribute, or `null` when absent
+* @param valueOf - reads one point's value; the two chart families differ only here
+* @param label - what to call the count in a diagnostic, e.g. `c:ptCount`
+*/
+function readIndexedPoints(pts, declaredCount, valueOf, label) {
+	let count = 0;
+	let dropped = 0;
+	for (const pt of pts) {
+		const idx = intValue(attr(pt, "idx")) ?? 0;
+		if (idx < 0 || idx >= MAX_POINT_INDEX) {
+			dropped++;
+			continue;
+		}
+		if (idx + 1 > count) count = idx + 1;
+	}
+	if (dropped > 0) warn("chart/point-index-out-of-range", `${label}: ${dropped} cache point(s) are indexed outside 0..1048575, which no worksheet-backed chart can reference; they were dropped`);
+	if (declaredCount !== null && declaredCount !== count) warn("chart/point-count-mismatch", `${label} declares ${declaredCount} point(s) but the cache carries ${pts.length}; reading ${count} rather than allocating the declared size`);
+	const points = new Array(count).fill(null);
+	for (const pt of pts) {
+		const idx = intValue(attr(pt, "idx")) ?? 0;
+		if (idx < 0 || idx >= count) continue;
+		points[idx] = valueOf(pt);
+	}
+	return points;
+}
+//#endregion
 //#region src/read/api/chart.ts
 /** A chart graphic-frame's chart, backed by its chart part. */
 var Chart = class {
@@ -4094,7 +4498,7 @@ var ChartSeries = class {
 		const dash = firstChild(ln, "a:prstDash");
 		const solid = readSolid(ln);
 		return {
-			widthPt: w === null ? null : w / 12700,
+			widthPt: w === null ? null : w / EMU_PER_POINT,
 			dash: dash ? attr(dash, "val") ?? null : null,
 			color: solid.color,
 			schemeColor: solid.schemeColor,
@@ -4188,22 +4592,11 @@ function findCache(container) {
 	}
 	return firstChild(container, "c:numLit") ?? firstChild(container, "c:strLit");
 }
-/** Read a cache's points (`c:pt[@idx]/c:v`) into an idx-ordered array sized by `c:ptCount`. */
+/** Read a cache's points (`c:pt[@idx]/c:v`) into an idx-ordered array; `c:ptCount` is the declared count. */
 function readPoints(cache) {
 	if (!cache) return [];
 	const ptCount = firstChild(cache, "c:ptCount");
-	let count = ptCount ? intValue(attr(ptCount, "val")) ?? 0 : 0;
-	const pts = getElements(cache, "c:pt");
-	for (const pt of pts) {
-		const idx = intValue(attr(pt, "idx")) ?? 0;
-		if (idx + 1 > count) count = idx + 1;
-	}
-	const points = new Array(count).fill(null);
-	for (const pt of pts) {
-		const idx = intValue(attr(pt, "idx")) ?? 0;
-		points[idx] = firstChild(pt, "c:v")?.textContent ?? null;
-	}
-	return points;
+	return readIndexedPoints(getElements(cache, "c:pt"), ptCount ? intValue(attr(ptCount, "val")) : null, (pt) => firstChild(pt, "c:v")?.textContent ?? null, "c:ptCount");
 }
 //#endregion
 //#region src/read/api/chartex.ts
@@ -4437,22 +4830,10 @@ var ChartExAxis = class {
 		this.chart.part.markDirty();
 	}
 };
-/** Read a `cx:lvl`'s points (`cx:pt[@idx]` text) into an idx-ordered array sized by `@ptCount`. */
+/** Read a `cx:lvl`'s points (`cx:pt[@idx]` text) into an idx-ordered array; `@ptCount` is the declared count. */
 function readLevelPoints(lvl) {
 	if (!lvl) return [];
-	const ptCount = intValue(attr(lvl, "ptCount"));
-	const pts = getElements(lvl, "cx:pt");
-	let count = ptCount ?? 0;
-	for (const pt of pts) {
-		const idx = intValue(attr(pt, "idx")) ?? 0;
-		if (idx + 1 > count) count = idx + 1;
-	}
-	const points = new Array(count).fill(null);
-	for (const pt of pts) {
-		const idx = intValue(attr(pt, "idx")) ?? 0;
-		points[idx] = pt.textContent ?? null;
-	}
-	return points;
+	return readIndexedPoints(getElements(lvl, "cx:pt"), intValue(attr(lvl, "ptCount")), (pt) => pt.textContent ?? null, "cx:lvl/@ptCount");
 }
 /** Parse an attribute as a boolean (`1`/`true` → true, `0`/`false` → false), or `null` when absent. */
 function boolAttr(element, name) {
@@ -4468,6 +4849,55 @@ function floatValue(value) {
 }
 //#endregion
 //#region src/read/api/diagram.ts
+/**
+* Read proxies for a SmartArt diagram (`dgm:dataModel`) hosted in a `p:graphicFrame`.
+*
+* SmartArt is a four-part construct, and the frame itself holds none of it: the
+* `a:graphicData` carries only a `dgm:relIds` with four relationship ids pointing at the
+* data, layout, quick-style and colours parts under `/ppt/diagrams/`. The **data** part is
+* the one with content in it — a flat `dgm:ptLst` of points plus a `dgm:cxnLst` of
+* connections that give the points their tree — and it is what this surface decodes. The
+* other three are generated presets (`urn:microsoft.com/office/officeart/…`) describing how
+* PowerPoint *draws* the graph rather than what it says; they surface as parts, not getters.
+*
+* The text is ordinary DrawingML: `dgm:pt/dgm:t` is an `a:CT_TextBody`, the same type a
+* shape's `p:txBody` is, so a point's text reads back through the same
+* {@link TextFrame}/`Paragraph`/`Run` proxies as any other text on the slide, run formatting
+* included.
+*
+* **Not every point is content.** A saved data model interleaves the user's nodes with
+* points the layout engine generated (`pres`), the diagram root (`doc`), and the transition
+* points sitting on each edge (`parTrans`/`sibTrans`, which carry text only where a layout
+* labels its arrows). {@link Diagram.text} applies exactly that filter; {@link Diagram.points}
+* applies none, so a consumer that needs the raw graph gets it.
+*
+* **The structure is in the connections, and {@link Diagram.nodes} is the view of it.** A
+* `parOf` edge names the parent in `@srcId`, the child in `@destId` and the child's sibling
+* position in `@srcOrd`; `points` order is document order and says nothing about depth. Three
+* decisions that tree makes, each of which could defensibly have gone the other way:
+*
+* - **`asst` points are in it.** An assistant is user content, and an org chart merely draws
+*   it off the main branch rather than under it. {@link DiagramPoint.type} carries the
+*   distinction, so folding it silently in with `node` would hide something a consumer can
+*   act on while omitting it would lose authored text.
+* - **Transition points are not.** A `parTrans`/`sibTrans` labels an *edge*, not a node, and
+*   reaches its edge through {@link DiagramConnection.parentTransitionId} /
+*   `siblingTransitionId`. Hanging one off `children` would make the tree disagree with what
+*   PowerPoint's own text pane shows.
+* - **A cycle in `parOf` throws.** It is a corrupt model rather than a shape the format can
+*   express, and the walk would not terminate; see `diagram/parent-edge-cycle`.
+*
+* **A point's text is stored twice.** The data model is what PowerPoint reads, but a deck
+* also carries a *drawing* part (`dsp:drawing`) holding a copy of every drawn string, and
+* every renderer without a SmartArt layout engine — LibreOffice, Google Slides, thumbnailers
+* — paints that copy and nothing else. {@link DiagramPoint.drawnShape} is the link between
+* the two, and {@link DiagramPoint.text}'s setter is what keeps them in step.
+*
+* Authoring a SmartArt graphic from nothing is out of scope: the layout part is a
+* constraint-solver program PowerPoint executes, and the presentation tree it generates is
+* not derivable from the user's content. Editing the text of one that already exists is
+* supported — see {@link DiagramPoint.text}.
+*/
 const POINT_TYPES = [
 	"node",
 	"asst",
@@ -4484,17 +4914,100 @@ const CONNECTION_TYPES = [
 ];
 /** The MS extension (`dgm:extLst/a:ext`) whose `@relId` names the fallback drawing part. */
 const DRAWING_EXT_URI = "http://schemas.microsoft.com/office/drawing/2008/diagram";
+/**
+* The node → drawn-shape index of one diagram: the `presOf` edges of the data model and the
+* `dsp:sp` elements of the drawing part, both keyed for lookup.
+*
+* Built once per {@link Diagram}, and only when a point is actually asked what draws it — the
+* drawing part is a second XML DOM and a consumer reading node text should not pay to parse
+* it. The consequence of that memo: a consumer who *adds* or *removes* shapes in the drawing
+* part through the escape hatches must re-reach the diagram to see them here.
+*/
+var DrawingIndex = class {
+	drawingPart;
+	themeContext;
+	/** `presOf` arms out of each source point, in `@srcOrd` order. */
+	#arms = /* @__PURE__ */ new Map();
+	/** Each `dsp:sp` by the `pres` modelId it draws. */
+	#shapes = /* @__PURE__ */ new Map();
+	constructor(root, drawingPart, themeContext) {
+		this.drawingPart = drawingPart;
+		this.themeContext = themeContext;
+		const cxnLst = root && firstChild(root, "dgm:cxnLst");
+		for (const cxn of cxnLst ? getElements(cxnLst, "dgm:cxn") : []) {
+			if (attr(cxn, "type") !== "presOf") continue;
+			const srcId = attr(cxn, "srcId");
+			const destId = attr(cxn, "destId");
+			if (!srcId || !destId) continue;
+			const arm = {
+				destId,
+				destinationOrder: intValue(attr(cxn, "destOrd")) ?? 0,
+				sourceOrder: intValue(attr(cxn, "srcOrd")) ?? 0
+			};
+			const list = this.#arms.get(srcId);
+			if (list) list.push(arm);
+			else this.#arms.set(srcId, [arm]);
+		}
+		for (const list of this.#arms.values()) list.sort((a, b) => a.sourceOrder - b.sourceOrder);
+		const drawingRoot = drawingPart?.dom.documentElement ?? null;
+		for (const sp of drawingRoot ? descendantsByTag(drawingRoot, OOXML_NS.dsp, "sp") : []) {
+			const modelId = attr(sp, "modelId");
+			if (modelId !== null && !this.#shapes.has(modelId)) this.#shapes.set(modelId, sp);
+		}
+	}
+	/**
+	* Resolve one authored point to the `pres` point that presents it and to the drawn
+	* paragraph carrying its text.
+	*
+	* A point commonly has **several** `presOf` arms — an org-chart node's box and the
+	* connector beneath it are two presentations of one node — so the arm is chosen by what it
+	* reaches rather than by its `@srcOrd`: the first, in `@srcOrd` order, whose `pres` point
+	* draws a `dsp:sp` that has a `dsp:txBody`. That selector produced a unique hit for all 90
+	* authored points measured across five layout families, and it degrades to "no arm" rather
+	* than to "the wrong arm" on a layout that was not.
+	*/
+	resolve(modelId) {
+		const arms = (modelId === null ? void 0 : this.#arms.get(modelId)) ?? [];
+		const first = arms[0];
+		if (!first) return {
+			presentationId: null,
+			drawnShape: null
+		};
+		for (const arm of arms) {
+			const sp = this.#shapes.get(arm.destId);
+			const txBody = sp && firstChild(sp, "dsp:txBody");
+			if (!sp || !txBody || !this.drawingPart) continue;
+			const paragraph = getElements(txBody, "a:p")[arm.destinationOrder];
+			return {
+				presentationId: arm.destId,
+				drawnShape: paragraph ? {
+					part: this.drawingPart,
+					modelId: arm.destId,
+					paragraphIndex: arm.destinationOrder,
+					textFrame: new TextFrame(txBody, this.drawingPart, this.themeContext),
+					element_: sp
+				} : null
+			};
+		}
+		return {
+			presentationId: first.destId,
+			drawnShape: null
+		};
+	}
+};
 /** One point (`dgm:pt`) of a diagram's data model. */
 var DiagramPoint = class {
 	pt;
 	part;
 	themeContext;
 	relationships;
-	constructor(pt, part, themeContext, relationships) {
+	drawing;
+	constructor(pt, part, themeContext, relationships, drawing) {
 		this.pt = pt;
 		this.part = part;
 		this.themeContext = themeContext;
 		this.relationships = relationships;
+		this.drawing = drawing;
 	}
 	/** This point's id (`@modelId`), which connections reference. */
 	get modelId() {
@@ -4530,15 +5043,87 @@ var DiagramPoint = class {
 	* This point's text body (`dgm:t`) as a {@link TextFrame}, or `null` when the point
 	* carries none. It is an `a:CT_TextBody` like any other, so `paragraphs`, `runs` and the
 	* `resolved*` getters all apply.
+	*
+	* **Writing through this edits the data model only**, and leaves the drawing cache
+	* holding the old string — which is what PowerPoint-less renderers draw. It is the escape
+	* hatch for run-level formatting, so it does exactly what it is told and nothing more;
+	* {@link text}'s setter is the path that mirrors.
 	*/
 	get textFrame() {
 		const t = firstChild(this.pt, "dgm:t");
 		return t ? new TextFrame(t, this.part, this.themeContext, void 0, this.relationships) : null;
 	}
+	/**
+	* The generated `pres` point that presents this one (`dgm:cxn[@type="presOf"]/@destId`),
+	* or `null` when nothing presents it — the normal state of an unlabelled transition point.
+	*
+	* Where a point has several `presOf` arms the one named here is the arm that draws text;
+	* see {@link drawnShape}, which resolves both.
+	*/
+	get presentationId() {
+		return this.drawing?.().resolve(this.modelId).presentationId ?? null;
+	}
+	/**
+	* The paragraph of the fallback drawing part (`dsp:drawing`) that carries this point's
+	* text, or `null` when nothing draws it.
+	*
+	* The mapping runs through the `pres` point rather than directly: a `dsp:sp/@modelId` is
+	* always a `pres` point's id, so a lookup keyed on the authored point's own id finds
+	* nothing at all. It is many-to-one in both directions — one shape draws several points
+	* (`@destOrd` says which paragraph is whose, and it can contradict document order), and
+	* one point has several presentations, of which at most one holds text.
+	*
+	* `null` is a defined outcome, not a failure, and covers four real cases: the package
+	* carries no drawing part; the point has no `presOf` edge (every unlabelled
+	* `parTrans`/`sibTrans`); the `pres` point draws no `dsp:sp`; and the shape it draws has
+	* no `dsp:txBody` (a connector, or a picture node's filled rectangle).
+	*/
+	get drawnShape() {
+		return this.drawing?.().resolve(this.modelId).drawnShape ?? null;
+	}
 	/** This point's text, paragraphs joined by `\n`; `''` when it carries none. */
 	get text() {
 		return this.textFrame?.text ?? "";
 	}
+	/**
+	* Replace this point's text, in the data model **and** in the drawing cache.
+	*
+	* A diagram stores every string twice. `dgm:t` is what PowerPoint reads, and it recomputes
+	* the drawing from the data model on open; the `dsp:drawing` part is what every other
+	* renderer paints, and none of them recompute anything. Writing only the first is an edit
+	* that is invisible in LibreOffice, Google Slides, thumbnailers and web previews until
+	* someone opens the deck in PowerPoint and saves it.
+	*
+	* The data-model write always happens. The mirror is best-effort: when the point resolves
+	* to no drawn paragraph (see {@link drawnShape} for the four ways that occurs) the cache
+	* keeps the old string and a `diagram/drawing-cache-not-updated` diagnostic says so.
+	* Throwing instead would make the common case unusable in order to report the rare one,
+	* and returning a status would be a shape no other text setter here has.
+	*
+	* Two things it deliberately does not do. It does **not** recompute geometry: the drawn
+	* shape keeps its cached position and size, so a much longer string overflows its box in
+	* those same renderers until PowerPoint re-lays the diagram out. And it does not *create*
+	* a place to draw text — a transition point whose layout has no label slot has no
+	* `dsp:sp`, and PowerPoint strips text put on one, so the honest outcome is the
+	* diagnostic. Like every other `text` setter here it collapses the point to one run,
+	* keeping the first run's `a:rPr`; use {@link textFrame} for run-level work.
+	*/
+	set text(value) {
+		const frame = this.textFrame;
+		if (!frame) {
+			warn("diagram/point-has-no-text-body", `SmartArt point ${this.#label()} (type ${this.type}) has no dgm:t, so it is not a point text can be written to; nothing was changed`);
+			return;
+		}
+		frame.text = value;
+		const drawn = this.drawnShape;
+		const paragraph = drawn?.textFrame.paragraphs[drawn.paragraphIndex];
+		if (!drawn || !paragraph) {
+			warn("diagram/drawing-cache-not-updated", `SmartArt point ${this.#label()} resolves to no drawn paragraph, so ${this.part.partName} now holds the new text but the drawing cache still holds the old one; PowerPoint redraws it on open, other renderers do not`);
+			return;
+		}
+		setParagraphText(paragraph.element_, value);
+		drawn.part.markDirty();
+	}
 	/** Escape hatch: the underlying `dgm:pt` element. After mutating it call {@link Diagram.markDirty}. */
 	get element_() {
 		return this.pt;
@@ -4546,7 +5131,29 @@ var DiagramPoint = class {
 	#prSet() {
 		return firstChild(this.pt, "dgm:prSet");
 	}
+	/** How a diagnostic names this point: its `@modelId`, which is all a corrupt point may have. */
+	#label() {
+		return this.modelId ?? "(no modelId)";
+	}
+};
+/**
+* One user-authored point in its place in the diagram's tree — a `node` or an `asst`, never a
+* generated `pres` point or a transition label. See {@link Diagram.nodes}.
+*/
+var DiagramNode = class {
+	point;
+	parent;
+	level;
+	/** Child nodes, ordered by their `parOf` edge's `@srcOrd`. Empty for a leaf. */
+	children = [];
+	constructor(point, parent, level) {
+		this.point = point;
+		this.parent = parent;
+		this.level = level;
+	}
 };
+/** Sort key for a root with no `parOf` edge at all, so it lands after the ordered ones. */
+const MAX_ORDER = Number.MAX_SAFE_INTEGER;
 /** A SmartArt graphic frame's diagram, backed by its `dgm:dataModel` part. */
 var Diagram = class {
 	part;
@@ -4554,6 +5161,9 @@ var Diagram = class {
 	opc;
 	frameRelationships;
 	themeContext;
+	#relationships;
+	#docPrSetCache;
+	#drawing;
 	constructor(part, relIds, opc, frameRelationships, themeContext) {
 		this.part = part;
 		this.relIds = relIds;
@@ -4568,14 +5178,88 @@ var Diagram = class {
 	/**
 	* Every point (`dgm:ptLst/dgm:pt`) in document order, unfiltered — generated `pres`
 	* points and the `doc` root included. Filter on {@link DiagramPoint.type} for the user's
-	* nodes; {@link text} is the shortcut for the common case.
+	* nodes; {@link text} is the shortcut for the common case, {@link nodes} the structured one.
+	*
+	* Built per access like every other read proxy (`docs/reference/pptx-read.md`, "Object
+	* model"), so `points[0] !== points[0]` while both wrap the same `dgm:pt`. Key a `Map`
+	* on {@link DiagramPoint.modelId}, not on the point.
 	*/
 	get points() {
 		const root = this.#root();
 		const ptLst = root && firstChild(root, "dgm:ptLst");
 		if (!ptLst) return [];
-		const relationships = this.opc.relationshipsFor(this.part.partName);
-		return getElements(ptLst, "dgm:pt").map((pt) => new DiagramPoint(pt, this.part, this.themeContext, relationships));
+		const relationships = this.#relationships ??= this.opc.relationshipsFor(this.part.partName);
+		const drawing = () => this.#drawingIndex();
+		return getElements(ptLst, "dgm:pt").map((pt) => new DiagramPoint(pt, this.part, this.themeContext, relationships, drawing));
+	}
+	/**
+	* The authored tree — every `node` and `asst` point in its place, roots in `@srcOrd`
+	* order — as a view over {@link points} and {@link connections} rather than a replacement
+	* for either.
+	*
+	* A root is a content point whose `parOf` parent is not itself content, which in a
+	* PowerPoint-authored model means the `doc` point. Transition points are not members; see
+	* this module's header for that decision and the two beside it.
+	*
+	* @throws PackageReadError `diagram/parent-edge-cycle` when the `parOf` edges make a
+	* point its own ancestor, which is a corrupt model rather than a diagram shape.
+	*/
+	get nodes() {
+		const content = /* @__PURE__ */ new Map();
+		for (const point of this.points) {
+			const modelId = point.modelId;
+			if (modelId !== null && (point.type === "node" || point.type === "asst")) content.set(modelId, point);
+		}
+		const childrenOf = /* @__PURE__ */ new Map();
+		const edgeTo = /* @__PURE__ */ new Map();
+		for (const connection of this.connections) {
+			const { sourceId, destinationId } = connection;
+			if (connection.type !== "parOf" || sourceId === null || destinationId === null) continue;
+			if (!content.has(destinationId)) continue;
+			const edge = {
+				parentId: sourceId,
+				childId: destinationId,
+				order: connection.sourceOrder ?? 0
+			};
+			const list = childrenOf.get(sourceId);
+			if (list) list.push(edge);
+			else childrenOf.set(sourceId, [edge]);
+			edgeTo.set(destinationId, edge);
+		}
+		for (const list of childrenOf.values()) list.sort((a, b) => a.order - b.order);
+		const roots = [...content].filter(([modelId]) => {
+			const parentId = edgeTo.get(modelId)?.parentId;
+			return parentId === void 0 || !content.has(parentId);
+		});
+		roots.sort(([a], [b]) => (edgeTo.get(a)?.order ?? MAX_ORDER) - (edgeTo.get(b)?.order ?? MAX_ORDER));
+		const placed = /* @__PURE__ */ new Set();
+		const build = (point, parent, level, path) => {
+			const modelId = point.modelId;
+			if (modelId !== null && path.has(modelId)) throw this.#cycleError(modelId);
+			const node = new DiagramNode(point, parent, level);
+			if (modelId === null) return node;
+			placed.add(modelId);
+			path.add(modelId);
+			for (const edge of childrenOf.get(modelId) ?? []) {
+				const child = content.get(edge.childId);
+				if (child) node.children.push(build(child, node, level + 1, path));
+			}
+			path.delete(modelId);
+			return node;
+		};
+		const tree = roots.map(([, point]) => build(point, null, 0, /* @__PURE__ */ new Set()));
+		if (placed.size !== content.size) {
+			const orphan = [...content.keys()].find((modelId) => !placed.has(modelId));
+			throw this.#cycleError(orphan ?? "(unidentified)");
+		}
+		return tree;
+	}
+	/**
+	* The point with this `@modelId`, or `null` — the lookup every connection getter implies,
+	* since a `DiagramConnection` names its ends by id and nothing else resolves them.
+	*/
+	point(modelId) {
+		return this.points.find((candidate) => candidate.modelId === modelId) ?? null;
 	}
 	/** Every edge (`dgm:cxnLst/dgm:cxn`) in document order. */
 	get connections() {
@@ -4666,14 +5350,32 @@ var Diagram = class {
 	#root() {
 		return this.part.dom.documentElement;
 	}
-	#docPrSetAttr(name) {
+	#cycleError(modelId) {
+		return new PackageReadError("diagram/parent-edge-cycle", `Diagram ${this.part.partName} has a parOf cycle reaching point ${modelId}, so its points do not form a tree`);
+	}
+	/**
+	* The `doc` point's `dgm:prSet`, which carries all three preset ids — resolved once
+	* rather than once per getter, since each lookup is a scan of the whole `ptLst`.
+	* `undefined` means "not looked up yet"; `null` means "looked up, not there".
+	*/
+	#docPrSet() {
+		if (this.#docPrSetCache !== void 0) return this.#docPrSetCache;
 		const root = this.#root();
 		const ptLst = root && firstChild(root, "dgm:ptLst");
-		if (!ptLst) return null;
-		const doc = getElements(ptLst, "dgm:pt").find((pt) => attr(pt, "type") === "doc");
-		const prSet = doc && firstChild(doc, "dgm:prSet");
+		const doc = ptLst && getElements(ptLst, "dgm:pt").find((pt) => attr(pt, "type") === "doc");
+		return this.#docPrSetCache = doc && firstChild(doc, "dgm:prSet") || null;
+	}
+	#docPrSetAttr(name) {
+		const prSet = this.#docPrSet();
 		return prSet ? attr(prSet, name) : null;
 	}
+	/**
+	* The drawing index, built on first use and kept — see {@link DrawingIndex} for what that
+	* memo costs a consumer who mutates the drawing part's shape tree by hand.
+	*/
+	#drawingIndex() {
+		return this.#drawing ??= new DrawingIndex(this.#root(), this.drawingPart, this.themeContext);
+	}
 	#relPart(qname) {
 		return this.#partForRelId(attr(this.relIds, qname));
 	}
@@ -5588,7 +6290,7 @@ var TableCell = class {
 		removeChildrenByQName(tcPr, [qname]);
 		const doc = ownerDocumentOf(tcPr);
 		const ln = createElement(doc, qname);
-		if (border.widthPt !== void 0 && border.widthPt !== null) setAttr(ln, "w", String(checkFiniteEmu(border.widthPt * 12700, "widthPt", "table/invalid-cell-border")));
+		if (border.widthPt !== void 0 && border.widthPt !== null) setAttr(ln, "w", String(checkFiniteEmu(border.widthPt * EMU_PER_POINT, "widthPt", "table/invalid-cell-border")));
 		if (border.noFill) ln.appendChild(createElement(doc, "a:noFill"));
 		else if (border.schemeColor || border.color) {
 			const fill = createElement(doc, "a:solidFill");
@@ -5778,7 +6480,8 @@ var TableCell = class {
 	/**
 	* The cell's edge borders (`a:tcPr/a:lnL|lnR|lnT|lnB|lnTlToBr|lnBlToTr`), or
 	* `null` when the cell defines none. Each present edge decodes to a
-	* {@link CellBorder} (width / dash / resolved + raw colour / suppressed flag);
+	* {@link CellBorder} (width / dash / resolved colour + its raw token and transform
+	* list / suppressed flag);
 	* absent edges are `null`. Cell borders are the biggest visible table gap — a
 	* replica built only from geometry and fill draws every cell edge-to-edge with
 	* no rule, so this surfaces the per-side stroke the writer's `border` option emits.
@@ -5794,8 +6497,9 @@ var TableCell = class {
 			const scheme = this.#fillSchemeColorOf(ln);
 			const resolved = this.themeColors ? resolveSolidFillColor(ln, this.themeColors) : null;
 			return {
-				widthPt: w === null ? null : w / 12700,
+				widthPt: w === null ? null : w / EMU_PER_POINT,
 				dash: dash ? attr(dash, "val") ?? null : null,
+				resolvedColor: resolved,
 				color: resolved ? resolved.effectiveHex : null,
 				schemeColor: scheme,
 				noFill: !!firstChild(ln, "a:noFill")
@@ -5860,7 +6564,7 @@ var TableCell = class {
 		const rig = firstChild(cell3D, "a:lightRig");
 		const pts = (value) => {
 			const emu = intValue(value);
-			return emu === null ? null : emu / 12700;
+			return emu === null ? null : emu / EMU_PER_POINT;
 		};
 		return {
 			material: attr(cell3D, "prstMaterial") ?? null,
@@ -6242,6 +6946,6 @@ function findShapeByIdDeep(shapes, id) {
 	}
 }
 //#endregion
-export { collectElements as $, readPatternFill as A, zipPathToPartName as At, LST_STYLE_LEVELS as B, getOrAddChild as Bt, Picture as C, SPPR_SP3D_AFTER as Ct, Run as D, relsPartNameFor as Dt, Paragraph as E, relativePartName as Et, resolveMasterColorContext as F, descendantsByTag as Ft, placeholderInheritedRunProps as G, removeAttr as Gt, placeholderInheritedAnchor as H, intValue as Ht, resolveNotesColorContext as I, escapeXmlAttribute as It, slideDefinesColor as J, serializeXml as Jt, placeholderInheritedXfrm as K, removeChildrenByQName as Kt, resolveSlideColorContext as L, firstChild as Lt, readGradientFill as M, boolValue as Mt, resolveColorElement as N, childElements as Nt, TextFrame as O, resolveRelativePartName as Ot, resolveLayoutColorContext as P, createElement as Pt, carriedDecorations as Q, resolveSlideThemeParts as R, firstChildElement as Rt, Connector as S, SPPR_SCENE3D_AFTER as St, Shape as T, partNameToZipPath as Tt, placeholderInheritedColor as U, ownerDocumentOf as Ut, RUN_PROP_NAMES as V, insertInOrder as Vt, placeholderInheritedListStyles as W, parseXml as Wt, cSldName as X, slideDefinesProp as Y, setAttr as Yt, cSldOf as Z, ChartExAxis as _, SHAPE_AFTER_SPPR as _t, isConnector as a, fmtEntry as at, ChartAxis as b, SPPR_FILL_AFTER as bt, isPicture as c, parseClrMap as ct, Table as d, resolveSchemeToken as dt, firstShapeChild as et, TableCell as f, styleRefFill as ft, ChartEx as g, RPR_FILL_AFTER as gt, DiagramPoint as h, FILL_CHOICES as ht, isAutoShape as i, SCHEME_SLOTS as it, readPictureFill as j, attr as jt, spPrXfrmEmu as k, resolveSingleRel as kt, wrapShapeElement as l, parseClrScheme as lt, Diagram as m, substitutePhClr as mt, buildShapes as n, nvPrOf as nt, isGraphicFrame as o, intAttr as ot, TableRow as p, styleRefLine as pt, placeholderOf as q, replaceInParent as qt, findShapeByIdDeep as r, spTreeOf as rt, isGroupShape as s, isA as st, GroupShape as t, nthShapeChild as tt, GraphicFrame as u, resolveColor as ut, ChartExSeries as v, SPPR_AFTER_XFRM as vt, AutoShape as w, partNameExtension as wt, ChartSeries as x, SPPR_LN_AFTER as xt, Chart as y, SPPR_EFFECT_AFTER as yt, applyColorTransforms as z, getElements as zt };
+export { collectElements as $, spPrXfrmEmu as A, resolveRelativePartName as At, LST_STYLE_LEVELS as B, firstChildElement as Bt, Connector as C, SPPR_LN_AFTER as Ct, Paragraph as D, partNameToZipPath as Dt, Shape as E, partNameExtension as Et, resolveLayoutColorContext as F, childElements as Ft, placeholderInheritedRunProps as G, ownerDocumentOf as Gt, placeholderInheritedAnchor as H, getOrAddChild as Ht, resolveMasterColorContext as I, createElement as It, slideDefinesColor as J, removeChildrenByQName as Jt, placeholderInheritedXfrm as K, parseXml as Kt, resolveNotesColorContext as L, descendantsByTag as Lt, readPictureFill as M, zipPathToPartName as Mt, readGradientFill as N, attr as Nt, Run as O, relativePartName as Ot, resolveColorElement as P, boolValue as Pt, carriedDecorations as Q, resolveSlideColorContext as R, escapeXmlAttribute as Rt, ChartSeries as S, SPPR_FILL_AFTER as St, AutoShape as T, SPPR_SP3D_AFTER as Tt, placeholderInheritedColor as U, insertInOrder as Ut, RUN_PROP_NAMES as V, getElements as Vt, placeholderInheritedListStyles as W, intValue as Wt, cSldName as X, serializeXml as Xt, slideDefinesProp as Y, replaceInParent as Yt, cSldOf as Z, setAttr as Zt, ChartEx as _, FILL_CHOICES as _t, isConnector as a, fmtEntry as at, Chart as b, SPPR_AFTER_XFRM as bt, isPicture as c, parseClrMap as ct, Table as d, resolveSchemeToken as dt, firstShapeChild as et, TableCell as f, styleRefFill as ft, DiagramPoint as g, applyColorTransforms as gt, DiagramNode as h, presetColorHex as ht, isAutoShape as i, SCHEME_SLOTS as it, readPatternFill as j, resolveSingleRel as jt, TextFrame as k, relsPartNameFor as kt, wrapShapeElement as l, parseClrScheme as lt, Diagram as m, substitutePhClr as mt, buildShapes as n, nvPrOf as nt, isGraphicFrame as o, intAttr as ot, TableRow as p, styleRefLine as pt, placeholderOf as q, removeAttr as qt, findShapeByIdDeep as r, spTreeOf as rt, isGroupShape as s, isA as st, GroupShape as t, nthShapeChild as tt, GraphicFrame as u, resolveColor as ut, ChartExAxis as v, RPR_FILL_AFTER as vt, Picture as w, SPPR_SCENE3D_AFTER as wt, ChartAxis as x, SPPR_EFFECT_AFTER as xt, ChartExSeries as y, SHAPE_AFTER_SPPR as yt, resolveSlideThemeParts as z, firstChild as zt };
 
-//# sourceMappingURL=shapes-Dyw5bxwO.js.map
+//# sourceMappingURL=shapes-BemroU-z.js.map