@shbernal/ts-pptx 1.0.0 → 3.0.0

package/dist/{shapes-BZU8UTW2.js → shapes-BWifcHDV.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-C5Z1sKof.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-CgadEyPM.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,337 +823,80 @@ 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.
+* 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`.
+*
+* The one place the chain is spelled out. `placeholderInherited*` differ only in what they pull
+* from each tier, so they all walk this.
 */
-function placeholderInheritedDefRPrs(type, idx, level, ctx) {
+function styleTiers(type, idx, ctx) {
 	const tiers = [];
 	if (ctx.layoutRoot) {
 		const layoutPh = findPlaceholder(ctx.layoutRoot, type, idx);
-		tiers.push(layoutPh && lstStyleLevelDefRPr(placeholderLstStyle(layoutPh), level));
+		tiers.push(layoutPh && placeholderLstStyle(layoutPh));
 	}
 	if (ctx.masterRoot) {
 		const masterPh = findPlaceholder(ctx.masterRoot, type, idx);
-		tiers.push(masterPh && lstStyleLevelDefRPr(placeholderLstStyle(masterPh), level));
+		tiers.push(masterPh && placeholderLstStyle(masterPh));
 		const txStyles = firstChild(ctx.masterRoot, "p:txStyles");
-		const styleEl = txStyles && firstChild(txStyles, TX_STYLE_NAME[phCategory(type)]);
-		tiers.push(styleEl && lstStyleLevelDefRPr(styleEl, level));
+		tiers.push(txStyles && firstChild(txStyles, TX_STYLE_NAME[phCategory(type)]));
 	}
-	if (ctx.notesStyle) tiers.push(lstStyleLevelDefRPr(ctx.notesStyle, level));
+	if (ctx.notesStyle) tiers.push(ctx.notesStyle);
 	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}.
+* 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 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;
+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;
 }
 /**
-* 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.
+* 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 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`.
-*
-* 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.
-*/
-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) {
-	const tiers = [];
-	if (ctx.layoutRoot) {
-		const layoutPh = findPlaceholder(ctx.layoutRoot, type, idx);
-		tiers.push(layoutPh && placeholderLstStyle(layoutPh));
-	}
-	if (ctx.masterRoot) {
-		const masterPh = findPlaceholder(ctx.masterRoot, type, idx);
-		tiers.push(masterPh && placeholderLstStyle(masterPh));
-		const txStyles = firstChild(ctx.masterRoot, "p:txStyles");
-		tiers.push(txStyles && firstChild(txStyles, TX_STYLE_NAME[phCategory(type)]));
-	}
-	return tiers.filter((t) => t !== null);
+function placeholderInheritedDefRPrs(type, idx, level, ctx) {
+	return styleTiers(type, idx, ctx).map((tier) => lstStyleLevelDefRPr(tier, level)).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 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 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 placeholderInheritedListStyles(type, idx, ctx) {
+	return styleTiers(type, idx, ctx);
 }
-/** 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 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 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 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
@@ -1484,7 +1142,6 @@ function applyColorTransforms(baseHex, transforms) {
 			if (f !== null) alpha = clamp01((alpha ?? 1) + f);
 			break;
 		}
-		default: break;
 	}
 	return alpha === void 0 ? { hex: toHex(rgb) } : {
 		hex: toHex(rgb),
@@ -1504,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;
@@ -1523,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));
@@ -1999,112 +1645,203 @@ function readPictureFill(container, rels = null) {
 	const fillRect = stretch && firstChild(stretch, "a:fillRect");
 	const tile = firstChild(blipFill, "a:tile");
 	return {
-		relId,
-		partName: resolvePartName(relId, rels),
-		mode: stretch ? "stretch" : tile ? "tile" : null,
-		srcRect: srcRect ? readRect(srcRect) : null,
-		fillRect: fillRect ? readRect(fillRect) : null,
-		tile: tile ? readTile(tile) : null,
-		alpha: alphaMod ? amt === null ? 1 : amt / 1e5 : null,
-		dpi: intValue(attr(blipFill, "dpi")),
-		rotWithShape: boolValue(attr(blipFill, "rotWithShape"))
+		relId,
+		partName: resolvePartName(relId, rels),
+		mode: stretch ? "stretch" : tile ? "tile" : null,
+		srcRect: srcRect ? readRect(srcRect) : null,
+		fillRect: fillRect ? readRect(fillRect) : null,
+		tile: tile ? readTile(tile) : null,
+		alpha: alphaMod ? amt === null ? 1 : amt / 1e5 : null,
+		dpi: intValue(attr(blipFill, "dpi")),
+		rotWithShape: boolValue(attr(blipFill, "rotWithShape"))
+	};
+}
+//#endregion
+//#region src/read/api/pattern-fill.ts
+/**
+* Shared pattern-fill reader for DrawingML colour-bearing containers: a shape's `p:spPr`, a
+* slide's `p:bg/p:bgPr`, and a table's `a:tblPr` / cell's `a:tcPr`.
+*
+* `a:pattFill` is a preset hatch name plus two wrapped colours, and decoding it is three
+* lines — which is exactly why it had been open-coded in each place that needed it. Sharing
+* it is what keeps the three from drifting into different answers for the same element, the
+* same reason {@link import('./gradient.js').readGradientFill} and
+* {@link import('./picture-fill.js').readPictureFill} are shared.
+*/
+/**
+* Read a container's `a:pattFill`, or `null` when its fill is not a pattern.
+* @param {Element} container - the fill-bearing parent (`p:spPr`, `p:bgPr`, `a:tblPr`, `a:tcPr`, …)
+* @param {ColorContext} ctx - the theme colour context each colour resolves against
+* @returns {PatternFill | null} the decoded hatch, or `null`
+*/
+function readPatternFill(container, ctx) {
+	const patt = firstChild(container, "a:pattFill");
+	if (!patt) return null;
+	const wrapColor = (qname) => {
+		const wrap = firstChild(patt, qname);
+		const colorEl = wrap && firstChildElement(wrap);
+		return colorEl ? resolveColorElement(colorEl, ctx) : null;
+	};
+	return {
+		preset: attr(patt, "prst") ?? null,
+		foreground: wrapColor("a:fgClr"),
+		background: wrapColor("a:bgClr")
+	};
+}
+//#endregion
+//#region src/read/api/shapes/oxml.ts
+/**
+* Shape-element plumbing: the small element lookups every shape kind performs, plus the
+* shape-scoped re-exports of the shared schema-successor lists.
+*
+* 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.
+*/
+/** 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) {
+		if (node.nodeType !== 1) continue;
+		const child = node;
+		if (child.namespaceURI === OOXML_NS.p && child.localName?.startsWith("nv")) return firstChild(child, "p:cNvPr");
+	}
+	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
 	};
 }
-//#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.
-*
-* 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.
-*/
-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) {
-		if (node.nodeType !== 1) continue;
-		const child = node;
-		if (child.namespaceURI === OOXML_NS.p && child.localName?.startsWith("nv")) return firstChild(child, "p:cNvPr");
-	}
-	return 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);
 }
-function emuFrom(parent, qname, attribute) {
-	const element = parent && firstChild(parent, qname);
-	return element ? intValue(attr(element, attribute)) : null;
+/** 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
+	};
 }
-/** 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;
+function rotationDegrees(xfrm) {
+	const rot = intValue(attr(xfrm, "rot"));
+	return rot === null ? 0 : rot / 6e4;
 }
-/** 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 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;
@@ -2633,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");
@@ -2831,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");
@@ -2843,119 +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" });
-				break;
-		}
-	}
-	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.
@@ -3254,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`);
@@ -3314,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
@@ -3491,19 +3203,7 @@ var Shape = class {
 	*/
 	get patternFill() {
 		const props = this.properties();
-		const patt = props && firstChild(props, "a:pattFill");
-		if (!patt) return null;
-		const ctx = this.slide.themeContext();
-		const resolveWrap = (qname) => {
-			const wrap = firstChild(patt, qname);
-			const colorEl = wrap && firstChildElement(wrap);
-			return colorEl ? resolveColorElement(colorEl, ctx) : null;
-		};
-		return {
-			preset: attr(patt, "prst") ?? null,
-			foreground: resolveWrap("a:fgClr"),
-			background: resolveWrap("a:bgClr")
-		};
+		return props ? readPatternFill(props, this.slide.themeContext()) : null;
 	}
 	/**
 	* The shape's picture (image) fill (`spPr/a:blipFill`), or `null` when the fill
@@ -3726,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 = [
@@ -3969,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();
@@ -4355,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() {
@@ -4441,12 +4140,7 @@ function readPoints(cache) {
 		const idx = intValue(attr(pt, "idx")) ?? 0;
 		points[idx] = firstChild(pt, "c:v")?.textContent ?? null;
 	}
-	return points;
-}
-function toNumberOrNull$1(value) {
-	if (value === null || value === "") return null;
-	const number = Number(value);
-	return Number.isFinite(number) ? number : null;
+	return points;
 }
 //#endregion
 //#region src/read/api/chartex.ts
@@ -4591,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
@@ -4709,10 +4403,391 @@ 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 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 `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 (see `ooxml/check-enum.ts`).
+*/
+/** `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",
+	right: "a:lnR",
+	top: "a:lnT",
+	bottom: "a:lnB",
+	tlToBr: "a:lnTlToBr",
+	blToTr: "a:lnBlToTr"
+};
+/**
+* Get or create a child of `a:tcPr` at its schema position.
+* @param {Element} tcPr - the cell's properties element
+* @param {string} qname - the child to get or create
+* @returns {Element} the existing or newly-inserted child
+*/
+function tcPrChild(tcPr, qname) {
+	return getOrAddChild(tcPr, qname, TCPR_AFTER[qname] ?? []);
+}
+/**
+* Insert an already-built subtree into `a:tcPr` at its schema position.
+* @param {Element} tcPr - the cell's properties element
+* @param {string} qname - the qname of the node being inserted (decides where it goes)
+* @param {Element} node - the subtree to insert
+*/
+function insertTcPrChild(tcPr, qname, node) {
+	insertInOrder(tcPr, node, TCPR_AFTER[qname] ?? []);
+}
+/**
+* Round a measurement to whole EMU, rejecting a value that cannot be written.
+* `NaN`/`Infinity` would reach the attribute verbatim and make the part invalid, which is
+* exactly the "silent coercion of invalid input" the project's policy rules out.
+*/
+function checkFiniteEmu(value, field, code) {
+	if (!Number.isFinite(value)) throw new InvalidOptionError(code, `${field} must be a finite number of EMU, got: ${String(value)}`);
+	return Math.round(value);
+}
+//#endregion
+//#region src/read/api/table-structure.ts
+/**
+* Structural edits to an existing `a:tbl`: adding and removing rows and columns, and
+* merging and unmerging cells.
+*
+* The one fact that makes this tractable is that a stored table's grid is already
+* **rectangular**. Unlike the write path — which receives lopsided row arrays and has to
+* build the merge grid itself (`gen/slide/objects/table.ts` STEP 3) — every `a:tr` in a
+* conformant `a:tbl` holds exactly one `a:tc` per grid column, with the covered half of each
+* span present and flagged. So "the cell at (r, c)" is simply the c-th `a:tc` of the r-th
+* `a:tr`, and an edit's whole job is keeping that rectangle true.
+*
+* Three things have to stay in step, and every function here is written around them:
+*
+* 1. `a:tblGrid/a:gridCol` count == each row's `a:tc` count.
+* 2. A cell with `@gridSpan="n"` is followed by exactly `n-1` cells carrying `@hMerge="1"`,
+*    and a cell with `@rowSpan="n"` is under-hung by `n-1` cells carrying `@vMerge="1"`, in
+*    the same columns.
+* 3. A covered cell carries no span attributes of its own — its extent is the origin's.
+*
+* Breaking any of them produces a table PowerPoint reports as a corrupt file rather than as
+* a bad edit, which is why the span bookkeeping here is explicit rather than incidental.
+*/
+/** Every `a:tr` of a table, in document order. */
+function rowsOf(tbl) {
+	return getElements(tbl, "a:tr");
+}
+/** Every `a:tc` of a row, in document (left-to-right) order. */
+function cellsOf(tr) {
+	return getElements(tr, "a:tc");
+}
+/** The table's `a:tblGrid`, or a thrown error — `CT_Table` requires one. */
+function gridOf(tbl) {
+	const grid = firstChild(tbl, "a:tblGrid");
+	if (!grid) throw new InvalidOptionError("table/column-index-out-of-range", "This table has no a:tblGrid, so its columns cannot be edited");
+	return grid;
+}
+/** A cell's `@gridSpan`, defaulting to 1. */
+function gridSpanOf(tc) {
+	return intValue(attr(tc, "gridSpan")) ?? 1;
+}
+/** A cell's `@rowSpan`, defaulting to 1. */
+function rowSpanOf(tc) {
+	return intValue(attr(tc, "rowSpan")) ?? 1;
+}
+/** Whether a cell is the covered half of a horizontal merge. */
+function isHMerge(tc) {
+	return attr(tc, "hMerge") === "1" || attr(tc, "hMerge") === "true";
+}
+/** Whether a cell is the covered half of a vertical merge. */
+function isVMerge(tc) {
+	return attr(tc, "vMerge") === "1" || attr(tc, "vMerge") === "true";
+}
+/**
+* Set a span attribute, removing it when the span collapses to 1 — the schema default, and
+* what PowerPoint itself writes for an unmerged cell.
+*/
+function setSpan(tc, name, value) {
+	if (value <= 1) removeAttr(tc, name);
+	else setAttr(tc, name, String(value));
+}
+/**
+* Walk left from `col` to the origin of the horizontal run containing it.
+* A run is an origin followed by its `hMerge` continuations, so the origin is the first
+* cell at or left of `col` that is not one.
+* @returns the origin's column index, or `col` itself when the cell stands alone
+*/
+function hRunOrigin(cells, col) {
+	let idx = col;
+	while (idx > 0) {
+		const cell = cells[idx];
+		if (!cell || !isHMerge(cell)) break;
+		idx -= 1;
+	}
+	return idx;
+}
+/**
+* Walk up from `row` to the origin of the vertical run containing `(row, col)`.
+* @returns the origin's row index, or `row` itself when the cell stands alone
+*/
+function vRunOrigin(rows, row, col) {
+	let idx = row;
+	while (idx > 0) {
+		const cell = rows[idx]?.[col];
+		if (!cell || !isVMerge(cell)) break;
+		idx -= 1;
+	}
+	return idx;
+}
+/** A fresh, empty `a:tc`, shaped the way PowerPoint writes one. */
+function makeCell(doc) {
+	const tc = createElement(doc, "a:tc");
+	const txBody = createElement(doc, "a:txBody");
+	txBody.appendChild(createElement(doc, "a:bodyPr"));
+	txBody.appendChild(createElement(doc, "a:lstStyle"));
+	txBody.appendChild(createElement(doc, "a:p"));
+	tc.appendChild(txBody);
+	tc.appendChild(createElement(doc, "a:tcPr"));
+	return tc;
+}
+/** The grid as a row-major array of `a:tc` elements. */
+function gridOfCells(tbl) {
+	return rowsOf(tbl).map((tr) => cellsOf(tr));
+}
+/** Guard an index against `[0, limit]` (inclusive upper bound, for insertion points). */
+function checkIndex(index, limit, what, inclusive) {
+	const max = inclusive ? limit : limit - 1;
+	if (!Number.isInteger(index) || index < 0 || index > max) throw new InvalidOptionError(what === "row" ? "table/row-index-out-of-range" : "table/column-index-out-of-range", `${what} index ${String(index)} is out of range (expected 0..${max})`);
+	return index;
+}
+/**
+* Insert a row at `index` (default: append).
+*
+* The subtle case is inserting **through** a vertical merge. If the row currently at `index`
+* holds a `vMerge` continuation in some column, the span it belongs to straddles the
+* insertion point — so the new row must continue that span rather than interrupt it: the
+* origin's `@rowSpan` grows by one and the new cell is another continuation. Interrupting it
+* instead would leave an origin claiming more rows than it has continuations, which is the
+* corrupt-file case.
+*/
+function insertRow(tbl, index) {
+	const rows = rowsOf(tbl);
+	const at = index === void 0 ? rows.length : checkIndex(index, rows.length, "row", true);
+	const grid = gridOfCells(tbl);
+	const colCount = getElements(gridOf(tbl), "a:gridCol").length;
+	const doc = ownerDocumentOf(tbl);
+	const tr = createElement(doc, "a:tr");
+	setAttr(tr, "h", "0");
+	for (let col = 0; col < colCount; col++) {
+		const tc = makeCell(doc);
+		const displaced = grid[at]?.[col];
+		if (displaced && isVMerge(displaced)) {
+			const origin = grid[vRunOrigin(grid, at, col)]?.[col];
+			if (origin) setSpan(origin, "rowSpan", rowSpanOf(origin) + 1);
+			setAttr(tc, "vMerge", "1");
+			if (isHMerge(displaced)) setAttr(tc, "hMerge", "1");
+			const span = gridSpanOf(displaced);
+			if (span > 1) setSpan(tc, "gridSpan", span);
+		}
+		tr.appendChild(tc);
+	}
+	const before = rows[at] ?? null;
+	tbl.insertBefore(tr, before);
+	return tr;
+}
+/**
+* Remove the row at `index`.
+*
+* Two span cases, and they pull in opposite directions. A cell in this row that *continues*
+* a span from above shortens that span by one. A cell in this row that *starts* one cannot
+* simply take its span away — the rows below still hold its continuations — so the first
+* continuation is promoted to origin and inherits the remaining extent. Its content is gone
+* with the row, which is inherent to removing a row rather than a choice made here.
+*/
+function removeRow(tbl, index) {
+	const rows = rowsOf(tbl);
+	const at = checkIndex(index, rows.length, "row", false);
+	const grid = gridOfCells(tbl);
+	const row = grid[at] ?? [];
+	for (let col = 0; col < row.length; col++) {
+		const tc = row[col];
+		if (!tc) continue;
+		if (isVMerge(tc)) {
+			const origin = grid[vRunOrigin(grid, at, col)]?.[col];
+			if (origin) setSpan(origin, "rowSpan", rowSpanOf(origin) - 1);
+			continue;
+		}
+		const span = rowSpanOf(tc);
+		if (span > 1) {
+			const heir = grid[at + 1]?.[col];
+			if (heir) {
+				removeAttr(heir, "vMerge");
+				setSpan(heir, "rowSpan", span - 1);
+				setSpan(heir, "gridSpan", gridSpanOf(tc));
+			}
+		}
+	}
+	const tr = rows[at];
+	if (tr) tbl.removeChild(tr);
+}
+/**
+* Insert a column at `index` (default: append), `widthEmu` wide.
+*
+* Mirrors {@link insertRow}'s split case on the other axis: when the cell currently at
+* `index` is an `hMerge` continuation, the insertion point falls inside a horizontal span,
+* so the span widens by one and the new cell joins it as another continuation.
+*/
+function insertColumn(tbl, index, widthEmu = 914400) {
+	const grid = gridOf(tbl);
+	const cols = getElements(grid, "a:gridCol");
+	const at = index === void 0 ? cols.length : checkIndex(index, cols.length, "column", true);
+	const doc = ownerDocumentOf(tbl);
+	const gridCol = createElement(doc, "a:gridCol");
+	setAttr(gridCol, "w", String(Math.round(widthEmu)));
+	grid.insertBefore(gridCol, cols[at] ?? null);
+	for (const tr of rowsOf(tbl)) {
+		const cells = cellsOf(tr);
+		const tc = makeCell(doc);
+		const displaced = cells[at];
+		if (displaced && isHMerge(displaced)) {
+			const origin = cells[hRunOrigin(cells, at)];
+			if (origin) setSpan(origin, "gridSpan", gridSpanOf(origin) + 1);
+			setAttr(tc, "hMerge", "1");
+			if (isVMerge(displaced)) setAttr(tc, "vMerge", "1");
+			const span = rowSpanOf(displaced);
+			if (span > 1) setSpan(tc, "rowSpan", span);
+		}
+		tr.insertBefore(tc, cells[at] ?? firstChild(tr, "a:extLst"));
+	}
+	return gridCol;
+}
+/**
+* Remove the column at `index`.
+*
+* When the column falls inside a horizontal span, the span shrinks by one and a
+* *continuation* is removed rather than the origin — so the merged region narrows but keeps
+* its content. Only a column whose cell stands alone loses that cell outright.
+*/
+function removeColumn(tbl, index) {
+	const grid = gridOf(tbl);
+	const cols = getElements(grid, "a:gridCol");
+	const at = checkIndex(index, cols.length, "column", false);
+	const col = cols[at];
+	if (col) grid.removeChild(col);
+	for (const tr of rowsOf(tbl)) {
+		const cells = cellsOf(tr);
+		const originIdx = hRunOrigin(cells, at);
+		const origin = cells[originIdx];
+		if (!origin) continue;
+		const span = gridSpanOf(origin);
+		if (span > 1) {
+			setSpan(origin, "gridSpan", span - 1);
+			const victim = cells[originIdx + span - 1];
+			if (victim) tr.removeChild(victim);
+			continue;
+		}
+		const tc = cells[at];
+		if (tc) tr.removeChild(tc);
+	}
+}
+/**
+* Merge the rectangle `(row1, col1)`–`(row2, col2)` into one cell.
+*
+* The top-left cell becomes the origin and keeps its content; every other cell in the
+* rectangle becomes a covered cell — flagged, stripped of its own span attributes, and
+* emptied, since a covered cell is never rendered.
+*
+* A rectangle whose boundary **cuts through** an existing merge is rejected rather than
+* silently widened. Widening would be the friendlier-looking choice and the wrong one: the
+* caller asked for a specific region, and quietly returning a different one is how a layout
+* ends up subtly wrong with nothing to point at.
+*/
+function mergeCells(tbl, row1, col1, row2, col2) {
+	const grid = gridOfCells(tbl);
+	const rowCount = grid.length;
+	const colCount = getElements(gridOf(tbl), "a:gridCol").length;
+	const r1 = Math.min(row1, row2);
+	const r2 = Math.max(row1, row2);
+	const c1 = Math.min(col1, col2);
+	const c2 = Math.max(col1, col2);
+	checkIndex(r1, rowCount, "row", false);
+	checkIndex(r2, rowCount, "row", false);
+	checkIndex(c1, colCount, "column", false);
+	checkIndex(c2, colCount, "column", false);
+	if (r1 === r2 && c1 === c2) throw new InvalidOptionError("table/merge-range-invalid", "A merge needs at least two cells; the given range covers one");
+	for (let r = r1; r <= r2; r++) for (let c = c1; c <= c2; c++) {
+		if (!grid[r]?.[c]) continue;
+		const originRow = vRunOrigin(grid, r, c);
+		const originCol = hRunOrigin(grid[r] ?? [], c);
+		const origin = grid[originRow]?.[originCol];
+		if (!origin) continue;
+		if (originRow < r1 || originCol < c1) throw new InvalidOptionError("table/merge-range-invalid", `The range (${r1},${c1})-(${r2},${c2}) starts inside an existing merged cell at (${originRow},${originCol}); unmerge it first`);
+		if (originRow + rowSpanOf(origin) - 1 > r2 || originCol + gridSpanOf(origin) - 1 > c2) throw new InvalidOptionError("table/merge-range-invalid", `The range (${r1},${c1})-(${r2},${c2}) cuts through an existing merged cell at (${originRow},${originCol}); unmerge it first`);
+	}
+	const origin = grid[r1]?.[c1];
+	if (!origin) return;
+	setSpan(origin, "gridSpan", c2 - c1 + 1);
+	setSpan(origin, "rowSpan", r2 - r1 + 1);
+	removeAttr(origin, "hMerge");
+	removeAttr(origin, "vMerge");
+	for (let r = r1; r <= r2; r++) for (let c = c1; c <= c2; c++) {
+		if (r === r1 && c === c1) continue;
+		const tc = grid[r]?.[c];
+		if (!tc) continue;
+		removeAttr(tc, "gridSpan");
+		removeAttr(tc, "rowSpan");
+		if (c > c1) setAttr(tc, "hMerge", "1");
+		else removeAttr(tc, "hMerge");
+		if (r > r1) setAttr(tc, "vMerge", "1");
+		else removeAttr(tc, "vMerge");
+		emptyCellText(tc);
+	}
+}
+/**
+* Split the merged cell whose origin is `(row, col)` back into individual cells.
+* The origin keeps its content; the cells it covered come back empty, which is what they
+* already were.
+*/
+function unmergeCell(tbl, row, col) {
+	const grid = gridOfCells(tbl);
+	checkIndex(row, grid.length, "row", false);
+	checkIndex(col, getElements(gridOf(tbl), "a:gridCol").length, "column", false);
+	const origin = grid[row]?.[col];
+	if (!origin) return;
+	if (isHMerge(origin) || isVMerge(origin)) throw new InvalidOptionError("table/merge-range-invalid", `The cell at (${row},${col}) is a covered cell, not a merge origin; unmerge the origin at (${vRunOrigin(grid, row, col)},${hRunOrigin(grid[row] ?? [], col)}) instead`);
+	const rowSpan = rowSpanOf(origin);
+	const gridSpan = gridSpanOf(origin);
+	if (rowSpan === 1 && gridSpan === 1) return;
+	removeAttr(origin, "gridSpan");
+	removeAttr(origin, "rowSpan");
+	for (let r = row; r < row + rowSpan; r++) for (let c = col; c < col + gridSpan; c++) {
+		if (r === row && c === col) continue;
+		const tc = grid[r]?.[c];
+		if (!tc) continue;
+		removeAttr(tc, "hMerge");
+		removeAttr(tc, "vMerge");
+	}
+}
+/** Reduce a cell's text body to a single empty paragraph. */
+function emptyCellText(tc) {
+	const txBody = firstChild(tc, "a:txBody");
+	if (!txBody) return;
+	for (const p of getElements(txBody, "a:p")) txBody.removeChild(p);
+	txBody.appendChild(createElement(ownerDocumentOf(txBody), "a:p"));
 }
 //#endregion
 //#region src/read/api/table-style-resolve.ts
@@ -4893,6 +4968,63 @@ var Table = class {
 		const id = (tblPr && firstChild(tblPr, "a:tableStyleId"))?.textContent?.trim();
 		return id ? id : null;
 	}
+	/**
+	* The table's own background (`a:tblPr` fill) resolved against the slide's theme colour
+	* context to a literal hex, or `null` when the table carries no solid background.
+	*
+	* This is the table-level counterpart of {@link TableCell.resolvedFill}, and it is a
+	* genuinely different thing from a cell fill: a `a:tblPr` fill sits *behind* the grid, so
+	* a cell with no fill of its own shows it through. Reports `null` for a non-solid choice
+	* (`a:blipFill`/`a:gradFill`/`a:pattFill`/`a:noFill`) — read {@link pictureFill} for an
+	* image background — and `null` with no theme context.
+	*/
+	get resolvedFill() {
+		if (!this.themeColors) return null;
+		const tblPr = firstChild(this.tbl, "a:tblPr");
+		if (!tblPr || !FILL_CHOICES.some((q) => firstChild(tblPr, q))) return null;
+		return resolveSolidFillColor(tblPr, this.themeColors);
+	}
+	/**
+	* The table's picture background (`a:tblPr/a:blipFill`), or `null` when the table is not
+	* image-backed. The table-level twin of {@link TableCell.pictureFill}, and needed for the
+	* same reason: {@link resolvedFill} decodes only solid colours, so without this an
+	* image-backed table is indistinguishable from an unfilled one.
+	*/
+	get pictureFill() {
+		const tblPr = firstChild(this.tbl, "a:tblPr");
+		return tblPr ? readPictureFill(tblPr, this.rels ?? null) : null;
+	}
+	/**
+	* The table's gradient background (`a:tblPr/a:gradFill`), or `null` when it is not
+	* gradient-filled. Needed for the same reason {@link pictureFill} is:
+	* {@link resolvedFill} decodes only solid colours.
+	*/
+	get gradientFill() {
+		if (!this.themeColors) return null;
+		const tblPr = firstChild(this.tbl, "a:tblPr");
+		return tblPr ? readGradientFill(tblPr, this.themeColors) : null;
+	}
+	/**
+	* The table's pattern (hatch) background (`a:tblPr/a:pattFill`), or `null` when it is not
+	* pattern-filled.
+	*/
+	get patternFill() {
+		if (!this.themeColors) return null;
+		const tblPr = firstChild(this.tbl, "a:tblPr");
+		return tblPr ? readPatternFill(tblPr, this.themeColors) : null;
+	}
+	/**
+	* The raw `schemeClr` token of the table's own background
+	* (`a:tblPr/a:solidFill/a:schemeClr/@val`), or `null` for an absent or `srgbClr` fill.
+	* {@link resolvedFill} is the literal it resolves to; this is the unresolved reference,
+	* which is what a replica should carry so the copy still tracks its theme.
+	*/
+	get fillSchemeColor() {
+		const tblPr = firstChild(this.tbl, "a:tblPr");
+		const fill = tblPr && firstChild(tblPr, "a:solidFill");
+		const scheme = fill && firstChild(fill, "a:schemeClr");
+		return scheme ? attr(scheme, "val") : null;
+	}
 	/** Whether the first row is styled as a header (`a:tblPr/@firstRow`). */
 	get firstRowHeader() {
 		return this.#tblPrFlag("firstRow");
@@ -4909,6 +5041,83 @@ var Table = class {
 	cell(rowIndex, columnIndex) {
 		return this.rows[rowIndex]?.cells[columnIndex] ?? null;
 	}
+	/**
+	* Insert a row, defaulting to the bottom of the table. Returns the new {@link TableRow}.
+	*
+	* The new row is auto-height (`a:tr/@h="0"`) and its cells are empty. Inserting *through*
+	* a vertical merge extends that merge rather than interrupting it: the span's origin
+	* grows by a row and the new cell joins as a continuation, because an origin claiming
+	* more rows than it has continuations is a table PowerPoint reports as corrupt.
+	* @param {number} [index] - where to insert, `0`..`rowCount`; appended when omitted
+	* @throws {InvalidOptionError} when `index` is outside that range
+	*/
+	addRow(index) {
+		const tr = insertRow(this.tbl, index);
+		this.part.markDirty();
+		return new TableRow(tr, this.part, this.themeColors, this.#styleContext(), rowsOf(this.tbl).indexOf(tr), this.rels);
+	}
+	/**
+	* Remove the row at `index`, with its content.
+	*
+	* A cell in the row that *continues* a vertical merge shortens that merge. A cell that
+	* *starts* one hands the region to its first continuation, which becomes the new origin —
+	* the merged region survives one row shorter, and only the removed row's own text is lost.
+	* @throws {InvalidOptionError} when `index` is out of range
+	*/
+	removeRow(index) {
+		removeRow(this.tbl, index);
+		this.part.markDirty();
+	}
+	/**
+	* Insert a column, defaulting to the right-hand end. Updates `a:tblGrid` **and** every
+	* row, which is the pair that has to stay in step.
+	*
+	* The mirror of {@link addRow}'s merge case: inserting inside a horizontal merge widens
+	* it instead of splitting it.
+	* @param {number} [index] - where to insert, `0`..`columnCount`; appended when omitted
+	* @param {number} [widthEmu] - the new column's width; defaults to 1 inch
+	* @throws {InvalidOptionError} when `index` is outside that range
+	*/
+	addColumn(index, widthEmu) {
+		insertColumn(this.tbl, index, widthEmu);
+		this.part.markDirty();
+	}
+	/**
+	* Remove the column at `index`, from `a:tblGrid` and from every row.
+	*
+	* Inside a horizontal merge the region narrows by one and keeps its content: a covered
+	* cell is dropped rather than the origin. Elsewhere the column's cells go with it.
+	* @throws {InvalidOptionError} when `index` is out of range
+	*/
+	removeColumn(index) {
+		removeColumn(this.tbl, index);
+		this.part.markDirty();
+	}
+	/**
+	* Merge the rectangle between two cell positions into one cell. The top-left cell keeps
+	* its content; the rest become covered cells and are emptied, since a covered cell is
+	* never rendered.
+	*
+	* A rectangle that cuts through an existing merge is **rejected**, not silently widened
+	* to fit — the caller asked for a specific region, and quietly producing a different one
+	* is how a layout ends up wrong with nothing to point at. Unmerge first.
+	* @throws {InvalidOptionError} when an index is out of range, the range covers one cell,
+	*   or it partially overlaps an existing merge
+	*/
+	mergeCells(row1, col1, row2, col2) {
+		mergeCells(this.tbl, row1, col1, row2, col2);
+		this.part.markDirty();
+	}
+	/**
+	* Split the merged cell whose **origin** is `(row, col)` back into individual cells.
+	* A no-op on a cell that is not merged; addressing a covered cell instead of the origin
+	* throws, and the message names the origin to use.
+	* @throws {InvalidOptionError} when an index is out of range or the cell is a covered cell
+	*/
+	unmergeCell(row, col) {
+		unmergeCell(this.tbl, row, col);
+		this.part.markDirty();
+	}
 	/** Escape hatch: the underlying `a:tbl` element. After mutating it call {@link markDirty}, or `save()` writes the original bytes. */
 	get element_() {
 		return this.tbl;
@@ -4999,6 +5208,183 @@ var TableCell = class {
 		return firstChild(this.tc, "a:tcPr");
 	}
 	/**
+	* The cell's `a:tcPr`, creating it when absent.
+	*
+	* `CT_TableCell` sequences `a:txBody` then `a:tcPr` then `a:extLst`, so a newly created
+	* one is inserted before `a:extLst` — appending it blindly would put it after and make
+	* the part invalid. Every setter below goes through here for that reason.
+	*/
+	#getOrAddTcPr() {
+		return getOrAddChild(this.tc, "a:tcPr", ["a:extLst"]);
+	}
+	/**
+	* Set (or clear) the cell's vertical text anchor (`a:tcPr/@anchor`).
+	* `null` removes the attribute, leaving PowerPoint's default of top.
+	* @throws {InvalidOptionError} when the value is outside `ST_TextAnchoringType`
+	*/
+	setAnchor(value) {
+		this.#setTcPrAttr("anchor", value, ANCHOR_VALUES, "table/invalid-cell-anchor");
+	}
+	/**
+	* Set (or clear) the cell's text direction (`a:tcPr/@vert`), e.g. `'vert270'`.
+	* `null` removes the attribute, leaving the default horizontal text.
+	* @throws {InvalidOptionError} when the value is outside `ST_TextVerticalType`
+	*/
+	setVerticalText(value) {
+		this.#setTcPrAttr("vert", value, VERT_VALUES, "table/invalid-cell-vert");
+	}
+	/**
+	* Set (or clear) `a:tcPr/@horzOverflow` — what a single glyph too wide for the cell does.
+	* `null` removes the attribute; so does `'clip'` in effect, since it is the schema
+	* default, but the attribute is still written as asked.
+	* @throws {InvalidOptionError} when the value is outside `ST_TextHorzOverflowType`
+	*/
+	setHorzOverflow(value) {
+		this.#setTcPrAttr("horzOverflow", value, HORZ_OVERFLOW_VALUES, "table/invalid-cell-overflow");
+	}
+	/**
+	* Centre the cell's text block horizontally, or stop doing so (`a:tcPr/@anchorCtr`).
+	* `false` removes the attribute rather than writing `"0"`, since `false` is the schema
+	* default and the two are indistinguishable to a renderer.
+	*/
+	setAnchorCtr(value) {
+		const tcPr = this.#getOrAddTcPr();
+		if (value) setAttr(tcPr, "anchorCtr", "1");
+		else removeAttr(tcPr, "anchorCtr");
+		this.part.markDirty();
+	}
+	/**
+	* Set the cell's text insets in EMU (`a:tcPr/@marL`/`@marR`/`@marT`/`@marB`).
+	*
+	* Partial: only the sides named are touched, so `{ left: 0 }` flushes the text left and
+	* leaves the other three alone. A side given as `null` has its attribute removed, which
+	* returns it to the schema default (91440 EMU left/right, 45720 top/bottom) — not to
+	* zero. Pass `{}` to change nothing.
+	* @throws {InvalidOptionError} when a value is not a finite number
+	*/
+	setMarginsEmu(margins) {
+		const tcPr = this.#getOrAddTcPr();
+		const sides = [
+			["marL", margins.left],
+			["marR", margins.right],
+			["marT", margins.top],
+			["marB", margins.bottom]
+		];
+		for (const [name, value] of sides) {
+			if (value === void 0) continue;
+			if (value === null) removeAttr(tcPr, name);
+			else setAttr(tcPr, name, String(checkFiniteEmu(value, name, "table/invalid-cell-margin")));
+		}
+		this.part.markDirty();
+	}
+	/**
+	* Set (or clear) one of the cell's six borders — the four edges and the two diagonals.
+	*
+	* `null` removes the element entirely, which is "inherit", and is a different thing from
+	* `{ noFill: true }`, which writes an explicit no-border and suppresses whatever would
+	* otherwise be inherited. The element is inserted at its schema position rather than
+	* appended: `CT_TableCellProperties` is a sequence, and an out-of-order `a:tcPr` is
+	* reported by PowerPoint as a corrupt file rather than as a bad edit.
+	*
+	* Colour is either `color` (6-hex, `#` optional) or `schemeColor` (a theme token); giving
+	* both prefers the token, matching how the read side reports them.
+	* @throws {InvalidOptionError} when the width or colour cannot be written
+	*/
+	setBorder(edge, border) {
+		const qname = EDGE_QNAMES[edge];
+		if (!qname) throw new InvalidOptionError("table/invalid-cell-border", `Unknown table cell edge: ${JSON.stringify(edge)}. Expected one of: ${Object.keys(EDGE_QNAMES).join(", ")}.`);
+		if (border === null) {
+			const tcPr = this.#tcPr();
+			if (!tcPr || !firstChild(tcPr, qname)) return;
+			removeChildrenByQName(tcPr, [qname]);
+			this.part.markDirty();
+			return;
+		}
+		const tcPr = this.#getOrAddTcPr();
+		removeChildrenByQName(tcPr, [qname]);
+		const doc = ownerDocumentOf(tcPr);
+		const ln = createElement(doc, qname);
+		if (border.widthPt !== void 0 && border.widthPt !== null) setAttr(ln, "w", String(checkFiniteEmu(border.widthPt * 12700, "widthPt", "table/invalid-cell-border")));
+		if (border.noFill) ln.appendChild(createElement(doc, "a:noFill"));
+		else if (border.schemeColor || border.color) {
+			const fill = createElement(doc, "a:solidFill");
+			const scheme = border.schemeColor;
+			const clr = createElement(doc, scheme ? "a:schemeClr" : "a:srgbClr");
+			setAttr(clr, "val", scheme ? scheme : normalizeHex(border.color));
+			fill.appendChild(clr);
+			ln.appendChild(fill);
+		}
+		if (border.dash) {
+			const dash = createElement(doc, "a:prstDash");
+			setAttr(dash, "val", border.dash);
+			ln.appendChild(dash);
+		}
+		insertTcPrChild(tcPr, qname, ln);
+		this.part.markDirty();
+	}
+	/**
+	* Replace the cell's fill with a solid colour (`a:tcPr/a:solidFill`), or clear it.
+	*
+	* `null` removes the `a:solidFill` and lets the cell inherit from the table style again.
+	* That is not the same as {@link noFill}, which writes an explicit `a:noFill` and so
+	* suppresses the inherited shading. Any competing fill choice (`a:gradFill`,
+	* `a:blipFill`, …) is dropped first — `EG_FillProperties` admits one.
+	* @throws {InvalidOptionError} when `color` is not a 6-digit hex string
+	*/
+	setFillColor(color) {
+		this.#setFill(color === null ? null : {
+			qname: "a:srgbClr",
+			val: normalizeHex(color)
+		});
+	}
+	/**
+	* Replace the cell's fill with a theme colour token (`a:solidFill/a:schemeClr/@val`), or
+	* clear it. Preferred over {@link setFillColor} when the deck's theme should keep
+	* driving the colour.
+	*/
+	setFillSchemeColor(token) {
+		this.#setFill(token === null ? null : {
+			qname: "a:schemeClr",
+			val: token
+		});
+	}
+	/**
+	* Write an explicit `<a:noFill/>` on the cell — a transparent cell that shows the table
+	* background (or the slide) through. Distinct from `setFillColor(null)`, which removes
+	* the fill and lets the table style's shading apply again.
+	*/
+	noFill() {
+		const tcPr = this.#getOrAddTcPr();
+		removeChildrenByQName(tcPr, FILL_CHOICES);
+		tcPrChild(tcPr, "a:noFill");
+		this.part.markDirty();
+	}
+	/** Set or clear one `a:tcPr` attribute, vetting it against its schema enum first. */
+	#setTcPrAttr(name, value, valid, code) {
+		if (value === null) {
+			const tcPr = this.#tcPr();
+			if (!tcPr) return;
+			removeAttr(tcPr, name);
+			this.part.markDirty();
+			return;
+		}
+		const checked = checkEnumOrThrow(value, valid, name, code);
+		setAttr(this.#getOrAddTcPr(), name, checked);
+		this.part.markDirty();
+	}
+	/** Replace (or remove) the cell's solid fill, keeping `EG_FillProperties` single-valued. */
+	#setFill(color) {
+		if (color === null) {
+			const tcPr = this.#tcPr();
+			if (!tcPr || !firstChild(tcPr, "a:solidFill")) return;
+			removeChildrenByQName(tcPr, ["a:solidFill"]);
+			this.part.markDirty();
+			return;
+		}
+		setSolidFill(this.#getOrAddTcPr(), TCPR_AFTER["a:solidFill"] ?? [], color);
+		this.part.markDirty();
+	}
+	/**
 	* The cell's solid fill resolved against the table's theme colour context to a
 	* literal hex — the table-cell counterpart of
 	* {@link import('./shapes.js').AutoShape.resolvedFill}. The cell's own
@@ -5020,11 +5406,25 @@ var TableCell = class {
 	*/
 	get resolvedFill() {
 		if (!this.themeColors) return null;
-		const tcPr = this.#tcPr();
-		if (tcPr && FILL_CHOICES.some((q) => firstChild(tcPr, q))) return resolveSolidFillColor(tcPr, this.themeColors);
+		if (this.hasOwnFill) return resolveSolidFillColor(this.#tcPr(), this.themeColors);
 		return this.style ? this.#styleFill() : null;
 	}
 	/**
+	* Whether the cell carries a fill of its **own** (`a:tcPr` holds an `EG_FillProperties`
+	* child), as opposed to inheriting one from the table style's header/banding rules.
+	*
+	* This is the flag that disambiguates {@link resolvedFill}, which deliberately reports
+	* either — it answers "what colour does this cell render as", and both sources are valid
+	* answers to that. Anything that has to reproduce the cell rather than describe it needs
+	* to know which: baking an inherited banding colour into a copy makes the copy look right
+	* until someone changes its table style, and then nothing moves. `false` for a cell whose
+	* `a:tcPr` is empty or absent, whatever the style graph would render it as.
+	*/
+	get hasOwnFill() {
+		const tcPr = this.#tcPr();
+		return !!tcPr && FILL_CHOICES.some((q) => firstChild(tcPr, q));
+	}
+	/**
 	* 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}
@@ -5045,6 +5445,24 @@ var TableCell = class {
 		return resolveTableCellStyleFill(s.style.element_, s.flags, this.rowIndex, this.colIndex, s.rowCount, s.colCount, s.ctx);
 	}
 	/**
+	* The cell's gradient fill (`a:tcPr/a:gradFill`), or `null` when the cell is not
+	* gradient-filled. The cell twin of {@link Table.gradientFill}, and needed for the same
+	* reason {@link pictureFill} is: {@link resolvedFill} reports `null` for every non-solid
+	* choice, so without this a gradient cell is indistinguishable from an unfilled one.
+	*/
+	get gradientFill() {
+		const tcPr = this.#tcPr();
+		return tcPr && this.themeColors ? readGradientFill(tcPr, this.themeColors) : null;
+	}
+	/**
+	* The cell's pattern (hatch) fill (`a:tcPr/a:pattFill`), or `null` when the cell is not
+	* pattern-filled.
+	*/
+	get patternFill() {
+		const tcPr = this.#tcPr();
+		return tcPr && this.themeColors ? readPatternFill(tcPr, this.themeColors) : null;
+	}
+	/**
 	* The raw `schemeClr` token of the cell's solid fill (`a:tcPr/a:solidFill/a:schemeClr/@val`),
 	* e.g. `accent1`/`bg1`, or `null` when the fill is absent or an explicit `srgbClr`.
 	* The resolved literal is {@link resolvedFill}; this is the unresolved reference.
@@ -5111,6 +5529,88 @@ var TableCell = class {
 		return (tcPr && attr(tcPr, "anchor")) ?? null;
 	}
 	/**
+	* Whether the cell's whole text **block** is centred horizontally within it
+	* (`a:tcPr/@anchorCtr`). `false` when unset — that is the schema default, and it is
+	* what PowerPoint writes nothing for.
+	*
+	* Distinct from a paragraph's `align`, which decides where each *line* sits inside the
+	* text block; this decides where the block sits inside the cell.
+	*/
+	get anchorCtr() {
+		const tcPr = this.#tcPr();
+		return tcPr ? attr(tcPr, "anchorCtr") === "1" || attr(tcPr, "anchorCtr") === "true" : false;
+	}
+	/**
+	* The cell's 3-D bevel (`a:tcPr/a:cell3D`), or `null` when it has none.
+	*
+	* `CT_Cell3D` requires an `a:bevel`, so a present `cell3D` always reports a bevel;
+	* `lightRig` is `null` when the cell leaves the scene lighting to the renderer. Sizes are
+	* reported in **points** (the attributes are EMU), matching how the write option takes them.
+	*/
+	get cell3D() {
+		const tcPr = this.#tcPr();
+		const cell3D = tcPr && firstChild(tcPr, "a:cell3D");
+		if (!cell3D) return null;
+		const bevel = firstChild(cell3D, "a:bevel");
+		const rig = firstChild(cell3D, "a:lightRig");
+		const pts = (value) => {
+			const emu = intValue(value);
+			return emu === null ? null : emu / 12700;
+		};
+		return {
+			material: attr(cell3D, "prstMaterial") ?? null,
+			bevel: {
+				preset: bevel ? attr(bevel, "prst") ?? null : null,
+				widthPt: bevel ? pts(attr(bevel, "w")) : null,
+				heightPt: bevel ? pts(attr(bevel, "h")) : null
+			},
+			lightRig: rig ? {
+				rig: attr(rig, "rig") ?? null,
+				dir: attr(rig, "dir") ?? null
+			} : null
+		};
+	}
+	/**
+	* The cell's unique identifier (`a:tc/@id`), or `null` when it has none.
+	*
+	* This is what {@link headerIds} references: a data cell names the header cells that
+	* govern it by their `@id`, which is how a complex table tells a screen reader what a
+	* value means. Unrelated to the shape-level `p:cNvPr/@id` — it is an `xs:string` scoped
+	* to the table, not a slide-wide numeric id.
+	*
+	* **PowerPoint does not write this and strips it on save**, so it will read `null` on
+	* any deck PowerPoint has saved, however it was produced. It is surfaced for decks from
+	* other producers. There is deliberately no write-API counterpart — see
+	* `test/read/fixtures/authoring/probe-table-cell-a11y-and-3d.ps1` for the measurement.
+	*/
+	get id() {
+		return attr(this.tc, "id") ?? null;
+	}
+	/**
+	* The `@id`s of the header cells that govern this cell
+	* (`a:tcPr/a:headers/a:header/@val`), in document order. Empty when the cell declares no
+	* header association — which is the common case, since only a complex table needs one.
+	*
+	* Carries the same caveat as {@link id}: PowerPoint strips `a:headers` on save, so this
+	* is empty on any PowerPoint-saved deck. `Table.firstRowHeader` (`a:tblPr/@firstRow`) is
+	* the header marker PowerPoint does keep.
+	*/
+	get headerIds() {
+		const tcPr = this.#tcPr();
+		const headers = tcPr && firstChild(tcPr, "a:headers");
+		if (!headers) return [];
+		return getElements(headers, "a:header").map((header) => attr(header, "val")).filter((val) => val !== null && val !== "");
+	}
+	/**
+	* How the cell treats a glyph too wide for its text width (`a:tcPr/@horzOverflow`):
+	* `'clip'` cuts it at the cell edge, `'overflow'` lets it draw past. `null` when unset
+	* (PowerPoint clips). Not a wrap flag — cell text always wraps to the column width.
+	*/
+	get horzOverflow() {
+		const tcPr = this.#tcPr();
+		return (tcPr && attr(tcPr, "horzOverflow")) ?? null;
+	}
+	/**
 	* The cell's text insets in EMU (`a:tcPr/@marL`/`@marR`/`@marT`/`@marB`), or
 	* `null` when the cell sets none. Each side is `null` when only some are set.
 	*/
@@ -5280,6 +5780,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);
@@ -5360,6 +5884,6 @@ function buildShapes(parent, slide) {
 	return shapes;
 }
 //#endregion
-export { escapeXmlAttribute as $, resolveMasterColorContext as A, restyleSlide as B, Paragraph as C, readGradientFill as D, readPictureFill as E, flattenShape as F, relsPartNameFor as G, partNameExtension as H, flattenSlide as I, OOXML_NS as J, resolveRelativePartName as K, parseClrMap as L, resolveSlideColorContext as M, resolveSlideThemeParts as N, resolveColorElement as O, applyColorTransforms as P, createElement as Q, parseClrScheme as R, Shape as S, TextFrame as T, partNameToZipPath as U, styleRefFill as V, relativePartName as W, boolValue as X, attr as Y, childElements$2 as Z, ChartAxis as _, isGraphicFrame as a, intValue as at, Picture as b, wrapShapeElement as c, removeAttr as ct, TableCell as d, setAttr as dt, firstChild as et, TableRow as f, Chart as g, ChartExSeries as h, isConnector as i, insertInOrder as it, resolveNotesColorContext as j, resolveLayoutColorContext as k, GraphicFrame as l, removeChildrenByQName as lt, ChartExAxis as m, buildShapes as n, getElements as nt, isGroupShape as o, ownerDocumentOf as ot, ChartEx as p, zipPathToPartName as q, isAutoShape as r, getOrAddChild as rt, isPicture as s, parseXml as st, GroupShape as t, firstChildElement as tt, Table as u, serializeXml as ut, ChartSeries as v, Run as w, AutoShape as x, Connector as y, remapLiteralColors 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-BZU8UTW2.js.map
+//# sourceMappingURL=shapes-BWifcHDV.js.map