@shbernal/ts-pptx 2.0.0 → 3.1.0

package/dist/{shapes-CaOgR0i1.js → shapes-DMThLsZN.js}

@@ -1,6 +1,6 @@
 import { n as warn } from "./diagnostics-DYQC7xLV.js";
-import { i as PackageReadError, n as InvalidOptionError, o as UnsupportedFeatureError, t as InternalError } from "./errors-DGE9zh3U.js";
-import { r as getImageSizeFromBytes, t as fitSrcRectPercents } from "./image-size-C8uYE8GJ.js";
+import { i as PackageReadError, n as InvalidOptionError, o as UnsupportedFeatureError, t as InternalError } from "./errors-Bvln0H-7.js";
+import { C as getImageSizeFromBytes, _ as SLIDE_LAYOUT_REL, b as THEME_REL, c as TEXT_VERTICAL, d as IMAGE_REL, f as NOTES_MASTER_REL, l as checkEnumOrThrow, m as OFFICE_DOCUMENT_REL, o as TEXT_ANCHORS, s as TEXT_HORZ_OVERFLOW, v as SLIDE_MASTER_REL, x as fitSrcRectPercents } from "./st-enums-evQG2A7Z.js";
 import { DOMParser, MIME_TYPE, XMLSerializer, onErrorStopParsing } from "@xmldom/xmldom";
 /** Parse an XML string strictly: any well-formedness error throws. */
 function parseXml(xml) {
@@ -58,11 +58,25 @@ function getElements(parent, qname) {
 	return out;
 }
 /** All direct child elements in document order, regardless of qname. */
-function childElements$2(parent) {
+function childElements(parent) {
 	const out = [];
 	for (let node = parent.firstChild; node; node = node.nextSibling) if (node.nodeType === 1) out.push(node);
 	return out;
 }
+/**
+* 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
+* the very elements being iterated.
+*
+* Note the DOM's own exclusion: `root` itself is never a candidate, only its descendants.
+*/
+function descendantsByTag(root, ns, local) {
+	const out = [];
+	for (const element of root.getElementsByTagNameNS(ns, local)) out.push(element);
+	return out;
+}
 /** First direct child element matching a qname, or `null`. */
 function firstChild(parent, qname) {
 	const { uri, local } = splitQName(qname);
@@ -216,6 +230,20 @@ function escapeXmlAttribute(value) {
 * A partname is an absolute, `/`-separated path inside the package, e.g.
 * `/ppt/slides/slide1.xml`. Zip entry paths omit the leading slash.
 */
+/**
+* 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
+* same type would itself be malformed.
+*
+* The `OpcPackage` import is type-only, so this does not create a cycle with `package.ts` (which
+* imports this module at run time).
+*/
+function resolveSingleRel(opc, partName, type) {
+	const rels = opc.relationshipsFor(partName);
+	const rel = rels.byType(type)[0];
+	return rel ? rels.resolveTarget(rel.id) : null;
+}
 function zipPathToPartName(zipPath) {
 	return zipPath.startsWith("/") ? zipPath : `/${zipPath}`;
 }
@@ -272,16 +300,11 @@ function resolveRelativePartName(sourcePartName, target) {
 	return `/${segments.join("/")}`;
 }
 //#endregion
-//#region src/read/oxml/fill.ts
+//#region src/ooxml/sequence.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.
+* `EG_FillProperties` — the mutually exclusive fill choices, in schema order.
+* @see ECMA-376 Part 1 §20.1.8 (DrawingML fill group)
 */
-/** The mutually-exclusive fill choices (`EG_FillProperties`); a parent has at most one. */
 const FILL_CHOICES = [
 	"a:noFill",
 	"a:solidFill",
@@ -290,6 +313,143 @@ const FILL_CHOICES = [
 	"a:pattFill",
 	"a:grpFill"
 ];
+/** `EG_EffectProperties` — the two mutually exclusive effect containers. */
+const EFFECT_CHOICES = ["a:effectLst", "a:effectDag"];
+/** `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
+* 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.
+*/
+function successorsOf(sequence, member) {
+	const index = sequence.findIndex((step) => typeof step === "string" ? step === member : step.includes(member));
+	if (index < 0) throw new Error(`successorsOf: ${member} is not part of the given sequence`);
+	return sequence.slice(index + 1).flat();
+}
+/**
+* `CT_ShapeProperties` (`p:spPr`), in declaration order.
+* @see ECMA-376 Part 1 §20.1.2.2.35
+*/
+const SPPR_SEQUENCE = [
+	"a:xfrm",
+	GEOMETRY_CHOICES,
+	FILL_CHOICES,
+	"a:ln",
+	EFFECT_CHOICES,
+	"a:scene3d",
+	"a:sp3d",
+	"a:extLst"
+];
+/**
+* `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
+* shape ones.
+* @see ECMA-376 Part 1 §20.1.2.2.19
+*/
+const GRPSPPR_SEQUENCE = [
+	"a:xfrm",
+	FILL_CHOICES,
+	EFFECT_CHOICES,
+	"a:scene3d",
+	"a:extLst"
+];
+/**
+* `CT_LineProperties` (`a:ln`), in declaration order.
+* @see ECMA-376 Part 1 §20.1.2.2.24
+*/
+const LN_SEQUENCE = [
+	FILL_CHOICES,
+	["a:prstDash", "a:custDash"],
+	[
+		"a:round",
+		"a:bevel",
+		"a:miter"
+	],
+	"a:headEnd",
+	"a:tailEnd",
+	"a:extLst"
+];
+/**
+* `CT_TextCharacterProperties` (`a:rPr`/`a:defRPr`/`a:endParaRPr`), in declaration order.
+* @see ECMA-376 Part 1 §21.1.2.3.9
+*/
+const RPR_SEQUENCE = [
+	"a:ln",
+	FILL_CHOICES,
+	EFFECT_CHOICES,
+	"a:highlight",
+	["a:uLnTx", "a:uLn"],
+	["a:uFillTx", "a:uFill"],
+	"a:latin",
+	"a:ea",
+	"a:cs",
+	"a:sym",
+	"a:hlinkClick",
+	"a:hlinkMouseOver",
+	"a:rtl",
+	"a:extLst"
+];
+/**
+* `CT_TableCellProperties` (`a:tcPr`), in declaration order.
+* @see ECMA-376 Part 1 §21.1.3.17
+*/
+const TCPR_SEQUENCE = [
+	"a:lnL",
+	"a:lnR",
+	"a:lnT",
+	"a:lnB",
+	"a:lnTlToBr",
+	"a:lnBlToTr",
+	"a:cell3D",
+	...FILL_CHOICES,
+	"a:headers",
+	"a:extLst"
+];
+/**
+* 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)]));
+/** Successors of `a:xfrm` inside `p:spPr`. */
+const SPPR_AFTER_XFRM = successorsOf(SPPR_SEQUENCE, "a:xfrm");
+/** Successors of a fill choice inside `p:spPr`. */
+const SPPR_FILL_AFTER = successorsOf(SPPR_SEQUENCE, "a:solidFill");
+/** Successors of `a:ln` inside `p:spPr`. */
+const SPPR_LN_AFTER = successorsOf(SPPR_SEQUENCE, "a:ln");
+/** Successors of an effect container inside `p:spPr`. */
+const SPPR_EFFECT_AFTER = successorsOf(SPPR_SEQUENCE, "a:effectLst");
+/** Successors of `a:scene3d` inside `p:spPr`. */
+const SPPR_SCENE3D_AFTER = successorsOf(SPPR_SEQUENCE, "a:scene3d");
+/** Successors of `a:sp3d` inside `p:spPr`. */
+const SPPR_SP3D_AFTER = successorsOf(SPPR_SEQUENCE, "a:sp3d");
+/** Successors of `a:xfrm` inside `p:grpSpPr`. */
+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:spPr` within `p:sp` (and before `p:style` within `p:pic` / `p:cxnSp`).
+* `p:blipFill` and the `p:nv*Pr` wrapper precede `p:spPr` and so are deliberately absent.
+*/
+const SHAPE_AFTER_SPPR = ["p:style", "p:txBody"];
+/** Successors of a fill choice inside `a:ln`. */
+const LN_FILL_AFTER = successorsOf(LN_SEQUENCE, "a:solidFill");
+/** Successors of a fill choice inside `a:rPr` (and `a:defRPr`/`a:endParaRPr`). */
+const RPR_FILL_AFTER = successorsOf(RPR_SEQUENCE, "a:solidFill");
+//#endregion
+//#region 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.
+*/
 /** Normalize a 6-hex RGB string (optional leading `#`) to upper-case, or throw. */
 function normalizeHex(value) {
 	const hex = value.startsWith("#") ? value.slice(1) : value;
@@ -318,41 +478,27 @@ function setSolidFill(parent, afterOrder, color) {
 //#endregion
 //#region src/read/oxml/theme.ts
 /**
-* Theme resolution for the {@link Presentation.importSlide} `theme: 'preserve'`
-* mode: bake the values a slide's *source* theme would have produced into the
-* slide XML, so the slide no longer depends on which theme it resolves against.
+* Theme colour resolution: turning a DrawingML colour reference or a style-matrix reference into
+* something literal.
 *
-* Two kinds of theme dependency are flattened (see IMPORT_SLIDE_THEME_PRESERVE):
+* Two maps do the colour work. A scheme token (`accent1`, `bg1`, …) routes through the master's
+* `clrMap` to a `clrScheme` slot, whose literal RGB is the answer; child colour transforms
+* (`lumMod`/`shade`/`alpha`/…) are carried through untouched rather than computed, so a caller
+* that re-emits them renders identically. A style-matrix reference (`a:fillRef`/`a:lnRef`) instead
+* indexes the theme's `fmtScheme`, and resolves to a deep-cloned entry with its `phClr`
+* placeholder substituted.
 *
-* 1. **`a:schemeClr` tokens** — a scheme token (`accent1`, `bg1`, …) routes
-*    through the master's `clrMap` to a `clrScheme` slot, whose literal RGB we
-*    emit as `a:srgbClr`. Child colour transforms (`lumMod`/`shade`/`alpha`/…)
-*    are carried through untouched, so tints/shades render identically — we swap
-*    only the *base* colour reference, never compute the transform math.
-* 2. **Style-matrix refs** — a shape's `p:style` (`lnRef`/`fillRef`/`effectRef`)
-*    indexes the theme's `fmtScheme`; we resolve the indexed entry into an
-*    explicit `spPr` fill/line/effect (substituting its `phClr` placeholder with
-*    the ref's own colour) and neutralize the ref so it cannot re-resolve. The
-*    `fontRef` is left intact so its font (and resolved colour) can re-bind to
-*    the destination theme — the deliberate "normalize fonts on attach" bonus.
-* 3. **Placeholder-inherited run colour** — a run whose `a:rPr` carries no own
-*    fill takes its colour from the source placeholder → layout → master text
-*    style chain (`p:txStyles` / placeholder `a:lstStyle`). Rebinding to the
-*    destination master would replace that chain and flip the colour, so we
-*    resolve each such run's effective colour from the *source* styles and write
-*    it explicitly onto the run.
-* 4. **Placeholder-inherited geometry & run size** — a placeholder shape with no
-*    own `a:xfrm` takes its position/size from the matching source layout/master
-*    placeholder, and a run with no own `sz`/`b`/`i` takes them from the same text
-*    style chain. Rebinding to the destination master replaces both inheritances,
-*    so a title clips off-canvas and type comes out at the wrong size. We bake the
-*    effective `a:xfrm` onto the shape and the effective `sz`/`b`/`i` onto each run.
-*    Typeface (`a:latin`) is deliberately *not* baked — it re-binds to the
-*    destination theme along with `fontRef`.
+* Everything here is **pure**: it reads a DOM and builds detached elements, and mutates nothing
+* the caller passes in. Two very different consumers depend on that:
 *
-* All functions operate purely on DOM elements; the caller gathers the source
-* `clrMap` / `clrScheme` / `fmtScheme` parts (and the source layout/master roots
-* for the placeholder inheritance passes) and owns marking the slide dirty.
+* - the read model's colour getters, which resolve a colour to report it;
+* - the import-time flatten passes (`read/api/ops/flatten.ts`), which resolve the same colour in
+*   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.
+* Placeholder-inheritance resolution (what a placeholder gets from its layout/master chain) is
+* its own concern and lives in `placeholder-inherit.ts`.
 */
 /** The 12 `a:clrScheme` slot names, in schema order. */
 const SCHEME_SLOTS = [
@@ -376,39 +522,6 @@ const DIRECT_SLOT_TOKENS = /* @__PURE__ */ new Set([
 	"dk2",
 	"lt2"
 ]);
-/** Schema successors for ordered insertion into `p:spPr` (CT_ShapeProperties). */
-const SPPR_XFRM_AFTER = [
-	"a:custGeom",
-	"a:prstGeom",
-	...FILL_CHOICES,
-	"a:ln",
-	"a:effectLst",
-	"a:effectDag",
-	"a:scene3d",
-	"a:sp3d",
-	"a:extLst"
-];
-const SPPR_FILL_AFTER$1 = [
-	"a:ln",
-	"a:effectLst",
-	"a:effectDag",
-	"a:scene3d",
-	"a:sp3d",
-	"a:extLst"
-];
-const SPPR_LN_AFTER$1 = [
-	"a:effectLst",
-	"a:effectDag",
-	"a:scene3d",
-	"a:sp3d",
-	"a:extLst"
-];
-const SPPR_EFFECT_AFTER = [
-	"a:scene3d",
-	"a:sp3d",
-	"a:extLst"
-];
-const SHAPE_AFTER_SPPR$1 = ["p:style", "p:txBody"];
 /** Parse an `a:clrScheme` into slot → 6-hex RGB, reading `srgbClr`/`sysClr`. */
 function parseClrScheme(clrScheme) {
 	const out = /* @__PURE__ */ new Map();
@@ -452,12 +565,6 @@ function resolveSchemeToken(token, ctx) {
 	const slot = DIRECT_SLOT_TOKENS.has(token) ? token : ctx.clrMap.get(token);
 	return slot ? ctx.clrScheme.get(slot) ?? null : null;
 }
-/** Direct child *elements* of `parent`, in order. */
-function childElements$1(parent) {
-	const out = [];
-	for (let node = parent.firstChild; node; node = node.nextSibling) if (node.nodeType === 1) out.push(node);
-	return out;
-}
 /** Whether `el` is a DrawingML element with the given local name. */
 function isA(el, local) {
 	return !!el && el.namespaceURI === OOXML_NS.a && el.localName === local;
@@ -476,7 +583,7 @@ function colorElementHex(color) {
 */
 function resolveColor(color, ctx) {
 	if (!color) return null;
-	const transforms = childElements$1(color);
+	const transforms = childElements(color);
 	if (isA(color, "srgbClr")) {
 		const hex = attr(color, "val");
 		return hex ? {
@@ -502,239 +609,128 @@ function resolveColor(color, ctx) {
 	return null;
 }
 /**
-* Flatten one slide's theme dependencies in place:
-*
-* 1. carry the background the slide inherited from its source layout/master onto
-*    the slide (so it survives rebinding to a different master);
-* 2. materialize `p:bgRef` and style-matrix refs into explicit fills/lines/effects;
-* 3. bake each placeholder's effective geometry (inherited `a:xfrm`) onto the
-*    shape so a rebind cannot move or resize it;
-* 4. bake each placeholder run's effective colour and size/weight (inherited from
-*    the source layout/master text styles) explicitly onto the run;
-* 5. rewrite every remaining `a:schemeClr` to its literal `a:srgbClr`.
-*
-* Steps run in this order so the inherited/materialized backgrounds are present
-* before the final scheme-colour sweep resolves the colours they carry. The
-* placeholder geometry/colour/size passes have no data dependency on the others.
-* The caller marks the part dirty.
+* Resolve a `+mj-*`/`+mn-*` major/minor font token against a theme `a:fontScheme`
+* to a literal typeface name. A non-token `typeface` (an already-literal face) is
+* returned verbatim. `null` when `typeface` is absent, or when a token cannot be
+* resolved (no `fontScheme`, or the indexed major/minor script slot is empty).
+* The script suffix selects the scheme child: `lt`→`a:latin`, `ea`→`a:ea`,
+* `cs`→`a:cs`.
 */
-function flattenSlide(slideRoot, ctx) {
-	applyInheritedBackground(slideRoot, ctx);
-	materializeBackground(slideRoot, ctx);
-	materializeStyleRefs(slideRoot, ctx);
-	resolvePlaceholderGeometry(slideRoot, ctx);
-	resolvePlaceholderRunColors(slideRoot, ctx);
-	resolvePlaceholderRunSizes(slideRoot, ctx);
-	resolveSchemeColors(slideRoot, ctx);
+function resolveThemeFont(typeface, fontScheme) {
+	if (!typeface) return null;
+	const match = /^\+(mj|mn)-(lt|ea|cs)$/.exec(typeface);
+	if (!match) return typeface;
+	if (!fontScheme) return null;
+	const font = firstChild(fontScheme, match[1] === "mj" ? "a:majorFont" : "a:minorFont");
+	const childName = match[2] === "lt" ? "a:latin" : match[2] === "ea" ? "a:ea" : "a:cs";
+	const child = font && firstChild(font, childName);
+	return child && attr(child, "typeface") || null;
 }
-/**
-* Flatten a single lifted shape's theme dependencies in place — the shape-scoped
-* subset of {@link flattenSlide} used by `Presentation.importShape` `preserve`
-* mode. It runs every pass that resolves a *shape's* theme references against the
-* source theme (style-matrix refs, placeholder-inherited geometry/colour/size/
-* anchor/list-style, scheme colours) but deliberately **omits** the two
-* slide-scoped background passes (`applyInheritedBackground`/`materializeBackground`):
-* a background belongs to a slide, not to a shape being composed onto a foreign host.
-*
-* Unlike {@link flattenSlide}, this also **demotes** a lifted placeholder to a
-* plain shape ({@link demotePlaceholders}) once everything it inherited is baked.
-* A placeholder makes sense on its own slide, where it resolves against that deck's
-* master/layout; lifted onto a foreign host its surviving `p:ph` would re-resolve
-* against the *host* placeholder of the same type/idx (wrong inheritance, or a
-* fallback when absent) and could collide with the host's own placeholder. The
-* extra bakes here (anchor + list style, on top of the geometry/colour/size the
-* shared passes cover) make the shape self-contained so demotion loses nothing
-* visible. This is why the demotion is scoped to `flattenShape`: `flattenSlide`
-* keeps placeholders as placeholders by design.
-*
-* `shapeRoot` must be an element whose *descendants* include the lifted shape
-* (the passes match via `getElementsByTagNameNS`, which excludes the root element
-* itself) — the caller wraps the imported `p:sp`/`p:pic`/`p:graphicFrame`/`p:grpSp`
-* in a throwaway container before calling. The caller marks the part dirty.
-*/
-function flattenShape(shapeRoot, ctx) {
-	materializeStyleRefs(shapeRoot, ctx);
-	resolvePlaceholderGeometry(shapeRoot, ctx);
-	resolvePlaceholderRunColors(shapeRoot, ctx);
-	resolvePlaceholderRunSizes(shapeRoot, ctx);
-	resolvePlaceholderBodyPr(shapeRoot, ctx);
-	resolvePlaceholderListStyle(shapeRoot, ctx);
-	resolveSchemeColors(shapeRoot, ctx);
-	demotePlaceholders(shapeRoot);
+/** Replace every `phClr` under `el` with the ref colour (ref transforms first, then the `phClr`'s own). */
+function substitutePhClr(el, ref) {
+	const doc = ownerDocumentOf(el);
+	for (const phClr of descendantsByTag(el, OOXML_NS.a, "schemeClr")) {
+		if (attr(phClr, "val") !== "phClr") continue;
+		const srgb = createElement(doc, "a:srgbClr");
+		setAttr(srgb, "val", ref.hex);
+		for (const t of ref.transforms) srgb.appendChild(t.cloneNode(true));
+		while (phClr.firstChild) srgb.appendChild(phClr.firstChild);
+		replaceInParent(phClr, srgb);
+	}
 }
-/**
-* Restyle a rebound slide in place (the `theme: 'restyle'` mode): the exact
-* inverse of {@link flattenSlide}. It bakes *nothing* — leaving every
-* `a:schemeClr`/style-matrix ref and `p:bg` `bgRef` symbolic is the whole point,
-* so they re-resolve against the *destination* master's `clrMap` + theme once the
-* slide is rebound. The single mutation is dropping the slide's own colour-map
-* override (`p:clrMapOvr/a:overrideClrMapping`): a source override would keep
-* mapping the slide's scheme-token names the source way and defeat the re-brand,
-* so it must yield to the destination master's `p:clrMap`.
-*
-* Caveat carried from the plan: only *symbolic* colours re-brand. Anything the
-* source authored as a literal `a:srgbClr` has no theme reference to re-resolve
-* and stays exactly that colour. The caller marks the part dirty.
-*/
-function restyleSlide(slideRoot) {
-	removeChildrenByQName(slideRoot, ["p:clrMapOvr"]);
+/** The `idx`-th entry (1-based) of a `fmtScheme` style list, deep-cloned, or `null`. */
+function fmtEntry(ctx, listName, idx) {
+	const list = ctx.fmtScheme && firstChild(ctx.fmtScheme, listName);
+	if (!list || idx < 1) return null;
+	const entry = childElements(list)[idx - 1];
+	return entry ? entry.cloneNode(true) : null;
 }
 /**
-* The optional inverse of {@link resolveSchemeColors}, for `restyle`'s
-* force-remap-literals mode (the {@link Presentation.importSlide} `remapLiterals`
-* option). Every literal `a:srgbClr` whose value equals a *source* `clrScheme`
-* slot is rewritten back to a symbolic `a:schemeClr` so it re-resolves against the
-* destination theme; a literal matching no slot (the common case) is left exactly
-* as authored. Transform children (`lumMod`/`shade`/`alpha`/…) are carried across.
-*
-* Plain `restyle` cannot re-brand a literal — it carries no theme reference. This
-* re-introduces one by matching the literal's RGB against the slots the *source*
-* theme defined, emitting the scheme token that routes through the source `clrMap`
-* (so a literal equal to the source `accent1` slot becomes `schemeClr accent1`,
-* which the destination `clrMap`/theme then re-resolve). Slots are matched in
-* `clrScheme` order, so the first slot defining a given RGB wins when several share
-* it. Opt-in because it deliberately reinterprets authored literals as theme
-* colours — visual QA territory, the same caveat as the rest of `restyle`.
+* 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
+* colour cannot be resolved. Shared by the flatten path and the read-model
+* `resolveStyleFillColor` getter so both see the same fill.
 */
-function remapLiteralColors(slideRoot, ctx) {
-	const slotByHex = reverseClrScheme(ctx.clrScheme);
-	if (slotByHex.size === 0) return;
-	const tokenBySlot = reverseClrMap(ctx.clrMap);
-	const doc = ownerDocumentOf(slideRoot);
-	for (const srgb of elementsByTag(slideRoot, OOXML_NS.a, "srgbClr")) {
-		const hex = attr(srgb, "val");
-		const slot = hex ? slotByHex.get(hex.toUpperCase()) : void 0;
-		if (!slot) continue;
-		const scheme = createElement(doc, "a:schemeClr");
-		setAttr(scheme, "val", tokenBySlot.get(slot) ?? slot);
-		while (srgb.firstChild) scheme.appendChild(srgb.firstChild);
-		replaceInParent(srgb, scheme);
-	}
-}
-/** Reverse a slot → RGB `clrScheme` into RGB → slot, in `SCHEME_SLOTS` order (first slot wins on a shared RGB). */
-function reverseClrScheme(clrScheme) {
-	const out = /* @__PURE__ */ new Map();
-	for (const slot of SCHEME_SLOTS) {
-		const hex = clrScheme.get(slot);
-		if (hex && !out.has(hex.toUpperCase())) out.set(hex.toUpperCase(), slot);
-	}
-	return out;
-}
-/** Reverse a token → slot `clrMap` into slot → token (first token wins on a shared slot). */
-function reverseClrMap(clrMap) {
-	const out = /* @__PURE__ */ new Map();
-	for (const [token, slot] of clrMap) if (!out.has(slot)) out.set(slot, token);
-	return out;
+function styleRefFill(fillRef, ctx) {
+	if (!fillRef) return null;
+	const idx = intAttr(fillRef, "idx");
+	if (idx === null || idx <= 0) return null;
+	const fill = idx >= 1e3 ? fmtEntry(ctx, "a:bgFillStyleLst", idx - 1e3) : fmtEntry(ctx, "a:fillStyleLst", idx);
+	const ref = resolveColor(firstChildElement(fillRef), ctx);
+	if (!fill || !ref) return null;
+	substitutePhClr(fill, ref);
+	return fill;
 }
 /**
-* If the slide has no own `p:bg`, insert (a copy of) the background it inherited
-* from its source layout/master as an explicit `p:cSld/p:bg`. The clone is left
-* unresolved here; the later passes flatten its `bgRef`/`schemeClr` in place.
+* 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}.
 */
-function applyInheritedBackground(slideRoot, ctx) {
-	const inherited = ctx.inheritedBackground;
-	if (!inherited) return;
-	const cSld = firstChild(slideRoot, "p:cSld");
-	if (!cSld || firstChild(cSld, "p:bg")) return;
-	insertInOrder(cSld, ownerDocumentOf(slideRoot).importNode(inherited, true), [
-		"p:spTree",
-		"p:custDataLst",
-		"p:controls",
-		"p:extLst"
-	]);
+function styleRefLine(lnRef, ctx) {
+	if (!lnRef) return null;
+	const idx = intAttr(lnRef, "idx");
+	if (idx === null || idx <= 0) return null;
+	const ln = fmtEntry(ctx, "a:lnStyleLst", idx);
+	const ref = resolveColor(firstChildElement(lnRef), ctx);
+	if (!ln || !ref) return null;
+	substitutePhClr(ln, ref);
+	return ln;
+}
+/** Read an integer attribute; `null`/empty/non-finite → `null`. */
+function intAttr(el, name) {
+	const value = attr(el, name);
+	if (value === null || value === "") return null;
+	const n = Number(value);
+	return Number.isFinite(n) ? n : null;
 }
+//#endregion
+//#region src/read/oxml/placeholder-inherit.ts
 /**
-* Resolve every `p:bgRef` (theme-indexed background) under the slide into an
-* explicit `p:bgPr` fill, so the background no longer depends on the destination
-* theme's `fmtScheme`. A `bgPr` background is left for the scheme-colour sweep.
+* Resolving what a placeholder shape *inherits* from its source layout/master chain.
+*
+* A placeholder that sets none of its own colour, size, geometry, anchor or list style takes
+* each from a chain: the layout placeholder's `a:lstStyle`, then the master placeholder's, then
+* the master's `p:txStyles` category style (and, on a notes context, the notesMaster
+* `p:notesStyle`). Every function here answers "what would this placeholder get?" — none of them
+* writes anything.
+*
+* **Two callers, one answer.** The read model's getters (`Run.resolvedColor`,
+* `TextFrame.resolvedAnchor`, the font getters) and the import-time flatten passes
+* (`read/api/ops/flatten.ts`, which bakes the inherited values onto a slide so they survive a
+* rebind to a different master) both ask the same questions. They must not answer them
+* differently: if the getter and the bake disagreed, a caller would see one colour before export
+* and another in the file. Sharing this module is what makes that structurally impossible.
+*
+* This module is pure — mutation lives in the flatten pass, which is also why it sits in
+* `read/oxml/` (substrate) rather than `read/api/ops/`.
 */
-function materializeBackground(slideRoot, ctx) {
-	const doc = ownerDocumentOf(slideRoot);
-	for (const bg of elementsByTag(slideRoot, OOXML_NS.p, "bg")) {
-		const bgRef = firstChild(bg, "p:bgRef");
-		if (!bgRef) continue;
-		const fill = styleRefFill(bgRef, ctx);
-		const bgPr = createElement(doc, "p:bgPr");
-		bgPr.appendChild(fill ?? createElement(doc, "a:noFill"));
-		bg.replaceChild(bgPr, bgRef);
-	}
-}
-/** Rewrite every `a:schemeClr` under `root` to a literal `a:srgbClr` when resolvable. */
-function resolveSchemeColors(root, ctx) {
-	const doc = ownerDocumentOf(root);
-	for (const schemeClr of elementsByTag(root, OOXML_NS.a, "schemeClr")) {
-		const token = attr(schemeClr, "val");
-		const hex = token ? resolveSchemeToken(token, ctx) : null;
-		if (!hex) continue;
-		const srgb = createElement(doc, "a:srgbClr");
-		setAttr(srgb, "val", hex);
-		while (schemeClr.firstChild) srgb.appendChild(schemeClr.firstChild);
-		replaceInParent(schemeClr, srgb);
-	}
-}
-/** Schema successors of `a:solidFill` inside `a:rPr` (CT_TextCharacterProperties sequence). */
-const RPR_FILL_AFTER = [
-	"a:effectLst",
-	"a:effectDag",
-	"a:highlight",
-	"a:uLnTx",
-	"a:uLn",
-	"a:uFillTx",
-	"a:uFill",
-	"a:latin",
-	"a:ea",
-	"a:cs",
-	"a:sym",
-	"a:hlinkClick",
-	"a:hlinkMouseOver",
-	"a:rtl",
-	"a:extLst"
-];
 /** The master `p:txStyles` style element name for a placeholder category. */
 const TX_STYLE_NAME = {
 	title: "p:titleStyle",
 	body: "p:bodyStyle",
 	other: "p:otherStyle"
 };
-/**
-* Bake placeholder-inherited run colours onto the slide (gap 1). For each
-* placeholder run that defines no colour of its own (nor at paragraph/text-body
-* level on the *slide*), resolve the colour it would inherit from the source
-* `slideLayout`/`slideMaster` text styles and write it explicitly onto the run's
-* `a:rPr`. After this the run's colour cannot change when the slide is rebound to
-* the destination master. `a:fld` runs (dates, slide numbers) are treated like
-* `a:r`. Only colour is resolved; other inheritable run properties are left to
-* re-bind to the destination styles.
-*/
-function resolvePlaceholderRunColors(slideRoot, ctx) {
-	if (!ctx.layoutRoot && !ctx.masterRoot) return;
-	for (const sp of elementsByTag(slideRoot, OOXML_NS.p, "sp")) {
-		const ph = placeholderOf(sp);
-		if (!ph) continue;
-		const txBody = firstChild(sp, "p:txBody");
-		if (!txBody) continue;
-		const type = attr(ph, "type");
-		const idx = attr(ph, "idx") ?? "0";
-		const slideLst = firstChild(txBody, "a:lstStyle");
-		const byLevel = /* @__PURE__ */ new Map();
-		for (const p of getElements(txBody, "a:p")) {
-			const pPr = firstChild(p, "a:pPr");
-			const level = (pPr && intValue(attr(pPr, "lvl"))) ?? 0;
-			const runs = [...getElements(p, "a:r"), ...getElements(p, "a:fld")];
-			if (runs.length === 0) continue;
-			let color = byLevel.get(level);
-			if (color === void 0) {
-				color = placeholderInheritedColor(type, idx, level, ctx);
-				byLevel.set(level, color);
-			}
-			if (!color) continue;
-			for (const run of runs) {
-				if (slideDefinesColor(run, pPr, slideLst, level)) continue;
-				writeRunColor(run, color);
-			}
-		}
-	}
-}
+/** The ordered children of a `CT_TextListStyle` (`a:lstStyle` / a `p:txStyles` style). */
+const LST_STYLE_LEVELS = [
+	"a:defPPr",
+	"a:lvl1pPr",
+	"a:lvl2pPr",
+	"a:lvl3pPr",
+	"a:lvl4pPr",
+	"a:lvl5pPr",
+	"a:lvl6pPr",
+	"a:lvl7pPr",
+	"a:lvl8pPr",
+	"a:lvl9pPr"
+];
+/** Inheritable run properties baked under `preserve`: size and weight/slant (not typeface). */
+const RUN_PROP_NAMES = [
+	"sz",
+	"b",
+	"i"
+];
 /** The `p:ph` element of a shape (`p:sp/p:nvSpPr/p:nvPr/p:ph`), or `null`. */
 function placeholderOf(sp) {
 	const nvSpPr = firstChild(sp, "p:nvSpPr");
@@ -784,7 +780,7 @@ const SINGLETON_PH = /* @__PURE__ */ new Set([
 */
 function findPlaceholder(root, slideType, slideIdx) {
 	if (slideType && SINGLETON_PH.has(slideType)) {
-		for (const sp of elementsByTag(root, OOXML_NS.p, "sp")) {
+		for (const sp of descendantsByTag(root, OOXML_NS.p, "sp")) {
 			const ph = placeholderOf(sp);
 			if (ph && attr(ph, "type") === slideType) return sp;
 		}
@@ -793,7 +789,7 @@ function findPlaceholder(root, slideType, slideIdx) {
 	const cat = phCategory(slideType);
 	let idxMatch = null;
 	let catMatch = null;
-	for (const sp of elementsByTag(root, OOXML_NS.p, "sp")) {
+	for (const sp of descendantsByTag(root, OOXML_NS.p, "sp")) {
 		const ph = placeholderOf(sp);
 		if (!ph) continue;
 		const type = attr(ph, "type");
@@ -827,259 +823,14 @@ function lstStyleLevelFill(listStyle, level) {
 	return defRPr ? firstChild(defRPr, "a:solidFill") : null;
 }
 /**
-* The colour *element* a placeholder run inherits from the source style chain: the
-* layout placeholder's `a:lstStyle`, then the master placeholder's, then the
-* master `p:txStyles` category style. Returns the first tier's colour element that
-* resolves against `ctx` (the `a:srgbClr`/`a:schemeClr`/… inside its
-* `a:solidFill`), or `null` when nothing in the chain defines a resolvable colour.
-* The read-model `Run.resolvedColor` getter feeds this element to
-* `resolveColorElement` for the `effectiveHex`; the flatten path resolves it
-* directly via {@link placeholderInheritedColor}.
-*/
-function placeholderInheritedFill(type, idx, level, ctx) {
-	const tiers = [];
-	if (ctx.layoutRoot) {
-		const layoutPh = findPlaceholder(ctx.layoutRoot, type, idx);
-		tiers.push(layoutPh && lstStyleLevelFill(placeholderLstStyle(layoutPh), level));
-	}
-	if (ctx.masterRoot) {
-		const masterPh = findPlaceholder(ctx.masterRoot, type, idx);
-		tiers.push(masterPh && lstStyleLevelFill(placeholderLstStyle(masterPh), level));
-		const txStyles = firstChild(ctx.masterRoot, "p:txStyles");
-		const styleEl = txStyles && firstChild(txStyles, TX_STYLE_NAME[phCategory(type)]);
-		tiers.push(styleEl && lstStyleLevelFill(styleEl, level));
-	}
-	if (ctx.notesStyle) tiers.push(lstStyleLevelFill(ctx.notesStyle, level));
-	for (const fill of tiers) {
-		const colorEl = fill && firstChildElement(fill);
-		if (colorEl && resolveColor(colorEl, ctx)) return colorEl;
-	}
-	return null;
-}
-/**
-* The level `a:defRPr` elements a placeholder inherits from the source style
-* chain, in resolution order: the layout placeholder's `a:lstStyle`, then the
-* master placeholder's, then the master `p:txStyles` category style — and, on a
-* notes context only, the notesMaster `p:notesStyle` (see `ctx.notesStyle`). Tiers
-* with no `a:defRPr` for `level` are dropped. The shared root for inherited run
-* *size* and *typeface* resolution (the size/face sibling of
-* {@link placeholderInheritedFill}), read directly by the flatten path and the
-* read-model font getters.
-*/
-function placeholderInheritedDefRPrs(type, idx, level, ctx) {
-	const tiers = [];
-	if (ctx.layoutRoot) {
-		const layoutPh = findPlaceholder(ctx.layoutRoot, type, idx);
-		tiers.push(layoutPh && lstStyleLevelDefRPr(placeholderLstStyle(layoutPh), level));
-	}
-	if (ctx.masterRoot) {
-		const masterPh = findPlaceholder(ctx.masterRoot, type, idx);
-		tiers.push(masterPh && lstStyleLevelDefRPr(placeholderLstStyle(masterPh), level));
-		const txStyles = firstChild(ctx.masterRoot, "p:txStyles");
-		const styleEl = txStyles && firstChild(txStyles, TX_STYLE_NAME[phCategory(type)]);
-		tiers.push(styleEl && lstStyleLevelDefRPr(styleEl, level));
-	}
-	if (ctx.notesStyle) tiers.push(lstStyleLevelDefRPr(ctx.notesStyle, level));
-	return tiers.filter((t) => t !== null);
-}
-/**
-* Resolve a `+mj-*`/`+mn-*` major/minor font token against a theme `a:fontScheme`
-* to a literal typeface name. A non-token `typeface` (an already-literal face) is
-* returned verbatim. `null` when `typeface` is absent, or when a token cannot be
-* resolved (no `fontScheme`, or the indexed major/minor script slot is empty).
-* The script suffix selects the scheme child: `lt`→`a:latin`, `ea`→`a:ea`,
-* `cs`→`a:cs`.
-*/
-function resolveThemeFont(typeface, fontScheme) {
-	if (!typeface) return null;
-	const match = /^\+(mj|mn)-(lt|ea|cs)$/.exec(typeface);
-	if (!match) return typeface;
-	if (!fontScheme) return null;
-	const font = firstChild(fontScheme, match[1] === "mj" ? "a:majorFont" : "a:minorFont");
-	const childName = match[2] === "lt" ? "a:latin" : match[2] === "ea" ? "a:ea" : "a:cs";
-	const child = font && firstChild(font, childName);
-	return child && attr(child, "typeface") || null;
-}
-/**
-* The colour a placeholder run inherits from the source style chain, resolved to a
-* literal `{ hex, transforms }`. Thin wrapper over {@link placeholderInheritedFill}
-* for the flatten path, which re-emits the transforms verbatim. Returns `null`
-* when nothing in the chain defines a resolvable colour (the run then re-binds to
-* the destination).
-*/
-function placeholderInheritedColor(type, idx, level, ctx) {
-	const colorEl = placeholderInheritedFill(type, idx, level, ctx);
-	return colorEl ? resolveColor(colorEl, ctx) : null;
-}
-/** Whether the *slide itself* already fixes this run's colour (so a rebind cannot change it). */
-function slideDefinesColor(run, pPr, slideLst, level) {
-	const rPr = firstChild(run, "a:rPr");
-	if (rPr && FILL_CHOICES.some((q) => firstChild(rPr, q))) return true;
-	const defRPr = pPr && firstChild(pPr, "a:defRPr");
-	if (defRPr && firstChild(defRPr, "a:solidFill")) return true;
-	return !!lstStyleLevelFill(slideLst, level);
-}
-/** Write a resolved colour as an explicit `a:solidFill` (with carried transforms) onto a run's `a:rPr`. */
-function writeRunColor(run, color) {
-	const doc = ownerDocumentOf(run);
-	const rPr = getOrAddChild(run, "a:rPr", ["a:t"]);
-	const fill = createElement(doc, "a:solidFill");
-	const srgb = createElement(doc, "a:srgbClr");
-	setAttr(srgb, "val", color.hex);
-	for (const t of color.transforms) srgb.appendChild(t.cloneNode(true));
-	fill.appendChild(srgb);
-	insertInOrder(rPr, fill, RPR_FILL_AFTER);
-}
-/**
-* Bake placeholder-inherited geometry onto the slide (gap 3). A placeholder shape
-* that carries no own `p:spPr/a:xfrm` takes its position/size from the matching
-* source `slideLayout` placeholder, else the `slideMaster` placeholder. Rebinding
-* to the destination master replaces that inheritance, so the placeholder would
-* snap to the destination default (often clipping off-canvas). We deep-clone the
-* effective source `a:xfrm` and write it explicitly onto the shape. Shapes with
-* their own `a:xfrm` are left untouched (explicit geometry is not inherited), and
-* an orphan placeholder with no source match keeps the current fall-back behaviour.
-*/
-function resolvePlaceholderGeometry(slideRoot, ctx) {
-	if (!ctx.layoutRoot && !ctx.masterRoot) return;
-	for (const sp of elementsByTag(slideRoot, OOXML_NS.p, "sp")) {
-		const ph = placeholderOf(sp);
-		if (!ph) continue;
-		const spPr = firstChild(sp, "p:spPr");
-		if (spPr && firstChild(spPr, "a:xfrm")) continue;
-		const found = placeholderInheritedXfrm(attr(ph, "type"), attr(ph, "idx") ?? "0", ctx);
-		if (!found) continue;
-		insertInOrder(getOrAddChild(sp, "p:spPr", SHAPE_AFTER_SPPR$1), found.xfrm.cloneNode(true), SPPR_XFRM_AFTER);
-	}
-}
-/**
-* The `a:xfrm` a placeholder inherits from the source layout, then master,
-* tagged with which tier it came from — `null` when neither defines one. The
-* read-model {@link resolveInheritedFrame} (`theme-context.ts`) sibling of
-* {@link placeholderInheritedAnchor}; also the bake source for
-* {@link resolvePlaceholderGeometry}.
-*/
-function placeholderInheritedXfrm(type, idx, ctx) {
-	for (const [root, source] of [[ctx.layoutRoot, "layout"], [ctx.masterRoot, "master"]]) {
-		if (!root) continue;
-		const ph = findPlaceholder(root, type, idx);
-		const spPr = ph && firstChild(ph, "p:spPr");
-		const xfrm = spPr && firstChild(spPr, "a:xfrm");
-		if (xfrm) return {
-			xfrm,
-			source
-		};
-	}
-	return null;
-}
-/**
-* The vertical anchor (`a:bodyPr/@anchor`) a placeholder inherits from the source
-* layout, then master, or `null`. Resolves per-attribute: the first tier whose
-* placeholder `a:bodyPr` actually sets `@anchor` wins, so a layout `a:bodyPr`
-* present but without `@anchor` does not mask the master's. The read-model
-* {@link TextFrame.resolvedAnchor} sibling of {@link placeholderInheritedXfrm}.
-*/
-function placeholderInheritedAnchor(type, idx, ctx) {
-	for (const root of [ctx.layoutRoot, ctx.masterRoot]) {
-		if (!root) continue;
-		const ph = findPlaceholder(root, type, idx);
-		const txBody = ph && firstChild(ph, "p:txBody");
-		const bodyPr = txBody && firstChild(txBody, "a:bodyPr");
-		const anchor = bodyPr && attr(bodyPr, "anchor");
-		if (anchor) return anchor;
-	}
-	return null;
-}
-/**
-* Bake the placeholder-inherited vertical anchor onto a lifted shape's text body
-* (the {@link flattenShape} placeholder-demotion path). A placeholder whose own
-* `a:bodyPr` sets no `@anchor` inherits it from the source layout/master placeholder;
-* once {@link demotePlaceholders} strips the `p:ph` the shape would lose that
-* inheritance and fall back to top-anchored, so a vertically-centred title jumps.
-* We resolve the effective anchor from the source chain (via
-* {@link placeholderInheritedAnchor}) and write it explicitly. Shapes whose
-* `a:bodyPr` already fixes `@anchor`, and placeholders with no resolvable inherited
-* anchor, are left untouched. Other `a:bodyPr` knobs (insets, autofit) are left as
-* authored — they have sane defaults a plain shape keeps.
-*/
-function resolvePlaceholderBodyPr(shapeRoot, ctx) {
-	if (!ctx.layoutRoot && !ctx.masterRoot) return;
-	for (const sp of elementsByTag(shapeRoot, OOXML_NS.p, "sp")) {
-		const ph = placeholderOf(sp);
-		if (!ph) continue;
-		const txBody = firstChild(sp, "p:txBody");
-		if (!txBody) continue;
-		const bodyPr = firstChild(txBody, "a:bodyPr");
-		if (bodyPr && attr(bodyPr, "anchor") != null) continue;
-		const anchor = placeholderInheritedAnchor(attr(ph, "type"), attr(ph, "idx") ?? "0", ctx);
-		if (!anchor) continue;
-		setAttr(bodyPr ?? getOrAddChild(txBody, "a:bodyPr", ["a:lstStyle", "a:p"]), "anchor", anchor);
-	}
-}
-/** The ordered children of a `CT_TextListStyle` (`a:lstStyle` / a `p:txStyles` style). */
-const LST_STYLE_LEVELS = [
-	"a:defPPr",
-	"a:lvl1pPr",
-	"a:lvl2pPr",
-	"a:lvl3pPr",
-	"a:lvl4pPr",
-	"a:lvl5pPr",
-	"a:lvl6pPr",
-	"a:lvl7pPr",
-	"a:lvl8pPr",
-	"a:lvl9pPr"
-];
-/**
-* Bake the placeholder-inherited list style onto a lifted shape's text body (the
-* {@link flattenShape} placeholder-demotion path). A placeholder's per-level
-* *paragraph* formatting — indent (`marL`/`indent`), bullets (`a:buChar`/
-* `a:buAutoNum`/`a:buNone`), alignment, and the level `a:defRPr` — is inherited
-* from the source layout/master placeholder `a:lstStyle` and the master
-* `p:txStyles` category style. Run colour/size are baked onto each run by the
-* sibling passes, but paragraph-level defaults live here; once
-* {@link demotePlaceholders} strips the `p:ph` the shape stops inheriting them, so
-* bullets and indents would vanish. We materialize the effective list style onto
-* the shape's `p:txBody/a:lstStyle`.
+* The source style tiers a placeholder resolves against, most specific first: the layout
+* placeholder's `a:lstStyle`, the master placeholder's, then the master `p:txStyles` category
+* style — and, on a notes context only, the notesMaster `p:notesStyle`.
 *
-* Resolution is per *level*, most specific tier wins whole: the slide's own level
-* (if it defines one) is kept verbatim, else the first source tier that defines it
-* (layout placeholder, then master placeholder, then master category style) is
-* cloned. This is a whole-element overlay, not the per-attribute merge PowerPoint
-* does — but explicit paragraph `a:pPr` on the slide's own runs travels with the
-* shape and still wins, so this only supplies defaults for the inherited case
-* (paragraphs that set no `a:pPr` of their own). Scheme colours in the cloned
-* levels are resolved by the later {@link resolveSchemeColors} pass.
+* The one place the chain is spelled out. `placeholderInherited*` differ only in what they pull
+* from each tier, so they all walk this.
 */
-function resolvePlaceholderListStyle(shapeRoot, ctx) {
-	if (!ctx.layoutRoot && !ctx.masterRoot) return;
-	for (const sp of elementsByTag(shapeRoot, OOXML_NS.p, "sp")) {
-		const ph = placeholderOf(sp);
-		if (!ph) continue;
-		const txBody = firstChild(sp, "p:txBody");
-		if (!txBody) continue;
-		const tiers = placeholderInheritedListStyles(attr(ph, "type"), attr(ph, "idx") ?? "0", ctx);
-		if (tiers.length === 0) continue;
-		const slideLst = firstChild(txBody, "a:lstStyle");
-		const merged = createElement(ownerDocumentOf(txBody), "a:lstStyle");
-		let any = false;
-		for (const level of LST_STYLE_LEVELS) {
-			const src = (slideLst && firstChild(slideLst, level)) ?? tiers.map((t) => firstChild(t, level)).find((e) => !!e) ?? null;
-			if (!src) continue;
-			merged.appendChild(src.cloneNode(true));
-			any = true;
-		}
-		if (!any) continue;
-		if (slideLst) txBody.replaceChild(merged, slideLst);
-		else insertInOrder(txBody, merged, ["a:p"]);
-	}
-}
-/**
-* The source list-style tiers a placeholder inherits paragraph formatting from,
-* most specific first: layout placeholder `a:lstStyle`, master placeholder
-* `a:lstStyle`, then the master `p:txStyles` category style (itself a
-* `CT_TextListStyle`). The paragraph-level sibling of {@link placeholderInheritedDefRPrs}.
-*/
-function placeholderInheritedListStyles(type, idx, ctx) {
+function styleTiers(type, idx, ctx) {
 	const tiers = [];
 	if (ctx.layoutRoot) {
 		const layoutPh = findPlaceholder(ctx.layoutRoot, type, idx);
@@ -1091,73 +842,61 @@ function placeholderInheritedListStyles(type, idx, ctx) {
 		const txStyles = firstChild(ctx.masterRoot, "p:txStyles");
 		tiers.push(txStyles && firstChild(txStyles, TX_STYLE_NAME[phCategory(type)]));
 	}
+	if (ctx.notesStyle) tiers.push(ctx.notesStyle);
 	return tiers.filter((t) => t !== null);
 }
 /**
-* Strip the `p:ph` marker from every placeholder shape in a lifted subtree so it
-* becomes a self-contained ordinary shape (the {@link flattenShape} path only). By
-* the time this runs, the shape's inherited geometry, colour, run size, anchor, and
-* list style are all baked explicitly, so it no longer needs — and must not keep —
-* its placeholder identity: a surviving `p:ph` would re-resolve against the *host*
-* deck's layout/master placeholder of the same type/idx (wrong inheritance, or a
-* fallback when the host has none) and could collide with the host slide's own
-* placeholder of that type. Removing the marker severs both. The `p:nvPr` itself is
-* kept (it can carry media/custom-data children); only the `p:ph` child goes.
+* The colour *element* a placeholder run inherits from the source style chain. Returns the
+* first tier's colour element that resolves against `ctx` (the `a:srgbClr`/`a:schemeClr`/…
+* inside its `a:solidFill`), or `null` when nothing in the chain defines a resolvable colour.
+* The read-model `Run.resolvedColor` getter feeds this element to `resolveColorElement` for the
+* `effectiveHex`; the flatten path resolves it directly via {@link placeholderInheritedColor}.
 */
-function demotePlaceholders(shapeRoot) {
-	for (const sp of elementsByTag(shapeRoot, OOXML_NS.p, "sp")) {
-		const nvSpPr = firstChild(sp, "p:nvSpPr");
-		const nvPr = nvSpPr && firstChild(nvSpPr, "p:nvPr");
-		if (nvPr) removeChildrenByQName(nvPr, ["p:ph"]);
+function placeholderInheritedFill(type, idx, level, ctx) {
+	for (const tier of styleTiers(type, idx, ctx)) {
+		const fill = lstStyleLevelFill(tier, level);
+		const colorEl = fill && firstChildElement(fill);
+		if (colorEl && resolveColor(colorEl, ctx)) return colorEl;
 	}
+	return null;
 }
-/** Inheritable run properties baked under `preserve`: size and weight/slant (not typeface). */
-const RUN_PROP_NAMES = [
-	"sz",
-	"b",
-	"i"
-];
 /**
-* Bake placeholder-inherited run size/weight onto the slide (gap 3). Mirrors
-* {@link resolvePlaceholderRunColors}: for each placeholder run that sets no
-* `sz`/`b`/`i` of its own (nor at paragraph/text-body level on the *slide*),
-* resolve the value it would inherit from the source `slideLayout`/`slideMaster`
-* text styles — per paragraph list level — and write it explicitly onto the run's
-* `a:rPr`. Each property resolves independently up the chain. Typeface (`a:latin`)
-* is left to re-bind to the destination theme, as gap 1 does for the `fontRef`.
+* The level `a:defRPr` elements a placeholder inherits from the source style chain, in
+* resolution order. Tiers with no `a:defRPr` for `level` are dropped. The shared root for
+* inherited run *size* and *typeface* resolution (the size/face sibling of
+* {@link placeholderInheritedFill}), read directly by the flatten path and the read-model font
+* getters.
 */
-function resolvePlaceholderRunSizes(slideRoot, ctx) {
-	if (!ctx.layoutRoot && !ctx.masterRoot) return;
-	for (const sp of elementsByTag(slideRoot, OOXML_NS.p, "sp")) {
-		const ph = placeholderOf(sp);
-		if (!ph) continue;
-		const txBody = firstChild(sp, "p:txBody");
-		if (!txBody) continue;
-		const type = attr(ph, "type");
-		const idx = attr(ph, "idx") ?? "0";
-		const slideLst = firstChild(txBody, "a:lstStyle");
-		const byLevel = /* @__PURE__ */ new Map();
-		for (const p of getElements(txBody, "a:p")) {
-			const pPr = firstChild(p, "a:pPr");
-			const level = (pPr && intValue(attr(pPr, "lvl"))) ?? 0;
-			const runs = [...getElements(p, "a:r"), ...getElements(p, "a:fld")];
-			if (runs.length === 0) continue;
-			let props = byLevel.get(level);
-			if (props === void 0) {
-				props = placeholderInheritedRunProps(type, idx, level, ctx);
-				byLevel.set(level, props);
-			}
-			if (!props) continue;
-			for (const run of runs) writeRunProps(run, props, pPr, slideLst, level);
-		}
-	}
+function placeholderInheritedDefRPrs(type, idx, level, ctx) {
+	return styleTiers(type, idx, ctx).map((tier) => lstStyleLevelDefRPr(tier, level)).filter((t) => t !== null);
+}
+/**
+* The source list-style tiers a placeholder inherits paragraph formatting from, most specific
+* first. The paragraph-level sibling of {@link placeholderInheritedDefRPrs} — it hands back the
+* tier elements whole rather than pulling one level's properties out of each.
+*
+* The notes tier is included for consistency with the rest of the chain, though it cannot arise
+* in practice: the only caller is the list-style bake in `flattenShape`, which runs on slide and
+* shape contexts, and `ctx.notesStyle` is set only on a notes context.
+*/
+function placeholderInheritedListStyles(type, idx, ctx) {
+	return styleTiers(type, idx, ctx);
+}
+/**
+* The colour a placeholder run inherits from the source style chain, resolved to a
+* literal `{ hex, transforms }`. Thin wrapper over {@link placeholderInheritedFill}
+* for the flatten path, which re-emits the transforms verbatim. Returns `null`
+* when nothing in the chain defines a resolvable colour (the run then re-binds to
+* the destination).
+*/
+function placeholderInheritedColor(type, idx, level, ctx) {
+	const colorEl = placeholderInheritedFill(type, idx, level, ctx);
+	return colorEl ? resolveColor(colorEl, ctx) : null;
 }
 /**
-* The run size/weight a placeholder run inherits from the source style chain:
-* layout placeholder `a:lstStyle` → master placeholder `a:lstStyle` → master
-* `p:txStyles` category style, per list level. Each of `sz`/`b`/`i` is taken from
-* the first tier that defines it (properties resolve independently). Returns
-* `null` when no tier defines any of them.
+* The run size/weight a placeholder run inherits from the source style chain, per list level.
+* Each of `sz`/`b`/`i` is taken from the first tier that defines it (properties resolve
+* independently). Returns `null` when no tier defines any of them.
 */
 function placeholderInheritedRunProps(type, idx, level, ctx) {
 	const tiers = placeholderInheritedDefRPrs(type, idx, level, ctx);
@@ -1174,141 +913,60 @@ function placeholderInheritedRunProps(type, idx, level, ctx) {
 	}
 	return any ? props : null;
 }
-/** Whether the *slide itself* already fixes a run property (so a rebind cannot change it). */
-function slideDefinesProp(name, run, pPr, slideLst, level) {
-	const rPr = firstChild(run, "a:rPr");
-	if (rPr && attr(rPr, name) != null) return true;
-	const defRPr = pPr && firstChild(pPr, "a:defRPr");
-	if (defRPr && attr(defRPr, name) != null) return true;
-	const slideDefRPr = lstStyleLevelDefRPr(slideLst, level);
-	return !!(slideDefRPr && attr(slideDefRPr, name) != null);
-}
-/** Write each resolved run property onto a run's `a:rPr`, skipping ones the slide already fixes. */
-function writeRunProps(run, props, pPr, slideLst, level) {
-	let rPr = null;
-	for (const name of RUN_PROP_NAMES) {
-		const value = props[name];
-		if (value == null) continue;
-		if (slideDefinesProp(name, run, pPr, slideLst, level)) continue;
-		rPr ??= getOrAddChild(run, "a:rPr", ["a:t"]);
-		setAttr(rPr, name, value);
-	}
-}
-/** Snapshot all descendant elements of `root` matching a namespace + local name. */
-function elementsByTag(root, ns, local) {
-	const out = [];
-	for (const el of root.getElementsByTagNameNS(ns, local)) out.push(el);
-	return out;
-}
 /**
-* Resolve each shape's `p:style` `lnRef`/`fillRef`/`effectRef` into explicit
-* `spPr` children (using the theme `fmtScheme`), then neutralize the ref. The
-* `fontRef` is intentionally left for the destination theme to re-resolve.
+* The `a:xfrm` a placeholder inherits from the source layout, then master,
+* tagged with which tier it came from — `null` when neither defines one. The
+* read-model `resolveInheritedFrame` (`theme-context.ts`) sibling of
+* {@link placeholderInheritedAnchor}; also the bake source for the flatten pass'
+* `resolvePlaceholderGeometry`.
 */
-function materializeStyleRefs(root, ctx) {
-	if (!ctx.fmtScheme) return;
-	for (const style of elementsByTag(root, OOXML_NS.p, "style")) {
-		const shape = style.parentNode;
-		if (!shape) continue;
-		const spPr = getOrAddChild(shape, "p:spPr", SHAPE_AFTER_SPPR$1);
-		materializeFill(spPr, firstChild(style, "a:fillRef"), ctx);
-		materializeLine(spPr, firstChild(style, "a:lnRef"), ctx);
-		materializeEffect(spPr, firstChild(style, "a:effectRef"), ctx);
-	}
-}
-/** Replace every `phClr` under `el` with the ref colour (ref transforms first, then the `phClr`'s own). */
-function substitutePhClr(el, ref) {
-	const doc = ownerDocumentOf(el);
-	for (const phClr of elementsByTag(el, OOXML_NS.a, "schemeClr")) {
-		if (attr(phClr, "val") !== "phClr") continue;
-		const srgb = createElement(doc, "a:srgbClr");
-		setAttr(srgb, "val", ref.hex);
-		for (const t of ref.transforms) srgb.appendChild(t.cloneNode(true));
-		while (phClr.firstChild) srgb.appendChild(phClr.firstChild);
-		replaceInParent(phClr, srgb);
+function placeholderInheritedXfrm(type, idx, ctx) {
+	for (const [root, source] of [[ctx.layoutRoot, "layout"], [ctx.masterRoot, "master"]]) {
+		if (!root) continue;
+		const ph = findPlaceholder(root, type, idx);
+		const spPr = ph && firstChild(ph, "p:spPr");
+		const xfrm = spPr && firstChild(spPr, "a:xfrm");
+		if (xfrm) return {
+			xfrm,
+			source
+		};
 	}
-}
-/** The `idx`-th entry (1-based) of a `fmtScheme` style list, deep-cloned, or `null`. */
-function fmtEntry(ctx, listName, idx) {
-	const list = ctx.fmtScheme && firstChild(ctx.fmtScheme, listName);
-	if (!list || idx < 1) return null;
-	const entry = childElements$1(list)[idx - 1];
-	return entry ? entry.cloneNode(true) : null;
-}
-/**
-* 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
-* colour cannot be resolved. Shared by the flatten path ({@link materializeFill})
-* and the read-model `resolveStyleFillColor` getter so both see the same fill.
-*/
-function styleRefFill(fillRef, ctx) {
-	if (!fillRef) return null;
-	const idx = intAttr(fillRef, "idx");
-	if (idx === null || idx <= 0) return null;
-	const fill = idx >= 1e3 ? fmtEntry(ctx, "a:bgFillStyleLst", idx - 1e3) : fmtEntry(ctx, "a:fillStyleLst", idx);
-	const ref = resolveColor(firstChildElement(fillRef), ctx);
-	if (!fill || !ref) return null;
-	substitutePhClr(fill, ref);
-	return fill;
+	return null;
 }
 /**
-* 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}.
+* The vertical anchor (`a:bodyPr/@anchor`) a placeholder inherits from the source
+* layout, then master, or `null`. Resolves per-attribute: the first tier whose
+* placeholder `a:bodyPr` actually sets `@anchor` wins, so a layout `a:bodyPr`
+* present but without `@anchor` does not mask the master's. The read-model
+* `TextFrame.resolvedAnchor` sibling of {@link placeholderInheritedXfrm}.
 */
-function styleRefLine(lnRef, ctx) {
-	if (!lnRef) return null;
-	const idx = intAttr(lnRef, "idx");
-	if (idx === null || idx <= 0) return null;
-	const ln = fmtEntry(ctx, "a:lnStyleLst", idx);
-	const ref = resolveColor(firstChildElement(lnRef), ctx);
-	if (!ln || !ref) return null;
-	substitutePhClr(ln, ref);
-	return ln;
-}
-function materializeFill(spPr, fillRef, ctx) {
-	if (!fillRef) return;
-	if (!FILL_CHOICES.some((q) => firstChild(spPr, q))) {
-		const fill = styleRefFill(fillRef, ctx);
-		if (fill) insertInOrder(spPr, fill, SPPR_FILL_AFTER$1);
-	}
-	neutralizeRef(fillRef);
-}
-function materializeLine(spPr, lnRef, ctx) {
-	if (!lnRef) return;
-	if (!firstChild(spPr, "a:ln")) {
-		const ln = styleRefLine(lnRef, ctx);
-		if (ln) insertInOrder(spPr, ln, SPPR_LN_AFTER$1);
-	}
-	neutralizeRef(lnRef);
-}
-function materializeEffect(spPr, effectRef, ctx) {
-	if (!effectRef) return;
-	const idx = intAttr(effectRef, "idx");
-	if (idx !== null && idx > 0 && !firstChild(spPr, "a:effectLst") && !firstChild(spPr, "a:effectDag")) {
-		const style = fmtEntry(ctx, "a:effectStyleLst", idx);
-		const ref = resolveColor(firstChildElement(effectRef), ctx);
-		if (style && ref) {
-			substitutePhClr(style, ref);
-			for (const child of childElements$1(style)) if (isA(child, "effectLst") || isA(child, "effectDag")) insertInOrder(spPr, child, SPPR_EFFECT_AFTER);
-			else if (isA(child, "scene3d")) insertInOrder(spPr, child, ["a:sp3d", "a:extLst"]);
-			else if (isA(child, "sp3d")) insertInOrder(spPr, child, ["a:extLst"]);
-		}
+function placeholderInheritedAnchor(type, idx, ctx) {
+	for (const root of [ctx.layoutRoot, ctx.masterRoot]) {
+		if (!root) continue;
+		const ph = findPlaceholder(root, type, idx);
+		const txBody = ph && firstChild(ph, "p:txBody");
+		const bodyPr = txBody && firstChild(txBody, "a:bodyPr");
+		const anchor = bodyPr && attr(bodyPr, "anchor");
+		if (anchor) return anchor;
 	}
-	neutralizeRef(effectRef);
+	return null;
 }
-/** Strip a style-matrix ref to `idx="0"` with no colour child so it contributes nothing. */
-function neutralizeRef(ref) {
-	setAttr(ref, "idx", "0");
-	for (const child of childElements$1(ref)) ref.removeChild(child);
+/** Whether the *slide itself* already fixes this run's colour (so a rebind cannot change it). */
+function slideDefinesColor(run, pPr, slideLst, level) {
+	const rPr = firstChild(run, "a:rPr");
+	if (rPr && FILL_CHOICES.some((q) => firstChild(rPr, q))) return true;
+	const defRPr = pPr && firstChild(pPr, "a:defRPr");
+	if (defRPr && firstChild(defRPr, "a:solidFill")) return true;
+	return !!lstStyleLevelFill(slideLst, level);
 }
-function intAttr(el, name) {
-	const value = attr(el, name);
-	if (value === null || value === "") return null;
-	const n = Number(value);
-	return Number.isFinite(n) ? n : null;
+/** Whether the *slide itself* already fixes a run property (so a rebind cannot change it). */
+function slideDefinesProp(name, run, pPr, slideLst, level) {
+	const rPr = firstChild(run, "a:rPr");
+	if (rPr && attr(rPr, name) != null) return true;
+	const defRPr = pPr && firstChild(pPr, "a:defRPr");
+	if (defRPr && attr(defRPr, name) != null) return true;
+	const slideDefRPr = lstStyleLevelDefRPr(slideLst, level);
+	return !!(slideDefRPr && attr(slideDefRPr, name) != null);
 }
 //#endregion
 //#region src/read/oxml/color-transform.ts
@@ -1503,17 +1161,6 @@ function applyColorTransforms(baseHex, transforms) {
 * background needs on top of {@link resolveSlideThemeParts} — so a token resolves
 * identically whether it is read or baked.
 */
-const SLIDE_LAYOUT_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideLayout";
-const SLIDE_MASTER_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideMaster";
-const NOTES_MASTER_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesMaster";
-const THEME_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme";
-const OFFICE_DOCUMENT_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument";
-/** Resolve the single relationship of `type` owned by `partName`, or `null`. */
-function resolveSingleRel(opc, partName, type) {
-	const rels = opc.relationshipsFor(partName);
-	const rel = rels.byType(type)[0];
-	return rel ? rels.resolveTarget(rel.id) : null;
-}
 /** The document element of a part, or `null` when the partname/part is absent. */
 function documentElement(opc, partName) {
 	return partName ? opc.part(partName)?.dom.documentElement ?? null : null;
@@ -1522,7 +1169,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
-* size/colour/face/bold resolution (see `FlattenContext.defaultTextStyle`).
+* size/colour/face/bold resolution (see `ThemeContext.defaultTextStyle`).
 */
 function presentationDefaultTextStyle(opc) {
 	const root = documentElement(opc, resolveSingleRel(opc, "/", OFFICE_DOCUMENT_REL));
@@ -2044,73 +1691,15 @@ function readPatternFill(container, ctx) {
 //#endregion
 //#region src/read/api/shapes/oxml.ts
 /**
-* Shape-element plumbing: the schema-successor lists that keep a get-or-added child in document
-* order, and the small element lookups every shape kind performs.
+* Shape-element plumbing: the small element lookups every shape kind performs, plus the
+* shape-scoped re-exports of the shared schema-successor lists.
 *
 * The successor arrays are the reason a setter can create a missing `a:xfrm` / `a:solidFill` /
 * `a:ln` without corrupting the part: `getOrAddChild` inserts before the first listed sibling it
 * finds, so each list must name exactly the children that legally *follow* the one being added.
+* They are declared once in `src/ooxml/sequence.ts` (derived from each complexType's sequence)
+* and re-exported here so the shape modules keep importing them from one place.
 */
-const SPPR_AFTER_XFRM = [
-	"a:custGeom",
-	"a:prstGeom",
-	"a:noFill",
-	"a:solidFill",
-	"a:gradFill",
-	"a:blipFill",
-	"a:pattFill",
-	"a:grpFill",
-	"a:ln",
-	"a:effectLst",
-	"a:effectDag",
-	"a:scene3d",
-	"a:sp3d",
-	"a:extLst"
-];
-const GRPSPPR_AFTER_XFRM = [
-	"a:noFill",
-	"a:solidFill",
-	"a:gradFill",
-	"a:blipFill",
-	"a:pattFill",
-	"a:grpFill",
-	"a:effectLst",
-	"a:effectDag",
-	"a:scene3d",
-	"a:extLst"
-];
-const SHAPE_AFTER_SPPR = ["p:style", "p:txBody"];
-const SPPR_FILL_AFTER = [
-	"a:ln",
-	"a:effectLst",
-	"a:effectDag",
-	"a:scene3d",
-	"a:sp3d",
-	"a:extLst"
-];
-const SPPR_LN_AFTER = [
-	"a:effectLst",
-	"a:effectDag",
-	"a:scene3d",
-	"a:sp3d",
-	"a:extLst"
-];
-const GRPSPPR_FILL_AFTER = [
-	"a:effectLst",
-	"a:effectDag",
-	"a:scene3d",
-	"a:extLst"
-];
-const LN_FILL_AFTER = [
-	"a:prstDash",
-	"a:custDash",
-	"a:round",
-	"a:bevel",
-	"a:miter",
-	"a:headEnd",
-	"a:tailEnd",
-	"a:extLst"
-];
 /** First `<p:cNvPr>` reached through the shape's non-visual properties wrapper (`p:nv*Pr`). */
 function nonVisualCNvPr(element) {
 	for (let node = element.firstChild; node; node = node.nextSibling) {
@@ -2118,24 +1707,141 @@ function nonVisualCNvPr(element) {
 		const child = node;
 		if (child.namespaceURI === OOXML_NS.p && child.localName?.startsWith("nv")) return firstChild(child, "p:cNvPr");
 	}
-	return null;
+	return null;
+}
+function emuFrom(parent, qname, attribute) {
+	const element = parent && firstChild(parent, qname);
+	return element ? intValue(attr(element, attribute)) : null;
+}
+/**
+* One EMU coordinate from a shape's own `p:spPr/a:xfrm`, or `null` when any link in that chain
+* is absent — which is how an inheriting placeholder (one with no `a:xfrm` of its own) reports
+* that its geometry comes from the layout/master instead. See `placeholderInheritedXfrm` for
+* resolving what it would inherit.
+*/
+function spPrXfrmEmu(sp, container, axis) {
+	const spPr = firstChild(sp, "p:spPr");
+	const xfrm = spPr && firstChild(spPr, "a:xfrm");
+	const el = xfrm && firstChild(xfrm, container);
+	return el ? intValue(attr(el, axis)) : null;
+}
+/** Get-or-add `p:spPr/a:xfrm` for shapes whose transform lives in `p:spPr` (`p:sp`, `p:pic`, `p:cxnSp`). */
+function getOrAddSpPrXfrm(shapeElement) {
+	return getOrAddChild(getOrAddChild(shapeElement, "p:spPr", SHAPE_AFTER_SPPR), "a:xfrm", SPPR_AFTER_XFRM);
+}
+//#endregion
+//#region src/read/api/shapes/geometry.ts
+/**
+* Reading geometry out of a shape: transform boxes, rotation and flips, and custom-geometry paths.
+*
+* Every value here comes straight off `a:xfrm` / `a:path` attributes, so these are pure element
+* 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).
+*/
+function ptAxis(pt, axis) {
+	return (pt ? intValue(attr(pt, axis)) : null) ?? 0;
+}
+/** Parse one `<a:path>` into its viewport attrs (with schema defaults) and ordered segments. */
+function readGeometryPath(path) {
+	const commands = [];
+	for (let node = path.firstChild; node; node = node.nextSibling) {
+		if (node.nodeType !== 1) continue;
+		const seg = node;
+		if (seg.namespaceURI !== OOXML_NS.a) continue;
+		const pts = getElements(seg, "a:pt");
+		switch (seg.localName) {
+			case "moveTo":
+				commands.push({
+					cmd: "moveTo",
+					x: ptAxis(pts[0], "x"),
+					y: ptAxis(pts[0], "y")
+				});
+				break;
+			case "lnTo":
+				commands.push({
+					cmd: "lnTo",
+					x: ptAxis(pts[0], "x"),
+					y: ptAxis(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")
+				});
+				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")
+				});
+				break;
+			case "arcTo":
+				commands.push({
+					cmd: "arcTo",
+					wR: intValue(attr(seg, "wR")) ?? 0,
+					hR: intValue(attr(seg, "hR")) ?? 0,
+					stAng: (intValue(attr(seg, "stAng")) ?? 0) / 6e4,
+					swAng: (intValue(attr(seg, "swAng")) ?? 0) / 6e4
+				});
+				break;
+			case "close": commands.push({ cmd: "close" });
+		}
+	}
+	return {
+		w: intValue(attr(path, "w")) ?? 0,
+		h: intValue(attr(path, "h")) ?? 0,
+		fill: attr(path, "fill") ?? "norm",
+		stroke: boolValue(attr(path, "stroke")) ?? true,
+		commands
+	};
 }
-function emuFrom(parent, qname, attribute) {
-	const element = parent && firstChild(parent, qname);
-	return element ? intValue(attr(element, attribute)) : null;
+/** Validate and round an EMU geometry value; extents (`cx`/`cy`) must be non-negative. */
+function toEmu(value, attribute, allowNegative) {
+	if (!Number.isFinite(value)) throw new InvalidOptionError("coord/non-finite", `${attribute} must be a finite number of EMU, got ${value}`);
+	if (!allowNegative && value < 0) throw new InvalidOptionError("coord/negative", `${attribute} must be non-negative, got ${value}`);
+	return Math.round(value);
 }
-/** Direct child *elements* of `parent`, in document order. */
-function childElements(parent) {
-	const out = [];
-	for (let node = parent.firstChild; node; node = node.nextSibling) if (node.nodeType === 1) out.push(node);
-	return out;
+/** A point + extent pair (`a:off`/`a:ext` or `a:chOff`/`a:chExt`) from a transform, or `null` if either is incomplete. */
+function readBox(xfrm, offName, extName) {
+	const off = firstChild(xfrm, offName);
+	const ext = firstChild(xfrm, extName);
+	const x = off && intValue(attr(off, "x"));
+	const y = off && intValue(attr(off, "y"));
+	const cx = ext && intValue(attr(ext, "cx"));
+	const cy = ext && intValue(attr(ext, "cy"));
+	if (x === null || y === null || cx === null || cy === null) return null;
+	return {
+		x,
+		y,
+		cx,
+		cy
+	};
 }
-/** Get-or-add `p:spPr/a:xfrm` for shapes whose transform lives in `p:spPr` (`p:sp`, `p:pic`, `p:cxnSp`). */
-function getOrAddSpPrXfrm(shapeElement) {
-	return getOrAddChild(getOrAddChild(shapeElement, "p:spPr", SHAPE_AFTER_SPPR), "a:xfrm", SPPR_AFTER_XFRM);
+function rotationDegrees(xfrm) {
+	const rot = intValue(attr(xfrm, "rot"));
+	return rot === null ? 0 : rot / 6e4;
+}
+function transformFlipH(xfrm) {
+	return boolValue(attr(xfrm, "flipH")) === true;
+}
+function transformFlipV(xfrm) {
+	return boolValue(attr(xfrm, "flipV")) === true;
 }
 //#endregion
-//#region src/read/group-transform.ts
+//#region src/read/api/shapes/group-transform.ts
 /** Normalise a degree value into [0, 360). */
 function normalizeDegrees(value) {
 	return (value % 360 + 360) % 360;
@@ -2664,22 +2370,68 @@ var Paragraph = class {
 		return this.#emuAttrPt("indent");
 	}
 	/**
-	* Bullet description for this paragraph, derived from the `a:pPr` bullet
-	* children, or `null` when unset (inherited from the list style):
-	* - `'none'`          — explicit `a:buNone` (bullet suppressed)
-	* - `'char:•'`        — `a:buChar/@char` (the literal glyph follows the colon)
-	* - `'autoNum:arabicPeriod'` — `a:buAutoNum/@type` (auto-numbered)
+	* 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.
+	*
+	* Structured rather than a tagged string, which is not merely tidier. The
+	* 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
+	* `n` bullet on every converted deck, silently. See {@link BulletDetail}.
 	*/
-	get bullet() {
+	get bulletDetail() {
 		const pPr = firstChild(this.element, "a:pPr");
 		if (!pPr) return null;
-		if (firstChild(pPr, "a:buNone")) return "none";
+		if (firstChild(pPr, "a:buNone")) return { kind: "none" };
+		const style = this.#bulletStyle(pPr);
 		const buChar = firstChild(pPr, "a:buChar");
-		if (buChar) return `char:${attr(buChar, "char") ?? ""}`;
+		if (buChar) return {
+			kind: "char",
+			char: attr(buChar, "char") ?? "",
+			...style
+		};
 		const buAutoNum = firstChild(pPr, "a:buAutoNum");
-		if (buAutoNum) return `autoNum:${attr(buAutoNum, "type") ?? ""}`;
+		if (buAutoNum) return {
+			kind: "autoNum",
+			scheme: attr(buAutoNum, "type") ?? "",
+			startAt: intValue(attr(buAutoNum, "startAt")),
+			...style
+		};
+		const buBlip = firstChild(pPr, "a:buBlip");
+		if (buBlip) return {
+			kind: "picture",
+			imagePartName: this.#bulletImagePartName(buBlip),
+			...style
+		};
 		return null;
 	}
+	/** The `a:buFont` / `a:buSz*` / `a:buClr` siblings of a `a:pPr` bullet choice. */
+	#bulletStyle(pPr) {
+		const buFont = firstChild(pPr, "a:buFont");
+		const buSzPct = firstChild(pPr, "a:buSzPct");
+		const buSzPts = firstChild(pPr, "a:buSzPts");
+		const buClr = firstChild(pPr, "a:buClr");
+		const colorEl = buClr ? firstChildElement(buClr) : null;
+		const pctVal = buSzPct ? intValue(attr(buSzPct, "val")) : null;
+		const ptVal = buSzPts ? intValue(attr(buSzPts, "val")) : null;
+		return {
+			font: buFont ? attr(buFont, "typeface") ?? null : null,
+			sizePct: pctVal === null ? null : pctVal / 1e3,
+			sizePt: ptVal === null ? null : ptVal / 100,
+			color: colorEl?.localName === "srgbClr" ? attr(colorEl, "val") ?? null : null,
+			schemeColor: colorEl?.localName === "schemeClr" ? attr(colorEl, "val") ?? null : null,
+			resolvedColor: this.themeContext ? resolveColorElement(colorEl, this.themeContext) : null
+		};
+	}
+	/** Resolve a picture bullet's `a:buBlip/a:blip/@r:embed` to an absolute partname. */
+	#bulletImagePartName(buBlip) {
+		const blip = firstChild(buBlip, "a:blip");
+		const relId = blip && attr(blip, "r:embed");
+		if (!relId || !this.relationships) return null;
+		return this.relationships.resolveTarget(relId);
+	}
 	/** Points from a spacing child's `a:spcPts/@val` (hundredths of a point), or `null`. */
 	#spacingPt(qname) {
 		const pPr = firstChild(this.element, "a:pPr");
@@ -2862,7 +2614,7 @@ function setTextBodyText(txBody, value) {
 		p = createElement(doc, "a:p");
 		txBody.appendChild(p);
 	}
-	for (const child of [...childElements$2(p)]) if (child.localName === "r" || child.localName === "br" || child.localName === "fld") p.removeChild(child);
+	for (const child of childElements(p)) if (child.localName === "r" || child.localName === "br" || child.localName === "fld") p.removeChild(child);
 	const run = createElement(doc, "a:r");
 	if (rPrTemplate) run.appendChild(rPrTemplate.cloneNode(true));
 	const t = createElement(doc, "a:t");
@@ -2874,117 +2626,6 @@ function setTextBodyText(txBody, value) {
 	p.insertBefore(run, endParaRPr);
 }
 //#endregion
-//#region src/read/api/shapes/geometry.ts
-/**
-* Reading geometry out of a shape: transform boxes, rotation and flips, and custom-geometry paths.
-*
-* Every value here comes straight off `a:xfrm` / `a:path` attributes, so these are pure element
-* 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).
-*/
-function ptAxis(pt, axis) {
-	return (pt ? intValue(attr(pt, axis)) : null) ?? 0;
-}
-/** Parse one `<a:path>` into its viewport attrs (with schema defaults) and ordered segments. */
-function readGeometryPath(path) {
-	const commands = [];
-	for (let node = path.firstChild; node; node = node.nextSibling) {
-		if (node.nodeType !== 1) continue;
-		const seg = node;
-		if (seg.namespaceURI !== OOXML_NS.a) continue;
-		const pts = getElements(seg, "a:pt");
-		switch (seg.localName) {
-			case "moveTo":
-				commands.push({
-					cmd: "moveTo",
-					x: ptAxis(pts[0], "x"),
-					y: ptAxis(pts[0], "y")
-				});
-				break;
-			case "lnTo":
-				commands.push({
-					cmd: "lnTo",
-					x: ptAxis(pts[0], "x"),
-					y: ptAxis(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")
-				});
-				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")
-				});
-				break;
-			case "arcTo":
-				commands.push({
-					cmd: "arcTo",
-					wR: intValue(attr(seg, "wR")) ?? 0,
-					hR: intValue(attr(seg, "hR")) ?? 0,
-					stAng: (intValue(attr(seg, "stAng")) ?? 0) / 6e4,
-					swAng: (intValue(attr(seg, "swAng")) ?? 0) / 6e4
-				});
-				break;
-			case "close": commands.push({ cmd: "close" });
-		}
-	}
-	return {
-		w: intValue(attr(path, "w")) ?? 0,
-		h: intValue(attr(path, "h")) ?? 0,
-		fill: attr(path, "fill") ?? "norm",
-		stroke: boolValue(attr(path, "stroke")) ?? true,
-		commands
-	};
-}
-/** Validate and round an EMU geometry value; extents (`cx`/`cy`) must be non-negative. */
-function toEmu(value, attribute, allowNegative) {
-	if (!Number.isFinite(value)) throw new InvalidOptionError("coord/non-finite", `${attribute} must be a finite number of EMU, got ${value}`);
-	if (!allowNegative && value < 0) throw new InvalidOptionError("coord/negative", `${attribute} must be non-negative, got ${value}`);
-	return Math.round(value);
-}
-/** A point + extent pair (`a:off`/`a:ext` or `a:chOff`/`a:chExt`) from a transform, or `null` if either is incomplete. */
-function readBox(xfrm, offName, extName) {
-	const off = firstChild(xfrm, offName);
-	const ext = firstChild(xfrm, extName);
-	const x = off && intValue(attr(off, "x"));
-	const y = off && intValue(attr(off, "y"));
-	const cx = ext && intValue(attr(ext, "cx"));
-	const cy = ext && intValue(attr(ext, "cy"));
-	if (x === null || y === null || cx === null || cy === null) return null;
-	return {
-		x,
-		y,
-		cx,
-		cy
-	};
-}
-function rotationDegrees(xfrm) {
-	const rot = intValue(attr(xfrm, "rot"));
-	return rot === null ? 0 : rot / 6e4;
-}
-function transformFlipH(xfrm) {
-	return boolValue(attr(xfrm, "flipH")) === true;
-}
-function transformFlipV(xfrm) {
-	return boolValue(attr(xfrm, "flipV")) === true;
-}
-//#endregion
 //#region src/read/api/shapes/base.ts
 /**
 * The abstract base every shape kind extends.
@@ -3283,9 +2924,25 @@ var Shape = class {
 		});
 	}
 	/**
+	* `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},
+	* {@link resolvedFill}, {@link gradientFill}, {@link patternFill},
+	* {@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.
+	*/
+	get fillNoFill() {
+		const props = this.properties();
+		return !!(props && firstChild(props, "a:noFill"));
+	}
+	/**
 	* 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}.
 	*/
 	noFill() {
 		if (!this.supportsFill) throw new UnsupportedFeatureError("shape/fill-unsupported", `${this.shapeType} shapes do not support a solid fill`);
@@ -3343,6 +3000,32 @@ var Shape = class {
 		return !!(ln && firstChild(ln, "a:noFill"));
 	}
 	/**
+	* 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.
+	*
+	* Not cosmetic on a thick dashed rule: the cap decides whether each dash reads
+	* as a rectangle or a lozenge, and it extends every dash by the stroke width.
+	* SVG's `stroke-linecap` is the exact equivalent (`flat`→`butt`, `rnd`→`round`,
+	* `sq`→`square`).
+	*/
+	get lineCap() {
+		const ln = this.#line();
+		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) —
+	* or `null` when unset. It shifts a thick outline by half its width, so it
+	* changes where the border sits relative to the fill.
+	*/
+	get lineAlign() {
+		const ln = this.#line();
+		return ln ? attr(ln, "algn") ?? null : null;
+	}
+	/**
 	* Preset geometry name (`spPr/a:prstGeom/@prst`, e.g. `rect`), or `null` for
 	* custom geometry or none. Not an auto-shape-only property: PowerPoint gives a
 	* picture and a connector a preset geometry too (a `p:pic` is `rect` unless it
@@ -3743,7 +3426,6 @@ var AutoShape = class extends Shape {
 * blip plumbing (content-type → extension, the SVG extension blip, the recolour effects) lives
 * here rather than on the base: no other shape kind carries it.
 */
-const IMAGE_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image";
 const ASVG_NS = "http://schemas.microsoft.com/office/drawing/2016/SVG/main";
 const PIC_AFTER_BLIPFILL = ["p:spPr", "p:style"];
 const BLIPFILL_AFTER_BLIP = [
@@ -3986,7 +3668,7 @@ var Picture = class extends Shape {
 		const opc = this.slide.presentation.opc;
 		const mediaPartName = opc.reserveMediaPartName(extension);
 		opc.addPart(mediaPartName, contentType, bytes);
-		const relId = this.slide.relationships.add(IMAGE_REL_TYPE, relativePartName(this.slide.partName, mediaPartName)).id;
+		const relId = this.slide.relationships.add(IMAGE_REL, relativePartName(this.slide.partName, mediaPartName)).id;
 		setAttr(this.#getOrAddBlip(), "r:embed", relId);
 		if (options.fit) this.#applyFit(options.fit, bytes);
 		this.markDirty();
@@ -4115,7 +3797,7 @@ var Chart = class {
 		for (let node = plotArea.firstChild; node; node = node.nextSibling) {
 			if (node.nodeType !== 1) continue;
 			const element = node;
-			if (element.namespaceURI === OOXML_NS.c && /Ax$/.test(element.localName ?? "")) out.push(new ChartAxis(element, this.part));
+			if (element.namespaceURI === OOXML_NS.c && (element.localName ?? "").endsWith("Ax")) out.push(new ChartAxis(element, this.part));
 		}
 		return out;
 	}
@@ -4372,7 +4054,7 @@ var ChartSeries = class {
 	/** Cached numeric values (`c:val`); non-numeric or missing points are `null`. */
 	get values() {
 		const val = firstChild(this.ser, "c:val");
-		return readPoints(val && findCache(val)).map(toNumberOrNull$1);
+		return readPoints(val && findCache(val)).map(intValue);
 	}
 	/** Cached category labels for this series (`c:cat`), as written. */
 	get categories() {
@@ -4460,11 +4142,6 @@ function readPoints(cache) {
 	}
 	return points;
 }
-function toNumberOrNull$1(value) {
-	if (value === null || value === "") return null;
-	const number = Number(value);
-	return Number.isFinite(number) ? number : null;
-}
 //#endregion
 //#region src/read/api/chartex.ts
 /** A chartEx graphic-frame's chart, backed by its `cx:chartSpace` part. */
@@ -4608,7 +4285,7 @@ var ChartExSeries = class {
 	get values() {
 		const data = this.chart.dataElementById(this.dataId);
 		const numDim = data && firstChild(data, "cx:numDim");
-		return readLevelPoints(numDim && firstChild(numDim, "cx:lvl")).map(toNumberOrNull);
+		return readLevelPoints(numDim && firstChild(numDim, "cx:lvl")).map(intValue);
 	}
 	/**
 	* Cached category labels (`cx:strDim`'s leaf `cx:lvl` — the first level, which
@@ -4726,56 +4403,30 @@ function floatValue(value) {
 	const number = Number(value);
 	return Number.isFinite(number) ? number : null;
 }
-function toNumberOrNull(value) {
-	if (value === null || value === "") return null;
-	const number = Number(value);
-	return Number.isFinite(number) ? number : null;
-}
 //#endregion
 //#region src/read/api/table-edit.ts
 /**
-* Ordered mutation of a table cell's `a:tcPr`, and the schema facts every such edit needs.
+* 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
 * file rather than as a bad edit. Every insertion therefore goes through
-* {@link getOrAddChild} / {@link insertInOrder} with the new element's *successors*, which
-* is what {@link TCPR_AFTER} tabulates. Writing that table once, here, is the point of this
-* module: a setter that hand-rolls its own successor list is one rename away from silently
-* producing an invalid part.
+* {@link getOrAddChild} / {@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
 * 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.
-*/
-/**
-* `CT_TableCellProperties`' child sequence, in declaration order.
-* @see ECMA-376 Part 1 §21.1.3.17 (`a:tcPr`)
-*/
-const TCPR_SEQUENCE = [
-	"a:lnL",
-	"a:lnR",
-	"a:lnT",
-	"a:lnB",
-	"a:lnTlToBr",
-	"a:lnBlToTr",
-	"a:cell3D",
-	"a:noFill",
-	"a:solidFill",
-	"a:gradFill",
-	"a:blipFill",
-	"a:pattFill",
-	"a:grpFill",
-	"a:headers",
-	"a:extLst"
-];
-/**
-* For each `a:tcPr` child, the children that must follow it — i.e. what a new one is
-* inserted *before*. Derived from {@link TCPR_SEQUENCE} rather than written out, so the two
-* cannot disagree and adding a child to the sequence updates every successor list at once.
+* is a caller to throw at rather than a deck to degrade (see `ooxml/check-enum.ts`).
 */
-const TCPR_AFTER = Object.fromEntries(TCPR_SEQUENCE.map((qname, index) => [qname, TCPR_SEQUENCE.slice(index + 1)]));
+/** `ST_TextAnchoringType` — `a:tcPr/@anchor`. */
+const ANCHOR_VALUES = TEXT_ANCHORS;
+/** `ST_TextVerticalType` — `a:tcPr/@vert`. */
+const VERT_VALUES = TEXT_VERTICAL;
+/** `ST_TextHorzOverflowType` — `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 = {
 	left: "a:lnL",
@@ -4785,45 +4436,6 @@ const EDGE_QNAMES = {
 	tlToBr: "a:lnTlToBr",
 	blToTr: "a:lnBlToTr"
 };
-/** `ST_TextAnchoringType` — `a:tcPr/@anchor`. */
-const ANCHOR_VALUES = [
-	"t",
-	"ctr",
-	"b",
-	"just",
-	"dist"
-];
-/** `ST_TextVerticalType` — `a:tcPr/@vert`. */
-const VERT_VALUES = [
-	"horz",
-	"vert",
-	"vert270",
-	"wordArtVert",
-	"eaVert",
-	"mongolianVert",
-	"wordArtVertRtl"
-];
-/** `ST_TextHorzOverflowType` — `a:tcPr/@horzOverflow`. */
-const HORZ_OVERFLOW_VALUES = ["clip", "overflow"];
-/**
-* Check a value against its `ST_` union, throwing when it is outside.
-*
-* Throwing rather than warn-and-drop, which is the opposite of what the *write* path does
-* with the same enums — and deliberately so. On the write path an option comes from a deck
-* being built, and dropping one value is better than failing a whole build; here it comes
-* from a caller editing one attribute, so silently doing nothing would leave them looking at
-* an unchanged deck with no explanation.
-*
-* @param {string} value - the value the caller asked for
-* @param {readonly string[]} valid - the enum's members
-* @param {string} attribute - the attribute's name, for the message
-* @param {InvalidOptionErrorCode} code - the condition to report
-* @returns {string} `value`, when it is legal
-*/
-function checkEnum(value, valid, attribute, code) {
-	if (valid.includes(value)) return value;
-	throw new InvalidOptionError(code, `Invalid ${attribute}: ${JSON.stringify(value)}. Expected one of: ${valid.join(", ")}.`);
-}
 /**
 * Get or create a child of `a:tcPr` at its schema position.
 * @param {Element} tcPr - the cell's properties element
@@ -5756,7 +5368,7 @@ var TableCell = class {
 			this.part.markDirty();
 			return;
 		}
-		const checked = checkEnum(value, valid, name, code);
+		const checked = checkEnumOrThrow(value, valid, name, code);
 		setAttr(this.#getOrAddTcPr(), name, checked);
 		this.part.markDirty();
 	}
@@ -5813,6 +5425,27 @@ var TableCell = class {
 		return !!tcPr && FILL_CHOICES.some((q) => firstChild(tcPr, q));
 	}
 	/**
+	* `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 import('./shapes.js').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 fillColor},
+	* {@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
+	* apart paints a transparent cell in the style's shading.
+	*/
+	get fillNoFill() {
+		const tcPr = this.#tcPr();
+		return !!tcPr && !!firstChild(tcPr, "a:noFill");
+	}
+	/**
 	* The cell's picture (image) fill (`a:tcPr/a:blipFill`), or `null` when the cell
 	* is not image-filled. The cell counterpart of
 	* {@link import('./shapes.js').AutoShape.pictureFill}: {@link resolvedFill}
@@ -6168,6 +5801,30 @@ var GroupShape = class extends Shape {
 			"p:graphicFrame"
 		]);
 	}
+	/**
+	* The group's own child coordinate space (`p:grpSpPr/a:xfrm/a:chOff` and
+	* `a:chExt`) in EMU, or `null` when the group has no transform or either
+	* element is incomplete.
+	*
+	* Most consumers should not need this: {@link Shape.absoluteFrame} already
+	* 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
+	* source child space to reproduce the scaling, and without it only groups whose
+	* child space is the identity can be rebuilt.
+	*/
+	get childFrame() {
+		const xfrm = this.xfrm();
+		const box = xfrm && readBox(xfrm, "a:chOff", "a:chExt");
+		if (!box) return null;
+		return {
+			offsetX: box.x,
+			offsetY: box.y,
+			extentX: box.cx,
+			extentY: box.cy
+		};
+	}
 	/** The shapes nested directly inside this group, in document order. */
 	get shapes() {
 		return buildShapes(this.element, this.slide);
@@ -6248,6 +5905,6 @@ function buildShapes(parent, slide) {
 	return shapes;
 }
 //#endregion
-export { createElement as $, resolveLayoutColorContext as A, remapLiteralColors as B, Paragraph as C, readPictureFill as D, readPatternFill as E, applyColorTransforms as F, relativePartName as G, styleRefFill as H, flattenShape as I, zipPathToPartName as J, relsPartNameFor as K, flattenSlide as L, resolveNotesColorContext as M, resolveSlideColorContext as N, readGradientFill as O, resolveSlideThemeParts as P, childElements$2 as Q, parseClrMap as R, Shape as S, TextFrame as T, partNameExtension as U, restyleSlide as V, partNameToZipPath as W, attr as X, OOXML_NS as Y, boolValue as Z, ChartAxis as _, isGraphicFrame as a, insertInOrder as at, Picture as b, wrapShapeElement as c, parseXml as ct, TableCell as d, serializeXml as dt, escapeXmlAttribute as et, TableRow as f, setAttr as ft, Chart as g, ChartExSeries as h, isConnector as i, getOrAddChild as it, resolveMasterColorContext as j, resolveColorElement as k, GraphicFrame as l, removeAttr as lt, ChartExAxis as m, buildShapes as n, firstChildElement as nt, isGroupShape as o, intValue as ot, ChartEx as p, resolveRelativePartName as q, isAutoShape as r, getElements as rt, isPicture as s, ownerDocumentOf as st, GroupShape as t, firstChild as tt, Table as u, removeChildrenByQName as ut, ChartSeries as v, Run as w, AutoShape as x, Connector as y, parseClrScheme as z };
+export { resolveColor as $, resolveColorElement as A, getOrAddChild as At, placeholderInheritedColor as B, Paragraph as C, childElements as Ct, readPatternFill as D, firstChild as Dt, spPrXfrmEmu as E, escapeXmlAttribute as Et, resolveSlideThemeParts as F, removeAttr as Ft, slideDefinesColor as G, placeholderInheritedRunProps as H, applyColorTransforms as I, removeChildrenByQName as It, fmtEntry as J, slideDefinesProp as K, LST_STYLE_LEVELS as L, replaceInParent as Lt, resolveMasterColorContext as M, intValue as Mt, resolveNotesColorContext as N, ownerDocumentOf as Nt, readPictureFill as O, firstChildElement as Ot, resolveSlideColorContext as P, parseXml as Pt, parseClrScheme as Q, RUN_PROP_NAMES as R, serializeXml as Rt, Shape as S, boolValue as St, TextFrame as T, descendantsByTag as Tt, placeholderInheritedXfrm as U, placeholderInheritedListStyles as V, placeholderOf as W, isA as X, intAttr as Y, parseClrMap as Z, ChartAxis as _, resolveRelativePartName as _t, isGraphicFrame as a, RPR_FILL_AFTER as at, Picture as b, OOXML_NS as bt, wrapShapeElement as c, SPPR_EFFECT_AFTER as ct, TableCell as d, SPPR_SCENE3D_AFTER as dt, resolveSchemeToken as et, TableRow as f, SPPR_SP3D_AFTER as ft, Chart as g, relsPartNameFor as gt, ChartExSeries as h, relativePartName as ht, isConnector as i, FILL_CHOICES as it, resolveLayoutColorContext as j, insertInOrder as jt, readGradientFill as k, getElements as kt, GraphicFrame as l, SPPR_FILL_AFTER as lt, ChartExAxis as m, partNameToZipPath as mt, buildShapes as n, styleRefLine as nt, isGroupShape as o, SHAPE_AFTER_SPPR as ot, ChartEx as p, partNameExtension as pt, SCHEME_SLOTS as q, isAutoShape as r, substitutePhClr as rt, isPicture as s, SPPR_AFTER_XFRM as st, GroupShape as t, styleRefFill as tt, Table as u, SPPR_LN_AFTER as ut, ChartSeries as v, resolveSingleRel as vt, Run as w, createElement as wt, AutoShape as x, attr as xt, Connector as y, zipPathToPartName as yt, placeholderInheritedAnchor as z, setAttr as zt };
 
-//# sourceMappingURL=shapes-CaOgR0i1.js.map
+//# sourceMappingURL=shapes-DMThLsZN.js.map