@shbernal/ts-pptx 4.0.1 → 4.2.0

package/dist/{shapes-re0KyQk_.js → shapes-CAPOjU0Q.js}

@@ -1,18 +1,19 @@
-import { i as PackageReadError, l as warn, n as InvalidOptionError, o as UnsupportedFeatureError, t as InternalError } from "./errors-C4oENPcu.js";
-import { F as EMU_PER_INCH, I as EMU_PER_POINT, P as ptToHundredths, b as FIXED_PCT_PER_PERCENT, k as emuToPoints, v as ANGLE_UNITS_PER_DEGREE, w as PERCENT_SCALE } from "./table-cell-margins-EVg0EwxT.js";
-import { $t as THEME_REL, E as EMBEDDED_FONT_SLOTS, Ft as OFFICE_DOCUMENT_REL, G as TEXT_HORZ_OVERFLOW, H as TEXT_ANCHORS, I as PRESET_LINE_DASHES, Jt as SLIDE_MASTER_REL, Kt as SLIDE_LAYOUT_REL, S as COLOR_MAP_TOKENS, V as SCHEME_COLOR_VALUES, X as TEXT_VERTICAL, Xt as TABLE_STYLES_CONTENT_TYPE, Y as TEXT_UNDERLINE_TYPES, Z as THEME_COLOR_SLOTS, c as checkEnumOrThrow, h as stripHash, in as OOXML_NS, jt as NOTES_MASTER_REL, on as TABLE_GRAPHIC_DATA_URI, p as isHexColor, pn as imageFormatForContentType, r as getImageSizeFromBytes, t as fitSrcRectPercents, u as boolValue, wt as IMAGE_REL } from "./image-size-CvN2iCA4.js";
+import { a as PackageReadError, n as InternalError, r as InvalidOptionError, s as UnsupportedFeatureError, u as warn } from "./entry-errors-JMthgJ2g.js";
+import { Ht as SCHEME_COLOR_VALUES, Kt as TEXT_HORZ_OVERFLOW, Lt as PRESET_LINE_DASHES, M as IMAGE_REL, Qt as THEME_COLOR_SLOTS, Tt as EMBEDDED_FONT_SLOTS, U as OFFICE_DOCUMENT_REL, Ut as TEXT_ANCHORS, Xt as TEXT_UNDERLINE_TYPES, Zt as TEXT_VERTICAL, a as getImageSizeFromBytes, dn as stripHash, et as SLIDE_LAYOUT_REL, ft as OOXML_NS, in as checkEnumOrThrow, it as TABLE_STYLES_CONTENT_TYPE, ln as isHexColor, mt as TABLE_GRAPHIC_DATA_URI, nt as SLIDE_MASTER_REL, on as boolValue, r as fitSrcRectPercents, st as THEME_REL, t as CHART_METADATA_EXT_URI, vn as imageFormatForContentType, xt as COLOR_MAP_TOKENS, z as NOTES_MASTER_REL } from "./chart-metadata-CwiTTcJq.js";
+import { F as EMU_PER_INCH, I as EMU_PER_POINT, P as ptToHundredths, b as FIXED_PCT_PER_PERCENT, k as emuToPoints, v as ANGLE_UNITS_PER_DEGREE, w as PERCENT_SCALE } from "./enums-BP9wsb9Q.js";
 import { DOMParser, MIME_TYPE, XMLSerializer, onErrorStopParsing } from "@xmldom/xmldom";
 /** Parse an XML string strictly: any well-formedness error throws. */
 function parseXml(xml) {
 	return new DOMParser({ onError: onErrorStopParsing }).parseFromString(xml, MIME_TYPE.XML_TEXT);
 }
 /**
-* Serialize a Document to an XML string. Does not pretty-print or normalize
-* whitespace. The XML declaration is not part of the DOM; callers that need
-* it (see `Part.serialize`) must prepend it themselves.
+* Serialize a Document, or one element of it, to an XML string. Does not pretty-print or
+* normalize whitespace. The XML declaration is not part of the DOM; callers that need it (see
+* `Part.serialize`) must prepend it themselves. An element is written with the namespace
+* declarations its subtree uses but inherits from an ancestor, so it stands alone.
 */
-function serializeXml(doc) {
-	return new XMLSerializer().serializeToString(doc);
+function serializeXml(node) {
+	return new XMLSerializer().serializeToString(node);
 }
 function splitQName(qname) {
 	const colon = qname.indexOf(":");
@@ -49,7 +50,7 @@ function childElements(parent) {
 * All *descendant* elements of `root` matching a namespace + local name, snapshotted into an
 * array. Unlike {@link getElements} (direct children only) this searches the whole subtree, and
 * unlike the live `HTMLCollection` that `getElementsByTagNameNS` returns, the result does not
-* change as the caller mutates the tree — which is what makes it safe to iterate while replacing
+* change as the caller mutates the tree, which is what makes it safe to iterate while replacing
 * the very elements being iterated.
 *
 * Note the DOM's own exclusion: `root` itself is never a candidate, only its descendants.
@@ -137,7 +138,7 @@ function removeAttr(element, qname) {
 * Get the first child element matching `qname`, creating and inserting it when
 * absent. A newly created element is inserted before the first existing child
 * whose qname appears in `before` (the schema successors of the new element),
-* or appended when none are present — keeping the parent's children in the
+* or appended when none are present, keeping the parent's children in the
 * sequence order OOXML mandates.
 */
 function getOrAddChild(parent, qname, before = []) {
@@ -207,7 +208,7 @@ function boolAttr(element, qname) {
 *
 * `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
+* 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
 */
@@ -262,8 +263,7 @@ function concatDrawingMLText(rich) {
 	for (const t of rich.getElementsByTagNameNS(OOXML_NS.a, "t")) out += t.textContent ?? "";
 	return out === "" ? null : out;
 }
-//#endregion
-//#region src/read/opc/partnames.ts
+// src/read/opc/partnames.ts
 /**
 * OPC partname helpers (ECMA-376 Part 2 pack-URI grammar).
 *
@@ -272,8 +272,8 @@ function concatDrawingMLText(rich) {
 */
 /**
 * Resolve the single relationship of `type` owned by `partName` to its target partname, or
-* `null` when the part declares none. For the one-of-a-kind links in a deck's spine — a slide to
-* its layout, a layout to its master, a master to its theme — where a second relationship of the
+* `null` when the part declares none. For the one-of-a-kind links in a deck's spine (a slide to
+* its layout, a layout to its master, a master to its theme), where a second relationship of the
 * same type would itself be malformed.
 *
 * The `OpcPackage` import is type-only, so this does not create a cycle with `package.ts` (which
@@ -289,7 +289,7 @@ function resolveSingleRel(opc, partName, type) {
 *
 * Ten sites in the API layer wrote the `resolveTarget` + `opc.part` pair out; two more wrote
 * the `byType(T)[0]` that precedes it (see {@link singleRelPart}). `resolveTarget` keeps its
-* throw on an id the part does not declare — a dangling `r:id` is a malformed package, not a
+* throw on an id the part does not declare: a dangling `r:id` is a malformed package, not a
 * missing part, and the graphic-frame accessors rely on the distinction.
 */
 function relPart(opc, rels, relId) {
@@ -321,7 +321,7 @@ function resolvePartName(relId, rels) {
 * {@link resolveSingleRel}, resolved the rest of the way to the {@link Part}.
 *
 * For the one-of-a-kind links in a deck's spine, where the caller wants the part rather than
-* its name — a slide to its notes slide or its layout, a layout to its master, a part to its
+* its name: a slide to its notes slide or its layout, a layout to its master, a part to its
 * `core.xml` or `app.xml`.
 */
 function singleRelPart(opc, partName, type) {
@@ -337,7 +337,7 @@ function partNameToZipPath(partName) {
 }
 /**
 * Lowercased extension without the dot, or `''` when the part has none.
-* Per OPC, the extension is everything after the last dot — so the leading
+* Per OPC, the extension is everything after the last dot, so the leading
 * dot of `/_rels/.rels` still yields `rels`.
 */
 function partNameExtension(partName) {
@@ -352,7 +352,7 @@ function relsPartNameFor(sourcePartName) {
 }
 /**
 * Build a relationship `Target` for `targetPartName` relative to its source
-* part's directory — the inverse of {@link resolveRelativePartName}. Both names
+* part's directory. It is the inverse of {@link resolveRelativePartName}. Both names
 * are absolute partnames. E.g. source `/ppt/slides/slide1.xml`, target
 * `/ppt/media/image1.png` → `../media/image1.png`.
 */
@@ -384,15 +384,14 @@ function resolveRelativePartName(sourcePartName, target) {
 	}
 	return `/${segments.join("/")}`;
 }
-//#endregion
-//#region src/ooxml/sequence.ts
+// src/ooxml/sequence.ts
 /**
 * Schema child-sequence order for the OOXML complexTypes both halves of the library insert into.
 *
 * **What these are for.** `getOrAddChild(parent, qname, before)` / `insertInOrder(parent, node,
 * before)` place a newly created child before the first sibling named in `before`. So `before`
 * must list exactly the children that legally *follow* the one being inserted. Get it wrong and
-* the part is schema-invalid — which PowerPoint reports as a corrupt file, not as a bad option,
+* the part is schema-invalid, which PowerPoint reports as a corrupt file, not as a bad option,
 * so the failure surfaces far from its cause with no compile-time signal.
 *
 * **Why they are derived, not written out.** These successor lists used to be hand-maintained,
@@ -409,7 +408,7 @@ function resolveRelativePartName(sourcePartName, target) {
 * both are bound by the same ECMA-376 sequence.
 */
 /**
-* `EG_FillProperties` — the mutually exclusive fill choices, in schema order.
+* `EG_FillProperties`: the mutually exclusive fill choices, in schema order.
 * @see ECMA-376 Part 1 §20.1.8 (DrawingML fill group)
 */
 const FILL_CHOICES = [
@@ -420,16 +419,16 @@ const FILL_CHOICES = [
 	"a:pattFill",
 	"a:grpFill"
 ];
-/** `EG_EffectProperties` — the two mutually exclusive effect containers. */
+/** `EG_EffectProperties`: the two mutually exclusive effect containers. */
 const EFFECT_CHOICES = ["a:effectLst", "a:effectDag"];
-/** `EG_Geometry` — the two mutually exclusive geometry choices. */
+/** `EG_Geometry`: the two mutually exclusive geometry choices. */
 const GEOMETRY_CHOICES = ["a:custGeom", "a:prstGeom"];
 /**
 * Everything that legally follows `member` in `sequence`, flattened.
 *
 * `member` may name a single element or any member of a choice group; either way the result
 * starts after the step it occupies, so a choice member never lists its own siblings. Throws on
-* an unknown name rather than returning `[]` — an empty successor list silently *appends*, which
+* an unknown name rather than returning `[]`. An empty successor list silently *appends*, which
 * is exactly the corruption these lists exist to prevent, so a typo must fail loudly and at
 * module-load time rather than produce a subtly out-of-order part at run time.
 */
@@ -456,7 +455,7 @@ const SPPR_SEQUENCE = [
 * `CT_Shape` (`p:sp`), in declaration order.
 *
 * `p:pic` (`CT_Picture`) and `p:cxnSp` (`CT_Connector`) are not this type, but their successors
-* of `p:spPr` are a *subset* of this one's in the same relative order — both run `p:spPr`,
+* of `p:spPr` are a *subset* of this one's in the same relative order: both run `p:spPr`,
 * `p:style`, `p:extLst` and neither has a `p:txBody`. So {@link SHAPE_AFTER_SPPR} serves all
 * three: naming an element that cannot occur in a given parent is inert, because the successor
 * list is only ever matched against children that are actually there.
@@ -471,7 +470,7 @@ const SP_SEQUENCE = [
 ];
 /**
 * `CT_GroupShapeProperties` (`p:grpSpPr`), in declaration order. A group carries no `a:ln` and
-* no `a:sp3d` — which is exactly why it needs its own successor lists rather than borrowing the
+* no `a:sp3d`, which is exactly why it needs its own successor lists rather than borrowing the
 * shape ones.
 * @see ECMA-376 Part 1 §20.1.2.2.19
 */
@@ -557,7 +556,7 @@ const TCPR_SEQUENCE = [
 	"a:extLst"
 ];
 /**
-* For each `a:tcPr` child, the children that must follow it — i.e. what a new one is inserted
+* For each `a:tcPr` child, the children that must follow it, i.e. what a new one is inserted
 * *before*. Every child gets an entry, so a caller can look one up by qname.
 */
 const TCPR_AFTER = Object.fromEntries(TCPR_SEQUENCE.map((qname, index) => [qname, TCPR_SEQUENCE.slice(index + 1)]));
@@ -578,13 +577,13 @@ const GRPSPPR_AFTER_XFRM = successorsOf(GRPSPPR_SEQUENCE, "a:xfrm");
 /** Successors of a fill choice inside `p:grpSpPr`. */
 const GRPSPPR_FILL_AFTER = successorsOf(GRPSPPR_SEQUENCE, "a:solidFill");
 /**
-* Successors of `p:grpSpPr` within `p:grpSp` — every drawable child, plus `p:contentPart` and
+* Successors of `p:grpSpPr` within `p:grpSp`: every drawable child, plus `p:contentPart` and
 * `p:extLst`. Derived rather than written out, which is the whole point of this module: the
 * literal it replaces named five of the seven.
 */
 const GROUP_AFTER_GRPSPPR = successorsOf(GROUP_SHAPE_SEQUENCE, "p:grpSpPr");
 /**
-* Successors of `p:spPr` within `p:sp`, and equally within `p:pic` / `p:cxnSp` — see
+* Successors of `p:spPr` within `p:sp`, and equally within `p:pic` / `p:cxnSp`. See
 * {@link SP_SEQUENCE} for why one list covers all three. `p:blipFill` and the `p:nv*Pr` wrapper
 * precede `p:spPr`, so slicing the sequence drops them without anyone having to remember to.
 */
@@ -601,8 +600,8 @@ const RPR_FILL_AFTER = successorsOf(RPR_SEQUENCE, "a:solidFill");
 /** Successors of `a:latin` inside `a:rPr` (and `a:defRPr`/`a:endParaRPr`). */
 const RPR_LATIN_AFTER = successorsOf(RPR_SEQUENCE, "a:latin");
 /**
-* `CT_Presentation` (`p:presentation`), in declaration order. Every child is a single element —
-* there are no choice groups — so the declaration is a plain string list.
+* `CT_Presentation` (`p:presentation`), in declaration order. Every child is a single element
+* (there are no choice groups), so the declaration is a plain string list.
 * @see ECMA-376 Part 1 §19.2.1.26
 */
 const PRESENTATION_SEQUENCE = [
@@ -638,7 +637,7 @@ const PRESENTATION_AFTER_EMBEDDED_FONT_LST = successorsOf(PRESENTATION_SEQUENCE,
 */
 const EMBEDDED_FONT_ENTRY_SEQUENCE = ["p:font", ...EMBEDDED_FONT_SLOTS.map((slot) => `p:${slot}`)];
 /**
-* For each `p:embeddedFont` child, the children that must follow it — i.e. what a new one is
+* For each `p:embeddedFont` child, the children that must follow it, i.e. what a new one is
 * inserted *before*. Every child gets an entry, so a caller can look one up by qname.
 */
 const EMBEDDED_FONT_ENTRY_AFTER = Object.fromEntries(EMBEDDED_FONT_ENTRY_SEQUENCE.map((qname, index) => [qname, EMBEDDED_FONT_ENTRY_SEQUENCE.slice(index + 1)]));
@@ -731,8 +730,7 @@ const TEXT_BODY_SEQUENCE = [
 const TXBODY_AFTER_BODYPR = successorsOf(TEXT_BODY_SEQUENCE, "a:bodyPr");
 /** Successors of `a:lstStyle` inside a text body. */
 const TXBODY_AFTER_LSTSTYLE = successorsOf(TEXT_BODY_SEQUENCE, "a:lstStyle");
-//#endregion
-//#region src/read/oxml/color-transform.ts
+// 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
@@ -744,22 +742,22 @@ const TXBODY_AFTER_LSTSTYLE = successorsOf(TEXT_BODY_SEQUENCE, "a:lstStyle");
 * 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
+* Colour-space model (verified against PowerPoint output; see
+* `test/read/color-transform.test.ts`): 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
+*  - `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
+*  - `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
+*  - `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
+*  - `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
@@ -854,8 +852,8 @@ function hslToRgb({ h, s, l }) {
 /**
 * 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
+* 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.
@@ -877,7 +875,7 @@ function hslClrToHex(hue, sat, lum) {
 /**
 * 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
+* 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
@@ -960,15 +958,14 @@ function applyColorTransforms(baseHex, transforms) {
 		alpha
 	};
 }
-//#endregion
-//#region src/read/oxml/fill.ts
+// src/read/oxml/fill.ts
 /**
 * Shared solid-fill read/mutation helpers for DrawingML colour-bearing parents:
 * a run's `a:rPr`, a shape's `p:spPr` / `p:grpSpPr`, and a line's `a:ln`.
 *
 * A parent carries at most one `EG_FillProperties` choice, so setting a solid
 * fill first clears any competing choice, then inserts `a:solidFill` in document
-* order. These helpers never mark a part dirty — callers own that.
+* order. These helpers never mark a part dirty; callers own that.
 */
 /** Normalize a 6-hex RGB string (optional leading `#`) to upper-case, or throw. */
 function normalizeHex(value) {
@@ -1062,18 +1059,17 @@ function setSolidFill(parent, afterOrder, color) {
 	setAttr(clr, "val", color.val);
 	fill.appendChild(clr);
 }
-//#endregion
-//#region src/read/oxml/preset-color.ts
+// 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 —
+* 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…`;
+*    (`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.
 *
@@ -1084,7 +1080,7 @@ function setSolidFill(parent, afterOrder, color) {
 *
 * 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,
+* `test/read/preset-color.test.ts`. A name the reader cannot resolve is a hole in the table,
 * and that test is what finds it.
 */
 /**
@@ -1248,8 +1244,7 @@ function presetColorHex(name) {
 	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
+// src/read/oxml/theme.ts
 /**
 * Theme colour resolution: turning a DrawingML colour reference or a style-matrix reference into
 * something literal.
@@ -1269,7 +1264,7 @@ function presetColorHex(name) {
 *   order to *bake* it into a slide.
 *
 * They must agree, so they share this. The passes that write results back into a part live with
-* the other import operations, not here — this module deliberately has no mutating exports.
+* the other import operations, not here; this module deliberately has no mutating exports.
 * Placeholder-inheritance resolution (what a placeholder gets from its layout/master chain) is
 * its own concern and lives in `placeholder-inherit.ts`.
 */
@@ -1323,8 +1318,8 @@ function isA(el, local) {
 * `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.
+* 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;
@@ -1349,7 +1344,7 @@ function themeElementsOfRoot(themeRoot) {
 * 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 —
+* `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) {
@@ -1399,11 +1394,11 @@ function resolveThemeFont(typeface, fontScheme) {
 }
 /**
 * Swap one colour element for another, MOVING the old element's transform children onto the new
-* one — and, optionally, seeding it with a set of transforms of its own first.
+* one and, optionally, seeding it with a set of transforms of its own first.
 *
 * The move is the whole rule the flatten path exists to preserve: only the base reference is
 * swapped, never the transform math. Three sites implemented it and a fourth cloned instead of
-* moving, each with its own `while (old.firstChild) …` loop — duplication of exactly the one
+* moving, each with its own `while (old.firstChild) …` loop: duplication of exactly the one
 * invariant that must not vary.
 *
 * Transform ORDER matters and is the reason `seed` is separate: `substitutePhClr` puts the
@@ -1438,7 +1433,7 @@ function fmtEntry(ctx, listName, idx) {
 	return entry ? entry.cloneNode(true) : null;
 }
 /**
-* Build the explicit fill element a `p:style` `a:fillRef` resolves to — the indexed
+* Build the explicit fill element a `p:style` `a:fillRef` resolves to: the indexed
 * `fmtScheme` `fillStyleLst`/`bgFillStyleLst` entry (deep-cloned) with its `phClr`
 * replaced by the ref's resolved colour. Pure: mutates neither the ref nor the
 * theme. `null` when the ref is absent, `idx` is 0/unset, or the entry or its
@@ -1456,7 +1451,7 @@ function styleRefFill(fillRef, ctx) {
 	return fill;
 }
 /**
-* Build the explicit `a:ln` element a `p:style` `a:lnRef` resolves to — the indexed
+* Build the explicit `a:ln` element a `p:style` `a:lnRef` resolves to: the indexed
 * `fmtScheme` `lnStyleLst` entry (deep-cloned) with its `phClr` replaced by the
 * ref's resolved colour. Pure; the line/read counterpart of {@link styleRefFill}.
 */
@@ -1470,13 +1465,12 @@ function styleRefLine(lnRef, ctx) {
 	substitutePhClr(ln, ref);
 	return ln;
 }
-//#endregion
-//#region src/read/oxml/slide-dom.ts
+// src/read/oxml/slide-dom.ts
 /**
 * The `p:cSld` of a slide/layout/master/notes part root.
 *
 * Takes a nullable root and returns a nullable element so a caller can chain from
-* `part?.dom.documentElement` without a guard of its own — which is what a dozen callers were
+* `part?.dom.documentElement` without a guard of its own, which is what a dozen callers were
 * writing by hand, each in a slightly different spelling (`root && …`, `root ? … : null`).
 */
 function cSldOf(root) {
@@ -1490,8 +1484,8 @@ function spTreeOf(root) {
 /**
 * The `p:nvPr` of a shape, whichever `*nvPr` wrapper its kind uses.
 *
-* The wrapper's name varies by shape kind — `p:nvSpPr` on a `p:sp`, `p:nvPicPr` on a `p:pic`,
-* `p:nvGraphicFramePr`, `p:nvCxnSpPr`, `p:nvGrpSpPr` — but it is always the shape's first child
+* The wrapper's name varies by shape kind (`p:nvSpPr` on a `p:sp`, `p:nvPicPr` on a `p:pic`,
+* `p:nvGraphicFramePr`, `p:nvCxnSpPr`, `p:nvGrpSpPr`), but it is always the shape's first child
 * element, and `p:nvPr` is always inside it. Taking the first child element rather than naming
 * the wrapper is what lets one helper serve every kind; the callers that named `p:nvSpPr`
 * silently returned null on a picture.
@@ -1633,8 +1627,7 @@ function collectElements(node, out) {
 	out.push(node);
 	for (let child = node.firstChild; child; child = child.nextSibling) if (child.nodeType === 1) collectElements(child, out);
 }
-//#endregion
-//#region src/read/oxml/placeholder-inherit.ts
+// src/read/oxml/placeholder-inherit.ts
 /**
 * Resolving what a placeholder shape *inherits* from its source layout/master chain.
 *
@@ -1783,6 +1776,22 @@ function lstStyleLevelDefRPr(listStyle, level) {
 	const lvl = firstChild(listStyle, `a:lvl${level + 1}pPr`) ?? firstChild(listStyle, "a:defPPr");
 	return lvl ? firstChild(lvl, "a:defRPr") : null;
 }
+/**
+* The paragraph properties for `level` (0-based) in a `CT_TextListStyle`: the level-specific
+* `a:lvlNpPr`, else the `a:defPPr` fallback, as {@link lstStyleLevelDefRPr} reads them.
+*/
+function lstStyleLevel(listStyle, level) {
+	if (!listStyle) return null;
+	return firstChild(listStyle, `a:lvl${level + 1}pPr`) ?? firstChild(listStyle, "a:defPPr");
+}
+/**
+* The paragraph-property tiers a placeholder's paragraph at `level` inherits from, most specific
+* first: each source list style's level element. The paragraph-level twin of
+* {@link placeholderInheritedDefRPrs}.
+*/
+function placeholderInheritedLevels(type, idx, level, ctx) {
+	return styleTiers(type, idx, ctx).map((tier) => lstStyleLevel(tier, level)).filter((t) => t !== null);
+}
 /** The `a:solidFill` of a level's `a:defRPr`, or `null` when none is defined there. */
 function lstStyleLevelFill(listStyle, level) {
 	const defRPr = lstStyleLevelDefRPr(listStyle, level);
@@ -1934,15 +1943,14 @@ function slideDefinesProp(name, run, pPr, slideLst, level) {
 	const slideDefRPr = lstStyleLevelDefRPr(slideLst, level);
 	return !!(slideDefRPr && attr(slideDefRPr, name) != null);
 }
-//#endregion
-//#region src/read/api/coords.ts
+// src/read/api/coords.ts
 /**
-* ts-pptx: units at the read model's boundary — validated on the way in, converted on the way out.
+* pptx-ts: units at the read model's boundary, validated on the way in and converted on the way out.
 *
 * Every read-side setter that takes a measurement has to answer the same two questions before
 * the value reaches an attribute: is it finite, and (for an extent) is it positive. `NaN` or
 * `Infinity` written verbatim makes the part invalid, and silently coercing it to something
-* drawable is exactly the footgun the project's API policy rules out — so both are a throw.
+* drawable is exactly the footgun the project's API policy rules out, so both are a throw.
 *
 * The two halves used to be split across `table-edit.ts` (threw, then rounded) and `slide.ts`
 * (threw only, with the rounding done eight lines later at each build site), under two spellings
@@ -1960,7 +1968,7 @@ function checkFiniteEmu(value, field, code = "coord/non-finite") {
 	return Math.round(value);
 }
 /**
-* As {@link checkFiniteEmu}, and additionally rejects a non-positive value — the guard an
+* As {@link checkFiniteEmu}, and additionally rejects a non-positive value: the guard an
 * *extent* needs, since `ST_PositiveCoordinate` has no room for zero or below and a zero-size
 * shape is a degenerate result rather than a small one.
 */
@@ -1989,8 +1997,8 @@ function checkLineWidthEmu(value, field, code) {
 * insets in points while the DOM stores EMU, so `x === null ? null : x / EMU_PER_POINT` stood at
 * five getters across `chart.ts`, `shapes/base.ts`, `table.ts` and `text.ts`.
 *
-* The accumulator sites whose target is `number | undefined` do not come through here —
-* propagating a `null` would only have to be unwrapped again — but they do not open-code the
+* The accumulator sites whose target is `number | undefined` do not come through here
+* (propagating a `null` would only have to be unwrapped again), but they do not open-code the
 * division either: they unwrap the `null` themselves and call `emuToPoints`. {@link emuToPoints}
 * states the whole policy and names the one place still allowed to divide inline.
 */
@@ -2015,8 +2023,7 @@ function ptFromEmu(emu) {
 function ptFromHundredths(value) {
 	return value === null ? null : value / 100;
 }
-//#endregion
-//#region src/read/api/shapes/geometry.ts
+// src/read/api/shapes/geometry.ts
 /**
 * Reading geometry out of a shape: transform boxes, rotation and flips, and custom-geometry paths.
 *
@@ -2024,12 +2031,18 @@ function ptFromHundredths(value) {
 * readers with no theme or relationship context.
 */
 /**
-* One `a:pt` coordinate as a raw path-unit integer. A guide-name reference
-* (the `ST_AdjCoordinate` string form) is not produced by authored freeforms;
-* a non-numeric value degrades to `0` rather than crashing (documented edge).
+* An `ST_AdjCoordinate` attribute of a path segment: a raw path-unit integer, or the guide name it
+* references (the string form). Absent reads `0`.
 */
-function ptAxis(pt, axis) {
-	return (pt ? numberValue(attr(pt, axis)) : null) ?? 0;
+function adjValue(element, name) {
+	const value = element ? attr(element, name) : null;
+	if (value === null || value === "") return 0;
+	return numberValue(value) ?? value;
+}
+/** An `ST_AdjAngle` attribute of an `arcTo` in degrees, or the guide name it references. Absent reads `0`. */
+function adjAngle(seg, name) {
+	const value = adjValue(seg, name);
+	return typeof value === "number" ? value / ANGLE_UNITS_PER_DEGREE : value;
 }
 /** Parse one `<a:path>` into its viewport attrs (with schema defaults) and ordered segments. */
 function readGeometryPath(path) {
@@ -2043,44 +2056,44 @@ function readGeometryPath(path) {
 			case "moveTo":
 				commands.push({
 					cmd: "moveTo",
-					x: ptAxis(pts[0], "x"),
-					y: ptAxis(pts[0], "y")
+					x: adjValue(pts[0], "x"),
+					y: adjValue(pts[0], "y")
 				});
 				break;
 			case "lnTo":
 				commands.push({
 					cmd: "lnTo",
-					x: ptAxis(pts[0], "x"),
-					y: ptAxis(pts[0], "y")
+					x: adjValue(pts[0], "x"),
+					y: adjValue(pts[0], "y")
 				});
 				break;
 			case "cubicBezTo":
 				commands.push({
 					cmd: "cubicBezTo",
-					x1: ptAxis(pts[0], "x"),
-					y1: ptAxis(pts[0], "y"),
-					x2: ptAxis(pts[1], "x"),
-					y2: ptAxis(pts[1], "y"),
-					x: ptAxis(pts[2], "x"),
-					y: ptAxis(pts[2], "y")
+					x1: adjValue(pts[0], "x"),
+					y1: adjValue(pts[0], "y"),
+					x2: adjValue(pts[1], "x"),
+					y2: adjValue(pts[1], "y"),
+					x: adjValue(pts[2], "x"),
+					y: adjValue(pts[2], "y")
 				});
 				break;
 			case "quadBezTo":
 				commands.push({
 					cmd: "quadBezTo",
-					x1: ptAxis(pts[0], "x"),
-					y1: ptAxis(pts[0], "y"),
-					x: ptAxis(pts[1], "x"),
-					y: ptAxis(pts[1], "y")
+					x1: adjValue(pts[0], "x"),
+					y1: adjValue(pts[0], "y"),
+					x: adjValue(pts[1], "x"),
+					y: adjValue(pts[1], "y")
 				});
 				break;
 			case "arcTo":
 				commands.push({
 					cmd: "arcTo",
-					wR: numberValue(attr(seg, "wR")) ?? 0,
-					hR: numberValue(attr(seg, "hR")) ?? 0,
-					stAng: (numberValue(attr(seg, "stAng")) ?? 0) / ANGLE_UNITS_PER_DEGREE,
-					swAng: (numberValue(attr(seg, "swAng")) ?? 0) / ANGLE_UNITS_PER_DEGREE
+					wR: adjValue(seg, "wR"),
+					hR: adjValue(seg, "hR"),
+					stAng: adjAngle(seg, "stAng"),
+					swAng: adjAngle(seg, "swAng")
 				});
 				break;
 			case "close": commands.push({ cmd: "close" });
@@ -2120,17 +2133,16 @@ function transformFlipH(xfrm) {
 function transformFlipV(xfrm) {
 	return boolValue(attr(xfrm, "flipV")) === true;
 }
-//#endregion
-//#region src/read/api/theme-context.ts
+// src/read/api/theme-context.ts
 /**
 * Resolve a slide's theme colour context: the slide → slideLayout → slideMaster
 * → theme walk that turns a `schemeClr` token into a literal hex, plus the
 * `a:solidFill` helper the read-model colour getters share.
 *
-* One implementation backs two callers — the read-model getters
+* One implementation backs two callers: the read-model getters
 * (`Slide.themeContext` → `Shape.resolvedFill` / `Run.resolvedColor`) and the
 * `importSlide` `theme: 'preserve'` flatten path, which layers its `fmtScheme` /
-* background needs on top of {@link resolveSlideThemeParts} — so a token resolves
+* background needs on top of {@link resolveSlideThemeParts}. So a token resolves
 * identically whether it is read or baked.
 */
 /** The document element of a part, or `null` when the partname/part is absent. */
@@ -2140,7 +2152,7 @@ function documentElement(opc, partName) {
 /**
 * The presentation's `p:defaultTextStyle` (`presentation.xml`, reached via the
 * package `officeDocument` relationship), or `null` when absent. This is
-* PowerPoint's lowest-priority text fallback — the bottom tier of a slide run's
+* PowerPoint's lowest-priority text fallback: the bottom tier of a slide run's
 * size/colour/face/bold resolution (see `ThemeContext.defaultTextStyle`).
 */
 function presentationDefaultTextStyle(opc) {
@@ -2207,7 +2219,7 @@ function resolveSlideColorContext(opc, parts) {
 * are deliberately left absent. Instead the notesMaster's `p:notesStyle` is carried
 * as `notesStyle`, and the notes body `TextFrame` is built with a placeholder
 * context (see `NotesPlaceholder`) so a body run's
-* effective size/face/bold (and inherited colour) resolve against it — the notes
+* effective size/face/bold (and inherited colour) resolve against it, the notes
 * analogue of the slide placeholder chain. The maps are empty when the
 * notesMaster/theme chain is incomplete, in which case tokens stay unresolved.
 */
@@ -2226,7 +2238,7 @@ function resolveNotesColorContext(opc, notesPartName) {
 * The colour context a *slide master*'s own getters resolve against: the master's
 * `p:clrMap` plus its theme's `clrScheme`/`fmtScheme`/`fontScheme` (walked master →
 * theme). Backs the text frames of `SlideMaster`'s
-* placeholders — a master placeholder run's own `schemeClr` resolves to a literal
+* placeholders: a master placeholder run's own `schemeClr` resolves to a literal
 * hex the same way a slide run's does. `masterRoot` is carried so an inherited
 * placeholder value still resolves against the master's own text styles. The maps
 * are empty when the theme is missing, in which case tokens stay unresolved.
@@ -2245,7 +2257,7 @@ function resolveMasterColorContext(opc, masterPartName) {
 * The colour context a *slide layout*'s own getters resolve against: walk layout →
 * master → theme. The effective `clrMap` is the layout's own
 * `p:clrMapOvr/a:overrideClrMapping` when present (rare), else the master's
-* `p:clrMap` — the layout's usual `a:masterClrMapping` means "inherit the master
+* `p:clrMap`. The layout's usual `a:masterClrMapping` means "inherit the master
 * map". `clrScheme`/`fmtScheme`/`fontScheme` come from the master's theme, and both
 * `layoutRoot`/`masterRoot` are carried for inherited-placeholder resolution. Backs
 * the text frames of `SlideLayout`'s placeholders.
@@ -2297,8 +2309,8 @@ function themeElementsOf(opc, themePartName) {
 * The colour a run effectively renders when its own `a:rPr` defines none,
 * resolved to a full {@link ResolvedColor}. Walks the inheritance the way
 * PowerPoint does: the paragraph's `a:pPr/a:defRPr` colour, then the slide text
-* body's `a:lstStyle` colour for the run's `level`, then — only for a placeholder
-* run — the placeholder's layout → master → master-`p:txStyles` chain (via
+* body's `a:lstStyle` colour for the run's `level`, then (only for a placeholder
+* run) the placeholder's layout → master → master-`p:txStyles` chain (via
 * {@link placeholderInheritedFill}), then the presentation's `p:defaultTextStyle`
 * for the run's level (`ctx.defaultTextStyle`). The first tier that defines a
 * colour wins. `ph` is `null` for a non-placeholder run, which skips the
@@ -2321,11 +2333,11 @@ function resolveInheritedRunColor(ph, level, pPr, slideLstStyle, ctx) {
 /**
 * The `a:defRPr` tiers a run resolves an inherited character property against, in
 * priority order: the paragraph's `a:pPr/a:defRPr`, then the slide text body's
-* `a:lstStyle` level `a:defRPr`, then — only for a placeholder run — the
+* `a:lstStyle` level `a:defRPr`, then (only for a placeholder run) the
 * placeholder's layout → master → master-`p:txStyles` chain (via
 * {@link placeholderInheritedDefRPrs}), then the presentation's
 * `p:defaultTextStyle` level `a:defRPr` (`ctx.defaultTextStyle`). The first tier
-* that defines the property wins — each property resolves independently, mirroring
+* that defines the property wins; each property resolves independently, mirroring
 * how the colour resolver walks the same chain. `ph` is `null` for a
 * non-placeholder run, which skips the placeholder chain but still reaches
 * `p:defaultTextStyle`.
@@ -2380,8 +2392,8 @@ function resolveInheritedRunFontFace(ph, level, pPr, slideLstStyle, ctx) {
 * {@link resolveInheritedRunSize}: the first `a:defRPr/@<name>` in the paragraph →
 * slide → (placeholder) layout → master → `p:txStyles` → `p:defaultTextStyle`
 * 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
+* 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 resolveInheritedRunFlag(name, ph, level, pPr, slideLstStyle, ctx) {
@@ -2446,8 +2458,8 @@ function resolveInheritedFrame(ph, ctx) {
 }
 /**
 * 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,
+* `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.
@@ -2502,7 +2514,7 @@ function resolveSolidFillColor(container, ctx) {
 * `Shape.resolvedFill` when the shape carries no
 * explicit `spPr` fill choice. `null` when there is no `fillRef`, it cannot be
 * resolved, or the indexed style entry is not a solid fill (a gradient style fill
-* has no single colour — read it through `gradientStops` instead).
+* has no single colour; read it through `gradientStops` instead).
 */
 function resolveStyleFillColor(shape, ctx) {
 	const style = firstChild(shape, "p:style");
@@ -2523,7 +2535,7 @@ function resolveStyleLineColor(shape, ctx) {
 }
 /**
 * Resolve the text colour and typeface a shape derives from its `p:style/a:fontRef`
-* (the style-matrix font reference) — the tier PowerPoint applies to a shape's runs
+* (the style-matrix font reference): the tier PowerPoint applies to a shape's runs
 * just below their own `a:rPr` and above the placeholder/`p:defaultTextStyle` chain.
 * The `a:fontRef` child colour resolves through `ctx` like any other (it can carry
 * `lumMod`/`shade` transforms); `@idx` (`major`|`minor`|`none`) maps to the theme's
@@ -2541,54 +2553,12 @@ function resolveStyleFontRef(shape, ctx) {
 		face: token ? resolveThemeFont(token, ctx.fontScheme ?? null) : null
 	};
 }
-//#endregion
-//#region src/read/api/gradient.ts
-/**
-* Shared gradient-fill reader for DrawingML colour-bearing containers: a shape's
-* `p:spPr`, a line's `a:ln`, and a slide's `p:bg/p:bgPr`. Decodes an `a:gradFill`
-* into its stops (colour + position) plus the linear/path geometry, resolving each
-* stop's colour against the slide theme.
-*/
-/**
-* Read `a:gradFill/a:gsLst` stops from a container (`p:spPr` for a fill, `a:ln`
-* for a line stroke, or `p:bgPr` for a slide background). `null` when the
-* container has no gradient; `[]` when the gradient carries no stop list.
-*/
-function readGradientStops(container, ctx) {
-	const grad = firstChild(container, "a:gradFill");
-	if (!grad) return null;
-	const gsLst = firstChild(grad, "a:gsLst");
-	if (!gsLst) return [];
-	return getElements(gsLst, "a:gs").map((gs) => ({
-		position: pctAttr(gs, "pos"),
-		colorRef: readColorRef(firstChildElement(gs), ctx)
-	}));
-}
-/**
-* Read the full `a:gradFill` (stops + linear angle / path shape) from a container
-* (`p:spPr` for a fill, `a:ln` for a line stroke, or `p:bgPr` for a slide
-* background). `null` when the container has no gradient.
-*/
-function readGradientFill(container, ctx) {
-	const grad = firstChild(container, "a:gradFill");
-	if (!grad) return null;
-	const lin = firstChild(grad, "a:lin");
-	const path = firstChild(grad, "a:path");
-	const ang = lin ? numberValue(attr(lin, "ang")) : null;
-	return {
-		kind: lin ? "linear" : path ? "path" : null,
-		angleDeg: ang === null ? null : ang / ANGLE_UNITS_PER_DEGREE,
-		path: path ? attr(path, "path") ?? null : null,
-		stops: readGradientStops(container, ctx) ?? []
-	};
-}
-//#endregion
-//#region src/read/api/picture-fill.ts
+// src/read/api/picture-fill.ts
 /**
 * Shared picture-fill reader for DrawingML fill-bearing containers: a shape's
 * `p:spPr`, a table cell's `a:tcPr`, and a slide's `p:bg/p:bgPr`. Decodes an
 * `a:blipFill` into the embedded image reference plus the geometry that decides
-* how the image covers the surface — stretch vs tile, the source crop, and the
+* how the image covers the surface: stretch vs tile, the source crop, and the
 * tile offsets/scale.
 *
 * A picture fill is not a colour, so the solid-fill accessors
@@ -2619,7 +2589,7 @@ function readTile(tile) {
 }
 /**
 * Read an `a:blipFill` from a container (`p:spPr`, `a:tcPr`, or `p:bgPr`) into a
-* {@link PictureFill}. `rels` — the *owning part's* relationships — resolves the
+* {@link PictureFill}. `rels` (the *owning part's* relationships) resolves the
 * blip's `r:embed` to an absolute partname; pass `null` (or omit) to read the
 * geometry without resolving the image. `null` when the container's fill is not
 * a picture.
@@ -2647,14 +2617,57 @@ function readPictureFill(container, rels = null) {
 		rotWithShape: boolValue(attr(blipFill, "rotWithShape"))
 	};
 }
-//#endregion
-//#region src/read/api/pattern-fill.ts
+// src/read/api/gradient.ts
+/**
+* Shared gradient-fill reader for DrawingML colour-bearing containers: a shape's
+* `p:spPr`, a line's `a:ln`, and a slide's `p:bg/p:bgPr`. Decodes an `a:gradFill`
+* into its stops (colour + position) plus the linear/path geometry, resolving each
+* stop's colour against the slide theme.
+*/
+/**
+* Read `a:gradFill/a:gsLst` stops from a container (`p:spPr` for a fill, `a:ln`
+* for a line stroke, or `p:bgPr` for a slide background). `null` when the
+* container has no gradient; `[]` when the gradient carries no stop list.
+*/
+function readGradientStops(container, ctx) {
+	const grad = firstChild(container, "a:gradFill");
+	if (!grad) return null;
+	const gsLst = firstChild(grad, "a:gsLst");
+	if (!gsLst) return [];
+	return getElements(gsLst, "a:gs").map((gs) => ({
+		position: pctAttr(gs, "pos"),
+		colorRef: readColorRef(firstChildElement(gs), ctx)
+	}));
+}
+/**
+* Read the full `a:gradFill` (stops + linear angle / path shape) from a container
+* (`p:spPr` for a fill, `a:ln` for a line stroke, or `p:bgPr` for a slide
+* background). `null` when the container has no gradient.
+*/
+function readGradientFill(container, ctx) {
+	const grad = firstChild(container, "a:gradFill");
+	if (!grad) return null;
+	const lin = firstChild(grad, "a:lin");
+	const path = firstChild(grad, "a:path");
+	const ang = lin ? numberValue(attr(lin, "ang")) : null;
+	const focus = path ? firstChild(path, "a:fillToRect") : null;
+	return {
+		kind: lin ? "linear" : path ? "path" : null,
+		angleDeg: ang === null ? null : ang / ANGLE_UNITS_PER_DEGREE,
+		path: path ? attr(path, "path") ?? null : null,
+		stops: readGradientStops(container, ctx) ?? [],
+		rotateWithShape: boolAttr(grad, "rotWithShape"),
+		scaled: lin ? boolAttr(lin, "scaled") : null,
+		focusRect: focus ? readRect(focus) : null
+	};
+}
+// src/read/api/pattern-fill.ts
 /**
 * Shared pattern-fill reader for DrawingML colour-bearing containers: a shape's `p:spPr`, a
 * slide's `p:bg/p:bgPr`, and a table's `a:tblPr` / cell's `a:tcPr`.
 *
 * `a:pattFill` is a preset hatch name plus two wrapped colours, and decoding it is three
-* lines — which is exactly why it had been open-coded in each place that needed it. Sharing
+* lines, which is exactly why it had been open-coded in each place that needed it. Sharing
 * it is what keeps the three from drifting into different answers for the same element, the
 * same reason `readGradientFill` and
 * `readPictureFill` are shared.
@@ -2678,8 +2691,7 @@ function readPatternFill(container, ctx) {
 		background: colorOf("a:bgClr")
 	};
 }
-//#endregion
-//#region src/read/api/shapes/oxml.ts
+// src/read/api/shapes/oxml.ts
 /**
 * Shape-element plumbing: the small element lookups every shape kind performs, plus the
 * shape-scoped re-exports of the shared schema-successor lists.
@@ -2707,8 +2719,7 @@ function emuFrom(parent, qname, attribute) {
 function getOrAddSpPrXfrm(shapeElement) {
 	return getOrAddChild(getOrAddChild(shapeElement, "p:spPr", SHAPE_AFTER_SPPR), "a:xfrm", SPPR_AFTER_XFRM);
 }
-//#endregion
-//#region src/read/api/shapes/group-transform.ts
+// src/read/api/shapes/group-transform.ts
 /** Normalise a degree value into [0, 360). */
 function normalizeDegrees(value) {
 	return (value % 360 + 360) % 360;
@@ -2733,8 +2744,8 @@ function rotatePoint(point, center, degrees) {
 * `groups` runs **innermost first** (the shape's immediate `p:grpSp` parent, then
 * outward). An empty list returns the shape's own box and orientation unchanged.
 *
-* The returned `box` is the *unrotated* placement box — the same box PowerPoint
-* writes when you Ungroup — with the effective rotation reported separately.
+* The returned `box` is the *unrotated* placement box (the same box PowerPoint
+* writes when you Ungroup), with the effective rotation reported separately.
 * Values are exact; callers round or convert units as they see fit.
 *
 * Returns `null` when a group's `a:chExt` is degenerate (zero on either axis):
@@ -2806,8 +2817,7 @@ function composeGroupFrame(shape, groups) {
 		flipV
 	};
 }
-//#endregion
-//#region src/read/api/line.ts
+// src/read/api/line.ts
 /**
 * Shared line reader for DrawingML strokes: a shape's `p:spPr/a:ln`, a table cell's edges
 * (`a:tcPr/a:lnL` and its siblings, each a `CT_LineProperties`), and a chart series'
@@ -2832,10 +2842,9 @@ function readLineBasics(ln, ctx) {
 		noFill: !!firstChild(ln, "a:noFill")
 	};
 }
-//#endregion
-//#region src/read/api/hyperlink.ts
+// src/read/api/hyperlink.ts
 /**
-* `a:hlinkClick` — the one reading of a click hyperlink, wherever it hangs.
+* `a:hlinkClick`: the one reading of a click hyperlink, wherever it hangs.
 *
 * DrawingML puts the same element in two places: on a run's `a:rPr`, which links a span of text,
 * and on a shape's `p:cNvPr`, which links the whole shape. They are the same element with the same
@@ -2873,10 +2882,9 @@ function readHyperlink(parent, rels) {
 		relId
 	};
 }
-//#endregion
-//#region src/read/api/shapes/effects.ts
+// src/read/api/shapes/effects.ts
 /**
-* Decoding a shape's `a:effectLst` — shadow, glow, reflection, soft edge.
+* Decoding a shape's `a:effectLst`: shadow, glow, reflection, soft edge.
 *
 * Free functions over `(effectLst, ctx)` rather than methods, because that is all they ever
 * needed: the block was five getters and two private helpers on `Shape` whose only reference
@@ -2885,7 +2893,7 @@ function readHyperlink(parent, rels) {
 * per-concern modules `shapes/` already has (`oxml.ts`, `geometry.ts`).
 *
 * Every decoder returns `null` for an absent element rather than an empty object, and leaves an
-* unstated attribute off its result rather than defaulting it — "absent" and "stated as the
+* unstated attribute off its result rather than defaulting it. "Absent" and "stated as the
 * default" are different facts about the source part, and a replica that has to carry the
 * effect needs to know which it is.
 */
@@ -2932,7 +2940,11 @@ function readShadow(shdw, ctx) {
 */
 function readOuterShadow(effectLst, ctx) {
 	const shdw = effect(effectLst, "a:outerShdw");
-	return shdw ? readShadow(shdw, ctx) : null;
+	if (!shdw) return null;
+	const out = readShadow(shdw, ctx);
+	const rotate = boolAttr(shdw, "rotWithShape");
+	if (rotate !== null) out.rotateWithShape = rotate;
+	return out;
 }
 /**
 * The inner shadow (`a:effectLst/a:innerShdw`), or `null`.
@@ -2992,8 +3004,7 @@ function readSoftEdge(effectLst) {
 	if (!soft) return null;
 	return { radiusPt: scaledAttr(soft, "rad", 12700) ?? 0 };
 }
-//#endregion
-//#region src/read/api/text/run.ts
+// src/read/api/text/run.ts
 /** One text run (`a:r`): a span of text with uniform character formatting. */
 var Run = class {
 	element;
@@ -3004,7 +3015,7 @@ var Run = class {
 		this.context = context;
 		this.inherited = inherited;
 	}
-	/** The run's text (`a:t`), verbatim — whitespace is not normalized. */
+	/** The run's text (`a:t`), verbatim; whitespace is not normalized. */
 	get text() {
 		return firstChild(this.element, "a:t")?.textContent ?? "";
 	}
@@ -3059,7 +3070,7 @@ var Run = class {
 	/**
 	* Strikethrough token (`a:rPr/@strike`: `noStrike` | `sngStrike` |
 	* `dblStrike`), or `null` when unset (inherited from the style). Surfaced as
-	* the raw token — `sngStrike` is the writer's single-strike value.
+	* the raw token; `sngStrike` is the writer's single-strike value.
 	*/
 	get strike() {
 		return this.#rPrAttrRaw("strike");
@@ -3077,8 +3088,8 @@ var Run = class {
 	* `30`), negative for subscript (`-40`), or `null` when unset. Reported as the
 	* percentage (`@baseline` ÷ 1000).
 	*
-	* `@baseline` is `a:ST_Percentage`, a union that also admits `"62.5%"` — the only form the
-	* Strict profile has — so it is read through `parsePercentPoints` rather than as a bare number.
+	* `@baseline` is `a:ST_Percentage`, a union that also admits `"62.5%"` (the only form the
+	* Strict profile has), so it is read through `parsePercentPoints` rather than as a bare number.
 	*/
 	get baselinePct() {
 		const rPr = this.#rPr();
@@ -3093,6 +3104,14 @@ var Run = class {
 		return ptFromHundredths(this.#rPrAttr("spc"));
 	}
 	/**
+	* Kerning threshold in points (`a:rPr/@kern`, authored in hundredths of a point), or `null`
+	* when unset: text at this font size or larger is pair-kerned, and `0` means kerning is off.
+	* PowerPoint's own default is `12`. The read counterpart of the write-side `kerning` option.
+	*/
+	get kerningPt() {
+		return ptFromHundredths(this.#rPrAttr("kern"));
+	}
+	/**
 	* The run's highlight colour (`a:rPr/a:highlight`), resolved to a literal hex
 	* through the owning slide's theme, or `null` when the run has no highlight or
 	* its colour cannot be made literal. The writer authors highlights from a hex
@@ -3116,6 +3135,83 @@ var Run = class {
 	get hyperlink() {
 		return readHyperlink(this.#rPr(), this.context.rels);
 	}
+	/**
+	* The run's language tag (`a:rPr/@lang`, e.g. `fr-FR`), or `null` when unset. Decides spelling,
+	* hyphenation and font fallback. The read counterpart of the write-side `lang` option.
+	*/
+	get language() {
+		return this.#rPrAttrRaw("lang");
+	}
+	/**
+	* The run's own glow (`a:rPr/a:effectLst/a:glow`), resolved against the slide theme, or `null`.
+	* The read counterpart of the write-side text `glow` option; a shape's glow is `Shape.glow`.
+	*/
+	get glow() {
+		const rPr = this.#rPr();
+		return readGlow(rPr && firstChild(rPr, "a:effectLst"), this.context.ctx);
+	}
+	/**
+	* The run's own outer shadow (`a:rPr/a:effectLst/a:outerShdw`), resolved against the slide
+	* theme, or `null`. The read counterpart of a run's `shadow` option and of a table cell's,
+	* which writes it on every run of the cell; a shape's shadow is `Shape.shadow`.
+	*/
+	get shadow() {
+		const rPr = this.#rPr();
+		return readOuterShadow(rPr && firstChild(rPr, "a:effectLst"), this.context.ctx);
+	}
+	/**
+	* The run's own inner shadow (`a:rPr/a:effectLst/a:innerShdw`), resolved against the slide
+	* theme, or `null`. What a run's `shadow: { type: 'inner' }` writes.
+	*/
+	get innerShadow() {
+		const rPr = this.#rPr();
+		return readInnerShadow(rPr && firstChild(rPr, "a:effectLst"), this.context.ctx);
+	}
+	/** The run's text outline (`a:rPr/a:ln`), or `null` when it has none. The read counterpart of `outline`. */
+	get outline() {
+		const rPr = this.#rPr();
+		const ln = rPr && firstChild(rPr, "a:ln");
+		if (!ln) return null;
+		const fill = firstChild(ln, "a:solidFill");
+		return {
+			widthPt: ptFromEmu(numberValue(attr(ln, "w"))),
+			noFill: firstChild(ln, "a:noFill") !== null,
+			colorRef: readColorRef(fill && firstChildElement(fill), this.context.ctx)
+		};
+	}
+	/**
+	* The underline's own colour (`a:rPr/a:uFill/a:solidFill`), as written and resolved, or `null`
+	* when the underline follows the text colour. The read counterpart of `underline.color`.
+	*/
+	get underlineColor() {
+		const rPr = this.#rPr();
+		const uFill = rPr && firstChild(rPr, "a:uFill");
+		const fill = uFill && firstChild(uFill, "a:solidFill");
+		return fill ? readColorRef(firstChildElement(fill), this.context.ctx) : null;
+	}
+	/**
+	* The East Asian typeface (`a:rPr/a:ea/@typeface`), or `null` when unset. {@link fontName} is the
+	* Latin slot. The read counterpart of the write-side `fontFaceEA` option.
+	*/
+	get eastAsianFontName() {
+		const rPr = this.#rPr();
+		const ea = rPr && firstChild(rPr, "a:ea");
+		return ea ? attr(ea, "typeface") : null;
+	}
+	/**
+	* How many line breaks (`a:br`) sit directly before this run in its paragraph, with no run or
+	* field between them. A soft break is not a run, so without this the runs on either side of one
+	* read as plain neighbours. The read counterpart of the write-side `softBreakBefore` option.
+	*/
+	get breaksBefore() {
+		let count = 0;
+		for (let node = this.element.previousSibling; node; node = node.previousSibling) {
+			if (node.nodeType !== 1) continue;
+			if (node.localName !== "br") break;
+			count++;
+		}
+		return count;
+	}
 	/** Latin typeface name (`a:rPr/a:latin/@typeface`), or `null` when unset. */
 	get fontName() {
 		const rPr = this.#rPr();
@@ -3152,7 +3248,7 @@ var Run = class {
 	* The colour this run effectively renders, resolved against the owning slide's
 	* theme to a literal hex. It is the run's own solid fill
 	* ({@link color}/{@link schemeColor}) when set; otherwise the shape's
-	* `p:style/a:fontRef` colour, then — for a run inside a placeholder — the colour
+	* `p:style/a:fontRef` colour, then (for a run inside a placeholder) the colour
 	* it inherits from the placeholder/list-style chain (layout → master placeholder
 	* `a:lstStyle` → master `p:txStyles`), then the presentation's
 	* `p:defaultTextStyle`. `null` when the run sets no colour and inherits none, or the
@@ -3160,12 +3256,24 @@ var Run = class {
 	* `null` too when the run's own fill is not a solid colour (`a:noFill`, a gradient):
 	* the run decides its own colour then, and the one it would otherwise inherit is not
 	* what it paints in, the rule `Shape.resolvedFill` and `TableCell.resolvedFill` follow.
-	* The returned {@link ResolvedColor} carries `effectiveHex` — the base colour with
-	* its child transforms (`lumMod`/`shade`/…) applied — for the final rendered colour.
+	* A run with a click hyperlink (`a:hlinkClick`) and no fill of its own is painted in the
+	* theme's `hlink` colour instead, resolved through the slide's colour map, unless the link
+	* carries the 2018 `ahyp:hlinkClr val="tx"` extension, which asks for the text colour above.
+	* The returned {@link ResolvedColor} carries `effectiveHex`, the base colour with
+	* its child transforms (`lumMod`/`shade`/…) applied, for the final rendered colour.
 	*/
 	get resolvedColor() {
 		const rPr = this.#rPr();
 		if (hasFillChoice(rPr)) return resolveSolidFillColor(rPr, this.context.ctx);
+		const hlinkClick = rPr && firstChild(rPr, "a:hlinkClick");
+		if (hlinkClick && !followsTextColor(hlinkClick)) {
+			const hex = resolveSchemeToken("hlink", this.context.ctx);
+			return hex ? {
+				hex,
+				transforms: [],
+				effectiveHex: hex
+			} : null;
+		}
 		const inherit = this.context.inherit;
 		return inherit?.fontRef?.color ?? inherit?.tableText?.color ?? this.inherited?.color() ?? null;
 	}
@@ -3174,7 +3282,7 @@ var Run = class {
 	* ({@link fontSizePt}) when set; otherwise, for a run inside a placeholder, the
 	* size 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 size and inherits none — the
+	* `p:txStyles`). `null` when the run sets no size and inherits none. This is the
 	* resolved counterpart of {@link fontSizePt}, which reports only the run's own value.
 	*/
 	get resolvedSizePt() {
@@ -3183,13 +3291,14 @@ var Run = class {
 	/**
 	* The typeface this run effectively renders, resolved to a literal face name. It
 	* is the run's own `a:latin` ({@link fontName}) when set; otherwise the face named
-	* by the shape's `p:style/a:fontRef` (`idx` → theme major/minor font), then — for a
-	* run inside a placeholder — the face it inherits from the placeholder/list-style
+	* by the shape's `p:style/a:fontRef` (`idx` → theme major/minor font), then (for a
+	* run inside a placeholder) the face it inherits from the placeholder/list-style
 	* chain, then the presentation's `p:defaultTextStyle`. A `+mj-*`/`+mn-*`
-	* major/minor theme-font token — on the run itself or reached through the chain —
+	* major/minor theme-font token, on the run itself or reached through the chain,
 	* is resolved through the theme `fontScheme` to its concrete face. `null` when the
-	* run names no face and inherits none, or a token cannot be resolved — the resolved
-	* counterpart of {@link fontName}, which reports the raw `@typeface` (possibly a token).
+	* run names no face and inherits none, or a token cannot be resolved. This is the
+	* resolved counterpart of {@link fontName}, which reports the raw `@typeface` (possibly a
+	* token).
 	*/
 	get resolvedFontFace() {
 		const own = this.fontName;
@@ -3202,7 +3311,7 @@ var Run = class {
 	* ({@link bold}) when set; otherwise, for a run inside a placeholder, the bold
 	* 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 `@b` and inherits none — the
+	* `p:txStyles`). `null` when the run sets no `@b` and inherits none. This is the
 	* resolved counterpart of {@link bold}, which reports only the run's own value.
 	*/
 	get resolvedBold() {
@@ -3213,7 +3322,7 @@ var Run = class {
 	* ({@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
+	* `p:txStyles`). `null` when the run sets no `@i` and inherits none. This is 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.
@@ -3261,8 +3370,31 @@ var Run = class {
 		if (edit === null ? applySolidFill(this.#rPr(), null) : applySolidFill(this.#rPr(), edit, () => this.#getOrAddRPr(), RPR_FILL_AFTER)) this.context.part.markDirty();
 	}
 };
-//#endregion
-//#region src/read/api/text/edit.ts
+/** Whether a hyperlink's `ahyp:hlinkClr val="tx"` extension asks for the text colour rather than the theme's `hlink`. */
+function followsTextColor(hlinkClick) {
+	const extLst = firstChild(hlinkClick, "a:extLst");
+	if (!extLst) return false;
+	for (const ext of getElements(extLst, "a:ext")) for (const child of childElements(ext)) if (child.localName === "hlinkClr" && child.namespaceURI === OOXML_NS.ahyp) return attr(child, "val") === "tx";
+	return false;
+}
+/**
+* One text field (`a:fld`): text PowerPoint computes as it renders, such as a slide number
+* (`slidenum`) or a date (`datetime1`). A field carries the same `a:rPr` a run does, so it reads
+* and resolves its formatting like one. {@link text} is the rendering PowerPoint last cached,
+* which it recomputes on open.
+*/
+var Field = class extends Run {
+	runIndex;
+	constructor(element, context, inherited, runIndex) {
+		super(element, context, inherited);
+		this.runIndex = runIndex;
+	}
+	/** The field type (`@type`), such as `slidenum` or `datetime1`, or `null` when unset. */
+	get type() {
+		return attr(this.element_, "type");
+	}
+};
+// src/read/api/text/edit.ts
 /**
 * The two free text-body mutators, shared by the three proxies that own an `a:txBody`.
 *
@@ -3274,7 +3406,7 @@ var Run = class {
 * Replace a text body's content (`a:txBody` or `a:txBody`-shaped element) with a
 * single paragraph and run, preserving the `a:rPr` of the body's first existing
 * run when there is one. Shared by {@link TextFrame.text} and `TableCell.text`.
-* Does **not** mark any part dirty — the caller owns the `Part` and must call
+* Does **not** mark any part dirty: the caller owns the `Part` and must call
 * `markDirty()` after.
 */
 function setTextBodyText(txBody, value) {
@@ -3298,7 +3430,7 @@ function setTextBodyText(txBody, value) {
 * 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`.
+* nodes' strings. Does **not** mark any part dirty; the caller owns the `Part`.
 */
 function setParagraphText(p, value) {
 	const doc = p.ownerDocument;
@@ -3316,12 +3448,11 @@ function setParagraphText(p, value) {
 	const endParaRPr = firstChild(p, "a:endParaRPr");
 	p.insertBefore(run, endParaRPr);
 }
-//#endregion
-//#region src/read/api/text/paragraph.ts
+// src/read/api/text/paragraph.ts
 /**
 * The `Paragraph` read/write proxy (`a:p`).
 *
-* A paragraph owns its `a:pPr` — alignment, indents, spacing, the bullet — and hands each
+* A paragraph owns its `a:pPr` (alignment, indents, spacing, the bullet) and hands each
 * `a:r` to a {@link Run}. It is handed its frame's {@link TextContext}, and builds the one
 * {@link InheritedRunProps} its runs share.
 */
@@ -3335,12 +3466,51 @@ var Paragraph = class {
 		this.context = context;
 		this.slideLstStyle = slideLstStyle;
 	}
-	/** The runs (`a:r`) in document order. Fields (`a:fld`) and breaks are not runs; see `text`. */
+	/** The runs (`a:r`) in document order. Fields (`a:fld`) are not runs (see {@link fields}), nor are breaks. */
 	get runs() {
 		const inherited = this.#inheritedRunProps();
 		return getElements(this.element, "a:r").map((element) => new Run(element, this.context, inherited));
 	}
 	/**
+	* The OMML equations (`a14:m`) in document order. An equation is neither a run nor part of
+	* {@link text}; each says how many runs precede it, so an inline one keeps its place.
+	*/
+	get equations() {
+		const equations = [];
+		let runIndex = 0;
+		for (let node = this.element.firstChild; node; node = node.nextSibling) {
+			if (node.nodeType !== 1) continue;
+			const element = node;
+			if (element.namespaceURI === OOXML_NS.a && element.localName === "r") runIndex++;
+			if (element.namespaceURI !== OOXML_NS.a14 || element.localName !== "m") continue;
+			const omml = firstChildElement(element);
+			if (omml?.namespaceURI !== OOXML_NS.m) continue;
+			equations.push({
+				omml: serializeXml(omml),
+				inline: omml.localName === "oMath",
+				runIndex
+			});
+		}
+		return equations;
+	}
+	/**
+	* The fields (`a:fld`) in document order, each read like a run; see {@link Field}. Each says how
+	* many runs precede it, so a field between runs keeps its place.
+	*/
+	get fields() {
+		const inherited = this.#inheritedRunProps();
+		const fields = [];
+		let runIndex = 0;
+		for (let node = this.element.firstChild; node; node = node.nextSibling) {
+			if (node.nodeType !== 1) continue;
+			const element = node;
+			if (element.namespaceURI !== OOXML_NS.a) continue;
+			if (element.localName === "r") runIndex++;
+			else if (element.localName === "fld") fields.push(new Field(element, this.context, inherited, runIndex));
+		}
+		return fields;
+	}
+	/**
 	* What every run in this paragraph inherits when it sets no value of its own, or `null` for text
 	* that inherits through nothing. Runs in one paragraph share a level and `a:pPr`, so each
 	* property is resolved at most once per paragraph, and only when a run lacking its own value asks.
@@ -3364,6 +3534,15 @@ var Paragraph = class {
 			italic: once(resolveInheritedRunItalic)
 		};
 	}
+	/**
+	* The language of the paragraph's end mark (`a:endParaRPr/@lang`, e.g. `fr-FR`), or `null` when
+	* unset. It is what text typed at the end of the paragraph, or into an empty one, is spelled in.
+	* The write side states it from the text's `lang` option.
+	*/
+	get endLanguage() {
+		const end = firstChild(this.element, "a:endParaRPr");
+		return end ? attr(end, "lang") : null;
+	}
 	/** Indent level (`a:pPr/@lvl`), 0 when unset. */
 	get level() {
 		const pPr = firstChild(this.element, "a:pPr");
@@ -3374,8 +3553,7 @@ var Paragraph = class {
 	* `dist` | `thaiDist`), or `null` when unset (inherited from the list style).
 	*/
 	get align() {
-		const pPr = firstChild(this.element, "a:pPr");
-		return pPr ? attr(pPr, "algn") : null;
+		return alignOf(this.#pPr());
 	}
 	/**
 	* Space before the paragraph in points (`a:pPr/a:spcBef/a:spcPts/@val` is
@@ -3383,11 +3561,11 @@ var Paragraph = class {
 	* (`a:spcPct`, which has no fixed point value).
 	*/
 	get spaceBeforePt() {
-		return this.#spacingPt("a:spcBef");
+		return spacingPt(this.#pPr(), "a:spcBef");
 	}
 	/** Space after the paragraph in points; see {@link spaceBeforePt} for the percentage caveat. */
 	get spaceAfterPt() {
-		return this.#spacingPt("a:spcAft");
+		return spacingPt(this.#pPr(), "a:spcAft");
 	}
 	/**
 	* The paragraph's line spacing (`a:pPr/a:lnSpc`), as an exact point height
@@ -3395,37 +3573,112 @@ var Paragraph = class {
 	* `null` when unset (inherited from the list style). See {@link LineSpacing}.
 	*/
 	get lineSpacing() {
-		const pPr = firstChild(this.element, "a:pPr");
-		const lnSpc = pPr && firstChild(pPr, "a:lnSpc");
-		if (!lnSpc) return null;
-		const pts = firstChild(lnSpc, "a:spcPts");
-		if (pts) {
-			const val = numberValue(attr(pts, "val"));
-			return val === null ? null : {
-				type: "points",
-				valuePt: val / 100
-			};
-		}
-		const pct = firstChild(lnSpc, "a:spcPct");
-		if (pct) {
-			const val = pctPointsAttr(pct, "val");
-			return val === null ? null : {
-				type: "percent",
-				percent: val
-			};
-		}
-		return null;
+		return lineSpacingOf(this.#pPr());
 	}
 	/** Left margin of the paragraph in points (`a:pPr/@marL` is EMU; 12700 EMU = 1pt), or `null` when unset. */
 	get marginLeftPt() {
-		return this.#emuAttrPt("marL");
+		return emuAttrPt(this.#pPr(), "marL");
 	}
 	/** First-line indent in points (`a:pPr/@indent` is EMU; negative for a hanging indent), or `null` when unset. */
 	get indentPt() {
-		return this.#emuAttrPt("indent");
+		return emuAttrPt(this.#pPr(), "indent");
+	}
+	/**
+	* The alignment the paragraph renders with: its own, else the first its level inherits through
+	* the text body's `a:lstStyle`, the placeholder's layout and master list styles, the master's
+	* `p:txStyles` and the presentation's `p:defaultTextStyle`, the chain {@link Run.resolvedSizePt}
+	* walks. `null` when nothing in the chain states one (PowerPoint then aligns left).
+	*/
+	get resolvedAlign() {
+		return this.#resolved(alignOf);
+	}
+	/** The left margin in points the paragraph renders with, resolved as {@link resolvedAlign} is. */
+	get resolvedMarginLeftPt() {
+		return this.#resolved((pPr) => emuAttrPt(pPr, "marL"));
+	}
+	/** The first-line indent in points the paragraph renders with, resolved as {@link resolvedAlign} is. */
+	get resolvedIndentPt() {
+		return this.#resolved((pPr) => emuAttrPt(pPr, "indent"));
+	}
+	/** The line spacing the paragraph renders with, resolved as {@link resolvedAlign} is. */
+	get resolvedLineSpacing() {
+		return this.#resolved(lineSpacingOf);
+	}
+	/** The space before the paragraph in points, resolved as {@link resolvedAlign} is. */
+	get resolvedSpaceBeforePt() {
+		return this.#resolved((pPr) => spacingPt(pPr, "a:spcBef"));
+	}
+	/** The space after the paragraph in points, resolved as {@link resolvedAlign} is. */
+	get resolvedSpaceAfterPt() {
+		return this.#resolved((pPr) => spacingPt(pPr, "a:spcAft"));
+	}
+	/**
+	* The bullet the paragraph renders with: its own {@link bulletDetail}, else the first bullet its
+	* level inherits, resolved as {@link resolvedAlign} is. A picture bullet from an inherited tier
+	* reads with `imagePartName: null`, its image being a relationship of the layout or master.
+	* `null` when nothing in the chain names one.
+	*/
+	get resolvedBulletDetail() {
+		const own = this.bulletDetail;
+		if (own) return own;
+		for (const tier of this.#inheritedLevels()) {
+			const detail = this.#bulletDetailOf(tier, false);
+			if (detail) return detail;
+		}
+		return null;
+	}
+	/** The paragraph's own `a:pPr`, or `null`. */
+	#pPr() {
+		return firstChild(this.element, "a:pPr");
 	}
 	/**
-	* This paragraph's bullet — its kind, and for a drawn bullet the glyph, the
+	* The level elements the paragraph inherits paragraph properties from, most specific first: the
+	* text body's `a:lstStyle`, then for a placeholder its layout and master list styles and the
+	* master's `p:txStyles`, then `p:defaultTextStyle`. Empty for text that inherits through nothing.
+	*/
+	#inheritedLevels() {
+		const inherit = this.context.inherit;
+		if (!inherit) return [];
+		const level = this.level;
+		const { ctx } = this.context;
+		const tiers = [lstStyleLevel(this.slideLstStyle, level)];
+		if (inherit.ph) tiers.push(...placeholderInheritedLevels(inherit.ph.type, inherit.ph.idx, level, ctx));
+		tiers.push(lstStyleLevel(ctx.defaultTextStyle ?? null, level));
+		return tiers.filter((tier) => tier !== null);
+	}
+	/** The first value `read` finds in the paragraph's own `a:pPr`, then down {@link inheritedLevels}. */
+	#resolved(read) {
+		const own = read(this.#pPr());
+		if (own !== null) return own;
+		for (const tier of this.#inheritedLevels()) {
+			const value = read(tier);
+			if (value !== null) return value;
+		}
+		return null;
+	}
+	/**
+	* Right-to-left paragraph direction (`a:pPr/@rtl`), or `null` when unset (left to right). The
+	* read counterpart of the write-side `rtlMode` option.
+	*/
+	get rtl() {
+		const pPr = firstChild(this.element, "a:pPr");
+		return pPr ? boolValue(attr(pPr, "rtl")) : null;
+	}
+	/**
+	* The paragraph's own tab stops (`a:pPr/a:tabLst/a:tab`) in document order, or `null` when it
+	* states no tab list and inherits one. The read counterpart of the write-side `tabStops` option.
+	*/
+	get tabStops() {
+		const pPr = firstChild(this.element, "a:pPr");
+		const tabLst = pPr && firstChild(pPr, "a:tabLst");
+		if (!tabLst) return null;
+		return getElements(tabLst, "a:tab").map((tab) => ({
+			positionPt: ptFromEmu(numberValue(attr(tab, "pos"))),
+			alignment: attr(tab, "algn") ?? null
+		}));
+	}
+	/**
+	* This paragraph's bullet: its kind, and for a drawn bullet the glyph, the
 	* numbering start, and the bullet's own font/size/colour. `null` when the
 	* paragraph names no bullet at all and inherits one from the list style.
 	*
@@ -3433,11 +3686,18 @@ var Paragraph = class {
 	* previous `bullet` accessor reported `'none'` / `'char:•'` /
 	* `'autoNum:arabicPeriod'`, and that shape is ambiguous when the glyph is
 	* itself a colon; worse, it reads as a bare glyph, which is exactly how the
-	* script converter first consumed it — `'none'.codePointAt(0)` put a literal
+	* script converter first consumed it: `'none'.codePointAt(0)` put a literal
 	* `n` bullet on every converted deck, silently. See {@link BulletDetail}.
 	*/
 	get bulletDetail() {
-		const pPr = firstChild(this.element, "a:pPr");
+		return this.#bulletDetailOf(this.#pPr(), true);
+	}
+	/**
+	* The bullet a paragraph-properties element names, or `null`.
+	* @param resolveImage - resolve a picture bullet's image through this slide's relationships,
+	*   which only holds for the paragraph's own `a:pPr`
+	*/
+	#bulletDetailOf(pPr, resolveImage) {
 		if (!pPr) return null;
 		if (firstChild(pPr, "a:buNone")) return { kind: "none" };
 		const style = this.#bulletStyle(pPr);
@@ -3457,7 +3717,7 @@ var Paragraph = class {
 		const buBlip = firstChild(pPr, "a:buBlip");
 		if (buBlip) return {
 			kind: "picture",
-			imagePartName: this.#bulletImagePartName(buBlip),
+			imagePartName: resolveImage ? this.#bulletImagePartName(buBlip) : null,
 			...style
 		};
 		return null;
@@ -3489,18 +3749,6 @@ var Paragraph = class {
 		const blip = firstChild(buBlip, "a:blip");
 		return resolvePartName(blip && attr(blip, "r:embed"), this.context.rels);
 	}
-	/** Points from a spacing child's `a:spcPts/@val` (hundredths of a point), or `null`. */
-	#spacingPt(qname) {
-		const pPr = firstChild(this.element, "a:pPr");
-		const spc = pPr && firstChild(pPr, qname);
-		const pts = spc && firstChild(spc, "a:spcPts");
-		return ptFromHundredths(pts ? numberValue(attr(pts, "val")) : null);
-	}
-	/** Points from an EMU-valued `a:pPr` attribute (`marL` / `indent`), or `null`. */
-	#emuAttrPt(name) {
-		const pPr = firstChild(this.element, "a:pPr");
-		return ptFromEmu(pPr ? numberValue(attr(pPr, name)) : null);
-	}
 	/**
 	* The paragraph's text: run (`a:r`) and field (`a:fld`) text concatenated in
 	* document order, with each line break (`a:br`) rendered as `\n`.
@@ -3518,7 +3766,7 @@ var Paragraph = class {
 	/**
 	* 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
+	* alignment, bullet) alone. Sibling paragraphs are untouched. That is the difference from
 	* {@link TextFrame.text}, which collapses the whole body to one paragraph.
 	*/
 	set text(value) {
@@ -3535,8 +3783,43 @@ var Paragraph = class {
 	}
 };
 /** A shape's text frame (`p:txBody`): an ordered list of paragraphs. */
-//#endregion
-//#region src/read/api/text/frame.ts
+/** `@algn` of a paragraph-properties element (`a:pPr` or a list-style level), or `null`. */
+function alignOf(pPr) {
+	return pPr ? attr(pPr, "algn") : null;
+}
+/** Points from a spacing child's `a:spcPts/@val` (hundredths of a point), or `null`. */
+function spacingPt(pPr, qname) {
+	const spc = pPr && firstChild(pPr, qname);
+	const pts = spc && firstChild(spc, "a:spcPts");
+	return ptFromHundredths(pts ? numberValue(attr(pts, "val")) : null);
+}
+/** Points from an EMU-valued paragraph-properties attribute (`marL` / `indent`), or `null`. */
+function emuAttrPt(pPr, name) {
+	return ptFromEmu(pPr ? numberValue(attr(pPr, name)) : null);
+}
+/** The `a:lnSpc` of a paragraph-properties element as a {@link LineSpacing}, or `null`. */
+function lineSpacingOf(pPr) {
+	const lnSpc = pPr && firstChild(pPr, "a:lnSpc");
+	if (!lnSpc) return null;
+	const pts = firstChild(lnSpc, "a:spcPts");
+	if (pts) {
+		const val = numberValue(attr(pts, "val"));
+		return val === null ? null : {
+			type: "points",
+			valuePt: val / 100
+		};
+	}
+	const pct = firstChild(lnSpc, "a:spcPct");
+	if (pct) {
+		const val = pctPointsAttr(pct, "val");
+		return val === null ? null : {
+			type: "percent",
+			percent: val
+		};
+	}
+	return null;
+}
+// src/read/api/text/frame.ts
 /**
 * The `TextFrame` read/write proxy (`p:txBody` / `a:txBody`), and its `a:bodyPr` value types.
 *
@@ -3556,9 +3839,30 @@ var TextFrame = class {
 		return getElements(this.txBody, "a:p").map((element) => new Paragraph(element, this.context, slideLstStyle));
 	}
 	/**
+	* The character defaults this frame's own list style states for paragraphs at `level`
+	* (0-based): `a:lstStyle/a:lvlNpPr/a:defRPr`, else `a:defPPr/a:defRPr`. `null` when the frame
+	* has no list style or it states no defaults for that level.
+	*
+	* Only the frame's own tier. What a run inherits through it, and through a placeholder's
+	* layout and master, is the run's `resolved*` reads.
+	*/
+	listStyleDefaults(level = 0) {
+		const defRPr = lstStyleLevelDefRPr(firstChild(this.txBody, "a:lstStyle"), level);
+		if (!defRPr) return null;
+		const fill = firstChild(defRPr, "a:solidFill");
+		const latin = firstChild(defRPr, "a:latin");
+		return {
+			fontSizePt: ptFromHundredths(numberValue(attr(defRPr, "sz"))),
+			fontName: latin && attr(latin, "typeface") || null,
+			bold: boolValue(attr(defRPr, "b")),
+			italic: boolValue(attr(defRPr, "i")),
+			colorRef: fill ? readColorRef(firstChildElement(fill), this.context.ctx) : null
+		};
+	}
+	/**
 	* The frame's body properties (`a:bodyPr`: insets, anchor, vertical text), or
 	* `null` when there is no `a:bodyPr`. Only explicitly-set insets are reported
-	* (a missing side is the PowerPoint default — see {@link BodyProperties}).
+	* (a missing side is the PowerPoint default; see {@link BodyProperties}).
 	*/
 	get bodyProperties() {
 		const bodyPr = firstChild(this.txBody, "a:bodyPr");
@@ -3572,11 +3876,16 @@ var TextFrame = class {
 		inset("rIns", "right");
 		inset("tIns", "top");
 		inset("bIns", "bottom");
+		const spcCol = numberValue(attr(bodyPr, "spcCol"));
+		const warp = firstChild(bodyPr, "a:prstTxWarp");
 		return {
 			vert: attr(bodyPr, "vert") ?? null,
 			anchor: attr(bodyPr, "anchor") ?? null,
 			wrap: attr(bodyPr, "wrap") ?? null,
-			insetsPt
+			insetsPt,
+			columns: numberValue(attr(bodyPr, "numCol")),
+			columnSpacingPt: spcCol === null ? null : emuToPoints(spcCol),
+			textWarp: warp ? attr(warp, "prst") ?? null : null
 		};
 	}
 	/**
@@ -3585,7 +3894,7 @@ var TextFrame = class {
 	* layout → master placeholder `a:bodyPr`. `null` when nothing in the chain sets
 	* one (PowerPoint then defaults to top). Unlike {@link bodyProperties}'s
 	* `anchor` (own attribute only), this surfaces the inherited anchor a
-	* placeholder title relies on — the difference between a top- and
+	* placeholder title relies on: the difference between a top- and
 	* centre-anchored title that own-attribute reads alone cannot see.
 	*/
 	get resolvedAnchor() {
@@ -3597,8 +3906,8 @@ var TextFrame = class {
 	}
 	/**
 	* The frame's vertical-autofit mode (`a:bodyPr` autofit child), or `null` when
-	* there is no `a:bodyPr`. A `bodyPr` with no autofit child — or an explicit
-	* `a:noAutofit` — reads `'none'`. See {@link AutofitMode}. This is the deep-model
+	* there is no `a:bodyPr`. A `bodyPr` with no autofit child, or an explicit
+	* `a:noAutofit`, reads `'none'`. See {@link AutofitMode}. This is the deep-model
 	* counterpart of `inspectPptx`'s per-shape `autofit`; unlike the shallow surface
 	* it hangs off the navigable text frame.
 	*/
@@ -3612,8 +3921,8 @@ var TextFrame = class {
 	/**
 	* The baked shrink scale of a `normAutofit` frame as a percent (62.5 = 62.5%),
 	* or `null` when the frame has no `a:normAutofit` or bakes no scale. A bare
-	* `<a:normAutofit/>` (write-side `fit: 'shrink'`) carries no scale — PowerPoint
-	* computes it on edit and draws at 100% until then — so it too reads `null`; an
+	* `<a:normAutofit/>` (write-side `fit: 'shrink'`) carries no scale (PowerPoint
+	* computes it on edit and draws at 100% until then), so it too reads `null`; an
 	* explicit scale comes from `fit: { type: 'shrink', fontScale }`.
 	*/
 	get autofitFontScale() {
@@ -3662,17 +3971,16 @@ var TextFrame = class {
 		this.context.part.markDirty();
 	}
 };
-//#endregion
-//#region src/read/api/animation.ts
+// src/read/api/animation.ts
 /**
 * Spid-aware, otherwise-opaque handling of a slide's build-animation tree
 * (`p:timing` / `p:bldLst`).
 *
-* The `p:timing` subtree is `CT_TimeNodeList` — deeply recursive and modeled
+* The `p:timing` subtree is `CT_TimeNodeList`, deeply recursive and modeled
 * here as opaque DOM (an unmodified slide round-trips it byte-identically for
 * free). The only structured data we extract or rewrite is the set of `spid`
-* references — `<p:spTgt spid>` inside the timing tree and `<p:bldP spid>` in the
-* build list — so animations stay coherent when shape ids change. Three purely
+* references (`<p:spTgt spid>` inside the timing tree and `<p:bldP spid>` in the
+* build list), so animations stay coherent when shape ids change. Three purely
 * structural operations: **enumerate**, **remap**, and **prune**. See
 * `docs/contributing/design/animations.md` ("spid-aware operations").
 */
@@ -3686,7 +3994,7 @@ function spidElements(root) {
 	return out;
 }
 /**
-* Whether the slide carries build animations — a `<p:bldP>` entry or any timing
+* Whether the slide carries build animations: a `<p:bldP>` entry or any timing
 * node with a `presetID` (distinguishing animation timing from the media-loop
 * timing that has neither).
 */
@@ -3695,6 +4003,61 @@ function hasAnimations(root) {
 	for (const cTn of root.getElementsByTagNameNS(OOXML_NS.p, "cTn")) if (attr(cTn, "presetID") !== null) return true;
 	return false;
 }
+const TRIGGERS = {
+	clickEffect: "onClick",
+	withEffect: "withPrevious",
+	afterEffect: "afterPrevious"
+};
+/**
+* The time node enclosing `cTn`: its `p:par` (or `p:seq`) sits in a `p:childTnLst`, whose parent is
+* the enclosing `p:cTn`. `null` at the top of the tree.
+*/
+function parentTimeNode(cTn) {
+	const parent = cTn.parentNode?.parentNode?.parentNode;
+	if (!parent || parent.nodeType !== 1) return null;
+	const element = parent;
+	return element.localName === "cTn" && element.namespaceURI === P_NS ? element : null;
+}
+/** A number of milliseconds from a time attribute, or `null` for `indefinite` and anything else. */
+function millis(value) {
+	if (value === null || !/^\d+$/.test(value)) return null;
+	return Number(value);
+}
+/** Every preset effect in the slide's `p:timing`, in document order. See {@link BuildEffect}. */
+function readBuildEffects(root) {
+	const timing = firstChild(root, "p:timing");
+	if (!timing) return [];
+	const out = [];
+	for (const cTn of timing.getElementsByTagNameNS(P_NS, "cTn")) {
+		const presetClass = attr(cTn, "presetClass");
+		if (presetClass === null) continue;
+		let sequence = "other";
+		for (let node = parentTimeNode(cTn); node; node = parentTimeNode(node)) {
+			const type = attr(node, "nodeType");
+			if (type === "mainSeq") sequence = "main";
+			else if (type === "interactiveSeq") sequence = "interactive";
+			else continue;
+			break;
+		}
+		const stated = [...cTn.getElementsByTagNameNS(P_NS, "cTn")].map((node) => millis(attr(node, "dur"))).filter((dur) => dur !== null);
+		const step = parentTimeNode(cTn);
+		const stCondLst = step && firstChild(step, "p:stCondLst");
+		const cond = stCondLst && firstChild(stCondLst, "p:cond");
+		const spTgt = cTn.getElementsByTagNameNS(P_NS, "spTgt")[0] ?? null;
+		out.push({
+			sequence,
+			presetClass,
+			presetId: numberValue(attr(cTn, "presetID")),
+			presetSubtype: numberValue(attr(cTn, "presetSubtype")),
+			trigger: TRIGGERS[attr(cTn, "nodeType") ?? ""] ?? null,
+			durationMs: stated.length > 0 ? Math.max(...stated) : null,
+			delayMs: cond ? millis(attr(cond, "delay")) : null,
+			shapeId: spTgt ? numberValue(attr(spTgt, "spid")) : null,
+			textRange: spTgt !== null && firstChild(spTgt, "p:txEl") !== null
+		});
+	}
+	return out;
+}
 /** The sorted, de-duplicated set of `spid`s referenced by the slide's animations. */
 function enumerateSpids(root) {
 	const seen = /* @__PURE__ */ new Set();
@@ -3801,7 +4164,7 @@ function pruneSpids(root, spids) {
 * This is the whole-slide counterpart to {@link pruneSpids} (which drops the
 * builds of specific shapes). It only removes staging; it never deletes shapes,
 * so a slide that animated alternating states over the same region will show
-* them all at once after flattening — that is "drop animations", distinct from
+* them all at once after flattening. That is "drop animations", distinct from
 * "remove staged/duplicate shapes".
 */
 function flattenAnimations(root) {
@@ -3906,7 +4269,7 @@ function getOrCreateBldLst(timing, doc) {
 * id on the destination). For each mapped shape: its mainSeq click-group `<p:par>`
 * (the whole click step) and `<p:bldP>` are cloned, their `spid`s remapped, their
 * `<p:cTn>` ids renumbered to stay collision-free in the destination, and appended
-* after any existing build — matching how PowerPoint merges a pasted shape's
+* after any existing build, matching how PowerPoint merges a pasted shape's
 * animation. Returns `true` when anything was carried (so the caller can
 * `markDirty()`), `false` when the source shapes have no animation.
 */
@@ -3967,22 +4330,21 @@ function targetsOnly(root, spidMap) {
 	const targets = [...root.getElementsByTagNameNS(P_NS, "spTgt")].map((spTgt) => numberValue(attr(spTgt, "spid")));
 	return targets.length > 0 && targets.every((spid) => spid !== null && spidMap.has(spid));
 }
-//#endregion
-//#region src/read/api/shapes/base.ts
+// src/read/api/shapes/base.ts
 /**
 * The abstract base every shape kind extends.
 *
 * It owns everything a shape has regardless of kind: non-visual identity (id / name / hidden /
 * description / decorative), geometry through the subclass-supplied `a:xfrm`, and the `p:spPr`
-* surface — fill, line, gradient, effects — resolved against the host's theme. Kind-specific
+* surface (fill, line, gradient, effects) resolved against the host's theme. Kind-specific
 * reads live on the subclasses in the sibling modules.
 *
-* A proxy holds a back-reference to its owning {@link ShapeHost} — a `Slide`, a `SlideLayout` or a
-* `SlideMaster` — so it can resolve relationships and theme colours, and so a mutation can mark
+* A proxy holds a back-reference to its owning {@link ShapeHost} (a `Slide`, a `SlideLayout` or a
+* `SlideMaster`), so it can resolve relationships and theme colours, and so a mutation can mark
 * that host's part dirty.
 */
 const ADEC_NS = "http://schemas.microsoft.com/office/drawing/2017/decorative";
-/** Common base for every shape in a shape tree — a slide's, a layout's, or a master's. */
+/** Common base for every shape in a shape tree: a slide's, a layout's, or a master's. */
 var Shape = class {
 	element;
 	host;
@@ -4041,7 +4403,7 @@ var Shape = class {
 	/**
 	* Whether the shape is explicitly hidden (`p:cNvPr/@hidden="1"`); `false` when
 	* the attribute is unset. A hidden shape stays in the slide XML but is not
-	* rendered — decks use it as a fallback layer (e.g. a duotone-recolour source
+	* rendered. Decks use it as a fallback layer (e.g. a duotone-recolour source
 	* sitting behind the visible icon), so a faithful reader must distinguish it
 	* from the drawn shapes.
 	*/
@@ -4050,6 +4412,29 @@ var Shape = class {
 		return boolValue(cNvPr && attr(cNvPr, "hidden")) === true;
 	}
 	/**
+	* The shape's lock flags: the attributes of the locking element under its non-visual drawing
+	* properties (`a:spLocks`, `a:picLocks`, `a:cxnSpLocks`, `a:graphicFrameLocks` or
+	* `a:grpSpLocks`), each as the boolean it states, keyed by attribute name (`noMove`, `noGrp`, …).
+	* `null` when the shape has no locking element. The read counterpart of `objectLock`.
+	*/
+	get locks() {
+		const cNvPr = nonVisualCNvPr(this.element);
+		const nvPr = cNvPr?.parentNode;
+		if (!nvPr) return null;
+		for (const props of childElements(nvPr)) {
+			if (props === cNvPr) continue;
+			const lock = childElements(props).find((child) => child.localName?.endsWith("Locks"));
+			if (!lock) continue;
+			const out = {};
+			for (const attribute of Array.from(lock.attributes)) {
+				const value = boolValue(attribute.value);
+				if (value !== null) out[attribute.localName ?? attribute.name] = value;
+			}
+			return out;
+		}
+		return null;
+	}
+	/**
 	* The shape's alt-text description (`p:cNvPr/@descr`), or `null` when unset.
 	* This is the accessibility primitive a screen reader announces; an audit or
 	* accessible-export tool reads it here. Distinct from {@link name}, which is
@@ -4083,7 +4468,7 @@ var Shape = class {
 	/**
 	* Whether the shape is flagged **decorative** (`p:cNvPr/a:extLst/a:ext`
 	* uri `{C183D7F6-…}` / `adec:decorative@val`), PowerPoint's "Mark as
-	* decorative" — a purely visual element assistive tech should skip. `false`
+	* decorative": a purely visual element assistive tech should skip. `false`
 	* when the extension is absent. A decorative shape typically has no
 	* {@link description}; the two are alternatives, not companions.
 	*/
@@ -4154,8 +4539,8 @@ var Shape = class {
 	}
 	/**
 	* Clockwise rotation in degrees (`a:xfrm/@rot` ÷ 60000), or `null` when the
-	* shape has no own transform. A present xfrm with no `@rot` reads as `0`, so
-	* — mirroring {@link left}/{@link top}/{@link width}/{@link height} — `null`
+	* shape has no own transform. A present xfrm with no `@rot` reads as `0`, so,
+	* mirroring {@link left}/{@link top}/{@link width}/{@link height}, `null`
 	* ("inherits layout geometry") stays distinct from `0` ("has a transform, not
 	* rotated"). The value is faithful to the XML and not normalised to a signed
 	* range, so a `@rot` past 360° (e.g. a negative angle stored as `19216344`)
@@ -4202,7 +4587,7 @@ var Shape = class {
 	* equal the shape's own transform values.
 	*
 	* `null` when the shape (or any enclosing group) has no own transform, or a
-	* group's `a:chExt` is degenerate (zero) — there is then no resolvable frame.
+	* group's `a:chExt` is degenerate (zero). There is then no resolvable frame.
 	* {@link absoluteFrameFailure} says which of those it was.
 	*
 	* A rotated shape's returned `left`/`top` remain PowerPoint's unrotated
@@ -4217,7 +4602,7 @@ var Shape = class {
 	* Why {@link absoluteFrame} is `null`, or `null` when it resolved.
 	*
 	* `absoluteFrame` reports one `null` for three different situations, and only a
-	* caller that wants to *report* the unresolvable shape needs them apart — an
+	* caller that wants to *report* the unresolvable shape needs them apart: an
 	* inherited placeholder box is ordinary, a group with no usable `a:xfrm` is not.
 	* The distinction is not recoverable from the `null`, and re-deriving it means
 	* walking the same ancestry a second time, so it is named here instead. See
@@ -4320,13 +4705,13 @@ var Shape = class {
 		this.#applyFill(value === null ? null : { scheme: value });
 	}
 	/**
-	* `true` when the shape sets an explicit no-fill (`spPr/a:noFill`) — a
+	* `true` when the shape sets an explicit no-fill (`spPr/a:noFill`): a
 	* deliberately transparent surface. The fill-side counterpart of
 	* {@link lineNoFill}, and the only accessor that separates it from a shape
 	* carrying no fill child at all (one inheriting through `p:style/a:fillRef`):
-	* every other fill accessor — {@link fillColor}, {@link fillSchemeColor},
+	* every other fill accessor ({@link fillColor}, {@link fillSchemeColor},
 	* {@link resolvedFill}, {@link gradientFill}, {@link patternFill},
-	* {@link pictureFill} — reports `null` for both. The two paint completely
+	* {@link pictureFill}) reports `null` for both. The two paint completely
 	* differently, so a consumer that cannot tell them apart paints a transparent
 	* shape in the theme's accent colour.
 	*/
@@ -4335,7 +4720,7 @@ var Shape = class {
 		return !!(props && firstChild(props, "a:noFill"));
 	}
 	/**
-	* Set an explicit `<a:noFill/>` on the shape — a transparent surface. This is
+	* Set an explicit `<a:noFill/>` on the shape: a transparent surface. This is
 	* distinct from clearing the fill (`fillColor = null`), which removes the
 	* `a:solidFill` and lets the fill inherit from the shape's style/placeholder.
 	* Read it back with {@link fillNoFill}.
@@ -4365,14 +4750,14 @@ var Shape = class {
 	/**
 	* The line/border dash style (`spPr/a:ln/a:prstDash/@val`), e.g. `'dash'`,
 	* `'lgDashDot'`, `'sysDot'`, or `null` when the line is solid/unset. A faithful
-	* replica of dashed dividers and dashed card borders needs this — it is
+	* replica of dashed dividers and dashed card borders needs this: it is
 	* otherwise invisible in {@link lineColor}/{@link lineWidthPt} alone.
 	*/
 	get lineDash() {
 		return this.#lineBasics()?.dash ?? null;
 	}
 	/**
-	* `true` when the shape sets an explicit no-line (`spPr/a:ln/a:noFill`) — a
+	* `true` when the shape sets an explicit no-line (`spPr/a:ln/a:noFill`): a
 	* deliberately border-less shape. Distinct from simply having no `a:ln`
 	* (an inherited line), which {@link resolvedLine} cannot tell apart: both
 	* report `null`. A replica that relies on a shadow instead of a border needs
@@ -4382,8 +4767,20 @@ var Shape = class {
 		return this.#lineBasics()?.noFill ?? false;
 	}
 	/**
-	* The line end cap (`spPr/a:ln/@cap`) as the raw OOXML token — `'flat'`,
-	* `'rnd'` (round) or `'sq'` (square) — or `null` when unset (PowerPoint's
+	* Whether the shape states an outline of its **own** (`spPr/a:ln`), however little it holds.
+	*
+	* The line accessors all report `null` both for a shape with no `a:ln` and for one whose `a:ln`
+	* is empty, and the two are different statements to a writer: an empty `<a:ln/>` says "take the
+	* whole outline from `p:style` or the placeholder", which is what PowerPoint writes on its own
+	* placeholders, and `addShape` writes it for `line: { type: 'inherit' }`. A copy that has to
+	* reproduce the outline rather than describe it needs to know which one it has.
+	*/
+	get hasOwnLine() {
+		return this.#line() !== null;
+	}
+	/**
+	* The line end cap (`spPr/a:ln/@cap`) as the raw OOXML token, `'flat'`,
+	* `'rnd'` (round) or `'sq'` (square), or `null` when unset (PowerPoint's
 	* default is `flat`). The write API authors this attribute through
 	* `ShapeLineProps.cap`, so without the accessor a deck this library produced
 	* could not be read back without losing it.
@@ -4398,8 +4795,8 @@ var Shape = class {
 		return ln ? attr(ln, "cap") ?? null : null;
 	}
 	/**
-	* The line alignment (`spPr/a:ln/@algn`) as the raw OOXML token — `'ctr'`
-	* (centred on the shape's outline) or `'in'` (inset, drawn wholly inside it) —
+	* The line alignment (`spPr/a:ln/@algn`) as the raw OOXML token, `'ctr'`
+	* (centred on the shape's outline) or `'in'` (inset, drawn wholly inside it),
 	* or `null` when unset. It shifts a thick outline by half its width, so it
 	* changes where the border sits relative to the fill.
 	*/
@@ -4424,7 +4821,7 @@ var Shape = class {
 	* shape uses preset geometry / none. The faithful, multi-path counterpart of
 	* {@link presetGeometry}: each `a:path` keeps its own path-unit viewport
 	* (`w`/`h`) and ordered {@link GeometryCommand}s. Coordinates are raw path-unit
-	* integers, not EMU — pair the path `w`/`h` with the shape's box size to map
+	* integers, not EMU. Pair the path `w`/`h` with the shape's box size to map
 	* them into slide space.
 	*
 	* Not an auto-shape-only property either: a picture clipped to a freeform (what
@@ -4436,7 +4833,12 @@ var Shape = class {
 		const custGeom = props && firstChild(props, "a:custGeom");
 		if (!custGeom) return null;
 		const pathLst = firstChild(custGeom, "a:pathLst");
-		return { paths: pathLst ? getElements(pathLst, "a:path").map((p) => readGeometryPath(p)) : [] };
+		return {
+			paths: pathLst ? getElements(pathLst, "a:path").map((p) => readGeometryPath(p)) : [],
+			guides: readGeometryGuides(firstChild(custGeom, "a:gdLst")),
+			adjustHandles: readAdjustHandles(firstChild(custGeom, "a:ahLst")),
+			connectionSites: readConnectionSites(firstChild(custGeom, "a:cxnLst"))
+		};
 	}
 	/**
 	* Preset-geometry adjustment values (`spPr/a:prstGeom/a:avLst/a:gd`) as a
@@ -4485,7 +4887,7 @@ var Shape = class {
 	* The shape's gradient fill with its geometry (`spPr/a:gradFill`), or `null`
 	* when the fill is not a gradient. Unlike {@link gradientStops} (stops only),
 	* this also carries the linear {@link GradientFill.angleDeg} or the
-	* {@link GradientFill.path} shape — the geometry a faithful replica needs and
+	* {@link GradientFill.path} shape: the geometry a faithful replica needs and
 	* which the bare stop list omits.
 	*/
 	get gradientFill() {
@@ -4496,8 +4898,8 @@ var Shape = class {
 	* The shape's line/border **gradient** stroke (`spPr/a:ln/a:gradFill`), or
 	* `null` when the line is a solid, absent, or inherited border (see
 	* {@link resolvedLine}). The line counterpart of {@link gradientFill}: a
-	* gradient-stroked connector — common for faded process arrows in styled decks
-	* — otherwise surfaces only its {@link lineWidthPt}, dropping the colour
+	* gradient-stroked connector (common for faded process arrows in styled decks)
+	* otherwise surfaces only its {@link lineWidthPt}, dropping the colour
 	* entirely, so a replica cannot reproduce the stroke.
 	*/
 	get lineGradient() {
@@ -4505,6 +4907,15 @@ var Shape = class {
 		return ln ? this.#gradientFillIn(ln) : null;
 	}
 	/**
+	* The shape's line/border **pattern** stroke (`spPr/a:ln/a:pattFill`), or `null` when the line
+	* is not a pattern. The line counterpart of {@link patternFill}, and what the write side's
+	* `line.pattern` writes.
+	*/
+	get linePatternFill() {
+		const ln = this.#line();
+		return ln ? readPatternFill(ln, this.host.themeContext()) : null;
+	}
+	/**
 	* The shape's line/connector arrowheads (`a:ln/a:headEnd` + `a:tailEnd`), or
 	* `null` when neither end carries one. Essential for replicating connectors,
 	* whose dot/arrow ends are otherwise invisible in the geometry.
@@ -4557,7 +4968,7 @@ var Shape = class {
 	/**
 	* The shape's reflection (`spPr/a:effectLst/a:reflection`), or `null` when it has
 	* none. Read-only: this library authors no reflection, so a replica should carry
-	* the part rather than regenerate it — see {@link Reflection}.
+	* the part rather than regenerate it (see {@link Reflection}).
 	*/
 	get reflection() {
 		return readReflection(this.#effectLst());
@@ -4572,7 +4983,7 @@ var Shape = class {
 	/**
 	* The shape's pattern (hatch) fill (`spPr/a:pattFill`), or `null` when the fill
 	* is not a pattern. Surfaces the {@link PatternFill.preset} name and both
-	* colours resolved against the host's theme — the pattern counterpart of
+	* colours resolved against the host's theme: the pattern counterpart of
 	* {@link resolvedFill}, which reports `null` for a non-solid fill and so drops a
 	* hatched surface entirely.
 	*/
@@ -4583,8 +4994,8 @@ var Shape = class {
 	/**
 	* The shape's picture (image) fill (`spPr/a:blipFill`), or `null` when the fill
 	* is not a picture. The image-fill counterpart of {@link patternFill}: a shape
-	* whose *surface* is an image is not a {@link Picture} — it is an autoShape with
-	* a blip fill — and {@link resolvedFill} reports `null` for one, so without this
+	* whose *surface* is an image is not a {@link Picture} (it is an autoShape with
+	* a blip fill), and {@link resolvedFill} reports `null` for one, so without this
 	* an image-filled shape reads as unfilled. Carries the embedded image
 	* ({@link PictureFill.relId}/{@link PictureFill.partName}) plus the stretch/tile
 	* geometry.
@@ -4593,18 +5004,18 @@ var Shape = class {
 		const props = this.properties();
 		return props ? readPictureFill(props, this.host.relationships) : null;
 	}
-	/** The shape's effect list (`spPr/a:effectLst`), or `null` — what `shapes/effects.ts` decodes. */
+	/** The shape's effect list (`spPr/a:effectLst`), or `null`: what `shapes/effects.ts` decodes. */
 	#effectLst() {
 		const props = this.properties();
 		return props ? firstChild(props, "a:effectLst") : null;
 	}
 	/**
 	* The shape's solid fill resolved against the host's theme
-	* ({@link Slide.themeContext}) to a literal hex — the resolved counterpart of
+	* ({@link Slide.themeContext}) to a literal hex: the resolved counterpart of
 	* {@link fillColor}/{@link fillSchemeColor}, which report the raw reference.
 	* `null` when the shape has no `a:solidFill` (a gradient/none/inherited fill)
 	* or the colour cannot be made literal. The returned {@link ResolvedColor}
-	* carries the base `hex` and raw transforms, and `effectiveHex` — the base with
+	* carries the base `hex` and raw transforms, and `effectiveHex`, the base with
 	* its colour transforms (`lumMod`/`shade`/…) applied (read that for the final
 	* rendered colour).
 	*
@@ -4620,7 +5031,7 @@ var Shape = class {
 	}
 	/**
 	* The shape's line/border solid fill resolved against the host's theme to a
-	* literal hex — the resolved counterpart of {@link lineColor}/{@link lineSchemeColor}.
+	* literal hex: the resolved counterpart of {@link lineColor}/{@link lineSchemeColor}.
 	* `null` when the shape has no `a:ln/a:solidFill` or it cannot be made literal.
 	* Like {@link resolvedFill}, the result carries `effectiveHex` (the base colour
 	* with its transforms applied) for the final rendered colour.
@@ -4708,11 +5119,20 @@ var Shape = class {
 	}
 	/**
 	* This shape's placeholder identity (`p:ph` `type`/`idx`), or `null` when it is
-	* not a placeholder. Only `p:sp` shapes can be placeholders, so the base
-	* implementation always returns `null`; {@link AutoShape} overrides it.
+	* not a placeholder. `idx` defaults to `'0'` when the attribute is absent, as
+	* PowerPoint does. A text placeholder is a `p:sp`; a filled picture, table or chart
+	* placeholder is a `p:pic` or `p:graphicFrame` carrying the same `p:ph`, which is what
+	* inserting a picture into a picture placeholder produces. This used to be `null` for
+	* every shape but a `p:sp` (#111). Use {@link Slide.placeholder} to find a text
+	* placeholder by type.
 	*/
 	get placeholder() {
-		return null;
+		const nvPr = nvPrOf(this.element);
+		const ph = nvPr && firstChild(nvPr, "p:ph");
+		return ph ? {
+			type: attr(ph, "type"),
+			idx: attr(ph, "idx") ?? "0"
+		} : null;
 	}
 	/**
 	* Remove this shape from its parent (the host's shape tree, or an enclosing
@@ -4739,10 +5159,74 @@ var Shape = class {
 		return this.element;
 	}
 };
-//#endregion
-//#region src/read/api/shapes/autoshape.ts
+/** An `ST_AdjCoordinate` attribute: a number in EMU, a guide name, or `null` when absent. */
+function adjCoordinate(element, name) {
+	const value = attr(element, name);
+	if (value === null || value === "") return null;
+	const number = numberValue(value);
+	return number === null ? value : number;
+}
+/** An `ST_AdjAngle` attribute in degrees, or `null` when absent or a guide name. */
+function adjAngleDeg(element, name) {
+	const number = numberValue(attr(element, name));
+	return number === null ? null : number / 6e4;
+}
+/** A custom geometry's `a:gdLst` as {@link CustomGeometryGuide}s. */
+function readGeometryGuides(gdLst) {
+	if (!gdLst) return [];
+	return getElements(gdLst, "a:gd").map((gd) => ({
+		name: attr(gd, "name") ?? "",
+		formula: attr(gd, "fmla") ?? ""
+	}));
+}
+/** A custom geometry's `a:ahLst` as {@link CustomGeometryAdjustHandle}s, XY and polar in document order. */
+function readAdjustHandles(ahLst) {
+	if (!ahLst) return [];
+	const handles = [];
+	for (const handle of childElements(ahLst)) {
+		const pos = firstChild(handle, "a:pos");
+		const x = pos ? adjCoordinate(pos, "x") : null;
+		const y = pos ? adjCoordinate(pos, "y") : null;
+		if (handle.localName === "ahXY") handles.push({
+			kind: "xy",
+			x,
+			y,
+			gdRefX: attr(handle, "gdRefX"),
+			minX: adjCoordinate(handle, "minX"),
+			maxX: adjCoordinate(handle, "maxX"),
+			gdRefY: attr(handle, "gdRefY"),
+			minY: adjCoordinate(handle, "minY"),
+			maxY: adjCoordinate(handle, "maxY")
+		});
+		else if (handle.localName === "ahPolar") handles.push({
+			kind: "polar",
+			x,
+			y,
+			gdRefR: attr(handle, "gdRefR"),
+			minR: adjCoordinate(handle, "minR"),
+			maxR: adjCoordinate(handle, "maxR"),
+			gdRefAng: attr(handle, "gdRefAng"),
+			minAngDeg: adjAngleDeg(handle, "minAng"),
+			maxAngDeg: adjAngleDeg(handle, "maxAng")
+		});
+	}
+	return handles;
+}
+/** A custom geometry's `a:cxnLst` as {@link CustomGeometryConnectionSite}s. */
+function readConnectionSites(cxnLst) {
+	if (!cxnLst) return [];
+	return getElements(cxnLst, "a:cxn").map((cxn) => {
+		const pos = firstChild(cxn, "a:pos");
+		return {
+			angleDeg: adjAngleDeg(cxn, "ang"),
+			x: pos ? adjCoordinate(pos, "x") : null,
+			y: pos ? adjCoordinate(pos, "y") : null
+		};
+	});
+}
+// src/read/api/shapes/autoshape.ts
 /**
-* An auto shape, text box, or placeholder (`p:sp`) — the only shape kind that holds text.
+* An auto shape, text box, or placeholder (`p:sp`): the only shape kind that holds text.
 */
 /** An auto shape, text box, or placeholder (`p:sp`). The only kind that holds text. */
 var AutoShape = class extends Shape {
@@ -4765,22 +5249,8 @@ var AutoShape = class extends Shape {
 			inherit
 		});
 	}
-	/**
-	* This shape's placeholder identity (`p:ph` `type`/`idx`), or `null` when it is
-	* not a placeholder. `idx` defaults to `'0'` when the attribute is absent, as
-	* PowerPoint does. Use {@link Slide.placeholder} to find a placeholder by type.
-	*/
-	get placeholder() {
-		const nvPr = nvPrOf(this.element);
-		const ph = nvPr && firstChild(nvPr, "p:ph");
-		return ph ? {
-			type: attr(ph, "type"),
-			idx: attr(ph, "idx") ?? "0"
-		} : null;
-	}
 };
-//#endregion
-//#region src/read/api/shapes/picture.ts
+// src/read/api/shapes/picture.ts
 /**
 * A picture (`p:pic`).
 *
@@ -4809,6 +5279,34 @@ function recolorColorOf(color, ctx) {
 	if (!color || color.namespaceURI !== OOXML_NS.a) return null;
 	return readColorRef(color, ctx);
 }
+/** One `a:blip` child as a {@link Recolor}, or `null` when it is not one of the five recognised effects. */
+function recolorOf(child, ctx) {
+	switch (child.localName) {
+		case "duotone": return {
+			kind: "duotone",
+			stops: childElements(child).map((color) => recolorColorOf(color, ctx)).filter((c) => c !== null)
+		};
+		case "clrChange": {
+			const from = firstChild(child, "a:clrFrom");
+			const to = firstChild(child, "a:clrTo");
+			return {
+				kind: "clrChange",
+				from: from ? recolorColorOf(firstChildElement(from), ctx) : null,
+				to: to ? recolorColorOf(firstChildElement(to), ctx) : null
+			};
+		}
+		case "grayscl": return { kind: "grayscale" };
+		case "biLevel": return {
+			kind: "biLevel",
+			threshold: pctAttr(child, "thresh")
+		};
+		case "alphaModFix": return {
+			kind: "alphaModFix",
+			amount: pctAttr(child, "amt") ?? 1
+		};
+	}
+	return null;
+}
 /** A picture (`p:pic`). */
 var Picture = class extends Shape {
 	shapeType = "picture";
@@ -4848,7 +5346,7 @@ var Picture = class extends Shape {
 	* Microsoft SVG blip extension (`a:blip/a:extLst/a:ext/asvg:svgBlip/@r:embed`),
 	* or `null` when the picture has no SVG. PowerPoint usually pairs this with a
 	* raster fallback in `a:blip/@r:embed` ({@link imageRelId}), but some exporters
-	* emit an SVG-only blip where `imageRelId` is absent and only this resolves —
+	* emit an SVG-only blip where `imageRelId` is absent and only this resolves,
 	* so a reader that wants the real drawn art must consult both.
 	*/
 	get svgRelId() {
@@ -4861,14 +5359,14 @@ var Picture = class extends Shape {
 	}
 	/**
 	* Which drawable media this picture carries:
-	* - `'raster'` — only a raster blip (`a:blip/@r:embed`);
-	* - `'svg'` — only a vector blip (`asvg:svgBlip/@r:embed`, no raster). This
+	* - `'raster'`: only a raster blip (`a:blip/@r:embed`);
+	* - `'svg'`: only a vector blip (`asvg:svgBlip/@r:embed`, no raster). This
 	*   is what PowerPoint's *Insert → Icons* and a plain SVG insert produce;
-	* - `'both'` — a raster fallback *and* an SVG (PowerPoint's usual pairing);
-	* - `'none'` — a `p:pic` with no embedded blip at all (e.g. a linked image).
+	* - `'both'`: a raster fallback *and* an SVG (PowerPoint's usual pairing);
+	* - `'none'`: a `p:pic` with no embedded blip at all (e.g. a linked image).
 	*
-	* Lets a caller distinguish an SVG-only picture — where {@link imagePartName}
-	* is legitimately `null` — from a genuinely empty one, without two null checks.
+	* Lets a caller distinguish an SVG-only picture (where {@link imagePartName}
+	* is legitimately `null`) from a genuinely empty one, without two null checks.
 	*/
 	get mediaKind() {
 		const hasRaster = this.imageRelId != null;
@@ -4880,7 +5378,7 @@ var Picture = class extends Shape {
 	}
 	/**
 	* Absolute partname of whichever part actually carries this picture's drawn
-	* data — the raster part when present, otherwise the SVG part — or `null`
+	* data (the raster part when present, otherwise the SVG part), or `null`
 	* when the picture embeds neither. Use this when you just want "the bytes
 	* this picture shows"; prefer {@link imagePartName} / {@link svgPartName}
 	* (and {@link mediaKind}) when you need to know *which* kind it is. An
@@ -4891,8 +5389,52 @@ var Picture = class extends Shape {
 		return this.imagePartName ?? this.svgPartName;
 	}
 	/**
+	* The audio or video this picture plays (`p:nvPr/a:audioFile` or `a:videoFile`), or `null` for a
+	* still picture. Its blip ({@link imagePartName}) is then the poster frame. See {@link PictureMedia}.
+	*/
+	get media() {
+		const nvPr = firstChild(this.element, "p:nvPicPr");
+		const props = nvPr && firstChild(nvPr, "p:nvPr");
+		if (!props) return null;
+		const file = firstChild(props, "a:videoFile") ?? firstChild(props, "a:audioFile");
+		if (!file) return null;
+		const rels = this.host.relationships;
+		const embedded = descendantsByTag(props, OOXML_NS.p14, "media").map((media) => resolvePartName(attr(media, "r:embed"), rels)).find((name) => name !== null);
+		const linkId = attr(file, "r:link");
+		const partName = embedded ?? resolvePartName(linkId, rels);
+		const linkRel = linkId ? rels.get(linkId) : void 0;
+		return {
+			kind: file.localName === "audioFile" ? "audio" : "video",
+			partName,
+			contentType: partName === null ? null : this.host.opc.part(partName)?.contentType ?? null,
+			link: partName === null && linkRel?.targetMode === "External" ? linkRel.target : null,
+			repeatCount: this.#repeatCount()
+		};
+	}
+	/**
+	* The `repeatCount` of the media node the host's `p:timing` aims at this picture, as
+	* {@link PictureMedia.repeatCount} reports it.
+	*/
+	#repeatCount() {
+		const id = this.id;
+		const root = this.element.ownerDocument?.documentElement;
+		if (id === null || !root) return null;
+		for (const node of descendantsByTag(root, OOXML_NS.p, "cMediaNode")) {
+			const target = firstChild(node, "p:tgtEl");
+			const spTgt = target && firstChild(target, "p:spTgt");
+			if (!spTgt || attr(spTgt, "spid") !== String(id)) continue;
+			const cTn = firstChild(node, "p:cTn");
+			const value = cTn && attr(cTn, "repeatCount");
+			if (value === null) return null;
+			if (value === "indefinite") return "indefinite";
+			const count = Number(value);
+			return Number.isFinite(count) && count > 0 ? count / 1e3 : null;
+		}
+		return null;
+	}
+	/**
 	* The picture's crop as fractions of the *source image*, read from
-	* `p:blipFill/a:srcRect` — `{ left, top, right, bottom }`, each the amount
+	* `p:blipFill/a:srcRect` as `{ left, top, right, bottom }`, each the amount
 	* trimmed off that edge (so `0.1` = 10 % cropped away, an uncropped edge is
 	* `0`). `null` when there is no `a:srcRect` at all; an explicit
 	* `{0,0,0,0}` crop still reports zeros, since its presence is meaningful.
@@ -4910,44 +5452,32 @@ var Picture = class extends Shape {
 	* `null` when the blip carries none. Recognises the effects a faithful reader
 	* needs to reproduce a recoloured image: `a:duotone` (the two-stop icon-tint
 	* trick), `a:clrChange`, `a:grayscl`, `a:biLevel`, and `a:alphaModFix`; the
-	* first such effect in document order wins. Colours mirror the
+	* first such effect in document order wins, and {@link recolors} lists them all. Colours mirror the
 	* {@link GradientStop} split (`color`/`schemeColor`/`presetColor`) so theme
 	* tokens resolve through {@link Slide.themeContext}. `threshold`/`amount` are
 	* 0–1 fractions. {@link hidden} (the duotone fallback-layer trick) reports the
 	* *visibility* of a recolour source; this reports the *tint* itself.
 	*/
 	get recolor() {
+		return this.recolors[0] ?? null;
+	}
+	/**
+	* Every blip effect {@link recolor} recognises, in document order: the first is
+	* {@link recolor}. They combine (a picture can be faded with `a:alphaModFix` and
+	* recoloured too, which is how the write API emits `transparency` beside a
+	* recolour), and {@link recolor} alone reported only the first of them.
+	*/
+	get recolors() {
 		const blip = this.#blip();
-		if (!blip) return null;
+		if (!blip) return [];
 		const ctx = this.host.themeContext();
+		const out = [];
 		for (const child of childElements(blip)) {
 			if (child.namespaceURI !== OOXML_NS.a) continue;
-			switch (child.localName) {
-				case "duotone": return {
-					kind: "duotone",
-					stops: childElements(child).map((color) => recolorColorOf(color, ctx)).filter((c) => c !== null)
-				};
-				case "clrChange": {
-					const from = firstChild(child, "a:clrFrom");
-					const to = firstChild(child, "a:clrTo");
-					return {
-						kind: "clrChange",
-						from: from ? recolorColorOf(firstChildElement(from), ctx) : null,
-						to: to ? recolorColorOf(firstChildElement(to), ctx) : null
-					};
-				}
-				case "grayscl": return { kind: "grayscale" };
-				case "biLevel": return {
-					kind: "biLevel",
-					threshold: pctAttr(child, "thresh")
-				};
-				case "alphaModFix": return {
-					kind: "alphaModFix",
-					amount: pctAttr(child, "amt") ?? 1
-				};
-			}
+			const effect = recolorOf(child, ctx);
+			if (effect) out.push(effect);
 		}
-		return null;
+		return out;
 	}
 	/**
 	* The `p:blipFill/a:blip` this picture draws, or `null` when it has none. Three getters and
@@ -4983,7 +5513,7 @@ var Picture = class extends Shape {
 	*
 	* `fit` controls the picture's `a:srcRect` crop against its current frame
 	* extent (`a:xfrm/a:ext`):
-	* - omitted (default): geometry and crop are left untouched — the caller owns
+	* - omitted (default): geometry and crop are left untouched; the caller owns
 	*   sizing. Note an inherited `a:srcRect` was tuned to the *previous* image's
 	*   aspect ratio, so swapping in an image of a different ratio reuses a crop
 	*   that no longer fits and the result looks stretched; pass `fit` to refit.
@@ -5050,8 +5580,7 @@ var Picture = class extends Shape {
 		return getOrAddChild(getOrAddChild(this.element, "p:blipFill", PIC_BLIPFILL_AFTER), "a:blip", BLIPFILL_BLIP_AFTER);
 	}
 };
-//#endregion
-//#region src/read/api/shapes/connector.ts
+// src/read/api/shapes/connector.ts
 /**
 * A connector / line (`p:cxnSp`).
 */
@@ -5090,22 +5619,21 @@ var Connector = class extends Shape {
 		};
 	}
 };
-//#endregion
-//#region src/read/oxml/point-cache.ts
+// 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
+* 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()`
+* 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
@@ -5113,8 +5641,8 @@ var Connector = class extends Shape {
 *
 * 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.
+* 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.
@@ -5123,7 +5651,7 @@ var Connector = class extends Shape {
 * 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
+* 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;
@@ -5163,13 +5691,38 @@ function readIndexedPoints(pts, declaredCount, valueOf, label) {
 	}
 	return points;
 }
-//#endregion
-//#region src/read/api/chart.ts
+// src/read/api/chart.ts
 /** A chart graphic-frame's chart, backed by its chart part. */
 var Chart = class {
 	part;
-	constructor(part) {
+	rels;
+	constructor(part, rels = null) {
 		this.part = part;
+		this.rels = rels;
+	}
+	/** The chart area's fill and border (`c:chartSpace/c:spPr`), or `null` when it states none. */
+	get chartArea() {
+		const root = this.part.dom.documentElement;
+		const spPr = root ? firstChild(root, "c:spPr") : null;
+		return spPr ? readAreaFormat(spPr, null, this.rels) : null;
+	}
+	/** Whether the chart area's corners are rounded (`c:roundedCorners`), or `null` when unstated. */
+	get roundedCorners() {
+		const root = this.part.dom.documentElement;
+		const element = root ? firstChild(root, "c:roundedCorners") : null;
+		return element ? boolValue(attr(element, "val")) : null;
+	}
+	/** The plot area's fill, border and manual layout, or `null` when the chart has no plot area. */
+	get plotArea() {
+		const plotArea = this.#plotArea();
+		if (!plotArea) return null;
+		return readAreaFormat(firstChild(plotArea, "c:spPr"), firstChild(plotArea, "c:layout"), this.rels);
+	}
+	/** The title's manual layout (`c:title/c:layout`), or `null` when it is placed automatically. */
+	get titleLayout() {
+		const chart = this.#chart();
+		const title = chart && firstChild(chart, "c:title");
+		return readManualLayout(title && firstChild(title, "c:layout"));
 	}
 	/** Partname of the chart part. */
 	get partName() {
@@ -5224,9 +5777,28 @@ var Chart = class {
 		const overlay = firstChild(legend, "c:overlay");
 		return {
 			position: pos ? attr(pos, "val") : null,
-			overlay: overlay ? boolValue(attr(overlay, "val")) : null
+			overlay: overlay ? boolValue(attr(overlay, "val")) : null,
+			textStyle: readTextStyle(firstChild(legend, "c:txPr")),
+			layout: readManualLayout(firstChild(legend, "c:layout"))
 		};
 	}
+	/** The chart title's formatting (`c:title/c:tx/c:rich`), or `null` when the chart has no rich title. */
+	get titleStyle() {
+		const chart = this.#chart();
+		return readTitleStyle(chart && firstChild(chart, "c:title"));
+	}
+	/**
+	* The language the chart's text is tagged with: `c:lang`, which PowerPoint writes, else the first
+	* paragraph end's `@lang` in the part, where `addChart` writes its `lang`. `null` when neither says.
+	*/
+	get language() {
+		const root = this.part.dom.documentElement;
+		if (!root) return null;
+		const lang = firstChild(root, "c:lang");
+		if (lang) return attr(lang, "val");
+		const end = descendantsByTag(root, OOXML_NS.a, "endParaRPr").find((element) => attr(element, "lang"));
+		return end ? attr(end, "lang") : null;
+	}
 	/**
 	* The chart-level data-label settings, read from the first plot group's
 	* aggregate `c:dLbls` (the group-wide block after the series). `null` when the
@@ -5241,6 +5813,72 @@ var Chart = class {
 		const group = this.#chartGroups()[0];
 		return readDataLabels(group ? firstChild(group, "c:dLbls") : null);
 	}
+	/** The data table under the plot (`c:plotArea/c:dTable`), or `null` when the chart draws none. */
+	get dataTable() {
+		const plotArea = this.#plotArea();
+		const table = plotArea && firstChild(plotArea, "c:dTable");
+		if (!table) return null;
+		const flag = (qname) => {
+			const element = firstChild(table, qname);
+			return element ? boolValue(attr(element, "val")) : null;
+		};
+		return {
+			showHorizontalBorder: flag("c:showHorzBorder"),
+			showVerticalBorder: flag("c:showVertBorder"),
+			showOutline: flag("c:showOutline"),
+			showKeys: flag("c:showKeys"),
+			fontSizePt: readTextSizePt(firstChild(table, "c:txPr"))
+		};
+	}
+	/**
+	* The key/value annotations `addChart`'s `metadata` option writes: the pptx-ts extension on
+	* `c:chartSpace/c:extLst` (uri `{094A432E-1F6C-499B-95B8-B57DC9536949}`). `null` when the chart
+	* carries no such extension; an extension with no item reads as an empty map.
+	*/
+	get metadata() {
+		const root = this.part.dom.documentElement;
+		const extLst = root ? firstChild(root, "c:extLst") : null;
+		const ext = extLst ? getElements(extLst, "c:ext").find((element) => attr(element, "uri") === CHART_METADATA_EXT_URI) : void 0;
+		const payload = ext ? childElements(ext).find((element) => element.namespaceURI === "http://ts-pptx.com/schema/chart/metadata" && element.localName === "metadata") : void 0;
+		if (!payload) return null;
+		const out = {};
+		for (const item of childElements(payload)) {
+			if (item.namespaceURI !== "http://ts-pptx.com/schema/chart/metadata" || item.localName !== "item") continue;
+			const key = attr(item, "key");
+			if (key) out[key] = attr(item, "value") ?? "";
+		}
+		return out;
+	}
+	/**
+	* The plot groups (`c:barChart`, `c:lineChart`, …) of the plot area, in document order, each
+	* with what it sets on all its series and the series it plots. A combo chart has several.
+	*/
+	get plotGroups() {
+		return this.#chartGroups().map((group) => new ChartPlotGroup(group, this.part));
+	}
+	/** The 3-D view (`c:chart/c:view3D`), or `null` when the chart states none. */
+	get view3D() {
+		const chart = this.#chart();
+		const view = chart && firstChild(chart, "c:view3D");
+		if (!view) return null;
+		const number = (qname) => {
+			const element = firstChild(view, qname);
+			return element ? numberValue(attr(element, "val")) : null;
+		};
+		const rAngAx = firstChild(view, "c:rAngAx");
+		return {
+			rotX: number("c:rotX"),
+			rotY: number("c:rotY"),
+			perspective: number("c:perspective"),
+			rightAngleAxes: rAngAx ? boolValue(attr(rAngAx, "val")) : null
+		};
+	}
+	/** How blank cells plot (`c:chart/c:dispBlanksAs`): `gap`, `zero` or `span`, or `null` when unstated. */
+	get displayBlanksAs() {
+		const chart = this.#chart();
+		const element = chart && firstChild(chart, "c:dispBlanksAs");
+		return element ? attr(element, "val") : null;
+	}
 	/** The data series (`c:ser`) across all chart groups, in document order. */
 	get series() {
 		return this.#chartGroups().flatMap((group) => getElements(group, "c:ser")).map((ser) => new ChartSeries(ser, this.part));
@@ -5288,6 +5926,106 @@ var Chart = class {
 	}
 };
 /**
+* One plot group of a chart's plot area (`c:barChart`, `c:lineChart`, `c:pieChart`, …): the series
+* it plots and what it sets on all of them. Each accessor reads `null` (or `false` for an element
+* that is either there or not) where the group does not state it, including on a plot type whose
+* schema has no such element.
+*/
+var ChartPlotGroup = class {
+	group;
+	part;
+	constructor(group, part) {
+		this.group = group;
+		this.part = part;
+	}
+	/** The plot type, the element's local name less `Chart`: `bar`, `line`, `bar3D`, `doughnut`, … */
+	get type() {
+		return (this.group.localName ?? "").replace(/Chart$/, "");
+	}
+	/** The series this group plots (`c:ser`), in document order. */
+	get series() {
+		return getElements(this.group, "c:ser").map((ser) => new ChartSeries(ser, this.part));
+	}
+	/**
+	* The ids of the axes this group plots against (`c:axId`), as {@link ChartAxis.id} reads them: a
+	* combo's group on the secondary axes names the secondary pair. Empty for a pie or a doughnut.
+	*/
+	get axisIds() {
+		return childElements(this.group).filter((child) => child.localName === "axId").map((axId) => numberValue(attr(axId, "val"))).filter((id) => id !== null);
+	}
+	/** A bar group's direction (`c:barDir`): `bar` (horizontal) or `col` (vertical). */
+	get barDirection() {
+		return this.#value("c:barDir");
+	}
+	/** How the series stack (`c:grouping`): `clustered`, `stacked`, `percentStacked` or `standard`. */
+	get grouping() {
+		return this.#value("c:grouping");
+	}
+	/** The gap between bar clusters as a percentage of a bar's width (`c:gapWidth`). */
+	get gapWidthPct() {
+		return this.#number("c:gapWidth");
+	}
+	/** How far bars in a cluster overlap, -100 to 100 percent (`c:overlap`). */
+	get overlapPct() {
+		return this.#number("c:overlap");
+	}
+	/** Whether stacked bars are joined by series lines (`c:serLines`). */
+	get seriesLines() {
+		return firstChild(this.group, "c:serLines") !== null;
+	}
+	/** The series lines' stroke (`c:serLines/c:spPr/a:ln`), or `null` when they state none. */
+	get seriesLinesLine() {
+		return spPrLine(firstChild(this.group, "c:serLines"));
+	}
+	/** The depth gap of a 3-D bar group, as a percentage (`c:gapDepth`). */
+	get gapDepthPct() {
+		return this.#number("c:gapDepth");
+	}
+	/** The group-wide 3-D bar shape (`c:shape`); a series can state its own ({@link ChartSeries.shape}). */
+	get shape() {
+		return this.#value("c:shape");
+	}
+	/** The angle of a pie's first slice, 0 to 360 degrees (`c:firstSliceAng`). */
+	get firstSliceAngle() {
+		return this.#number("c:firstSliceAng");
+	}
+	/** A doughnut's hole, 10 to 90 percent of its size (`c:holeSize`). */
+	get holeSizePct() {
+		return this.#number("c:holeSize");
+	}
+	/** A radar's style (`c:radarStyle`): `standard`, `marker` or `filled`. */
+	get radarStyle() {
+		return this.#value("c:radarStyle");
+	}
+	/** Whether a surface is drawn as a wireframe (`c:wireframe`). */
+	get wireframe() {
+		const element = firstChild(this.group, "c:wireframe");
+		return element ? boolValue(attr(element, "val")) : null;
+	}
+	/** Whether a line or stock group draws up/down bars (`c:upDownBars`). */
+	get upDownBars() {
+		return firstChild(this.group, "c:upDownBars") !== null;
+	}
+	/** Escape hatch: the underlying plot-group element. After mutating it call {@link markDirty}, or `save()` writes the original bytes. */
+	get element_() {
+		return this.group;
+	}
+	/** Mark the owning chart part dirty so `save()` reserializes it. Call after mutating {@link element_}. */
+	markDirty() {
+		this.part.markDirty();
+	}
+	/** The `@val` of a named child, or `null`. */
+	#value(qname) {
+		const element = firstChild(this.group, qname);
+		return element ? attr(element, "val") : null;
+	}
+	/** The `@val` of a named child as a number, or `null`. */
+	#number(qname) {
+		const element = firstChild(this.group, qname);
+		return element ? numberValue(attr(element, "val")) : null;
+	}
+};
+/**
 * One axis (`c:catAx`/`c:valAx`/`c:dateAx`/`c:serAx`) of a chart's plot area.
 * All four share the scaling/delete/position/tickmark structure; `kind`
 * distinguishes them.
@@ -5385,6 +6123,81 @@ var ChartAxis = class {
 		const el = firstChild(this.ax, "c:minorUnit");
 		return el ? numberValue(attr(el, "val")) : null;
 	}
+	/** The tick labels' text formatting and rotation (`c:txPr`), or `null` when the axis states none. */
+	get labelStyle() {
+		return readTextStyle(firstChild(this.ax, "c:txPr"));
+	}
+	/** The axis title's formatting (`c:title/c:tx/c:rich`), or `null` when it has no rich title. */
+	get titleStyle() {
+		return readTitleStyle(firstChild(this.ax, "c:title"));
+	}
+	/** Where this axis crosses the other one, as a value on it (`c:crossesAt`), or `null`. */
+	get crossesAt() {
+		const element = firstChild(this.ax, "c:crossesAt");
+		return element ? numberValue(attr(element, "val")) : null;
+	}
+	/** Where this axis crosses the other one, as a rule (`c:crosses`: `autoZero`, `max`, `min`), or `null`. */
+	get crosses() {
+		const element = firstChild(this.ax, "c:crosses");
+		return element ? attr(element, "val") : null;
+	}
+	/** Whether a value axis crosses between categories or on them (`c:crossBetween`: `between`, `midCat`). */
+	get crossBetween() {
+		const element = firstChild(this.ax, "c:crossBetween");
+		return element ? attr(element, "val") : null;
+	}
+	/** A value axis' display units (`c:dispUnits`), or `null` when it shows plain values. */
+	get displayUnits() {
+		const units = firstChild(this.ax, "c:dispUnits");
+		if (!units) return null;
+		const builtIn = firstChild(units, "c:builtInUnit");
+		const custom = firstChild(units, "c:custUnit");
+		return {
+			builtIn: builtIn ? attr(builtIn, "val") : null,
+			custom: custom ? numberValue(attr(custom, "val")) : null,
+			showLabel: firstChild(units, "c:dispUnitsLbl") !== null
+		};
+	}
+	/** How many categories pass between two labels (`c:tickLblSkip`), or `null` when automatic. */
+	get labelSkip() {
+		const element = firstChild(this.ax, "c:tickLblSkip");
+		return element ? numberValue(attr(element, "val")) : null;
+	}
+	/** Whether a category axis flattens a multi-level category list (`c:noMultiLvlLbl`), or `null` when unstated. */
+	get noMultiLevelLabels() {
+		const element = firstChild(this.ax, "c:noMultiLvlLbl");
+		return element ? boolValue(attr(element, "val")) : null;
+	}
+	/** A date axis' base unit (`c:baseTimeUnit`: `days`, `months`, `years`), or `null`. */
+	get baseTimeUnit() {
+		return this.#value("c:baseTimeUnit");
+	}
+	/** A date axis' major unit scale (`c:majorTimeUnit`), or `null`. */
+	get majorTimeUnit() {
+		return this.#value("c:majorTimeUnit");
+	}
+	/** A date axis' minor unit scale (`c:minorTimeUnit`), or `null`. */
+	get minorTimeUnit() {
+		return this.#value("c:minorTimeUnit");
+	}
+	/** The axis line's own stroke (`c:spPr/a:ln`), or `null` when it states none. */
+	get line() {
+		const spPr = firstChild(this.ax, "c:spPr");
+		const ln = spPr && firstChild(spPr, "a:ln");
+		return ln ? readChartLine(ln) : null;
+	}
+	/** The major gridlines' stroke (`c:majorGridlines/c:spPr/a:ln`), or `null` when they state none. */
+	get majorGridlinesLine() {
+		const gridlines = firstChild(this.ax, "c:majorGridlines");
+		const spPr = gridlines && firstChild(gridlines, "c:spPr");
+		const ln = spPr && firstChild(spPr, "a:ln");
+		return ln ? readChartLine(ln) : null;
+	}
+	/** The `@val` of a named child, or `null`. */
+	#value(qname) {
+		const element = firstChild(this.ax, qname);
+		return element ? attr(element, "val") : null;
+	}
 	/** Escape hatch: the underlying axis element. After mutating it call {@link markDirty}, or `save()` writes the original bytes. */
 	get element_() {
 		return this.ax;
@@ -5416,20 +6229,14 @@ var ChartSeries = class {
 		return spPr ? readSolidFill(spPr) : null;
 	}
 	/**
-	* Series line/stroke (`c:spPr/a:ln`) — width, dash, colour. `null` when the
+	* Series line/stroke (`c:spPr/a:ln`): width, dash, colour. `null` when the
 	* series `c:spPr` has no `a:ln` (bar/area fills carry no line by default).
 	*/
 	get line() {
 		const spPr = firstChild(this.ser, "c:spPr");
 		const ln = spPr && firstChild(spPr, "a:ln");
 		if (!ln) return null;
-		const { widthPt, dash, colorRef, noFill } = readLineBasics(ln, null);
-		return {
-			widthPt,
-			dash,
-			colorRef,
-			noFill
-		};
+		return readChartLine(ln);
 	}
 	/** Series index (`c:idx/@val`), or `null` if absent. */
 	get index() {
@@ -5478,6 +6285,16 @@ var ChartSeries = class {
 	get yValues() {
 		return this.#numbers("c:yVal");
 	}
+	/**
+	* The number format the series' values are cached in (`c:numCache/c:formatCode` under `c:val`, or
+	* under `c:yVal` on a scatter or bubble series), or `null` when the cache states none. PowerPoint
+	* paints a source-linked data label and a data table in it.
+	*/
+	get valueFormatCode() {
+		const cache = findCache(firstChild(this.ser, "c:val") ?? firstChild(this.ser, "c:yVal"));
+		const formatCode = cache && firstChild(cache, "c:formatCode");
+		return formatCode ? formatCode.textContent ?? null : null;
+	}
 	/** Cached bubble sizes of a bubble series (`c:bubbleSize`); non-numeric or missing points are `null`. */
 	get bubbleSizes() {
 		return this.#numbers("c:bubbleSize");
@@ -5510,6 +6327,113 @@ var ChartSeries = class {
 	get dataLabels() {
 		return readDataLabels(firstChild(this.ser, "c:dLbls"));
 	}
+	/**
+	* The series' labels that state their own text (`c:ser/c:dLbls/c:dLbl` with `c:tx/c:rich`), in
+	* document order. A label that only formats or deletes its point has no text and is left out.
+	*/
+	get customLabels() {
+		const dLbls = firstChild(this.ser, "c:dLbls");
+		if (!dLbls) return [];
+		const labels = [];
+		for (const dLbl of childElements(dLbls)) {
+			if (dLbl.localName !== "dLbl") continue;
+			const idx = firstChild(dLbl, "c:idx");
+			const index = idx ? numberValue(attr(idx, "val")) : null;
+			const tx = firstChild(dLbl, "c:tx");
+			const rich = tx && firstChild(tx, "c:rich");
+			if (index === null || !rich) continue;
+			const runs = [];
+			for (const paragraph of childElements(rich)) {
+				if (paragraph.localName !== "p") continue;
+				for (const run of childElements(paragraph)) {
+					if (run.localName !== "r" && run.localName !== "fld") continue;
+					const text = firstChild(run, "a:t")?.textContent ?? "";
+					runs.push({
+						text,
+						field: run.localName === "fld" ? attr(run, "type") : null
+					});
+				}
+			}
+			labels.push({
+				index,
+				runs
+			});
+		}
+		return labels;
+	}
+	/** The series' gradient fill (`c:spPr/a:gradFill`), or `null`. */
+	get gradientFill() {
+		const spPr = firstChild(this.ser, "c:spPr");
+		return spPr ? readGradientFill(spPr, NO_THEME) : null;
+	}
+	/** The series' pattern fill (`c:spPr/a:pattFill`), or `null`. */
+	get patternFill() {
+		const spPr = firstChild(this.ser, "c:spPr");
+		return spPr ? readPatternFill(spPr, NO_THEME) : null;
+	}
+	/** The series' outer shadow (`c:spPr/a:effectLst/a:outerShdw`), or `null`. */
+	get shadow() {
+		const spPr = firstChild(this.ser, "c:spPr");
+		return readOuterShadow(spPr && firstChild(spPr, "a:effectLst"), NO_THEME);
+	}
+	/** The series' inner shadow (`c:spPr/a:effectLst/a:innerShdw`), or `null`. */
+	get innerShadow() {
+		const spPr = firstChild(this.ser, "c:spPr");
+		return readInnerShadow(spPr && firstChild(spPr, "a:effectLst"), NO_THEME);
+	}
+	/** Whether a line or scatter series is smoothed (`c:smooth`), or `null` when unstated. */
+	get smooth() {
+		const element = firstChild(this.ser, "c:smooth");
+		return element ? boolValue(attr(element, "val")) : null;
+	}
+	/** The series' data-point marker (`c:marker`), or `null` when it states none. */
+	get marker() {
+		const marker = firstChild(this.ser, "c:marker");
+		if (!marker) return null;
+		const symbol = firstChild(marker, "c:symbol");
+		const size = firstChild(marker, "c:size");
+		const spPr = firstChild(marker, "c:spPr");
+		const ln = spPr && firstChild(spPr, "a:ln");
+		return {
+			symbol: symbol ? attr(symbol, "val") : null,
+			size: size ? numberValue(attr(size, "val")) : null,
+			fill: spPr ? readSolidFill(spPr) : null,
+			line: ln ? readChartLine(ln) : null
+		};
+	}
+	/**
+	* The points this series formats on its own (`c:dPt`), in document order: a bar's per-point
+	* colours, a pie's slice colours. A `c:dPt` with no `c:idx` is left out.
+	*/
+	get dataPoints() {
+		const points = [];
+		for (const dPt of childElements(this.ser)) {
+			if (dPt.localName !== "dPt") continue;
+			const idx = firstChild(dPt, "c:idx");
+			const index = idx ? numberValue(attr(idx, "val")) : null;
+			if (index === null) continue;
+			const invert = firstChild(dPt, "c:invertIfNegative");
+			const spPr = firstChild(dPt, "c:spPr");
+			points.push({
+				index,
+				invertIfNegative: invert ? boolValue(attr(invert, "val")) : null,
+				fill: spPr ? readSolidFill(spPr) : null,
+				patternFill: spPr ? readPatternFill(spPr, NO_THEME) : null,
+				line: spPrLine(dPt)
+			});
+		}
+		return points;
+	}
+	/** Whether a bar series paints a negative bar inverted (`c:invertIfNegative`), or `null` when unstated. */
+	get invertIfNegative() {
+		const element = firstChild(this.ser, "c:invertIfNegative");
+		return element ? boolValue(attr(element, "val")) : null;
+	}
+	/** A 3-D bar series' own shape (`c:shape`: `box`, `cylinder`, `cone`, …), or `null` when unstated. */
+	get shape() {
+		const element = firstChild(this.ser, "c:shape");
+		return element ? attr(element, "val") : null;
+	}
 	/** Escape hatch: the underlying `c:ser` element. After mutating it call {@link markDirty}, or `save()` writes the original bytes. */
 	get element_() {
 		return this.ser;
@@ -5524,6 +6448,34 @@ var ChartSeries = class {
 		return readPoints(container && findCache(container)).map(numberValue);
 	}
 };
+/** The size, in points, a chart text block (`c:txPr`) sets on its first paragraph's `a:defRPr`. */
+function readTextSizePt(txPr) {
+	const paragraph = txPr && firstChild(txPr, "a:p");
+	const pPr = paragraph && firstChild(paragraph, "a:pPr");
+	const defRPr = pPr && firstChild(pPr, "a:defRPr");
+	const size = defRPr ? numberValue(attr(defRPr, "sz")) : null;
+	return size === null ? null : size / 100;
+}
+/**
+* A chart stroke (`a:ln`): {@link readLineBasics}' width, dash, colour and no-fill, then the cap and
+* the colour's `a:alpha`, which a chart part read without a theme leaves unresolved otherwise.
+*/
+function readChartLine(ln) {
+	const { widthPt, dash, colorRef, noFill } = readLineBasics(ln, null);
+	const solidFill = firstChild(ln, "a:solidFill");
+	const color = solidFill && firstChildElement(solidFill);
+	const alpha = color && firstChild(color, "a:alpha");
+	const alphaValue = alpha ? numberValue(attr(alpha, "val")) : null;
+	return {
+		widthPt,
+		dash,
+		colorRef,
+		noFill,
+		cap: attr(ln, "cap") ?? null,
+		alpha: alphaValue === null ? null : alphaValue / 1e5,
+		colorTransformed: color ? childElements(color).some((child) => child.localName !== "alpha") : false
+	};
+}
 /** Read a `c:dLbls` block's show flags, position and number format, or `null` when there is no block. */
 function readDataLabels(dLbls) {
 	if (!dLbls) return null;
@@ -5541,9 +6493,59 @@ function readDataLabels(dLbls) {
 		showBubbleSize: flag("c:showBubbleSize"),
 		showLeaderLines: flag("c:showLeaderLines"),
 		position: pos ? attr(pos, "val") : null,
-		numberFormat: readNumberFormat(dLbls)
+		numberFormat: readNumberFormat(dLbls),
+		textStyle: readTextStyle(firstChild(dLbls, "c:txPr")),
+		fill: spPrFill(dLbls),
+		leaderLines: spPrLine(firstChild(dLbls, "c:leaderLines"))
 	};
 }
+/** The size, in 1/60000 of a degree, of the `@rot` PowerPoint writes for an upright default. */
+const MAX_TEXT_ROTATION = 54e5;
+/** Read a chart text block, a `c:txPr` or a title's `c:rich`; see {@link ChartTextStyle}. */
+function readTextStyle(block) {
+	if (!block) return null;
+	const bodyPr = firstChild(block, "a:bodyPr");
+	const paragraph = firstChild(block, "a:p");
+	const pPr = paragraph && firstChild(paragraph, "a:pPr");
+	const defRPr = pPr && firstChild(pPr, "a:defRPr");
+	const run = paragraph && firstChild(paragraph, "a:r");
+	const props = [run && firstChild(run, "a:rPr"), defRPr].filter((element) => element !== null);
+	const first = (name) => {
+		for (const element of props) {
+			const value = attr(element, name);
+			if (value !== null) return value;
+		}
+		return null;
+	};
+	const child = (qname) => {
+		for (const element of props) {
+			const found = firstChild(element, qname);
+			if (found) return found;
+		}
+		return null;
+	};
+	const solidFill = child("a:solidFill");
+	const colorElement = solidFill && firstChildElement(solidFill);
+	const latin = child("a:latin");
+	const size = numberValue(first("sz"));
+	const rot = bodyPr ? numberValue(attr(bodyPr, "rot")) : null;
+	return {
+		sizePt: size === null ? null : size / 100,
+		bold: boolValue(first("b")),
+		italic: boolValue(first("i")),
+		underline: first("u"),
+		color: colorElement ? readColorRef(colorElement, null) : null,
+		colorTransformed: colorElement ? childElements(colorElement).some((transform) => transform.localName !== "alpha") : false,
+		fontName: latin ? attr(latin, "typeface") : null,
+		rotationDeg: rot === null || Math.abs(rot) > MAX_TEXT_ROTATION ? null : rot / 6e4,
+		align: pPr ? attr(pPr, "algn") : null
+	};
+}
+/** A `c:title`'s formatting, off its `c:tx/c:rich`. */
+function readTitleStyle(title) {
+	const tx = title && firstChild(title, "c:tx");
+	return readTextStyle(tx && firstChild(tx, "c:rich"));
+}
 /**
 * Read a `c:multiLvlStrCache` into its levels, in document order.
 *
@@ -5590,11 +6592,79 @@ function readSolidFill(container) {
 	const solidFill = firstChild(container, "a:solidFill");
 	const noFill = !!firstChild(container, "a:noFill");
 	if (!solidFill && !noFill) return null;
+	const color = solidFill ? firstChildElement(solidFill) : null;
+	return {
+		colorRef: readColorRef(color, null),
+		noFill,
+		alpha: colorAlpha(color)
+	};
+}
+/** The `a:alpha` of a colour element, 0 to 1, or `null`. */
+function colorAlpha(color) {
+	const alpha = color && firstChild(color, "a:alpha");
+	const value = alpha ? numberValue(attr(alpha, "val")) : null;
+	return value === null ? null : value / 1e5;
+}
+/**
+* The colour context a chart part's fills resolve against: none. A literal resolves with its
+* transforms; a scheme colour does not, since the part is read without its slide's theme.
+*/
+const NO_THEME = {
+	clrMap: /* @__PURE__ */ new Map(),
+	clrScheme: /* @__PURE__ */ new Map()
+};
+/** The solid fill of an element's `c:spPr`, or `null`. */
+function spPrFill(parent) {
+	const spPr = parent && firstChild(parent, "c:spPr");
+	return spPr ? readSolidFill(spPr) : null;
+}
+/** The stroke of an element's `c:spPr/a:ln`, or `null`. */
+function spPrLine(parent) {
+	const spPr = parent && firstChild(parent, "c:spPr");
+	const ln = spPr && firstChild(spPr, "a:ln");
+	return ln ? readChartLine(ln) : null;
+}
+/** A `c:layout`'s manual layout, or `null` when it has none. */
+function readManualLayout(layout) {
+	const manual = layout && firstChild(layout, "c:manualLayout");
+	if (!manual) return null;
+	const value = (qname) => {
+		const element = firstChild(manual, qname);
+		return element ? attr(element, "val") : null;
+	};
+	const number = (qname) => numberValue(value(qname));
+	return {
+		target: value("c:layoutTarget"),
+		xMode: value("c:xMode"),
+		yMode: value("c:yMode"),
+		x: number("c:x"),
+		y: number("c:y"),
+		w: number("c:w"),
+		h: number("c:h")
+	};
+}
+/** A chart surface's `c:spPr` and `c:layout` as a {@link ChartAreaFormat}. */
+function readAreaFormat(spPr, layout, rels) {
+	const solidFill = spPr && firstChild(spPr, "a:solidFill");
+	const color = solidFill && firstChildElement(solidFill);
+	const ln = spPr && firstChild(spPr, "a:ln");
 	return {
-		colorRef: readColorRef(solidFill ? firstChildElement(solidFill) : null, null),
-		noFill
+		fillNoFill: spPr ? firstChild(spPr, "a:noFill") !== null : false,
+		hasOwnFill: hasFillChoice(spPr),
+		fillColor: colorValueOf(color, "srgbClr"),
+		fillSchemeColor: colorValueOf(color, "schemeClr"),
+		resolvedFill: color && color.localName === "srgbClr" ? resolveColorElement(color, NO_THEME) : null,
+		gradientFill: spPr ? readGradientFill(spPr, NO_THEME) : null,
+		patternFill: spPr ? readPatternFill(spPr, NO_THEME) : null,
+		pictureFill: spPr ? readPictureFill(spPr, rels) : null,
+		border: ln ? readChartLine(ln) : null,
+		layout: readManualLayout(layout)
 	};
 }
+/** The `@val` of a colour element of the given local name, or `null`. */
+function colorValueOf(color, localName) {
+	return color && color.localName === localName ? attr(color, "val") : null;
+}
 /** Resolve a `c:cat`/`c:val`/`c:tx` container to its cache element (`c:numCache`/`c:strCache`/literal). */
 function findCache(container) {
 	if (!container) return null;
@@ -5633,8 +6703,7 @@ function readPoints(cache) {
 	const ptCount = firstChild(cache, "c:ptCount");
 	return readIndexedPoints(getElements(cache, "c:pt"), ptCount ? numberValue(attr(ptCount, "val")) : null, (pt) => firstChild(pt, "c:v")?.textContent ?? null, "c:ptCount");
 }
-//#endregion
-//#region src/read/api/chartex.ts
+// src/read/api/chartex.ts
 /** A chartEx graphic-frame's chart, backed by its `cx:chartSpace` part. */
 var ChartEx = class {
 	part;
@@ -5646,7 +6715,7 @@ var ChartEx = class {
 		return this.part.partName;
 	}
 	/**
-	* The `cx:series/@layoutId` tokens in plot-area document order — the raw chartEx
+	* The `cx:series/@layoutId` tokens in plot-area document order: the raw chartEx
 	* layout names (`waterfall`, `funnel`, `treemap`, `sunburst`, `boxWhisker`,
 	* `regionMap`, or `clusteredColumn`/`paretoLine` for histogram & pareto). This is
 	* the OOXML truth: a histogram and a pareto both surface as `clusteredColumn`, so
@@ -5775,7 +6844,7 @@ var ChartExSeries = class {
 		return readLevelPoints(numDim && firstChild(numDim, "cx:lvl")).map(numberValue);
 	}
 	/**
-	* Cached category labels (`cx:strDim`'s leaf `cx:lvl` — the first level, which
+	* Cached category labels (`cx:strDim`'s leaf `cx:lvl`, the first level, which
 	* the writer emits leaf-first). Empty when the data block carries no `cx:strDim`.
 	*/
 	get categories() {
@@ -5866,16 +6935,15 @@ function readLevelPoints(lvl) {
 	if (!lvl) return [];
 	return readIndexedPoints(getElements(lvl, "cx:pt"), numberValue(attr(lvl, "ptCount")), (pt) => pt.textContent ?? null, "cx:lvl/@ptCount");
 }
-//#endregion
-//#region src/read/api/diagram.ts
+// 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
+* 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.
 *
@@ -5908,14 +6976,14 @@ function readLevelPoints(lvl) {
 *
 * **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
+* 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}.
+* supported; see {@link DiagramPoint.text}.
 */
 const POINT_TYPES = [
 	"node",
@@ -5937,7 +7005,7 @@ const DRAWING_EXT_URI = OOXML_NS.dsp;
 * 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
+* 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.
@@ -5980,8 +7048,8 @@ var DrawingIndex = class {
 	* 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
+	* 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
@@ -6052,7 +7120,7 @@ var DiagramPoint = class {
 		return idAttr(this.pt, "cxnId");
 	}
 	/**
-	* Whether this point is an unfilled prompt (`dgm:prSet/@phldr`) — a node PowerPoint draws
+	* Whether this point is an unfilled prompt (`dgm:prSet/@phldr`): a node PowerPoint draws
 	* with a grey placeholder string and treats as empty. Excluded from {@link Diagram.text}:
 	* a layout that stores its prompt in `dgm:t` would otherwise extract as content.
 	*/
@@ -6071,7 +7139,7 @@ var DiagramPoint = class {
 	* `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
+	* 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.
 	*/
@@ -6086,7 +7154,7 @@ var DiagramPoint = class {
 	}
 	/**
 	* 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.
+	* 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.
@@ -6100,7 +7168,7 @@ var DiagramPoint = class {
 	*
 	* 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
+	* 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.
 	*
@@ -6134,7 +7202,7 @@ var DiagramPoint = class {
 	* 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
+	* 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.
@@ -6168,7 +7236,7 @@ var DiagramPoint = class {
 	}
 };
 /**
-* One user-authored point in its place in the diagram's tree — a `node` or an `asst`, never a
+* 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 {
@@ -6207,7 +7275,7 @@ var Diagram = class {
 		return this.part.partName;
 	}
 	/**
-	* Every point (`dgm:ptLst/dgm:pt`) in document order, unfiltered — generated `pres`
+	* Every point (`dgm:ptLst/dgm:pt`) in document order, unfiltered, with 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, {@link nodes} the structured one.
 	*
@@ -6224,8 +7292,8 @@ var Diagram = class {
 		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
+	* 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
@@ -6286,10 +7354,12 @@ var Diagram = class {
 		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.
+	* The point with this `@modelId`, or `null`. This is the lookup every connection getter implies,
+	* since a `DiagramConnection` names its ends by id and nothing else resolves them. Takes
+	* `null`, as a connection end with no id reads, and misses on it.
 	*/
 	point(modelId) {
+		if (modelId === null) return null;
 		return this.points.find((candidate) => candidate.modelId === modelId) ?? null;
 	}
 	/** Every edge (`dgm:cxnLst/dgm:cxn`) in document order. */
@@ -6313,7 +7383,7 @@ var Diagram = class {
 		});
 	}
 	/**
-	* The diagram's text in document order, blocks joined by `\n` — the counterpart to
+	* The diagram's text in document order, blocks joined by `\n`: the counterpart to
 	* `TextFrame.text` for a construct that has no single text body.
 	*
 	* Contributing points are the ones a user can type into: everything except the generated
@@ -6385,7 +7455,7 @@ var Diagram = class {
 		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
+	* 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".
 	*/
@@ -6401,7 +7471,7 @@ var Diagram = class {
 		return prSet ? attr(prSet, name) : null;
 	}
 	/**
-	* The drawing index, built on first use and kept — see {@link DrawingIndex} for what that
+	* 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() {
@@ -6421,15 +7491,14 @@ function idAttr(element, name) {
 	const raw = attr(element, name);
 	return raw === null || raw === "" || raw === "0" ? null : raw;
 }
-//#endregion
-//#region src/read/api/table-structure.ts
+// src/read/api/table-structure.ts
 /**
 * Structural edits to an existing `a:tbl`: adding and removing rows and columns, and
 * merging and unmerging cells.
 *
 * The one fact that makes this tractable is that a stored table's grid is already
-* **rectangular**. Unlike the write path — which receives lopsided row arrays and has to
-* build the merge grid itself (`gen/slide/objects/table.ts` STEP 3) — every `a:tr` in a
+* **rectangular**. Unlike the write path, which receives lopsided row arrays and has to
+* build the merge grid itself (`gen/slide/objects/table.ts` STEP 3), every `a:tr` in a
 * conformant `a:tbl` holds exactly one `a:tc` per grid column, with the covered half of each
 * span present and flagged. So "the cell at (r, c)" is simply the c-th `a:tc` of the r-th
 * `a:tr`, and an edit's whole job is keeping that rectangle true.
@@ -6463,7 +7532,7 @@ function rowsOf(tbl) {
 function cellsOf(tr) {
 	return getElements(tr, "a:tc");
 }
-/** The table's `a:tblGrid`, or a thrown error — `CT_Table` requires one. */
+/** The table's `a:tblGrid`, or a thrown error: `CT_Table` requires one. */
 function gridOf(tbl) {
 	const grid = firstChild(tbl, "a:tblGrid");
 	if (!grid) throw new InvalidOptionError("table/column-index-out-of-range", "This table has no a:tblGrid, so its columns cannot be edited");
@@ -6486,7 +7555,7 @@ function isVMerge(tc) {
 	return boolAttr(tc, "vMerge") === true;
 }
 /**
-* Set a span attribute, removing it when the span collapses to 1 — the schema default, and
+* Set a span attribute, removing it when the span collapses to 1: the schema default, and
 * what PowerPoint itself writes for an unmerged cell.
 */
 function setSpan(tc, name, value) {
@@ -6711,8 +7780,8 @@ function removeColumn(tbl, index) {
 /**
 * Merge the rectangle `(row1, col1)`–`(row2, col2)` into one cell.
 *
-* The top-left cell becomes the origin; every other cell in the rectangle becomes a covered cell
-* — flagged, given the spans PowerPoint repeats on a region's first row and column, and emptied,
+* The top-left cell becomes the origin; every other cell in the rectangle becomes a covered cell:
+* flagged, given the spans PowerPoint repeats on a region's first row and column, and emptied,
 * since a covered cell is never rendered.
 *
 * **The covered cells' text moves into the origin**, as PowerPoint's own Merge Cells does: each
@@ -6823,8 +7892,7 @@ function emptyCellText(tc) {
 	for (const p of getElements(txBody, "a:p")) txBody.removeChild(p);
 	txBody.appendChild(createElement(ownerDocumentOf(txBody), "a:p"));
 }
-//#endregion
-//#region src/read/api/table-style-resolve.ts
+// src/read/api/table-style-resolve.ts
 /**
 * Look up the `a:tblStyle` whose `@styleId` equals `styleId` in the deck's single
 * `tableStyles.xml`, or `null` when there is no such part or no matching style
@@ -6884,7 +7952,7 @@ function cellStyleParts(flags, row, col, rowCount, colCount) {
 /**
 * The fill a single `a:tcStyle` contributes. `fall` means the part defines no fill
 * (only borders, or nothing) so resolution continues to the next-lower part;
-* `stop` means the part settles the fill — either a resolved solid colour or `null`
+* `stop` means the part settles the fill, with either a resolved solid colour or `null`
 * for an explicit `a:noFill` / a non-solid style fill (a gradient has no single hex).
 */
 function tcStyleFill(tcStyle, ctx) {
@@ -6980,29 +8048,28 @@ function resolveTableCellTextStyle(style, flags, row, col, rowCount, colCount, c
 	}
 	return out;
 }
-//#endregion
-//#region src/read/api/table-edit.ts
+// src/read/api/table-edit.ts
 /**
 * Ordered mutation of a table cell's `a:tcPr`, and the cell-scoped schema facts every such
 * edit needs.
 *
 * `CT_TableCellProperties` declares its children as a **sequence**, so an append-only
-* implementation produces an out-of-order `a:tcPr` — which PowerPoint reports as a corrupt
+* implementation produces an out-of-order `a:tcPr`, which PowerPoint reports as a corrupt
 * file rather than as a bad edit. Every insertion therefore goes through
-* {@link getOrAddChild} / {@link insertInOrder} with the new element's *successors*, which is
+* {@link insertInOrder} with the new element's *successors*, which is
 * what `TCPR_AFTER` tabulates; it and the sequence it derives from live in
 * `src/ooxml/sequence.ts` alongside the other complexType orderings.
 *
 * The attribute values are the other half. A value outside its `ST_` union is equally fatal
-* and equally silent, so each is checked against the enum before it is written — the same
+* and equally silent, so each is checked against the enum before it is written: the same
 * validate-at-the-boundary rule the write path follows, with the difference that here there
 * is a caller to throw at rather than a deck to degrade (see `ooxml/check-enum.ts`).
 */
-/** `ST_TextAnchoringType` — `a:tcPr/@anchor`. */
+/** `ST_TextAnchoringType`, for `a:tcPr/@anchor`. */
 const ANCHOR_VALUES = TEXT_ANCHORS;
-/** `ST_TextVerticalType` — `a:tcPr/@vert`. */
+/** `ST_TextVerticalType`, for `a:tcPr/@vert`. */
 const VERT_VALUES = TEXT_VERTICAL;
-/** `ST_TextHorzOverflowType` — `a:tcPr/@horzOverflow`. */
+/** `ST_TextHorzOverflowType`, for `a:tcPr/@horzOverflow`. */
 const HORZ_OVERFLOW_VALUES = TEXT_HORZ_OVERFLOW;
 /** The four edges plus the two diagonals, keyed as {@link TableCellEdge} names them. */
 const EDGE_QNAMES = {
@@ -7022,8 +8089,7 @@ const EDGE_QNAMES = {
 function insertTcPrChild(tcPr, qname, node) {
 	insertInOrder(tcPr, node, TCPR_AFTER[qname] ?? []);
 }
-//#endregion
-//#region src/read/api/table-cell.ts
+// src/read/api/table-cell.ts
 /** One table cell (`a:tc`). */
 var TableCell = class {
 	tc;
@@ -7114,7 +8180,7 @@ var TableCell = class {
 	* The cell's `a:tcPr`, creating it when absent.
 	*
 	* `CT_TableCell` sequences `a:txBody` then `a:tcPr` then `a:extLst`, so a newly created
-	* one is inserted before `a:extLst` — appending it blindly would put it after and make
+	* one is inserted before `a:extLst`; appending it blindly would put it after and make
 	* the part invalid. Every setter below goes through here for that reason.
 	*/
 	#getOrAddTcPr() {
@@ -7137,7 +8203,7 @@ var TableCell = class {
 		this.#setTcPrAttr("vert", value, VERT_VALUES, "table/invalid-cell-vert");
 	}
 	/**
-	* Set (or clear) `a:tcPr/@horzOverflow` — what a single glyph too wide for the cell does.
+	* Set (or clear) `a:tcPr/@horzOverflow`: what a single glyph too wide for the cell does.
 	* `null` removes the attribute; so does `'clip'` in effect, since it is the schema
 	* default, but the attribute is still written as asked.
 	* @throws {InvalidOptionError} when the value is outside `ST_TextHorzOverflowType`
@@ -7161,7 +8227,7 @@ var TableCell = class {
 	*
 	* Partial: only the sides named are touched, so `{ left: 0 }` flushes the text left and
 	* leaves the other three alone. A side given as `null` has its attribute removed, which
-	* returns it to the schema default (91440 EMU left/right, 45720 top/bottom) — not to
+	* returns it to the schema default (91440 EMU left/right, 45720 top/bottom), not to
 	* zero. Pass `{}` to change nothing.
 	* @throws {InvalidOptionError} when a value is not a finite number
 	*/
@@ -7181,7 +8247,7 @@ var TableCell = class {
 		this.part.markDirty();
 	}
 	/**
-	* Set (or clear) one of the cell's six borders — the four edges and the two diagonals.
+	* Set (or clear) one of the cell's six borders: the four edges and the two diagonals.
 	*
 	* `null` removes the element entirely, which is "inherit", and is a different thing from
 	* `{ noFill: true }`, which writes an explicit no-border and suppresses whatever would
@@ -7234,7 +8300,7 @@ var TableCell = class {
 	* `null` removes the `a:solidFill` and lets the cell inherit from the table style again.
 	* That is not the same as {@link noFill}, which writes an explicit `a:noFill` and so
 	* suppresses the inherited shading. Any competing fill choice (`a:gradFill`,
-	* `a:blipFill`, …) is dropped first — `EG_FillProperties` admits one.
+	* `a:blipFill`, …) is dropped first, since `EG_FillProperties` admits one.
 	* @throws {InvalidOptionError} when `color` is not a 6-digit hex string
 	*/
 	setFillColor(color) {
@@ -7249,7 +8315,7 @@ var TableCell = class {
 		this.#applyFill(token === null ? null : { scheme: token });
 	}
 	/**
-	* Write an explicit `<a:noFill/>` on the cell — a transparent cell that shows the table
+	* Write an explicit `<a:noFill/>` on the cell: a transparent cell that shows the table
 	* background (or the slide) through. Distinct from `setFillColor(null)`, which removes
 	* the fill and lets the table style's shading apply again.
 	*/
@@ -7275,23 +8341,23 @@ var TableCell = class {
 	}
 	/**
 	* The cell's solid fill resolved against the table's theme colour context to a
-	* literal hex — the table-cell counterpart of
+	* literal hex. It is the table-cell counterpart of
 	* {@link AutoShape.resolvedFill}. The cell's own
 	* `a:tcPr/a:solidFill` wins; when the cell defines none, this falls back to the
 	* table **style** graph (the `firstRow`/banded/`wholeTbl` shading the
-	* `a:tableStyleId` supplies — see {@link Table.resolvedStyle}), so a styled cell
+	* `a:tableStyleId` supplies; see {@link Table.resolvedStyle}), so a styled cell
 	* with an empty `a:tcPr` reports the colour PowerPoint actually renders rather
 	* than `null`.
 	*
 	* A cell that carries *some other* fill choice (`a:blipFill`/`a:gradFill`/
 	* `a:pattFill`/`a:noFill`) overrides the style graph in PowerPoint, so this
-	* reports `null` for one rather than falling through to the inherited shading —
+	* reports `null` for one rather than falling through to the inherited shading,
 	* the same guard {@link AutoShape.resolvedFill} applies to
 	* the style matrix. Read {@link pictureFill} for an image-filled cell. Also
 	* `null` when neither source yields a solid colour (an
 	* unmapped token, an explicit style `a:noFill`). The returned
 	* {@link ResolvedColor} carries `effectiveHex` (the base colour with its
-	* `lumMod`/`lumOff`/… transforms applied) — read that for the final colour.
+	* `lumMod`/`lumOff`/… transforms applied); read that for the final colour.
 	*/
 	get resolvedFill() {
 		if (this.hasOwnFill) return resolveSolidFillColor(this.#tcPr(), this.themeContext);
@@ -7302,7 +8368,7 @@ var TableCell = class {
 	* child), as opposed to inheriting one from the table style's header/banding rules.
 	*
 	* This is the flag that disambiguates {@link resolvedFill}, which deliberately reports
-	* either — it answers "what colour does this cell render as", and both sources are valid
+	* either: it answers "what colour does this cell render as", and both sources are valid
 	* answers to that. Anything that has to reproduce the cell rather than describe it needs
 	* to know which: baking an inherited banding colour into a copy makes the copy look right
 	* until someone changes its table style, and then nothing moves. `false` for a cell whose
@@ -7312,20 +8378,20 @@ var TableCell = class {
 		return hasFillChoice(this.#tcPr());
 	}
 	/**
-	* `true` when the cell sets an explicit no-fill (`a:tcPr/a:noFill`) — a deliberately
+	* `true` when the cell sets an explicit no-fill (`a:tcPr/a:noFill`): a deliberately
 	* transparent cell showing the table background (or the slide) through. The cell-side
 	* counterpart of {@link AutoShape.fillNoFill}, and what
 	* {@link noFill} writes.
 	*
 	* {@link hasOwnFill} is not this question: it is `true` for *any* `EG_FillProperties`
 	* child, so on its own it cannot separate a suppressed fill from a gradient or an image
-	* one — and every colour accessor ({@link resolvedFill}, {@link fillSchemeColor})
+	* one, and every colour accessor ({@link resolvedFill}, {@link fillSchemeColor})
 	* reports `null` for a no-fill cell exactly as it does for a
 	* cell that inherits its shading from the table style. Deriving it as "has a fill of its
 	* own, and no accessor recognises it" instead of reading it has two failure modes: it
 	* folds `a:grpFill` in with `a:noFill`, and its meaning changes silently the day a
-	* further fill kind gets an accessor. The two paint completely differently — an
-	* inherited banding colour versus nothing at all — so a consumer that cannot tell them
+	* further fill kind gets an accessor. The two paint completely differently (an
+	* inherited banding colour versus nothing at all), so a consumer that cannot tell them
 	* apart paints a transparent cell in the style's shading.
 	*/
 	get fillNoFill() {
@@ -7383,7 +8449,7 @@ var TableCell = class {
 	* `null` when the cell defines none. Each present edge decodes to a
 	* {@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
+	* 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.
 	*/
@@ -7393,7 +8459,10 @@ var TableCell = class {
 		const decode = (qname) => {
 			const ln = firstChild(tcPr, qname);
 			if (!ln) return null;
-			return readLineBasics(ln, this.themeContext);
+			return {
+				...readLineBasics(ln, this.themeContext),
+				cap: attr(ln, "cap") ?? null
+			};
 		};
 		const borders = {
 			left: decode("a:lnL"),
@@ -7423,7 +8492,7 @@ var TableCell = class {
 	}
 	/**
 	* Whether the cell's whole text **block** is centred horizontally within it
-	* (`a:tcPr/@anchorCtr`). `false` when unset — that is the schema default, and it is
+	* (`a:tcPr/@anchorCtr`). `false` when unset; that is the schema default, and it is
 	* what PowerPoint writes nothing for.
 	*
 	* Distinct from a paragraph's `align`, which decides where each *line* sits inside the
@@ -7467,12 +8536,12 @@ var TableCell = class {
 	*
 	* This is what {@link headerIds} references: a data cell names the header cells that
 	* govern it by their `@id`, which is how a complex table tells a screen reader what a
-	* value means. Unrelated to the shape-level `p:cNvPr/@id` — it is an `xs:string` scoped
+	* value means. Unrelated to the shape-level `p:cNvPr/@id`: it is an `xs:string` scoped
 	* to the table, not a slide-wide numeric id.
 	*
 	* **PowerPoint does not write this and strips it on save**, so it will read `null` on
 	* any deck PowerPoint has saved, however it was produced. It is surfaced for decks from
-	* other producers. There is deliberately no write-API counterpart — see
+	* other producers. There is deliberately no write-API counterpart; see
 	* `test/read/fixtures/authoring/probe-table-cell-a11y-and-3d.ps1` for the measurement.
 	*/
 	get id() {
@@ -7481,7 +8550,7 @@ var TableCell = class {
 	/**
 	* The `@id`s of the header cells that govern this cell
 	* (`a:tcPr/a:headers/a:header/@val`), in document order. Empty when the cell declares no
-	* header association — which is the common case, since only a complex table needs one.
+	* header association, which is the common case, since only a complex table needs one.
 	*
 	* Carries the same caveat as {@link id}: PowerPoint strips `a:headers` on save, so this
 	* is empty on any PowerPoint-saved deck. `Table.firstRowHeader` (`a:tblPr/@firstRow`) is
@@ -7496,7 +8565,7 @@ var TableCell = class {
 	/**
 	* How the cell treats a glyph too wide for its text width (`a:tcPr/@horzOverflow`):
 	* `'clip'` cuts it at the cell edge, `'overflow'` lets it draw past. `null` when unset
-	* (PowerPoint clips). Not a wrap flag — cell text always wraps to the column width.
+	* (PowerPoint clips). Not a wrap flag: cell text always wraps to the column width.
 	*/
 	get horzOverflow() {
 		const tcPr = this.#tcPr();
@@ -7542,8 +8611,7 @@ var TableCell = class {
 		this.part.markDirty();
 	}
 };
-//#endregion
-//#region src/read/api/table-row.ts
+// src/read/api/table-row.ts
 /** One table row (`a:tr`). */
 var TableRow = class {
 	tr;
@@ -7577,8 +8645,7 @@ var TableRow = class {
 		this.part.markDirty();
 	}
 };
-//#endregion
-//#region src/read/api/table.ts
+// src/read/api/table.ts
 /** A table: a grid of rows and cells inside a graphic frame. */
 var Table = class {
 	tbl;
@@ -7603,7 +8670,7 @@ var Table = class {
 	* from the deck's `tableStyles.xml`, or `null` when the table names no
 	* `a:tableStyleId`, the deck has no `tableStyles.xml`, or the id is a built-in
 	* `[MS-OE376]` style the deck does not materialise. This is what supplies the
-	* banded-row / header shading a cell with no own fill inherits — read the
+	* banded-row / header shading a cell with no own fill inherits. Read the
 	* resolved per-cell colour off {@link TableCell.resolvedFill}.
 	*
 	* Resolved afresh on every read, not through the per-instance memo the cells share, so an
@@ -7671,7 +8738,7 @@ var Table = class {
 	* `{5940675A-B579-460E-94D1-54222C63F5DA}`, or `null` when the table carries no
 	* `a:tableStyleId`. This is the reference into `ppt/tableStyles.xml` (or a
 	* built-in `[MS-OE376]` style) that supplies the banded-row / header shading the
-	* `firstRow`/`bandRow` flags activate — without it a replica loses the whole
+	* `firstRow`/`bandRow` flags activate. Without it a replica loses the whole
 	* table style, so it is the read counterpart of the writer's `tableStyle` option.
 	*/
 	get styleId() {
@@ -7686,7 +8753,7 @@ var Table = class {
 	* This is the table-level counterpart of {@link TableCell.resolvedFill}, and it is a
 	* genuinely different thing from a cell fill: a `a:tblPr` fill sits *behind* the grid, so
 	* a cell with no fill of its own shows it through. Reports `null` for a non-solid choice
-	* (`a:blipFill`/`a:gradFill`/`a:pattFill`/`a:noFill`) — read {@link pictureFill} for an
+	* (`a:blipFill`/`a:gradFill`/`a:pattFill`/`a:noFill`); read {@link pictureFill} for an
 	* image background.
 	*/
 	get resolvedFill() {
@@ -7764,6 +8831,13 @@ var Table = class {
 		return this.#tblPrFlag("lastCol");
 	}
 	/**
+	* Whether the table reads right to left (`a:tblPr/@rtl`), from `addTable`'s `rtl`: its columns
+	* run from the right edge, so column 0 is the rightmost.
+	*/
+	get rtl() {
+		return this.#tblPrFlag("rtl");
+	}
+	/**
 	* The cell at `(rowIndex, columnIndex)` (both zero-based), or `null` when out
 	* of range. Column index counts `a:tc` elements in the row, so a cell that
 	* spans columns (`gridSpan`) occupies a single index here.
@@ -7793,7 +8867,7 @@ var Table = class {
 	* Remove the row at `index`, with its content.
 	*
 	* A cell in the row that *continues* a vertical merge shortens that merge. A cell that
-	* *starts* one hands the region to its first continuation, which becomes the new origin —
+	* *starts* one hands the region to its first continuation, which becomes the new origin:
 	* the merged region survives one row shorter, and only the removed row's own text is lost.
 	* @throws {InvalidOptionError} when `index` is out of range
 	*/
@@ -7832,7 +8906,7 @@ var Table = class {
 	* never rendered.
 	*
 	* A rectangle that cuts through an existing merge is **rejected**, not silently widened
-	* to fit — the caller asked for a specific region, and quietly producing a different one
+	* to fit. The caller asked for a specific region, and quietly producing a different one
 	* is how a layout ends up wrong with nothing to point at. Unmerge first.
 	* @throws {InvalidOptionError} when an index is out of range, the range covers one cell,
 	*   or it partially overlaps an existing merge
@@ -7864,10 +8938,9 @@ var Table = class {
 		return tblPr ? boolAttr(tblPr, name) === true : false;
 	}
 };
-//#endregion
-//#region src/read/api/shapes/graphic-frame.ts
+// src/read/api/shapes/graphic-frame.ts
 /**
-* A graphic frame (`p:graphicFrame`) — the host element for a table, a chart, a chartEx
+* A graphic frame (`p:graphicFrame`): the host element for a table, a chart, a chartEx
 * chart, or a SmartArt diagram.
 *
 * Which one it holds is told by the `a:graphicData/@uri`, so the accessors below each check
@@ -7876,7 +8949,7 @@ var Table = class {
 * without it a consumer cannot tell "this frame holds content I cannot reach" from "this
 * frame holds a chart with nothing in it", since every predicate answers `false` for both.
 */
-/** A graphic frame (`p:graphicFrame`) — host for tables, charts and SmartArt diagrams. */
+/** A graphic frame (`p:graphicFrame`), the host for tables, charts and SmartArt diagrams. */
 var GraphicFrame = class extends Shape {
 	shapeType = "graphicFrame";
 	xfrm() {
@@ -7911,7 +8984,7 @@ var GraphicFrame = class extends Shape {
 		return this.#graphicDataUri() === OOXML_NS.dgm;
 	}
 	/**
-	* The `a:graphicData/@uri` verbatim — the namespace naming what this frame hosts, or
+	* The `a:graphicData/@uri` verbatim: the namespace naming what this frame hosts, or
 	* `null` when the frame carries no `a:graphicData`.
 	*
 	* Every `has*` predicate is a comparison against this, so a frame whose URI matches none
@@ -7938,7 +9011,7 @@ var GraphicFrame = class extends Shape {
 		const relId = chartRef && attr(chartRef, "r:id");
 		if (!relId) return null;
 		const part = relPart(this.host.opc, this.host.relationships, relId);
-		return part ? new Chart(part) : null;
+		return part ? new Chart(part, this.host.opc.relationshipsFor(part.partName)) : null;
 	}
 	/**
 	* The hosted chartEx chart (waterfall/funnel/treemap/…), or `null` when this
@@ -7978,25 +9051,24 @@ var GraphicFrame = class extends Shape {
 		return graphicData ? attr(graphicData, "uri") : null;
 	}
 };
-//#endregion
-//#region src/read/api/shapes.ts
+// src/read/api/shapes.ts
 /**
 * Read-model proxies for the shapes in a `p:spTree`.
 *
 * The `p:spTree` holds five shape kinds; each wraps its element and exposes
 * non-visual identity (id/name), geometry (left/top/width/height in EMU), and
 * kind-specific reads. Proxies hold a back-reference to the owning
-* {@link ShapeHost} — the slide, layout, or master whose part carries the tree —
+* {@link ShapeHost} (the slide, layout, or master whose part carries the tree),
 * so pictures can resolve their image relationship and so edits can mark that
 * part dirty.
 *
 * This module is the entry point for that model: the `Shape` base and the four leaf kinds live in
-* `./shapes/`, and only the dispatch that turns an element into a proxy — plus `GroupShape`, which
-* recurses back through it — is here. Everything the read API surfaces is re-exported below, so
+* `./shapes/`, and only the dispatch that turns an element into a proxy (plus `GroupShape`, which
+* recurses back through it) is here. Everything the read API surfaces is re-exported below, so
 * `pptx-ts/read` and its consumers keep importing shapes from one place.
 */
 /**
-* A group shape (`p:grpSp`) — contains nested shapes.
+* A group shape (`p:grpSp`), which contains nested shapes.
 *
 * It is the one kind defined here rather than under `./shapes/`: its `shapes` getter recurses
 * through `buildShapes` below, so putting it in a sibling module would make the dispatch and the
@@ -8030,7 +9102,7 @@ var GroupShape = class extends Shape {
 	* element is incomplete.
 	*
 	* Most consumers should not need this: {@link Shape.absoluteFrame} already
-	* composes the whole ancestor chain — child space, group flips and rotations —
+	* composes the whole ancestor chain (child space, group flips and rotations),
 	* and doing that arithmetic per consumer is how a shape in a nested group ends
 	* up subtly displaced. It is here for a *replica* consumer rather than a
 	* *paint* one: rebuilding this group and its children as OOXML needs the
@@ -8053,7 +9125,7 @@ var GroupShape = class extends Shape {
 		return buildShapes(this.element, this.host);
 	}
 };
-/** Narrow a shape to an {@link AutoShape} (`p:sp` — auto shape, text box, or placeholder). */
+/** Narrow a shape to an {@link AutoShape} (`p:sp`: auto shape, text box, or placeholder). */
 function isAutoShape(shape) {
 	return shape.shapeType === "autoShape";
 }
@@ -8065,7 +9137,7 @@ function isPicture(shape) {
 function isConnector(shape) {
 	return shape.shapeType === "connector";
 }
-/** Narrow a shape to a {@link GraphicFrame} (`p:graphicFrame` — table/chart host). */
+/** Narrow a shape to a {@link GraphicFrame} (`p:graphicFrame`, the table/chart host). */
 function isGraphicFrame(shape) {
 	return shape.shapeType === "graphicFrame";
 }
@@ -8093,7 +9165,7 @@ function wrapShapeElement(element, host) {
 * The richer of an `mc:AlternateContent`'s two branches: the first `mc:Choice`
 * that carries a shape element (what PowerPoint renders when it understands the
 * required feature), falling back to `mc:Fallback`. PowerPoint wraps a shape this
-* way when its full form needs a feature namespace a plain consumer lacks — a
+* way when its full form needs a feature namespace a plain consumer lacks: a
 * chartEx chart's `p:graphicFrame`, a zoom frame, an inline-math shape. Returns
 * the wrapped inner shape, or `null` when neither branch holds one.
 */
@@ -8130,11 +9202,13 @@ function buildShapes(parent, host) {
 /**
 * The first shape in `shapes` with the given drawing id (`p:cNvPr/@id`), walked
 * pre-order so a group is visited before its children. Backs
-* {@link ShapeHost.shapeByIdDeep} on all three hosts — drawing ids are unique
+* {@link ShapeHost.shapeByIdDeep} on all three hosts. Drawing ids are unique
 * within a part, so the first match is the only match and the walk order just
-* fixes a deterministic one.
+* fixes a deterministic one. A `null` id, as a shape's `id` reads when it has
+* no `@id`, is a miss, not a match on the first shape that lacks one too.
 */
 function findShapeByIdDeep(shapes, id) {
+	if (id === null) return void 0;
 	for (const shape of shapes) {
 		if (shape.id === id) return shape;
 		if (shape instanceof GroupShape) {
@@ -8143,7 +9217,6 @@ function findShapeByIdDeep(shapes, id) {
 		}
 	}
 }
-//#endregion
-export { placeholderInheritedColor as $, relsPartNameFor as $t, flattenAnimations as A, CSLD_AFTER_BG as At, readColorRef as B, SLIDE_AFTER_TRANSITION as Bt, ChartSeries as C, styleRefFill as Ct, Shape as D, presetColorHex as Dt, AutoShape as E, themeElementsOfRoot as Et, Paragraph as F, PRESENTATION_AFTER_SLD_ID_LST as Ft, resolveSlideColorContext as G, SPPR_LN_AFTER as Gt, resolveLayoutColorContext as H, SPPR_AFTER_XFRM as Ht, Run as I, PRESENTATION_AFTER_SLD_MASTER_ID_LST as It, checkPositiveEmu as J, TXBODY_AFTER_BODYPR as Jt, resolveSlideThemeParts as K, SPPR_SCENE3D_AFTER as Kt, readPatternFill as L, RPR_FILL_AFTER as Lt, pruneSpids as M, LN_SLOTS as Mt, remapSpids as N, PRESENTATION_AFTER_EMBEDDED_FONT_LST as Nt, carryShapeAnimations as O, hasFillChoice as Ot, TextFrame as P, PRESENTATION_AFTER_NOTES_MASTER_ID_LST as Pt, placeholderInheritedAnchor as Q, relativePartName as Qt, readPictureFill as R, RUN_AFTER_RPR as Rt, ChartAxis as S, resolveSchemeToken as St, Picture as T, substitutePhClr as Tt, resolveMasterColorContext as U, SPPR_EFFECT_AFTER as Ut, resolveColorElement as V, SLIDE_MASTER_AFTER_SLD_LAYOUT_ID_LST as Vt, resolveNotesColorContext as W, SPPR_FILL_AFTER as Wt, RUN_PROP_NAMES as X, partNameExtension as Xt, LST_STYLE_LEVELS as Y, TXBODY_AFTER_LSTSTYLE as Yt, lstStyleLevelDefRPr as Z, partNameToZipPath as Zt, DiagramPoint as _, parseXml as _n, isA as _t, isConnector as a, boolAttr as an, slideDefinesProp as at, ChartExSeries as b, serializeXml as bn, replaceColorElement as bt, isPicture as c, descendantsByTag as cn, carriedDecorations as ct, Table as d, getElements as dn, nextDrawingId as dt, resolveRelativePartName as en, placeholderInheritedListStyles as et, TableRow as f, getOrAddChild as fn, nthShapeChild as ft, DiagramNode as g, ownerDocumentOf as gn, fmtEntry as gt, Diagram as h, numberValue as hn, spTreeOf as ht, isAutoShape as i, attr as in, slideDefinesColor as it, hasAnimations as j, EMBEDDED_FONT_ENTRY_AFTER as jt, enumerateSpids as k, applyColorTransforms as kt, wrapShapeElement as l, firstChild as ln, collectElements as lt, resolveTableCellTextStyle as m, numberAttr as mn, reassignDrawingIds as mt, buildShapes as n, singleRelPart as nn, placeholderInheritedXfrm as nt, isGraphicFrame as o, childElements as on, cSldName as ot, TableCell as p, insertInOrder as pn, nvPrOf as pt, checkFiniteEmu as q, SPPR_SP3D_AFTER as qt, findShapeByIdDeep as r, zipPathToPartName as rn, placeholderOf as rt, isGroupShape as s, createElement as sn, cSldOf as st, GroupShape as t, resolveSingleRel as tn, placeholderInheritedRunProps as tt, GraphicFrame as u, firstChildElement as un, firstShapeChild as ut, ChartEx as v, removeAttr as vn, parseClrMap as vt, Connector as w, styleRefLine as wt, Chart as x, setAttr as xn, resolveColor as xt, ChartExAxis as y, removeChildrenByQName as yn, parseClrScheme as yt, readGradientFill as z, SHAPE_AFTER_SPPR as zt };
+export { LST_STYLE_LEVELS as $, TXBODY_AFTER_LSTSTYLE as $t, enumerateSpids as A, themeElementsOfRoot as At, composeGroupFrame as B, PRESENTATION_AFTER_SLD_MASTER_ID_LST as Bt, ChartPlotGroup as C, removeChildrenByQName as Cn, parseClrScheme as Ct, AutoShape as D, styleRefFill as Dt, Picture as E, resolveSchemeToken as Et, remapSpids as F, EMBEDDED_FONT_ENTRY_AFTER as Ft, resolveColorElement as G, SLIDE_MASTER_AFTER_SLD_LAYOUT_ID_LST as Gt, readGradientFill as H, RUN_AFTER_RPR as Ht, TextFrame as I, LN_SLOTS as It, resolveNotesColorContext as J, SPPR_FILL_AFTER as Jt, resolveLayoutColorContext as K, SPPR_AFTER_XFRM as Kt, Paragraph as L, PRESENTATION_AFTER_EMBEDDED_FONT_LST as Lt, hasAnimations as M, hasFillChoice as Mt, pruneSpids as N, applyColorTransforms as Nt, Shape as O, styleRefLine as Ot, readBuildEffects as P, CSLD_AFTER_BG as Pt, checkPositiveEmu as Q, TXBODY_AFTER_BODYPR as Qt, Field as R, PRESENTATION_AFTER_NOTES_MASTER_ID_LST as Rt, ChartAxis as S, removeAttr as Sn, parseClrMap as St, Connector as T, setAttr as Tn, resolveColor as Tt, readPictureFill as U, SHAPE_AFTER_SPPR as Ut, readPatternFill as V, RPR_FILL_AFTER as Vt, readColorRef as W, SLIDE_AFTER_TRANSITION as Wt, resolveSlideThemeParts as X, SPPR_SCENE3D_AFTER as Xt, resolveSlideColorContext as Y, SPPR_LN_AFTER as Yt, checkFiniteEmu as Z, SPPR_SP3D_AFTER as Zt, DiagramPoint as _, insertInOrder as _n, nvPrOf as _t, isConnector as a, resolveSingleRel as an, placeholderInheritedRunProps as at, ChartExSeries as b, ownerDocumentOf as bn, fmtEntry as bt, isPicture as c, attr as cn, slideDefinesColor as ct, Table as d, createElement as dn, cSldOf as dt, partNameExtension as en, RUN_PROP_NAMES as et, TableRow as f, descendantsByTag as fn, carriedDecorations as ft, DiagramNode as g, getOrAddChild as gn, nthShapeChild as gt, Diagram as h, getElements as hn, nextDrawingId as ht, isAutoShape as i, resolveRelativePartName as in, placeholderInheritedListStyles as it, flattenAnimations as j, presetColorHex as jt, carryShapeAnimations as k, substitutePhClr as kt, wrapShapeElement as l, boolAttr as ln, slideDefinesProp as lt, resolveTableCellTextStyle as m, firstChildElement as mn, firstShapeChild as mt, buildShapes as n, relativePartName as nn, placeholderInheritedAnchor as nt, isGraphicFrame as o, singleRelPart as on, placeholderInheritedXfrm as ot, TableCell as p, firstChild as pn, collectElements as pt, resolveMasterColorContext as q, SPPR_EFFECT_AFTER as qt, findShapeByIdDeep as r, relsPartNameFor as rn, placeholderInheritedColor as rt, isGroupShape as s, zipPathToPartName as sn, placeholderOf as st, GroupShape as t, partNameToZipPath as tn, lstStyleLevelDefRPr as tt, GraphicFrame as u, childElements as un, cSldName as ut, ChartEx as v, numberAttr as vn, reassignDrawingIds as vt, ChartSeries as w, serializeXml as wn, replaceColorElement as wt, Chart as x, parseXml as xn, isA as xt, ChartExAxis as y, numberValue as yn, spTreeOf as yt, Run as z, PRESENTATION_AFTER_SLD_ID_LST as zt };
 
-//# sourceMappingURL=shapes-re0KyQk_.js.map
+//# sourceMappingURL=shapes-CAPOjU0Q.js.map