@shbernal/ts-pptx 3.5.0 → 3.6.0

package/dist/{shapes-Kt51vry6.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 { M as TEXT_HORZ_OVERFLOW, N as TEXT_VERTICAL, P as checkEnumOrThrow, a as NOTES_MASTER_REL, c as OFFICE_DOCUMENT_REL, h as SLIDE_MASTER_REL, j as TEXT_ANCHORS, 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-CcKuzeuE.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,
@@ -1038,186 +1488,6 @@ function slideDefinesProp(name, run, pPr, 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.
-*/
-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;
-		}
-	}
-	return alpha === void 0 ? { hex: toHex(rgb) } : {
-		hex: toHex(rgb),
-		alpha
-	};
-}
-//#endregion
 //#region src/read/api/theme-context.ts
 /**
 * Resolve a slide's theme colour context: the slide → slideLayout → slideMaster
@@ -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
@@ -2580,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");
@@ -3083,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'`,
@@ -3266,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;
 	}
 	/**
@@ -3282,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;
 	}
 	/**
@@ -3300,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
@@ -3344,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;
 	}
 	/**
@@ -3656,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"),
@@ -3701,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
 					};
 				}
 			}
@@ -3844,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 {
@@ -4117,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,
@@ -4211,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
@@ -4460,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) {
@@ -5932,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");
@@ -6122,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.
@@ -6138,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")
@@ -6204,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,
@@ -6586,6 +6946,6 @@ function findShapeByIdDeep(shapes, id) {
 	}
 }
 //#endregion
-export { carriedDecorations as $, spPrXfrmEmu as A, resolveSingleRel as At, applyColorTransforms as B, getElements as Bt, Connector as C, SPPR_SCENE3D_AFTER as Ct, Paragraph as D, relativePartName as Dt, Shape as E, partNameToZipPath as Et, resolveLayoutColorContext as F, createElement as Ft, placeholderInheritedListStyles as G, parseXml as Gt, RUN_PROP_NAMES as H, insertInOrder as Ht, resolveMasterColorContext as I, descendantsByTag as It, placeholderOf as J, replaceInParent as Jt, placeholderInheritedRunProps as K, removeAttr as Kt, resolveNotesColorContext as L, escapeXmlAttribute as Lt, readPictureFill as M, attr as Mt, readGradientFill as N, boolValue as Nt, Run as O, relsPartNameFor as Ot, resolveColorElement as P, childElements as Pt, cSldOf as Q, resolveSlideColorContext as R, firstChild as Rt, ChartSeries as S, SPPR_LN_AFTER as St, AutoShape as T, partNameExtension as Tt, placeholderInheritedAnchor as U, intValue as Ut, LST_STYLE_LEVELS as V, getOrAddChild as Vt, placeholderInheritedColor as W, ownerDocumentOf as Wt, slideDefinesProp as X, setAttr as Xt, slideDefinesColor as Y, serializeXml as Yt, cSldName as Z, ChartEx as _, RPR_FILL_AFTER as _t, isConnector as a, SCHEME_SLOTS as at, Chart as b, SPPR_EFFECT_AFTER as bt, isPicture as c, isA as ct, Table as d, resolveColor as dt, collectElements as et, TableCell as f, resolveSchemeToken as ft, DiagramPoint as g, FILL_CHOICES as gt, DiagramNode as h, substitutePhClr as ht, isAutoShape as i, spTreeOf as it, readPatternFill as j, zipPathToPartName as jt, TextFrame as k, resolveRelativePartName as kt, wrapShapeElement as l, parseClrMap as lt, Diagram as m, styleRefLine as mt, buildShapes as n, nthShapeChild as nt, isGraphicFrame as o, fmtEntry as ot, TableRow as p, styleRefFill as pt, placeholderInheritedXfrm as q, removeChildrenByQName as qt, findShapeByIdDeep as r, nvPrOf as rt, isGroupShape as s, intAttr as st, GroupShape as t, firstShapeChild as tt, GraphicFrame as u, parseClrScheme as ut, ChartExAxis as v, SHAPE_AFTER_SPPR as vt, Picture as w, SPPR_SP3D_AFTER as wt, ChartAxis as x, SPPR_FILL_AFTER as xt, ChartExSeries as y, SPPR_AFTER_XFRM as yt, resolveSlideThemeParts as z, firstChildElement 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-Kt51vry6.js.map
+//# sourceMappingURL=shapes-BemroU-z.js.map