@shbernal/ts-pptx 2.0.0 → 3.0.0

package/dist/{presentation-MJe9WDi4.js → presentation-DAcOfzsP.js}

@@ -1,8 +1,9 @@
 import { i as PackageReadError, n as InvalidOptionError, o as UnsupportedFeatureError, t as InternalError } from "./errors-DGE9zh3U.js";
 import { d as emuToInches } from "./units-B-JUKwCS.js";
+import { _ as SLIDE_LAYOUT_REL, b as THEME_REL, d as IMAGE_REL, f as NOTES_MASTER_REL, m as OFFICE_DOCUMENT_REL, p as NOTES_SLIDE_REL, v as SLIDE_MASTER_REL, y as SLIDE_REL } from "./st-enums-CgadEyPM.js";
 import { i as FONT_REL_TYPE, n as FONT_DATA_CONTENT_TYPE, r as FONT_DATA_EXTENSION, t as EMBEDDED_FONT_SLOTS } from "./embedded-fonts-MaynAHa9.js";
 import { ZipWriter, readZip } from "./zip.js";
-import { $ as createElement, A as resolveLayoutColorContext, B as remapLiteralColors, D as readPictureFill, E as readPatternFill, G as relativePartName, H as styleRefFill, I as flattenShape, J as zipPathToPartName, K as relsPartNameFor, L as flattenSlide, M as resolveNotesColorContext, N as resolveSlideColorContext, O as readGradientFill, P as resolveSlideThemeParts, Q as childElements, R as parseClrMap, T as TextFrame, U as partNameExtension, V as restyleSlide, W as partNameToZipPath, X as attr, Y as OOXML_NS, Z as boolValue, at as insertInOrder, b as Picture, c as wrapShapeElement, ct as parseXml, dt as serializeXml, et as escapeXmlAttribute, ft as setAttr, it as getOrAddChild, j as resolveMasterColorContext, k as resolveColorElement, l as GraphicFrame, lt as removeAttr, n as buildShapes, nt as firstChildElement, ot as intValue, q as resolveRelativePartName, rt as getElements, st as ownerDocumentOf, t as GroupShape, tt as firstChild, ut as removeChildrenByQName, x as AutoShape, z as parseClrScheme } from "./shapes-CaOgR0i1.js";
+import { $ as resolveColor, A as resolveColorElement, At as getOrAddChild, B as placeholderInheritedColor, Ct as childElements, D as readPatternFill, Dt as firstChild, E as spPrXfrmEmu, Et as escapeXmlAttribute, F as resolveSlideThemeParts, Ft as removeAttr, G as slideDefinesColor, H as placeholderInheritedRunProps, It as removeChildrenByQName, J as fmtEntry, K as slideDefinesProp, L as LST_STYLE_LEVELS, Lt as replaceInParent, M as resolveMasterColorContext, Mt as intValue, N as resolveNotesColorContext, Nt as ownerDocumentOf, O as readPictureFill, Ot as firstChildElement, P as resolveSlideColorContext, Pt as parseXml, Q as parseClrScheme, R as RUN_PROP_NAMES, Rt as serializeXml, St as boolValue, T as TextFrame, Tt as descendantsByTag, U as placeholderInheritedXfrm, V as placeholderInheritedListStyles, W as placeholderOf, X as isA, Y as intAttr, Z as parseClrMap, _t as resolveRelativePartName, at as RPR_FILL_AFTER, b as Picture, bt as OOXML_NS, c as wrapShapeElement, ct as SPPR_EFFECT_AFTER, dt as SPPR_SCENE3D_AFTER, et as resolveSchemeToken, ft as SPPR_SP3D_AFTER, gt as relsPartNameFor, ht as relativePartName, it as FILL_CHOICES, j as resolveLayoutColorContext, jt as insertInOrder, k as readGradientFill, kt as getElements, l as GraphicFrame, lt as SPPR_FILL_AFTER, mt as partNameToZipPath, n as buildShapes, nt as styleRefLine, ot as SHAPE_AFTER_SPPR, pt as partNameExtension, q as SCHEME_SLOTS, rt as substitutePhClr, st as SPPR_AFTER_XFRM, t as GroupShape, tt as styleRefFill, ut as SPPR_LN_AFTER, vt as resolveSingleRel, wt as createElement, x as AutoShape, xt as attr, yt as zipPathToPartName, z as placeholderInheritedAnchor, zt as setAttr } from "./shapes-BWifcHDV.js";
 //#region src/read/opc/content-types.ts
 /**
 * Overlay over `[Content_Types].xml`, used to resolve part content types at
@@ -420,6 +421,477 @@ var OpcPackage = class OpcPackage {
 	}
 };
 //#endregion
+//#region src/read/api/ops/flatten.ts
+/**
+* Baking a slide's theme dependencies into the slide itself, for `Presentation.importSlide` /
+* `importShape`.
+*
+* A slide imported into another deck is rebound to the *destination* master, so everything it
+* resolved symbolically against its own theme silently re-resolves against a different one — its
+* scheme colours change, its style-matrix fills change, its placeholders snap to different
+* geometry and type sizes. The `theme: 'preserve'` mode exists to stop that: each pass here
+* resolves a dependency against the **source** theme (via `read/oxml/theme.ts` and
+* `read/oxml/placeholder-inherit.ts`) and writes the answer explicitly onto the slide, so after
+* the rebind there is nothing left to re-resolve.
+*
+* What gets flattened, and why each one matters:
+*
+* 1. **`a:schemeClr` tokens** — rewritten to the literal `a:srgbClr` the source `clrMap` +
+*    `clrScheme` produce. Child transforms (`lumMod`/`shade`/`alpha`/…) are carried through
+*    untouched, so tints and shades render identically; only the *base* reference is swapped,
+*    never the transform math.
+* 2. **Style-matrix refs** — a shape's `p:style` (`lnRef`/`fillRef`/`effectRef`) indexes the
+*    theme `fmtScheme`; the indexed entry is resolved into an explicit `spPr` fill/line/effect
+*    (with its `phClr` substituted) and the ref neutralized so it cannot re-resolve. The
+*    `fontRef` is deliberately left intact so its font can re-bind to the destination theme —
+*    the "normalize fonts on attach" bonus.
+* 3. **Placeholder-inherited run colour, size and weight** — a run that sets none of its own
+*    takes them from the source placeholder → layout → master text-style chain. Rebinding
+*    replaces that chain, so each is resolved from the source styles and written onto the run.
+*    Typeface (`a:latin`) is deliberately *not* baked — it re-binds along with `fontRef`.
+* 4. **Placeholder-inherited geometry** — a placeholder with no own `a:xfrm` takes position and
+*    size from the matching source layout/master placeholder; without baking it, a title snaps
+*    to the destination default and often clips off-canvas.
+*
+* The `restyle` mode is the deliberate inverse ({@link restyleSlide}): it bakes *nothing*, so
+* everything re-resolves against the destination and the slide takes on the new brand.
+*
+* **Why this lives in `api/ops/` and not in `read/oxml/`.** Everything here *mutates* a live
+* part. The modules it calls into resolve and build detached elements but never write, which is
+* what lets the read model's getters share them; keeping the writes on this side of the line is
+* what keeps that true. Callers own marking the part dirty.
+*/
+/**
+* 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.
+*/
+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);
+}
+/**
+* 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);
+}
+/**
+* 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 optional inverse of {@link resolveSchemeColors}, for `restyle`'s
+* force-remap-literals mode (the `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`.
+*/
+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 descendantsByTag(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;
+}
+/**
+* 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.
+*/
+function applyInheritedBackground(slideRoot, ctx) {
+	const inherited = ctx.inheritedBackground;
+	if (!inherited) return;
+	const cSld = firstChild(slideRoot, "p:cSld");
+	if (!cSld || firstChild(cSld, "p:bg")) return;
+	const bg = ownerDocumentOf(slideRoot).importNode(inherited, true);
+	insertInOrder(cSld, bg, [
+		"p:spTree",
+		"p:custDataLst",
+		"p:controls",
+		"p:extLst"
+	]);
+}
+/**
+* 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.
+*/
+function materializeBackground(slideRoot, ctx) {
+	const doc = ownerDocumentOf(slideRoot);
+	for (const bg of descendantsByTag(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 descendantsByTag(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);
+	}
+}
+/**
+* Bake placeholder-inherited run colours onto the slide. 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 descendantsByTag(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);
+			}
+		}
+	}
+}
+/** 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. 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 descendantsByTag(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;
+		const target = getOrAddChild(sp, "p:spPr", SHAPE_AFTER_SPPR);
+		insertInOrder(target, found.xfrm.cloneNode(true), SPPR_AFTER_XFRM);
+	}
+}
+/**
+* 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 and write it explicitly.
+* Shapes whose `a:bodyPr` already fixes `@anchor`, and placeholders with no
+* resolvable inherited anchor, are left untouched. Other `a:bodyPr` knobs (insets,
+* autofit) are left as authored — they have sane defaults a plain shape keeps.
+*/
+function resolvePlaceholderBodyPr(shapeRoot, ctx) {
+	if (!ctx.layoutRoot && !ctx.masterRoot) return;
+	for (const sp of descendantsByTag(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);
+	}
+}
+/**
+* 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 `resolveSchemeColors` pass.
+*/
+function resolvePlaceholderListStyle(shapeRoot, ctx) {
+	if (!ctx.layoutRoot && !ctx.masterRoot) return;
+	for (const sp of descendantsByTag(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"]);
+	}
+}
+/**
+* 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.
+*/
+function demotePlaceholders(shapeRoot) {
+	for (const sp of descendantsByTag(shapeRoot, OOXML_NS.p, "sp")) {
+		const nvSpPr = firstChild(sp, "p:nvSpPr");
+		const nvPr = nvSpPr && firstChild(nvSpPr, "p:nvPr");
+		if (nvPr) removeChildrenByQName(nvPr, ["p:ph"]);
+	}
+}
+/**
+* Bake placeholder-inherited run size/weight onto the slide. 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 the colour pass does for the `fontRef`.
+*/
+function resolvePlaceholderRunSizes(slideRoot, ctx) {
+	if (!ctx.layoutRoot && !ctx.masterRoot) return;
+	for (const sp of descendantsByTag(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);
+		}
+	}
+}
+/** 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);
+	}
+}
+/**
+* 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.
+*/
+function materializeStyleRefs(root, ctx) {
+	if (!ctx.fmtScheme) return;
+	for (const style of descendantsByTag(root, OOXML_NS.p, "style")) {
+		const shape = style.parentNode;
+		if (!shape) continue;
+		const spPr = getOrAddChild(shape, "p:spPr", SHAPE_AFTER_SPPR);
+		materializeFill(spPr, firstChild(style, "a:fillRef"), ctx);
+		materializeLine(spPr, firstChild(style, "a:lnRef"), ctx);
+		materializeEffect(spPr, firstChild(style, "a:effectRef"), ctx);
+	}
+}
+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);
+	}
+	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);
+	}
+	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(style)) if (isA(child, "effectLst") || isA(child, "effectDag")) insertInOrder(spPr, child, SPPR_EFFECT_AFTER);
+			else if (isA(child, "scene3d")) insertInOrder(spPr, child, SPPR_SCENE3D_AFTER);
+			else if (isA(child, "sp3d")) insertInOrder(spPr, child, SPPR_SP3D_AFTER);
+		}
+	}
+	neutralizeRef(effectRef);
+}
+/** 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(ref)) ref.removeChild(child);
+}
+//#endregion
 //#region src/read/api/slide-background.ts
 /**
 * Read a slide's effective background (`p:cSld/p:bg`), decoded into a typed union.
@@ -521,13 +993,6 @@ function readSlideBackground(bg, source, ctx, rels, themeRels) {
 }
 //#endregion
 //#region src/read/api/notes.ts
-/** One EMU coordinate from a placeholder's `p:spPr/a:xfrm` child, or `null` when absent. */
-function xfrmEmu$1(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;
-}
 /**
 * One placeholder shape (`p:sp`) of a notes slide. A notes slide holds a fixed set:
 * the slide thumbnail (`type="sldImg"`), the notes body (`type="body"`), and the
@@ -577,19 +1042,19 @@ var NotesPlaceholder = class {
 	}
 	/** Left edge in EMU (`a:off/@x`), or `null` when geometry is inherited (no own `a:xfrm`). */
 	get left() {
-		return xfrmEmu$1(this.sp, "a:off", "x");
+		return spPrXfrmEmu(this.sp, "a:off", "x");
 	}
 	/** Top edge in EMU (`a:off/@y`), or `null` when geometry is inherited. */
 	get top() {
-		return xfrmEmu$1(this.sp, "a:off", "y");
+		return spPrXfrmEmu(this.sp, "a:off", "y");
 	}
 	/** Width in EMU (`a:ext/@cx`), or `null` when geometry is inherited. */
 	get width() {
-		return xfrmEmu$1(this.sp, "a:ext", "cx");
+		return spPrXfrmEmu(this.sp, "a:ext", "cx");
 	}
 	/** Height in EMU (`a:ext/@cy`), or `null` when geometry is inherited. */
 	get height() {
-		return xfrmEmu$1(this.sp, "a:ext", "cy");
+		return spPrXfrmEmu(this.sp, "a:ext", "cy");
 	}
 	/**
 	* The placeholder's text as a navigable {@link TextFrame} (`p:txBody`), or `null`
@@ -855,8 +1320,6 @@ function readTagsForPart(opc, ownerPartName) {
 }
 //#endregion
 //#region src/read/api/chrome.ts
-const SLIDE_MASTER_REL$4 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideMaster";
-const THEME_REL$1 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme";
 const THEME_COLOR_SLOTS = [
 	"dk1",
 	"lt1",
@@ -966,23 +1429,10 @@ var Theme = class {
 		return themeElements ? firstChild(themeElements, "a:clrScheme") : null;
 	}
 };
-/** One EMU coordinate from a placeholder's `p:spPr/a:xfrm` child, or `null` when absent. */
-function xfrmEmu(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;
-}
-/** The `p:ph` element of a shape (`p:sp/p:nvSpPr/p:nvPr/p:ph`), or `null` when it is not a placeholder. */
-function placeholderElement(sp) {
-	const nvSpPr = firstChild(sp, "p:nvSpPr");
-	const nvPr = nvSpPr && firstChild(nvSpPr, "p:nvPr");
-	return nvPr ? firstChild(nvPr, "p:ph") : null;
-}
 /** The placeholder shapes (`p:sp` carrying a `p:ph`) of a master/layout `p:spTree`, in document order. */
 function placeholderShapes(spTree) {
 	if (!spTree) return [];
-	return getElements(spTree, "p:sp").filter((sp) => placeholderElement(sp) !== null);
+	return getElements(spTree, "p:sp").filter((sp) => placeholderOf(sp) !== null);
 }
 /**
 * One placeholder shape (`p:sp` with a `p:ph`) of a slide master or slide layout —
@@ -1008,12 +1458,12 @@ var Placeholder = class {
 	}
 	/** Placeholder type (`p:ph/@type`: `title` | `body` | `sldNum` | …), or `null` when absent (a body placeholder). */
 	get type() {
-		const ph = placeholderElement(this.sp);
+		const ph = placeholderOf(this.sp);
 		return ph ? attr(ph, "type") : null;
 	}
 	/** Placeholder index (`p:ph/@idx`), or `null` when unset. */
 	get idx() {
-		const ph = placeholderElement(this.sp);
+		const ph = placeholderOf(this.sp);
 		return ph ? attr(ph, "idx") : null;
 	}
 	/** Shape name (`p:cNvPr/@name`), or `''` when unnamed. */
@@ -1028,19 +1478,19 @@ var Placeholder = class {
 	}
 	/** Left edge in EMU (`a:off/@x`), or `null` when the placeholder carries no own `a:xfrm`. */
 	get left() {
-		return xfrmEmu(this.sp, "a:off", "x");
+		return spPrXfrmEmu(this.sp, "a:off", "x");
 	}
 	/** Top edge in EMU (`a:off/@y`), or `null` when the placeholder carries no own `a:xfrm`. */
 	get top() {
-		return xfrmEmu(this.sp, "a:off", "y");
+		return spPrXfrmEmu(this.sp, "a:off", "y");
 	}
 	/** Width in EMU (`a:ext/@cx`), or `null` when the placeholder carries no own `a:xfrm`. */
 	get width() {
-		return xfrmEmu(this.sp, "a:ext", "cx");
+		return spPrXfrmEmu(this.sp, "a:ext", "cx");
 	}
 	/** Height in EMU (`a:ext/@cy`), or `null` when the placeholder carries no own `a:xfrm`. */
 	get height() {
-		return xfrmEmu(this.sp, "a:ext", "cy");
+		return spPrXfrmEmu(this.sp, "a:ext", "cy");
 	}
 	/**
 	* The placeholder's text as a navigable {@link TextFrame} (`p:txBody`), or `null`
@@ -1086,7 +1536,7 @@ var SlideMaster = class {
 	}
 	/** The master's theme (via its `theme` relationship), or `null` when absent. */
 	get theme() {
-		const themePart = this.#relTarget(THEME_REL$1);
+		const themePart = this.#relTarget(THEME_REL);
 		return themePart ? new Theme(themePart) : null;
 	}
 	/**
@@ -1130,7 +1580,7 @@ var SlideMaster = class {
 	get background() {
 		const bg = backgroundElementOf(this.part.dom.documentElement);
 		if (!bg) return null;
-		const themePart = this.#relTarget(THEME_REL$1);
+		const themePart = this.#relTarget(THEME_REL);
 		return readSlideBackground(bg, "master", this.themeContext(), this.opc.relationshipsFor(this.partName), themePart ? this.opc.relationshipsFor(themePart.partName) : null);
 	}
 	/**
@@ -1190,7 +1640,7 @@ var SlideLayout = class {
 	/** The master this layout is built on (via its `slideMaster` relationship), or `null` when absent. */
 	get master() {
 		const rels = this.opc.relationshipsFor(this.partName);
-		const rel = rels.byType(SLIDE_MASTER_REL$4)[0];
+		const rel = rels.byType(SLIDE_MASTER_REL)[0];
 		const part = rel ? this.opc.part(rels.resolveTarget(rel.id)) : null;
 		return part ? new SlideMaster(this.opc, part) : null;
 	}
@@ -1665,9 +2115,6 @@ function carryShapeAnimations(sourceRoot, targetRoot, spidMap) {
 }
 //#endregion
 //#region src/read/api/slide.ts
-const IMAGE_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image";
-const NOTES_SLIDE_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesSlide";
-const SLIDE_LAYOUT_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideLayout";
 /** Recognize a handful of common raster formats from their leading bytes. */
 function sniffImageType(bytes) {
 	const b = bytes;
@@ -1942,7 +2389,7 @@ var Slide = class {
 	* slide-number field round-trip either way.
 	*/
 	get notesSlide() {
-		const notesRel = this.relationships.byType(NOTES_SLIDE_REL_TYPE)[0];
+		const notesRel = this.relationships.byType(NOTES_SLIDE_REL)[0];
 		if (!notesRel) return null;
 		const notesPart = this.presentation.opc.part(this.relationships.resolveTarget(notesRel.id));
 		if (!notesPart) return null;
@@ -1955,7 +2402,7 @@ var Slide = class {
 	* {@link master} and {@link theme} through it (`slide.layout.master.theme`).
 	*/
 	get layout() {
-		const rel = this.relationships.byType(SLIDE_LAYOUT_REL_TYPE)[0];
+		const rel = this.relationships.byType(SLIDE_LAYOUT_REL)[0];
 		if (!rel) return null;
 		const part = this.presentation.opc.part(this.relationships.resolveTarget(rel.id));
 		return part ? new SlideLayout(this.presentation.opc, part) : null;
@@ -2162,7 +2609,7 @@ var Slide = class {
 		const opc = this.presentation.opc;
 		const mediaPartName = opc.reserveMediaPartName(extension);
 		opc.addPart(mediaPartName, contentType, image);
-		const relId = this.relationships.add(IMAGE_REL_TYPE, relativePartName(this.partName, mediaPartName)).id;
+		const relId = this.relationships.add(IMAGE_REL, relativePartName(this.partName, mediaPartName)).id;
 		const id = this.#nextShapeId();
 		const pic = buildPicture(doc, {
 			id,
@@ -2402,7 +2849,7 @@ function readCustomProperties(opc) {
 	return out;
 }
 //#endregion
-//#region src/read/api/slide-dom.ts
+//#region src/read/oxml/slide-dom.ts
 /** The `p:cSld@name` of a slide/layout/master part (`''` when absent). */
 function cSldName(part) {
 	const root = part?.dom.documentElement;
@@ -2466,7 +2913,7 @@ function collectElements(node, out) {
 	for (let child = node.firstChild; child; child = child.nextSibling) if (child.nodeType === 1) collectElements(child, out);
 }
 //#endregion
-//#region src/read/api/rescale.ts
+//#region src/read/api/ops/rescale.ts
 /** Build the EMU transform mapping source-canvas coordinates onto the target canvas (see {@link ImportSlideOptions.rescale}). */
 function computeRescale(source, target, mode) {
 	if (mode === "stretch") return {
@@ -2554,7 +3001,7 @@ function rescaleTableGrid(graphicFrame, t) {
 	}
 }
 //#endregion
-//#region src/read/api/table-styles.ts
+//#region src/read/api/ops/table-styles.ts
 const TABLE_STYLES_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/tableStyles";
 const TABLE_STYLES_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.presentationml.tableStyles+xml";
 const TABLE_STYLES_DEFAULT_GUID = "{5C22544A-7EE6-4342-B048-85BDC9FD1C3A}";
@@ -2659,7 +3106,7 @@ function ensureTableStylesPart(dest) {
 	return part;
 }
 //#endregion
-//#region src/read/api/master-registry.ts
+//#region src/read/api/ops/master-registry.ts
 /**
 * Slide-master bookkeeping in `presentation.xml` and in a master's own
 * `p:sldLayoutIdLst`: registering a master so renderers treat it as active,
@@ -2671,8 +3118,6 @@ function ensureTableStylesPart(dest) {
 * they take a structural {@link DeckTarget} rather than a `Presentation`. The
 * source-side half that drives most of them is `part-copy.ts`.
 */
-const SLIDE_MASTER_REL$3 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideMaster";
-const SLIDE_LAYOUT_REL$3 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideLayout";
 /**
 * Wire a freshly-copied slide master into `presentation.xml`: add a
 * presentation→master relationship and a `p:sldMasterId` entry in
@@ -2684,8 +3129,8 @@ const SLIDE_LAYOUT_REL$3 = "http://schemas.openxmlformats.org/officeDocument/200
 function registerMaster(dest, masterPartName) {
 	const presPart = dest.presentationPart;
 	const presRels = dest.opc.relationshipsFor(presPart.partName);
-	for (const rel of presRels.byType(SLIDE_MASTER_REL$3)) if (presRels.resolveTarget(rel.id) === masterPartName) return;
-	const relId = presRels.add(SLIDE_MASTER_REL$3, relativePartName(presPart.partName, masterPartName)).id;
+	for (const rel of presRels.byType(SLIDE_MASTER_REL)) if (presRels.resolveTarget(rel.id) === masterPartName) return;
+	const relId = presRels.add(SLIDE_MASTER_REL, relativePartName(presPart.partName, masterPartName)).id;
 	const root = presPart.dom.documentElement;
 	if (!root) throw new PackageReadError("package/part-has-no-root", "presentation.xml has no document element to register a master in");
 	const lst = getOrAddChild(root, "p:sldMasterIdLst", [
@@ -2756,7 +3201,7 @@ function nextMasterLayoutId(dest) {
 		if (id !== null && id > max) max = id;
 	}
 	const presRels = dest.opc.relationshipsFor(presPart.partName);
-	for (const rel of presRels.byType(SLIDE_MASTER_REL$3)) {
+	for (const rel of presRels.byType(SLIDE_MASTER_REL)) {
 		const masterRoot = dest.opc.part(presRels.resolveTarget(rel.id))?.dom.documentElement;
 		const layoutLst = masterRoot && firstChild(masterRoot, "p:sldLayoutIdLst");
 		if (!layoutLst) continue;
@@ -2786,7 +3231,7 @@ function addLayoutToMaster(dest, masterPartName, layoutPartName) {
 	const masterPart = dest.opc.part(masterPartName);
 	const root = masterPart?.dom.documentElement;
 	if (!masterPart || !root) return;
-	const relId = dest.opc.relationshipsFor(masterPartName).add(SLIDE_LAYOUT_REL$3, relativePartName(masterPartName, layoutPartName)).id;
+	const relId = dest.opc.relationshipsFor(masterPartName).add(SLIDE_LAYOUT_REL, relativePartName(masterPartName, layoutPartName)).id;
 	const lst = getOrAddChild(root, "p:sldLayoutIdLst", [
 		"p:transition",
 		"p:timing",
@@ -2801,10 +3246,7 @@ function addLayoutToMaster(dest, masterPartName, layoutPartName) {
 	masterPart.markDirty();
 }
 //#endregion
-//#region src/read/api/part-copy.ts
-const SLIDE_LAYOUT_REL$2 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideLayout";
-const SLIDE_MASTER_REL$2 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideMaster";
-const NOTES_SLIDE_REL$2 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesSlide";
+//#region src/read/api/ops/part-copy.ts
 const SLIDE_MASTER_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.presentationml.slideMaster+xml";
 const SLIDE_LAYOUT_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.presentationml.slideLayout+xml";
 /**
@@ -2829,8 +3271,8 @@ function copyPart(ctx, sourcePartName) {
 	const sourceRels = ctx.source.relationshipsFor(sourcePartName);
 	const targetRels = ctx.dest.opc.relationshipsFor(newPartName);
 	for (const rel of sourceRels) {
-		if (rel.type === NOTES_SLIDE_REL$2) continue;
-		if (isMaster && rel.type === SLIDE_LAYOUT_REL$2) continue;
+		if (rel.type === "http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesSlide") continue;
+		if (isMaster && rel.type === "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideLayout") continue;
 		if (rel.targetMode === "External") {
 			targetRels.addWithId(rel.id, rel.type, rel.target, "External");
 			continue;
@@ -2853,13 +3295,76 @@ function copyPart(ctx, sourcePartName) {
 * accumulates exactly the imported layouts.
 */
 function linkLayoutIntoMaster(ctx, layoutSourceRels, layoutPartName) {
-	const masterRel = layoutSourceRels.byType(SLIDE_MASTER_REL$2)[0];
+	const masterRel = layoutSourceRels.byType(SLIDE_MASTER_REL)[0];
 	if (!masterRel) return;
 	const masterPartName = ctx.registry.get(layoutSourceRels.resolveTarget(masterRel.id));
 	if (!masterPartName) return;
 	addLayoutToMaster(ctx.dest, masterPartName, layoutPartName);
 }
 //#endregion
+//#region src/read/api/ops/carried-rels.ts
+/**
+* Relationship rewriting for content carried between packages.
+*
+* When a shape or decoration is deep-copied out of a source deck, every relationship
+* reference it carries (`r:embed` on a picture fill, `r:id` on a chart frame, `r:link` on a
+* linked image, …) still names an id in the *source* part's relationship list. Left alone
+* those ids either dangle or — worse — silently resolve to whatever the destination part
+* happens to have under the same id. This rewrites each one to a fresh relationship on the
+* destination part, copying the referenced part into the destination package on first sight.
+*
+* Both functions are pure with respect to the deck: everything they touch arrives as an
+* argument. They were private methods on `Presentation` and used no instance state, which
+* made the import subsystem look more entangled with the read model than it is.
+*/
+/**
+* Rewrite every relationship reference inside a carried subtree to a fresh destination-local id.
+* @param {Element} node - root of the carried subtree (rewritten in place)
+* @param {ImportContext} ctx - the open import (destination deck + source package + copy registry)
+* @param {Relationships} sourceRels - relationships of the source part the subtree came from
+* @param {string} destPartName - partname of the destination part the subtree is being placed in
+* @param {Relationships} destRels - relationships of that destination part
+* @param {Map<string, string>} relIdMap - per-call cache (source part + source id → new id) deduping references shared within one import
+*/
+function rewriteCarriedRels(node, ctx, sourceRels, destPartName, destRels, relIdMap) {
+	const elements = [];
+	collectElements(node, elements);
+	for (const el of elements) {
+		const refs = [];
+		const attrs = el.attributes;
+		for (let i = 0; i < attrs.length; i++) {
+			const a = attrs.item(i);
+			if (!a || a.namespaceURI !== OOXML_NS.r || !a.value) continue;
+			if (!sourceRels.get(a.value)) continue;
+			refs.push({
+				local: a.localName ?? a.name,
+				id: a.value
+			});
+		}
+		for (const { local, id } of refs) setAttr(el, `r:${local}`, carryRel(ctx, sourceRels, id, destPartName, destRels, relIdMap));
+	}
+}
+/**
+* Resolve one carried relationship to a fresh destination-local id, copying its internal target.
+* @param {ImportContext} ctx - the open import
+* @param {Relationships} sourceRels - relationships of the source part
+* @param {string} id - the source relationship id to carry
+* @param {string} destPartName - partname of the destination part
+* @param {Relationships} destRels - relationships of that destination part
+* @param {Map<string, string>} relIdMap - per-call dedupe cache
+* @return {string} the new relationship id on the destination part
+*/
+function carryRel(ctx, sourceRels, id, destPartName, destRels, relIdMap) {
+	const key = `${sourceRels.sourcePartName}|${id}`;
+	const cached = relIdMap.get(key);
+	if (cached) return cached;
+	const rel = sourceRels.get(id);
+	if (!rel) throw new InvalidOptionError("relationship/not-found", `Relationships of ${sourceRels.sourcePartName}: no relationship with id ${id}`);
+	const newId = rel.targetMode === "External" ? destRels.add(rel.type, rel.target, "External").id : destRels.add(rel.type, relativePartName(destPartName, copyPart(ctx, sourceRels.resolveTarget(id)))).id;
+	relIdMap.set(key, newId);
+	return newId;
+}
+//#endregion
 //#region src/read/api/ops/embedded-fonts.ts
 /**
 * Merging embedded font faces into a deck's `p:embeddedFontLst`.
@@ -3043,6 +3548,277 @@ function mergeEmbeddedFontEntries(dest, entries) {
 	if (copiedAny) presPart.markDirty();
 }
 //#endregion
+//#region src/read/api/ops/flatten-context.ts
+/**
+* The theme context a source slide is flattened against.
+*
+* `preserve`-mode import bakes a slide's *source* look into its XML — scheme colours and
+* style-matrix fills resolved to literals — so it keeps that look after being attached to a
+* different deck's master. Doing so needs the source subgraph's colour map, colour scheme,
+* format scheme, and the background the slide inherits but does not itself carry. This
+* gathers exactly that.
+*
+* Pure with respect to the destination deck: it reads only the source package. It was a
+* private method on `Presentation` that used no instance state.
+*/
+/** The `p:cSld/p:bg` element of a slide/layout/master root, or `null`. */
+function backgroundOf(root) {
+	const cSld = firstChild(root, "p:cSld");
+	return cSld ? firstChild(cSld, "p:bg") : null;
+}
+/**
+* The background the slide effectively inherits from its source subgraph: the layout's
+* `p:bg`, else the master's. Returns `null` when the slide carries its own `p:bg` (it stays
+* on the slide and is flattened directly) or when none exists.
+*/
+function effectiveBackground(sourceOpc, slideRoot, layoutPartName, masterPartName) {
+	if (slideRoot && backgroundOf(slideRoot)) return null;
+	const layoutRoot = layoutPartName ? sourceOpc.part(layoutPartName)?.dom.documentElement ?? null : null;
+	const masterRoot = masterPartName ? sourceOpc.part(masterPartName)?.dom.documentElement ?? null : null;
+	return (layoutRoot && backgroundOf(layoutRoot)) ?? (masterRoot && backgroundOf(masterRoot)) ?? null;
+}
+/**
+* Gather the flatten context for a source slide: walk slide → layout → master → theme,
+* reading the effective colour map (the slide's `clrMapOvr` override, or the master
+* `clrMap`), the theme `clrScheme`, and the theme `fmtScheme`.
+* @param {OpcPackage} sourceOpc - the source package to read
+* @param {string} slidePartName - partname of the source slide
+* @return {FlattenContext} the context {@link flattenSlide} / {@link flattenShape} resolve against
+*/
+function sourceFlattenContext(sourceOpc, slidePartName) {
+	const parts = resolveSlideThemeParts(sourceOpc, slidePartName);
+	const themeElements = parts.themeElements;
+	return {
+		clrMap: parts.clrMap,
+		clrScheme: parts.clrScheme,
+		fmtScheme: themeElements ? firstChild(themeElements, "a:fmtScheme") : null,
+		inheritedBackground: effectiveBackground(sourceOpc, parts.slideRoot, parts.layoutPartName, parts.masterPartName),
+		layoutRoot: parts.layoutRoot,
+		masterRoot: parts.masterRoot
+	};
+}
+//#endregion
+//#region src/read/api/ops/part-index.ts
+/**
+* Walking a deck's master/layout spine by partname.
+*
+* The `p:sldMasterIdLst` / `p:sldLayoutIdLst` entries hold relationship ids, not partnames, so
+* every traversal has to resolve through the owning part's relationships. These are the
+* source-side reads that do it — used against a *foreign* presentation as often as against this
+* one, which is why they take the deck rather than living on it.
+*/
+/** Master partnames in `p:sldMasterIdLst` order. */
+function slideMasterPartNames(pres) {
+	const root = pres.presentationPart.dom.documentElement;
+	const lst = root && firstChild(root, "p:sldMasterIdLst");
+	if (!lst) return [];
+	const rels = pres.opc.relationshipsFor(pres.presentationPart.partName);
+	const out = [];
+	for (const entry of getElements(lst, "p:sldMasterId")) {
+		const relId = attr(entry, "r:id");
+		if (relId) out.push(rels.resolveTarget(relId));
+	}
+	return out;
+}
+/** A master's layout partnames in `p:sldLayoutIdLst` order. */
+function layoutPartNamesOf(pres, masterPartName) {
+	const root = pres.opc.part(masterPartName)?.dom.documentElement;
+	const lst = root && firstChild(root, "p:sldLayoutIdLst");
+	if (!lst) return [];
+	const rels = pres.opc.relationshipsFor(masterPartName);
+	const out = [];
+	for (const entry of getElements(lst, "p:sldLayoutId")) {
+		const relId = attr(entry, "r:id");
+		if (relId) out.push(rels.resolveTarget(relId));
+	}
+	return out;
+}
+//#endregion
+//#region src/read/api/ops/import-slide.ts
+/**
+* The three ways a slide can be brought across from another deck.
+*
+* {@link Presentation.importSlide} picks one by `options.theme`, and the difference between
+* them is entirely about what happens to the slide's *look*:
+*
+* - **`copy`** — not here. It copies the source theme subgraph wholesale via `copyPart`, so
+*   the slide keeps its look by keeping its own theme; nothing needs rewriting.
+* - **`preserve`** ({@link importSlidePreserve}) — rebind to this deck's master, then bake
+*   the source theme into the slide XML. The slide looks the same as it did; it just no
+*   longer depends on the theme it came from.
+* - **`restyle`** ({@link importSlideRestyle}) — rebind and bake *nothing*, so the slide's
+*   symbolic theme references re-resolve against the destination theme and it re-brands.
+*
+* The two share {@link importSlideRebind} and are exact inverses on top of it: preserve
+* resolves every reference it can, restyle resolves none. Any baking added to the shared
+* rebind would break restyle by pinning the slide to its source look, which is why the
+* rebind carries no theme handling of its own — not even the inherited background.
+*
+* These were private methods on `Presentation`, where they made the read model's own surface
+* (open a deck, walk slides, read shapes) hard to see: the import machinery was roughly two
+* thirds of the class. They live here as free functions taking the destination deck, matching
+* the other `ops/` modules.
+*/
+/**
+* Import a slide in `preserve` mode: rebind it to this deck's master/layout, then flatten its
+* source theme into the slide XML (scheme colours + style-matrix fills baked to literals).
+*
+* The flatten context is gathered from the *source* subgraph, so it can be read before or
+* after the rebind; the rebind injects any carried decorations before we flatten, so a single
+* sweep resolves the theme references on the slide's own content and on the carried
+* decorations together.
+* @param {Presentation} dest - the destination deck
+* @param {ImportContext} ctx - the open import out of the source package
+* @param {Presentation} source - the source deck
+* @param {Slide} sourceSlide - the slide being imported
+* @param {boolean} carryGraphics - bake the source master/layout decorations onto the slide
+* @return {string} partname of the new slide part in the destination package
+*/
+function importSlidePreserve(dest, ctx, source, sourceSlide, carryGraphics) {
+	const flattenCtx = sourceFlattenContext(source.opc, sourceSlide.partName);
+	const { newPartName, slideRoot, newPart } = importSlideRebind(dest, ctx, source, sourceSlide, carryGraphics);
+	flattenSlide(slideRoot, flattenCtx);
+	newPart.markDirty();
+	return newPartName;
+}
+/**
+* Import a slide in `restyle` mode: rebind it to this deck's master/layout and then
+* {@link restyleSlide} it — drop its colour map override but bake *nothing*, so its symbolic
+* theme references re-resolve against the destination theme and the slide re-brands.
+*
+* The deliberate inverse of `preserve`: no flatten, no inherited-background bake, no
+* placeholder colour/size/geometry bake — every one of those would pin the slide to its
+* source look, the opposite of re-branding. Carried decorations are left symbolic too, so
+* they re-brand along with the slide.
+*
+* With `remapLiterals` it additionally force-remaps the slide's source-theme literal colours
+* back to symbolic scheme colours and copies any referenced source table style into this deck
+* — the two things plain `restyle` cannot re-brand.
+* @param {Presentation} dest - the destination deck
+* @param {ImportContext} ctx - the open import out of the source package
+* @param {Presentation} source - the source deck
+* @param {Slide} sourceSlide - the slide being imported
+* @param {boolean} carryGraphics - bake the source master/layout decorations onto the slide
+* @param {boolean} remapLiterals - additionally remap source-theme literal colours to scheme tokens
+* @return {string} partname of the new slide part in the destination package
+*/
+function importSlideRestyle(dest, ctx, source, sourceSlide, carryGraphics, remapLiterals) {
+	const { newPartName, slideRoot, newPart } = importSlideRebind(dest, ctx, source, sourceSlide, carryGraphics);
+	restyleSlide(slideRoot);
+	if (remapLiterals) {
+		const parts = resolveSlideThemeParts(source.opc, sourceSlide.partName);
+		remapLiteralColors(slideRoot, {
+			clrMap: parts.clrMap,
+			clrScheme: parts.clrScheme
+		});
+		copySourceTableStyles(dest, source.opc, slideRoot);
+	}
+	newPart.markDirty();
+	return newPartName;
+}
+/**
+* The rebind shared by `preserve` and `restyle`: copy the slide bytes into a fresh part,
+* rebuild its relationships (drop notes, repoint the `slideLayout` rel at this deck's
+* existing layout, copy every other internal target — media/charts — and pass externals
+* through), and optionally bake the source master/layout decorations onto the slide. Returns
+* the new part, its name, and its live root element for the caller's mode-specific pass.
+*
+* This carries *no* theme baking of its own — not even the inherited background.
+* `preserve` adds that via {@link flattenSlide}'s context; `restyle` must not, so the
+* background stays symbolic and re-brands.
+* @param {Presentation} dest - the destination deck
+* @param {ImportContext} ctx - the open import out of the source package
+* @param {Presentation} source - the source deck
+* @param {Slide} sourceSlide - the slide being imported
+* @param {boolean} carryGraphics - bake the source master/layout decorations onto the slide
+* @return {RebindResult} the new part, its partname, and its live root element
+*/
+function importSlideRebind(dest, ctx, source, sourceSlide, carryGraphics) {
+	const destLayout = destinationLayoutPartName(dest);
+	const sourcePart = source.opc.part(sourceSlide.partName);
+	if (!sourcePart) throw new PackageReadError("package/part-missing", `importSlide: source package has no part ${sourceSlide.partName}`);
+	const newPartName = dest.opc.reservePartNameLike(sourceSlide.partName);
+	const newPart = dest.opc.addPart(newPartName, sourcePart.contentType, sourcePart.bytes);
+	const slideRoot = newPart.dom.documentElement;
+	if (!slideRoot) throw new PackageReadError("package/part-has-no-root", `Imported slide ${newPartName} has no root element`);
+	const sourceRels = source.opc.relationshipsFor(sourceSlide.partName);
+	const targetRels = dest.opc.relationshipsFor(newPartName);
+	for (const rel of sourceRels) {
+		if (rel.type === "http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesSlide") continue;
+		if (rel.type === "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideLayout") {
+			targetRels.addWithId(rel.id, SLIDE_LAYOUT_REL, relativePartName(newPartName, destLayout));
+			continue;
+		}
+		if (rel.targetMode === "External") {
+			targetRels.addWithId(rel.id, rel.type, rel.target, "External");
+			continue;
+		}
+		const newTarget = copyPart(ctx, sourceRels.resolveTarget(rel.id));
+		targetRels.addWithId(rel.id, rel.type, relativePartName(newPartName, newTarget));
+	}
+	if (carryGraphics) carryMasterGraphics(dest, ctx, slideRoot, newPartName, sourceSlide.partName);
+	return {
+		newPartName,
+		slideRoot,
+		newPart
+	};
+}
+/**
+* Bake the source `slideLayout`/`slideMaster` shape-tree decorations onto the imported slide
+* (the `carryMasterGraphics` path). Every shape on those trees *except* placeholders is
+* deep-copied into the slide's `p:spTree` ahead of its own content — master decorations
+* first, then layout, then the slide's shapes — so document (z-)order keeps the master
+* furthest back. Each decoration's media and other relationship targets are copied into this
+* package and its `r:embed`/`r:id`/… references rewritten to fresh slide-local ids. The
+* injected shapes are left for the caller's {@link flattenSlide} pass to resolve any theme
+* references they carry.
+* @param {Presentation} dest - the destination deck
+* @param {ImportContext} ctx - the open import out of the source package
+* @param {Element} slideRoot - root element of the new slide part (mutated in place)
+* @param {string} newPartName - partname of the new slide part
+* @param {string} slidePartName - partname of the source slide, for resolving its layout/master
+*/
+function carryMasterGraphics(dest, ctx, slideRoot, newPartName, slidePartName) {
+	const sourceOpc = ctx.source;
+	const layoutPartName = resolveSingleRel(sourceOpc, slidePartName, SLIDE_LAYOUT_REL);
+	const masterPartName = layoutPartName ? resolveSingleRel(sourceOpc, layoutPartName, SLIDE_MASTER_REL) : null;
+	const cSld = firstChild(slideRoot, "p:cSld");
+	const spTree = cSld && firstChild(cSld, "p:spTree");
+	if (!spTree) return;
+	const doc = ownerDocumentOf(slideRoot);
+	const slideRels = dest.opc.relationshipsFor(newPartName);
+	const relIdMap = /* @__PURE__ */ new Map();
+	const anchor = firstShapeChild(spTree);
+	for (const partName of [masterPartName, layoutPartName]) {
+		if (!partName) continue;
+		const decorations = carriedDecorations(sourceOpc.part(partName)?.dom.documentElement ?? null);
+		if (decorations.length === 0) continue;
+		const sourceRels = sourceOpc.relationshipsFor(partName);
+		for (const deco of decorations) {
+			const imported = doc.importNode(deco, true);
+			rewriteCarriedRels(imported, ctx, sourceRels, newPartName, slideRels, relIdMap);
+			spTree.insertBefore(imported, anchor);
+		}
+	}
+}
+/**
+* The partname of the layout this deck's slides should attach to in `preserve` mode: the
+* first layout of the first slide master. Throws when the deck has no master/layout to attach
+* to (a deck ts-pptx always provides).
+* @param {Presentation} dest - the destination deck
+* @return {string} partname of the destination layout
+*/
+function destinationLayoutPartName(dest) {
+	const presRels = dest.opc.relationshipsFor(dest.presentationPart.partName);
+	const masterRel = presRels.byType(SLIDE_MASTER_REL)[0];
+	if (!masterRel) throw new InvalidOptionError("import/destination-missing-master", "importSlide preserve mode requires a slide master in the destination deck");
+	const masterPartName = presRels.resolveTarget(masterRel.id);
+	const masterRels = dest.opc.relationshipsFor(masterPartName);
+	const layoutRel = masterRels.byType(SLIDE_LAYOUT_REL)[0];
+	if (!layoutRel) throw new InvalidOptionError("import/destination-missing-layout", "importSlide preserve mode requires a slide layout in the destination deck");
+	return masterRels.resolveTarget(layoutRel.id);
+}
+//#endregion
 //#region src/read/api/ops/notes-master.ts
 /**
 * Carrying speaker notes and the deck's single notes master across an import or an append.
@@ -3054,10 +3830,6 @@ function mergeEmbeddedFontEntries(dest, entries) {
 * `Presentation`-to-`Presentation` path and the generator-XML path funnel through
 * `registerNotesMaster`: they differ only in how the *part* comes into being.
 */
-const SLIDE_REL$1 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slide";
-const NOTES_SLIDE_REL$1 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesSlide";
-const NOTES_MASTER_REL$1 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesMaster";
-const THEME_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme";
 const NOTES_MASTER_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.presentationml.notesMaster+xml";
 const THEME_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.theme+xml";
 const textEncoder$1 = new TextEncoder();
@@ -3080,24 +3852,24 @@ const textEncoder$1 = new TextEncoder();
 */
 function carryNotes(dest, source, ctx, sourceSlidePartName, newSlidePartName) {
 	const sourceSlideRels = source.opc.relationshipsFor(sourceSlidePartName);
-	const notesRel = sourceSlideRels.byType(NOTES_SLIDE_REL$1)[0];
+	const notesRel = sourceSlideRels.byType(NOTES_SLIDE_REL)[0];
 	if (!notesRel) return;
 	const sourceNotesPartName = sourceSlideRels.resolveTarget(notesRel.id);
 	const sourceNotesPart = source.opc.part(sourceNotesPartName);
 	if (!sourceNotesPart) return;
 	const newNotesPartName = dest.opc.reservePartNameLike(sourceNotesPartName);
 	dest.opc.addPart(newNotesPartName, sourceNotesPart.contentType, sourceNotesPart.bytes);
-	dest.opc.relationshipsFor(newSlidePartName).add(NOTES_SLIDE_REL$1, relativePartName(newSlidePartName, newNotesPartName));
+	dest.opc.relationshipsFor(newSlidePartName).add(NOTES_SLIDE_REL, relativePartName(newSlidePartName, newNotesPartName));
 	const notesSourceRels = source.opc.relationshipsFor(sourceNotesPartName);
 	const notesTargetRels = dest.opc.relationshipsFor(newNotesPartName);
 	for (const rel of notesSourceRels) {
-		if (rel.type === SLIDE_REL$1) {
-			notesTargetRels.addWithId(rel.id, SLIDE_REL$1, relativePartName(newNotesPartName, newSlidePartName));
+		if (rel.type === "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slide") {
+			notesTargetRels.addWithId(rel.id, SLIDE_REL, relativePartName(newNotesPartName, newSlidePartName));
 			continue;
 		}
-		if (rel.type === NOTES_MASTER_REL$1) {
+		if (rel.type === "http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesMaster") {
 			const notesMaster = ensureNotesMaster(dest, ctx, notesSourceRels.resolveTarget(rel.id));
-			notesTargetRels.addWithId(rel.id, NOTES_MASTER_REL$1, relativePartName(newNotesPartName, notesMaster));
+			notesTargetRels.addWithId(rel.id, NOTES_MASTER_REL, relativePartName(newNotesPartName, notesMaster));
 			continue;
 		}
 		if (rel.targetMode === "External") {
@@ -3119,7 +3891,7 @@ function carryNotes(dest, source, ctx, sourceSlidePartName, newSlidePartName) {
 function ensureNotesMaster(dest, ctx, sourceNotesMasterPartName) {
 	const presPart = dest.presentationPart;
 	const presRels = dest.opc.relationshipsFor(presPart.partName);
-	const existing = presRels.byType(NOTES_MASTER_REL$1)[0];
+	const existing = presRels.byType(NOTES_MASTER_REL)[0];
 	if (existing) return presRels.resolveTarget(existing.id);
 	return registerNotesMaster(dest, copyPart(ctx, sourceNotesMasterPartName));
 }
@@ -3135,7 +3907,7 @@ function ensureNotesMaster(dest, ctx, sourceNotesMasterPartName) {
 */
 function registerNotesMaster(dest, notesMasterPartName) {
 	const presPart = dest.presentationPart;
-	const relId = dest.opc.relationshipsFor(presPart.partName).add(NOTES_MASTER_REL$1, relativePartName(presPart.partName, notesMasterPartName)).id;
+	const relId = dest.opc.relationshipsFor(presPart.partName).add(NOTES_MASTER_REL, relativePartName(presPart.partName, notesMasterPartName)).id;
 	const root = presPart.dom.documentElement;
 	if (!root) throw new PackageReadError("package/part-has-no-root", "presentation.xml has no document element to register a notes master in");
 	const lst = getOrAddChild(root, "p:notesMasterIdLst", [
@@ -3169,7 +3941,7 @@ function registerNotesMaster(dest, notesMasterPartName) {
 function ensureNotesMasterFromXml(dest, master) {
 	const presPart = dest.presentationPart;
 	const presRels = dest.opc.relationshipsFor(presPart.partName);
-	const existing = presRels.byType(NOTES_MASTER_REL$1)[0];
+	const existing = presRels.byType(NOTES_MASTER_REL)[0];
 	if (existing) return presRels.resolveTarget(existing.id);
 	const masterPartName = dest.opc.reservePartNameLike("/ppt/notesMasters/notesMaster1.xml");
 	dest.opc.addPart(masterPartName, NOTES_MASTER_CONTENT_TYPE, textEncoder$1.encode(master.xml));
@@ -3179,48 +3951,6 @@ function ensureNotesMasterFromXml(dest, master) {
 	return registerNotesMaster(dest, masterPartName);
 }
 //#endregion
-//#region src/read/api/ops/part-index.ts
-/**
-* Walking a deck's master/layout spine by partname.
-*
-* The `p:sldMasterIdLst` / `p:sldLayoutIdLst` entries hold relationship ids, not partnames, so
-* every traversal has to resolve through the owning part's relationships. These are the
-* source-side reads that do it — used against a *foreign* presentation as often as against this
-* one, which is why they take the deck rather than living on it.
-*/
-/** Master partnames in `p:sldMasterIdLst` order. */
-function slideMasterPartNames(pres) {
-	const root = pres.presentationPart.dom.documentElement;
-	const lst = root && firstChild(root, "p:sldMasterIdLst");
-	if (!lst) return [];
-	const rels = pres.opc.relationshipsFor(pres.presentationPart.partName);
-	const out = [];
-	for (const entry of getElements(lst, "p:sldMasterId")) {
-		const relId = attr(entry, "r:id");
-		if (relId) out.push(rels.resolveTarget(relId));
-	}
-	return out;
-}
-/** A master's layout partnames in `p:sldLayoutIdLst` order. */
-function layoutPartNamesOf(pres, masterPartName) {
-	const root = pres.opc.part(masterPartName)?.dom.documentElement;
-	const lst = root && firstChild(root, "p:sldLayoutIdLst");
-	if (!lst) return [];
-	const rels = pres.opc.relationshipsFor(masterPartName);
-	const out = [];
-	for (const entry of getElements(lst, "p:sldLayoutId")) {
-		const relId = attr(entry, "r:id");
-		if (relId) out.push(rels.resolveTarget(relId));
-	}
-	return out;
-}
-/** 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;
-}
-//#endregion
 //#region src/read/api/ops/prune.ts
 /**
 * Orphan pruning after a part stops being referenced.
@@ -3286,8 +4016,6 @@ function isReferenced(pres, partName) {
 * scales it again on top of the first. It is owned by the calling `Presentation` and threaded
 * through here, so it lives as long as the deck does rather than as long as one call.
 */
-const SLIDE_LAYOUT_REL$1 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideLayout";
-const SLIDE_MASTER_REL$1 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideMaster";
 /**
 * Rescale an imported slide's geometry onto this deck's canvas (the `rescale`
 * option of {@link Presentation.importSlide}). Rewrites every top-level shape/group/
@@ -3302,8 +4030,8 @@ function rescaleImportedGeometry(dest, rescaledParts, slidePartName, theme, sour
 	const transform = computeRescale(source, target, mode);
 	rescalePartGeometry(dest, rescaledParts, slidePartName, transform);
 	if (theme === void 0 || theme === "copy") {
-		const layout = resolveSingleRel(dest.opc, slidePartName, SLIDE_LAYOUT_REL$1);
-		const master = layout ? resolveSingleRel(dest.opc, layout, SLIDE_MASTER_REL$1) : null;
+		const layout = resolveSingleRel(dest.opc, slidePartName, SLIDE_LAYOUT_REL);
+		const master = layout ? resolveSingleRel(dest.opc, layout, SLIDE_MASTER_REL) : null;
 		if (layout) rescalePartGeometry(dest, rescaledParts, layout, transform);
 		if (master) rescalePartGeometry(dest, rescaledParts, master, transform);
 	}
@@ -3330,14 +4058,14 @@ function rescalePartGeometry(dest, rescaledParts, partName, transform) {
 * Read-model entry point: `Presentation` wraps an `OpcPackage` and exposes a
 * navigable, typed view of the deck (slides → shapes → text), backed by the
 * live DOM so the same nodes can later be mutated.
+*
+* The class holds the model and the deck-level plumbing every operation needs — the part
+* index, the slide list, the copy registry that lets repeated imports from one source share
+* what they already copied, and the `p:sldIdLst` wiring. The operations themselves live in
+* `ops/`, one job per module, taking this deck as an argument. The slide-import machinery
+* used to sit here as ~280 lines of private methods and made that split hard to see: the
+* read model's own surface was outnumbered by one feature's internals.
 */
-const OFFICE_DOCUMENT_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument";
-const SLIDE_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slide";
-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_SLIDE_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesSlide";
-const NOTES_MASTER_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesMaster";
-const IMAGE_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image";
 const HYPERLINK_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink";
 const CHART_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/chart";
 const PACKAGE_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/package";
@@ -3668,13 +4396,14 @@ var Presentation = class Presentation {
 			throw new InvalidOptionError("import/slide-size-mismatch", `importSlide requires equal slide sizes (pass { rescale: 'fit' | 'stretch' } to rescale); target is ${fmt(target)}, source is ${fmt(incoming)}`);
 		}
 		if (sizesDiffer && options.rescale && (!target || !incoming)) throw new InvalidOptionError("import/slide-size-unknown", "importSlide rescale requires both decks to declare a slide size (p:sldSz)");
-		const newPartName = options.theme === "preserve" ? this.#importSlidePreserve(source, sourceSlide, options.carryMasterGraphics === true) : options.theme === "restyle" ? this.#importSlideRestyle(source, sourceSlide, options.carryMasterGraphics === true, options.remapLiterals === true) : copyPart(this.#importContext(source.opc), sourceSlide.partName);
+		const importCtx = this.#importContext(source.opc);
+		const newPartName = options.theme === "preserve" ? importSlidePreserve(this, importCtx, source, sourceSlide, options.carryMasterGraphics === true) : options.theme === "restyle" ? importSlideRestyle(this, importCtx, source, sourceSlide, options.carryMasterGraphics === true, options.remapLiterals === true) : copyPart(importCtx, sourceSlide.partName);
 		const newPart = this.opc.part(newPartName);
 		if (!newPart) throw new InternalError("import/part-went-missing", `Imported slide part went missing: ${newPartName}`);
 		if (sizesDiffer && options.rescale && target && incoming) rescaleImportedGeometry(this, this.#rescaledParts, newPartName, options.theme, incoming, target, options.rescale === true ? "fit" : options.rescale);
 		const slide = this.#insertSlidePart(newPart, options.at);
-		if (options.importNotes) carryNotes(this, source, this.#importContext(source.opc), sourceSlide.partName, newPartName);
-		if (options.embedFonts) carryEmbeddedFonts(this, source, this.#importContext(source.opc));
+		if (options.importNotes) carryNotes(this, source, importCtx, sourceSlide.partName, newPartName);
+		if (options.embedFonts) carryEmbeddedFonts(this, source, importCtx);
 		return slide;
 	}
 	/**
@@ -3965,14 +4694,14 @@ var Presentation = class Presentation {
 		const sourceRels = sourceOpc.relationshipsFor(source.partName);
 		const targetRels = this.opc.relationshipsFor(target.partName);
 		const relIdMap = /* @__PURE__ */ new Map();
-		const ctx = theme === "preserve" ? this.#sourceFlattenContext(sourceOpc, source.partName) : null;
+		const ctx = theme === "preserve" ? sourceFlattenContext(sourceOpc, source.partName) : null;
 		const importCtx = this.#importContext(sourceOpc);
 		const extLst = firstChild(spTree, "p:extLst");
 		const anchor = options.at == null ? extLst : nthShapeChild(spTree, options.at) ?? extLst;
 		const result = [];
 		for (const shapeEl of sourceElements) {
 			const imported = targetDoc.importNode(shapeEl, true);
-			this.#rewriteCarriedRels(imported, importCtx, sourceRels, target.partName, targetRels, relIdMap);
+			rewriteCarriedRels(imported, importCtx, sourceRels, target.partName, targetRels, relIdMap);
 			if (ctx) {
 				const holder = createElement(targetDoc, "p:spTree");
 				holder.appendChild(imported);
@@ -4008,215 +4737,6 @@ var Presentation = class Presentation {
 		return result;
 	}
 	/**
-	* Import a slide in `preserve` mode: rebind it to this deck's master/layout
-	* (see {@link #importSlideRebind}), then flatten its source theme into the slide
-	* XML (scheme colours + style-matrix fills baked to literals). Returns the new
-	* partname.
-	*
-	* The flatten context is gathered from the *source* subgraph, so it can be read
-	* before or after the rebind; the rebind injects any carried decorations before
-	* we flatten, so a single sweep resolves the theme references on the slide's own
-	* content and on the carried decorations together.
-	*/
-	#importSlidePreserve(source, sourceSlide, carryGraphics) {
-		const ctx = this.#sourceFlattenContext(source.opc, sourceSlide.partName);
-		const { newPartName, slideRoot, newPart } = this.#importSlideRebind(source, sourceSlide, carryGraphics);
-		flattenSlide(slideRoot, ctx);
-		newPart.markDirty();
-		return newPartName;
-	}
-	/**
-	* Import a slide in `restyle` mode: rebind it to this deck's master/layout (see
-	* {@link #importSlideRebind}) and then {@link restyleSlide} it — drop its colour
-	* map override but bake *nothing*, so its symbolic theme references re-resolve
-	* against the destination theme and the slide re-brands. Returns the new
-	* partname.
-	*
-	* The deliberate inverse of `preserve`: no flatten, no inherited-background
-	* bake, no placeholder colour/size/geometry bake — every one of those would pin
-	* the slide to its source look, the opposite of re-branding. Carried
-	* decorations are left symbolic too, so they re-brand along with the slide.
-	*
-	* With `remapLiterals` it additionally force-remaps the slide's source-theme
-	* literal colours back to symbolic scheme colours and copies any referenced
-	* source table style into this deck — the two things plain `restyle` cannot
-	* re-brand (see {@link ImportSlideOptions.remapLiterals}).
-	*/
-	#importSlideRestyle(source, sourceSlide, carryGraphics, remapLiterals) {
-		const { newPartName, slideRoot, newPart } = this.#importSlideRebind(source, sourceSlide, carryGraphics);
-		restyleSlide(slideRoot);
-		if (remapLiterals) {
-			const parts = resolveSlideThemeParts(source.opc, sourceSlide.partName);
-			remapLiteralColors(slideRoot, {
-				clrMap: parts.clrMap,
-				clrScheme: parts.clrScheme
-			});
-			copySourceTableStyles(this, source.opc, slideRoot);
-		}
-		newPart.markDirty();
-		return newPartName;
-	}
-	/**
-	* The rebind shared by `preserve` and `restyle`: copy the slide bytes into a
-	* fresh part, rebuild its relationships (drop notes, repoint the `slideLayout`
-	* rel at this deck's existing layout, copy every other internal target —
-	* media/charts — and pass externals through), and optionally bake the source
-	* master/layout decorations onto the slide. Returns the new part, its name, and
-	* its live root element for the caller's mode-specific pass (flatten vs restyle).
-	*
-	* This carries *no* theme baking of its own — not even the inherited background.
-	* `preserve` adds that via {@link flattenSlide}'s context; `restyle` must not,
-	* so the background stays symbolic and re-brands.
-	*/
-	#importSlideRebind(source, sourceSlide, carryGraphics) {
-		const destLayout = this.#destinationLayoutPartName();
-		const sourcePart = source.opc.part(sourceSlide.partName);
-		if (!sourcePart) throw new PackageReadError("package/part-missing", `importSlide: source package has no part ${sourceSlide.partName}`);
-		const newPartName = this.opc.reservePartNameLike(sourceSlide.partName);
-		const newPart = this.opc.addPart(newPartName, sourcePart.contentType, sourcePart.bytes);
-		const slideRoot = newPart.dom.documentElement;
-		if (!slideRoot) throw new PackageReadError("package/part-has-no-root", `Imported slide ${newPartName} has no root element`);
-		const ctx = this.#importContext(source.opc);
-		const sourceRels = source.opc.relationshipsFor(sourceSlide.partName);
-		const targetRels = this.opc.relationshipsFor(newPartName);
-		for (const rel of sourceRels) {
-			if (rel.type === NOTES_SLIDE_REL) continue;
-			if (rel.type === SLIDE_LAYOUT_REL) {
-				targetRels.addWithId(rel.id, SLIDE_LAYOUT_REL, relativePartName(newPartName, destLayout));
-				continue;
-			}
-			if (rel.targetMode === "External") {
-				targetRels.addWithId(rel.id, rel.type, rel.target, "External");
-				continue;
-			}
-			const newTarget = copyPart(ctx, sourceRels.resolveTarget(rel.id));
-			targetRels.addWithId(rel.id, rel.type, relativePartName(newPartName, newTarget));
-		}
-		if (carryGraphics) this.#carryMasterGraphics(ctx, slideRoot, newPartName, sourceSlide.partName);
-		return {
-			newPartName,
-			slideRoot,
-			newPart
-		};
-	}
-	/**
-	* Bake the source `slideLayout`/`slideMaster` shape-tree decorations onto the
-	* imported slide (the `carryMasterGraphics` path). Every shape on those trees
-	* *except* placeholders is deep-copied into the slide's `p:spTree` ahead of its
-	* own content — master decorations first, then layout, then the slide's shapes —
-	* so document (z-)order keeps the master furthest back. Each decoration's media
-	* and other relationship targets are copied into this package and its
-	* `r:embed`/`r:id`/… references rewritten to fresh slide-local ids. The injected
-	* shapes are left for the caller's {@link flattenSlide} pass to resolve any
-	* theme references they carry.
-	*/
-	#carryMasterGraphics(ctx, slideRoot, newPartName, slidePartName) {
-		const sourceOpc = ctx.source;
-		const layoutPartName = resolveSingleRel(sourceOpc, slidePartName, SLIDE_LAYOUT_REL);
-		const masterPartName = layoutPartName ? resolveSingleRel(sourceOpc, layoutPartName, SLIDE_MASTER_REL) : null;
-		const cSld = firstChild(slideRoot, "p:cSld");
-		const spTree = cSld && firstChild(cSld, "p:spTree");
-		if (!spTree) return;
-		const doc = ownerDocumentOf(slideRoot);
-		const slideRels = this.opc.relationshipsFor(newPartName);
-		const relIdMap = /* @__PURE__ */ new Map();
-		const anchor = firstShapeChild(spTree);
-		for (const partName of [masterPartName, layoutPartName]) {
-			if (!partName) continue;
-			const decorations = carriedDecorations(sourceOpc.part(partName)?.dom.documentElement ?? null);
-			if (decorations.length === 0) continue;
-			const sourceRels = sourceOpc.relationshipsFor(partName);
-			for (const deco of decorations) {
-				const imported = doc.importNode(deco, true);
-				this.#rewriteCarriedRels(imported, ctx, sourceRels, newPartName, slideRels, relIdMap);
-				spTree.insertBefore(imported, anchor);
-			}
-		}
-	}
-	/**
-	* Rewrite every relationship reference (`r:embed`, `r:id`, `r:link`, …) inside a
-	* carried decoration so it points at a fresh slide-local relationship, copying
-	* the referenced part into this package on first sight. `relIdMap` (keyed by
-	* source part + source rel id) dedupes references shared within one import call.
-	*/
-	#rewriteCarriedRels(node, ctx, sourceRels, newPartName, slideRels, relIdMap) {
-		const elements = [];
-		collectElements(node, elements);
-		for (const el of elements) {
-			const refs = [];
-			const attrs = el.attributes;
-			for (let i = 0; i < attrs.length; i++) {
-				const a = attrs.item(i);
-				if (!a || a.namespaceURI !== OOXML_NS.r || !a.value) continue;
-				if (!sourceRels.get(a.value)) continue;
-				refs.push({
-					local: a.localName ?? a.name,
-					id: a.value
-				});
-			}
-			for (const { local, id } of refs) setAttr(el, `r:${local}`, this.#carryRel(ctx, sourceRels, id, newPartName, slideRels, relIdMap));
-		}
-	}
-	/** Resolve a carried decoration's source relationship to a fresh slide-local id, copying its internal target. */
-	#carryRel(ctx, sourceRels, id, newPartName, slideRels, relIdMap) {
-		const key = `${sourceRels.sourcePartName}|${id}`;
-		const cached = relIdMap.get(key);
-		if (cached) return cached;
-		const rel = sourceRels.get(id);
-		if (!rel) throw new InvalidOptionError("relationship/not-found", `Relationships of ${sourceRels.sourcePartName}: no relationship with id ${id}`);
-		const newId = rel.targetMode === "External" ? slideRels.add(rel.type, rel.target, "External").id : slideRels.add(rel.type, relativePartName(newPartName, copyPart(ctx, sourceRels.resolveTarget(id)))).id;
-		relIdMap.set(key, newId);
-		return newId;
-	}
-	/**
-	* The partname of the layout this deck's slides should attach to in `preserve`
-	* mode: the first layout of the first slide master. Throws when the deck has no
-	* master/layout to attach to (a deck ts-pptx always provides).
-	*/
-	#destinationLayoutPartName() {
-		const presRels = this.opc.relationshipsFor(this.presentationPart.partName);
-		const masterRel = presRels.byType(SLIDE_MASTER_REL)[0];
-		if (!masterRel) throw new InvalidOptionError("import/destination-missing-master", "importSlide preserve mode requires a slide master in the destination deck");
-		const masterPartName = presRels.resolveTarget(masterRel.id);
-		const masterRels = this.opc.relationshipsFor(masterPartName);
-		const layoutRel = masterRels.byType(SLIDE_LAYOUT_REL)[0];
-		if (!layoutRel) throw new InvalidOptionError("import/destination-missing-layout", "importSlide preserve mode requires a slide layout in the destination deck");
-		return masterRels.resolveTarget(layoutRel.id);
-	}
-	/**
-	* Gather the flatten context for a source slide: walk slide → layout → master →
-	* theme, reading the effective colour map (the slide's `clrMapOvr` override, or
-	* the master `clrMap`), the theme `clrScheme`, and the theme `fmtScheme`.
-	*/
-	#sourceFlattenContext(sourceOpc, slidePartName) {
-		const parts = resolveSlideThemeParts(sourceOpc, slidePartName);
-		const themeElements = parts.themeElements;
-		return {
-			clrMap: parts.clrMap,
-			clrScheme: parts.clrScheme,
-			fmtScheme: themeElements ? firstChild(themeElements, "a:fmtScheme") : null,
-			inheritedBackground: this.#effectiveBackground(sourceOpc, parts.slideRoot, parts.layoutPartName, parts.masterPartName),
-			layoutRoot: parts.layoutRoot,
-			masterRoot: parts.masterRoot
-		};
-	}
-	/**
-	* The background the slide effectively inherits from its source subgraph: the
-	* layout's `p:bg`, else the master's. Returns `null` when the slide carries its
-	* own `p:bg` (it stays on the slide and is flattened directly) or none exists.
-	*/
-	#effectiveBackground(sourceOpc, slideRoot, layoutPartName, masterPartName) {
-		if (slideRoot && this.#backgroundOf(slideRoot)) return null;
-		const layoutRoot = layoutPartName ? sourceOpc.part(layoutPartName)?.dom.documentElement ?? null : null;
-		const masterRoot = masterPartName ? sourceOpc.part(masterPartName)?.dom.documentElement ?? null : null;
-		return (layoutRoot && this.#backgroundOf(layoutRoot)) ?? (masterRoot && this.#backgroundOf(masterRoot)) ?? null;
-	}
-	/** The `p:cSld/p:bg` element of a slide/layout/master root, or `null`. */
-	#backgroundOf(root) {
-		const cSld = firstChild(root, "p:cSld");
-		return cSld ? firstChild(cSld, "p:bg") : null;
-	}
-	/**
 	* Open an import out of `source`: this deck as the destination, paired with the
 	* copy registry for that package (created on first use). The registry is held on
 	* the class rather than in the context because it must outlive any one call —
@@ -4277,4 +4797,4 @@ var Presentation = class Presentation {
 //#endregion
 export { Placeholder as a, Theme as c, NotesSlide as d, OpcPackage as f, ContentTypes as h, Slide as i, readTagsForPart as l, Part as m, readCoreProperties as n, SlideLayout as o, Relationships as p, readCustomProperties as r, SlideMaster as s, Presentation as t, NotesPlaceholder as u };
 
-//# sourceMappingURL=presentation-MJe9WDi4.js.map
+//# sourceMappingURL=presentation-DAcOfzsP.js.map