@shbernal/ts-pptx 3.1.0 → 3.3.0

package/dist/{presentation-BP1B8PCF.js → presentation-DeKTJGHf.js}

@@ -1,9 +1,9 @@
 import { i as PackageReadError, n as InvalidOptionError, o as UnsupportedFeatureError, t as InternalError } from "./errors-Bvln0H-7.js";
-import { d as emuToInches } from "./units-C7QM1KgH.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-evQG2A7Z.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 { ft as emuToInches } from "./units-internal-CGf4VrXy.js";
+import { E as voidEl, T as raw, _ as FONT_DATA_EXTENSION, g as FONT_DATA_CONTENT_TYPE, h as EMBEDDED_FONT_SLOTS, n as makeXmlNotesMaster, o as makeXmlNotesSlideSkeleton, v as FONT_REL_TYPE, w as el } from "./notes-SCvpJz0l.js";
+import { _ as SLIDE_LAYOUT_REL, b as THEME_REL, d as IMAGE_REL, f as NOTES_MASTER_REL, h as OFFICE_REL, m as OFFICE_DOCUMENT_REL, p as NOTES_SLIDE_REL, v as SLIDE_MASTER_REL, y as SLIDE_REL } from "./st-enums-bVnezkMJ.js";
 import { ZipWriter, readZip } from "./zip.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-DMThLsZN.js";
+import { $ as parseClrScheme, A as readGradientFill, At as getElements, B as placeholderInheritedAnchor, Bt as setAttr, Ct as boolValue, D as spPrXfrmEmu, Dt as escapeXmlAttribute, E as TextFrame, Et as descendantsByTag, F as resolveSlideColorContext, Ft as parseXml, G as placeholderOf, H as placeholderInheritedListStyles, I as resolveSlideThemeParts, It as removeAttr, J as SCHEME_SLOTS, K as slideDefinesColor, Lt as removeChildrenByQName, M as resolveLayoutColorContext, Mt as insertInOrder, N as resolveMasterColorContext, Nt as intValue, O as readPatternFill, Ot as firstChild, P as resolveNotesColorContext, Pt as ownerDocumentOf, Q as parseClrMap, R as LST_STYLE_LEVELS, Rt as replaceInParent, S as AutoShape, St as attr, Tt as createElement, U as placeholderInheritedRunProps, V as placeholderInheritedColor, W as placeholderInheritedXfrm, X as intAttr, Y as fmtEntry, Z as isA, _t as relsPartNameFor, at as FILL_CHOICES, bt as zipPathToPartName, ct as SPPR_AFTER_XFRM, dt as SPPR_LN_AFTER, et as resolveColor, ft as SPPR_SCENE3D_AFTER, gt as relativePartName, ht as partNameToZipPath, it as substitutePhClr, j as resolveColorElement, jt as getOrAddChild, k as readPictureFill, kt as firstChildElement, l as wrapShapeElement, lt as SPPR_EFFECT_AFTER, mt as partNameExtension, n as buildShapes, nt as styleRefFill, ot as RPR_FILL_AFTER, pt as SPPR_SP3D_AFTER, q as slideDefinesProp, r as findShapeByIdDeep, rt as styleRefLine, st as SHAPE_AFTER_SPPR, t as GroupShape, tt as resolveSchemeToken, u as GraphicFrame, ut as SPPR_FILL_AFTER, vt as resolveRelativePartName, wt as childElements, x as Picture, xt as OOXML_NS, yt as resolveSingleRel, z as RUN_PROP_NAMES, zt as serializeXml } from "./shapes-BXVgsk0F.js";
 //#region src/read/opc/content-types.ts
 /**
 * Overlay over `[Content_Types].xml`, used to resolve part content types at
@@ -78,7 +78,7 @@ var ContentTypes = class ContentTypes {
 //#endregion
 //#region src/read/opc/part.ts
 const textDecoder$1 = new TextDecoder("utf-8");
-const textEncoder$4 = new TextEncoder();
+const textEncoder$5 = new TextEncoder();
 const XML_DECLARATION_RE = /^\uFEFF?<\?xml[^>]*\?>\s*/;
 /**
 * One OPC part. Holds the original bytes from the zip for its whole life;
@@ -135,7 +135,7 @@ var Part = class {
 		if (!this.#dirty) return this.#bytes;
 		let xml = serializeXml(this.dom);
 		if (!xml.startsWith("<?xml")) xml = (XML_DECLARATION_RE.exec(textDecoder$1.decode(this.#bytes))?.[0] ?? "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\r\n") + xml;
-		return textEncoder$4.encode(xml);
+		return textEncoder$5.encode(xml);
 	}
 };
 //#endregion
@@ -275,7 +275,7 @@ var Relationships = class Relationships {
 const CONTENT_TYPES_ZIP_PATH = "[Content_Types].xml";
 const RELATIONSHIPS_CONTENT_TYPE = "application/vnd.openxmlformats-package.relationships+xml";
 const textDecoder = new TextDecoder("utf-8");
-const textEncoder$3 = new TextEncoder();
+const textEncoder$4 = new TextEncoder();
 /**
 * An OPC package loaded from `.pptx` bytes.
 *
@@ -415,7 +415,7 @@ var OpcPackage = class OpcPackage {
 		for (const relationships of this.#relationshipsCache.values()) {
 			if (!relationships.isDirty) continue;
 			const relsPartName = relsPartNameFor(relationships.sourcePartName);
-			const bytes = textEncoder$3.encode(relationships.serialize());
+			const bytes = textEncoder$4.encode(relationships.serialize());
 			this.#parts.set(relsPartName, new Part(relsPartName, RELATIONSHIPS_CONTENT_TYPE, bytes));
 		}
 	}
@@ -1151,7 +1151,711 @@ var NotesSlide = class {
 		const cSld = root && firstChild(root, "p:cSld");
 		return cSld ? firstChild(cSld, "p:spTree") : null;
 	}
-};
+};
+//#endregion
+//#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,
+* promoting masters to the front of the id list, allocating ids out of the shared
+* master/layout id space, and emptying a freshly-copied master's layout list.
+*
+* These are the destination-side half of the import machinery -- they read and
+* write only this deck, never a source package and never the copy registry -- so
+* they take a structural {@link DeckTarget} rather than a `Presentation`. The
+* source-side half that drives most of them is `part-copy.ts`.
+*/
+/**
+* Wire a freshly-copied slide master into `presentation.xml`: add a
+* presentation→master relationship and a `p:sldMasterId` entry in
+* `p:sldMasterIdLst`. A master that is reachable only through the
+* slide→layout→master rel chain but absent from `p:sldMasterIdLst` is treated
+* as inactive by renderers, so its background/graphics never paint. No-op when
+* the master is already registered (shared across imports from one source).
+*/
+function registerMaster(dest, masterPartName) {
+	const presPart = dest.presentationPart;
+	const presRels = dest.opc.relationshipsFor(presPart.partName);
+	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", [
+		"p:notesMasterIdLst",
+		"p:handoutMasterIdLst",
+		"p:sldIdLst",
+		"p:sldSz",
+		"p:notesSz",
+		"p:embeddedFontLst",
+		"p:custShowLst",
+		"p:photoAlbum",
+		"p:custDataLst",
+		"p:kinsoku",
+		"p:defaultTextStyle",
+		"p:modifyVerifier",
+		"p:extLst"
+	]);
+	const entry = createElement(presPart.dom, "p:sldMasterId");
+	setAttr(entry, "id", String(nextMasterLayoutId(dest)));
+	setAttr(entry, "r:id", relId);
+	lst.appendChild(entry);
+	presPart.markDirty();
+}
+/**
+* Move the `p:sldMasterId` entries for `masterPartNames` to the front of
+* `p:sldMasterIdLst`, preserving their existing relative order, so the first of
+* them becomes the deck's `Designs(1)` — the theme PowerPoint's Design tab shows.
+* Reorders the id list only; relationships, ids, and all other parts are left as
+* they are. A no-op when the named masters already lead (idempotent re-call).
+*/
+function promoteMasters(dest, masterPartNames) {
+	if (masterPartNames.length === 0) return;
+	const presPart = dest.presentationPart;
+	const root = presPart.dom.documentElement;
+	const lst = root && firstChild(root, "p:sldMasterIdLst");
+	if (!lst) return;
+	const rels = dest.opc.relationshipsFor(presPart.partName);
+	const promote = new Set(masterPartNames);
+	const entries = getElements(lst, "p:sldMasterId");
+	const isPromoted = (entry) => {
+		const relId = attr(entry, "r:id");
+		return relId ? promote.has(rels.resolveTarget(relId)) : false;
+	};
+	const desired = [...entries.filter(isPromoted), ...entries.filter((e) => !isPromoted(e))];
+	if (desired.every((entry, i) => entry === entries[i])) return;
+	for (const entry of desired) lst.appendChild(entry);
+	presPart.markDirty();
+}
+/**
+* The next free id in the presentation-wide slide-master / slide-layout id space.
+*
+* `p:sldMasterId/@id` and every master's `p:sldLayoutId/@id` draw from ONE shared
+* id space (both ST_SlideMasterId/ST_SlideLayoutId, floor 2147483648) and must be
+* unique across the WHOLE presentation, not just within their own list. A duplicate
+* anywhere in this space makes PowerPoint report the file as corrupt on open
+* ("found a problem with content" / 0x80070570), even though LibreOffice silently
+* tolerates it — so an imported master AND each of its layouts must take an id past
+* the max of both the master-id list and every layout-id list. Recomputed per
+* allocation so ids appended earlier in the same import are counted.
+*/
+function nextMasterLayoutId(dest) {
+	let max = 2147483647;
+	const presPart = dest.presentationPart;
+	const root = presPart.dom.documentElement;
+	const masterLst = root && firstChild(root, "p:sldMasterIdLst");
+	if (masterLst) for (const entry of getElements(masterLst, "p:sldMasterId")) {
+		const id = intValue(attr(entry, "id"));
+		if (id !== null && id > max) max = id;
+	}
+	const presRels = dest.opc.relationshipsFor(presPart.partName);
+	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;
+		for (const entry of getElements(layoutLst, "p:sldLayoutId")) {
+			const id = intValue(attr(entry, "id"));
+			if (id !== null && id > max) max = id;
+		}
+	}
+	return max + 1;
+}
+/** Empty a freshly-copied master's `p:sldLayoutIdLst`; copied layouts repopulate it. */
+function clearLayoutIdList(dest, masterPartName) {
+	const masterPart = dest.opc.part(masterPartName);
+	const root = masterPart?.dom.documentElement;
+	const lst = root && firstChild(root, "p:sldLayoutIdLst");
+	if (!masterPart || !lst) return;
+	removeChildrenByQName(lst, ["p:sldLayoutId"]);
+	masterPart.markDirty();
+}
+/**
+* Append a `p:sldLayoutId` entry for `layoutPartName` to `masterPartName`'s
+* `p:sldLayoutIdLst`, adding the master→layout relationship it points at. The
+* destination-side half of linking a copied layout into its copied master; the
+* caller resolves which master that is from the source-side rels.
+*/
+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, relativePartName(masterPartName, layoutPartName)).id;
+	const lst = getOrAddChild(root, "p:sldLayoutIdLst", [
+		"p:transition",
+		"p:timing",
+		"p:hf",
+		"p:txStyles",
+		"p:extLst"
+	]);
+	const entry = createElement(masterPart.dom, "p:sldLayoutId");
+	setAttr(entry, "id", String(nextMasterLayoutId(dest)));
+	setAttr(entry, "r:id", relId);
+	lst.appendChild(entry);
+	masterPart.markDirty();
+}
+//#endregion
+//#region src/read/api/ops/page-owned.ts
+/** Relationship types whose target two copies of one page may point at together. */
+const SHARED_BY_PAGE_COPIES = /* @__PURE__ */ new Set([
+	SLIDE_LAYOUT_REL,
+	SLIDE_MASTER_REL,
+	NOTES_MASTER_REL,
+	THEME_REL,
+	OFFICE_REL + "themeOverride",
+	OFFICE_REL + "handoutMaster",
+	OFFICE_REL + "presProps",
+	OFFICE_REL + "viewProps",
+	OFFICE_REL + "tableStyles",
+	OFFICE_REL + "commentAuthors",
+	"http://schemas.microsoft.com/office/2018/10/relationships/authors",
+	IMAGE_REL,
+	OFFICE_REL + "audio",
+	OFFICE_REL + "video",
+	"http://schemas.microsoft.com/office/2007/relationships/media",
+	"http://schemas.microsoft.com/office/2017/06/relationships/model3d",
+	OFFICE_REL + "font",
+	SLIDE_REL,
+	OFFICE_REL + "hyperlink"
+]);
+/**
+* Whether a page copy may point at this relationship's target rather than taking
+* a copy of it. Everything not listed is owned by the page and copied — see the
+* module comment for why that is the safe default.
+*/
+function isSharedByPageCopies(relType) {
+	return SHARED_BY_PAGE_COPIES.has(relType);
+}
+/**
+* Give a just-cloned page its own copy of every part the source page owned,
+* within one package. The clone's relationships start as a byte copy of the
+* source page's, so this walks them and repoints the owned ones at fresh parts;
+* shared targets are left alone.
+*
+* The subtree under each owned part is copied the same way, so a chart's workbook
+* and user-shapes drawing come along while the image inside that drawing stays
+* shared. A relationship *back* to the source page — a notes slide names the
+* slide it annotates — is repointed at the clone, which is what makes the copied
+* notes belong to it.
+*
+* A dangling relationship is left dangling rather than made to throw: cloning a
+* damaged deck is not this function's problem to discover.
+*
+* @param opc               the package both pages live in
+* @param sourcePartName    partname of the page that was cloned
+* @param clonePartName     partname of the clone, whose rels are still the source's
+*/
+function duplicateOwnedTargets(opc, sourcePartName, clonePartName) {
+	const copies = /* @__PURE__ */ new Map([[sourcePartName, clonePartName]]);
+	const rels = opc.relationshipsFor(clonePartName);
+	for (const rel of Array.from(rels)) {
+		if (rel.targetMode === "External" || isSharedByPageCopies(rel.type)) continue;
+		const target = rels.resolveTarget(rel.id);
+		const fresh = duplicateSubtree(opc, target, copies);
+		if (fresh === target) continue;
+		rels.remove(rel.id);
+		rels.addWithId(rel.id, rel.type, relativePartName(clonePartName, fresh));
+	}
+}
+/**
+* Copy `partName` and, recursively, every part it owns, into fresh partnames.
+* `copies` dedupes within the one page copy, so a part two of the page's
+* relationships reach is copied once here even though the next page copy gets its
+* own. Returns the copy's partname, or `partName` unchanged when there is no such
+* part to copy.
+*/
+function duplicateSubtree(opc, partName, copies) {
+	const already = copies.get(partName);
+	if (already !== void 0) return already;
+	const part = opc.part(partName);
+	if (!part) return partName;
+	const fresh = opc.reservePartNameLike(partName);
+	opc.addPart(fresh, part.contentType, part.bytes);
+	copies.set(partName, fresh);
+	const sourceRels = opc.relationshipsFor(partName);
+	const freshRels = opc.relationshipsFor(fresh);
+	for (const rel of sourceRels) {
+		if (rel.targetMode === "External") {
+			freshRels.addWithId(rel.id, rel.type, rel.target, "External");
+			continue;
+		}
+		const target = sourceRels.resolveTarget(rel.id);
+		const newTarget = isSharedByPageCopies(rel.type) ? copies.get(target) ?? target : duplicateSubtree(opc, target, copies);
+		freshRels.addWithId(rel.id, rel.type, relativePartName(fresh, newTarget));
+	}
+	return fresh;
+}
+//#endregion
+//#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";
+const NOTES_SLIDE_CONTENT_TYPE$2 = "application/vnd.openxmlformats-officedocument.presentationml.notesSlide+xml";
+/** Open an ownership scope for one page copy. */
+function newOwnedScope() {
+	return /* @__PURE__ */ new Map();
+}
+/**
+* Copy one slide page across as a part of its own, deduping everything under it
+* but never the page itself. This is the `theme: 'copy'` arm of
+* {@link Presentation.importSlide}.
+*
+* The page is the one part an import is *not* allowed to share. `copyPart`'s
+* registry idempotence is right for a theme, master, layout or image, where a
+* second copy is waste; applied to the slide it made a repeated import of the
+* same source page return the first copy's partname, and the caller then wired a
+* second `p:sldId` to a part that already had one — a package PowerPoint refuses
+* to open (0x80070570), with nothing in the read model to show for it. So the
+* page goes into the selection plan `copyPart` already honours for a batch, which
+* re-materializes exactly the named pages and leaves the dedup of their
+* dependencies alone.
+*
+* @param ctx             the open import out of the source package
+* @param sourcePartName  partname of the source slide to bring across
+* @return                partname of the new slide part in `ctx.dest`
+*/
+function copySlidePart(ctx, sourcePartName) {
+	const destinations = /* @__PURE__ */ new Map([[sourcePartName, ctx.dest.opc.reservePartNameLike(sourcePartName)]]);
+	return copyPart({
+		...ctx,
+		selection: { destinations }
+	}, sourcePartName);
+}
+/**
+* Copy `sourcePartName` (and, recursively, every internal part it references)
+* from `ctx.source` into `ctx.dest`, returning the new partname. Idempotent
+* per source package via the copy registry. Relationship ids are preserved so
+* the copied part body's `r:id`/`r:embed` references stay valid; targets are
+* rewritten to the freshly-allocated partnames. Notes relationships are
+* dropped. A copied `slideMaster` does not drag in all its sibling layouts —
+* each imported `slideLayout` wires itself into the master instead (see
+* {@link linkLayoutIntoMaster}).
+*
+* With `ctx.selection`, partnames for the selected slides were already reserved
+* by the caller ({@link Presentation.importSlides}); this traversal wires their
+* relationships to each other instead of re-copying them. The batch's rule that
+* a `slide → slide` link may not leave the selection is enforced ahead of the
+* copy by {@link checkSelectionCopyable}, which also proves every part this
+* traversal will reach exists — so once copying starts there is nothing left to
+* throw, and a rejected batch never leaves a half-copied deck behind.
+*
+* Idempotence stops at the page's own parts. Reaching a page opens an
+* {@link OwnedScope}, and everything under it that {@link isSharedByPageCopies}
+* does not clear for sharing — a chart, a diagram, an OLE embedding, each with
+* its own subtree — is copied into that scope instead of the registry, so the
+* next copy of the page gets parts of its own. Pass `owned` to open the scope
+* from outside, as the rebinding import paths do for the page they build
+* themselves.
+*/
+function copyPart(ctx, sourcePartName, owned) {
+	if (owned) {
+		const alreadyOwned = owned.get(sourcePartName);
+		if (alreadyOwned !== void 0) return alreadyOwned;
+	} else {
+		const existing = ctx.registry.get(sourcePartName);
+		const selectedDest = ctx.selection?.destinations.get(sourcePartName);
+		if (existing && (selectedDest === void 0 || existing === selectedDest)) return existing;
+	}
+	const sourcePart = ctx.source.part(sourcePartName);
+	if (!sourcePart) throw new PackageReadError("package/part-missing", `importSlide: source package has no part ${sourcePartName}`);
+	const newPartName = owned ? ctx.dest.opc.reservePartNameLike(sourcePartName) : ctx.selection?.destinations.get(sourcePartName) ?? ctx.dest.opc.reservePartNameLike(sourcePartName);
+	if (!ctx.dest.opc.part(newPartName)) ctx.dest.opc.addPart(newPartName, sourcePart.contentType, sourcePart.bytes);
+	if (owned) owned.set(sourcePartName, newPartName);
+	else ctx.registry.set(sourcePartName, newPartName);
+	const scope = owned ?? (ctx.selection?.destinations.has(sourcePartName) ? newOwnedScope() : void 0);
+	const isMaster = sourcePart.contentType === SLIDE_MASTER_CONTENT_TYPE;
+	const sourceRels = ctx.source.relationshipsFor(sourcePartName);
+	const targetRels = ctx.dest.opc.relationshipsFor(newPartName);
+	for (const rel of sourceRels) {
+		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;
+		}
+		const newTargetPartName = copyPart(ctx, sourceRels.resolveTarget(rel.id), isSharedByPageCopies(rel.type) ? void 0 : scope);
+		targetRels.addWithId(rel.id, rel.type, relativePartName(newPartName, newTargetPartName));
+	}
+	if (isMaster) {
+		clearLayoutIdList(ctx.dest, newPartName);
+		registerMaster(ctx.dest, newPartName);
+	}
+	if (sourcePart.contentType === SLIDE_LAYOUT_CONTENT_TYPE) linkLayoutIntoMaster(ctx, sourceRels, newPartName);
+	return newPartName;
+}
+const NO_NOTES = {
+	pages: /* @__PURE__ */ new Set(),
+	copyMaster: false
+};
+/**
+* Dry-run {@link copyPart} over one source's batch selection, reading only the
+* *source* package: walk the graph the copy will walk, under the same
+* relationship-skipping rules, and throw what the copy would throw — a source
+* part that is missing, XML that will not parse, or a `slide → slide` link that
+* escapes the selection.
+*
+* This is what makes a rejected batch leave the destination byte-identical.
+* `importSlides` reserves partnames and mutates the destination only after this
+* passes, at which point the copy has no reachable failure left; a check that
+* lived inside the traversal instead would fire with parts already added, a
+* master already registered in `presentation.xml`, and no way back.
+*
+* Keep this in step with `copyPart`: the two must skip the same relationships
+* and stop at the same registry hits, or the guarantee is only as good as the
+* drift between them. With `notes` the same obligation extends to `carryNotes`,
+* which runs after the copy and is the batch's other way to reach a source part.
+*
+* @param source     the package the pages are coming from
+* @param registry   the copy registry for that source (parts already in `dest`)
+* @param selected   source partnames of the pages this batch selected
+* @param notes      the pages of `selected` whose notes travel too; none by default
+*/
+function checkSelectionCopyable(source, registry, selected, notes = NO_NOTES) {
+	const visited = /* @__PURE__ */ new Set();
+	const walk = (partName) => {
+		if (visited.has(partName)) return;
+		if (registry.has(partName) && !selected.has(partName)) return;
+		visited.add(partName);
+		const part = source.part(partName);
+		if (!part) throw new PackageReadError("package/part-missing", `importSlides: source package has no part ${partName}`);
+		const isMaster = part.contentType === SLIDE_MASTER_CONTENT_TYPE;
+		const isNotesSlide = part.contentType === NOTES_SLIDE_CONTENT_TYPE$2;
+		if (isMaster || part.contentType === SLIDE_LAYOUT_CONTENT_TYPE) part.dom;
+		const rels = source.relationshipsFor(partName);
+		for (const rel of rels) {
+			if (rel.type === "http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesSlide") {
+				if (notes.pages.has(partName)) walk(rels.resolveTarget(rel.id));
+				continue;
+			}
+			if (isNotesSlide) {
+				if (rel.type === "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slide") continue;
+				if (rel.type === "http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesMaster" && !notes.copyMaster) continue;
+			}
+			if (isMaster && rel.type === "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideLayout") continue;
+			if (rel.targetMode === "External") continue;
+			const targetPartName = rels.resolveTarget(rel.id);
+			if (rel.type === "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slide" && !selected.has(targetPartName) && !registry.has(targetPartName)) throw new InvalidOptionError("import/unresolved-slide-link", `importSlides: source slide ${partName} links to ${targetPartName}, which is not among the selected imported pages`);
+			walk(targetPartName);
+		}
+	};
+	for (const partName of selected) walk(partName);
+}
+/**
+* Wire a just-copied layout into its (already-copied) master. Resolves which
+* destination master that is by running the layout's *source* master rel through
+* the copy registry, then hands the destination-side wiring to
+* {@link addLayoutToMaster}. Called once per copied layout, so the master
+* accumulates exactly the imported layouts.
+*/
+function linkLayoutIntoMaster(ctx, layoutSourceRels, layoutPartName) {
+	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/notes-master.ts
+/**
+* Carrying speaker notes and the deck's single notes master across an import or an append.
+*
+* A `notesSlide` is not self-contained: it back-references the slide it annotates and forward-
+* references the deck's notes master. `CT_NotesMasterIdList` allows at most one master per
+* presentation, so a deck that already has one keeps it — the destination's notes styling wins —
+* and a source master is copied only into a deck that has none. That single rule is why both the
+* `Presentation`-to-`Presentation` path and the generator-XML path funnel through
+* `registerNotesMaster`: they differ only in how the *part* comes into being.
+*/
+const NOTES_MASTER_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.presentationml.notesMaster+xml";
+const THEME_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.theme+xml";
+const textEncoder$3 = new TextEncoder();
+/**
+* Carry the source slide's speaker notes onto the just-imported slide (the
+* `importNotes` option). The slide copy itself dropped the `notesSlide` rel, so
+* this copies the source `notesSlide` part into a fresh partname, wires a
+* `slide → notesSlide` rel on the new slide, and rebuilds the copied notesSlide's
+* own relationships:
+*
+* - its `slide` back-rel is repointed at the new slide (`newSlidePartName`) — the
+*   source slide is *not* copied (that would be circular);
+* - its `notesMaster` rel is resolved through {@link ensureNotesMaster}, which
+*   reuses this deck's notesMaster when it has one and copies the source's only
+*   when it has none (a deck may have at most one notesMaster);
+* - any other internal target (media, etc.) is copied via {@link copyPart}, under an
+*   ownership scope so a second copy of the page gets notes parts of its own.
+*
+* No-op when the source slide has no notes. Content-type registration for the
+* copied parts is handled by `addPart`/{@link copyPart}.
+*/
+function carryNotes(dest, source, ctx, sourceSlidePartName, newSlidePartName) {
+	const sourceSlideRels = source.opc.relationshipsFor(sourceSlidePartName);
+	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, relativePartName(newSlidePartName, newNotesPartName));
+	const owned = newOwnedScope();
+	owned.set(sourceNotesPartName, newNotesPartName);
+	const notesSourceRels = source.opc.relationshipsFor(sourceNotesPartName);
+	const notesTargetRels = dest.opc.relationshipsFor(newNotesPartName);
+	for (const rel of notesSourceRels) {
+		if (rel.type === "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slide") {
+			notesTargetRels.addWithId(rel.id, SLIDE_REL, relativePartName(newNotesPartName, newSlidePartName));
+			continue;
+		}
+		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, relativePartName(newNotesPartName, notesMaster));
+			continue;
+		}
+		if (rel.targetMode === "External") {
+			notesTargetRels.addWithId(rel.id, rel.type, rel.target, "External");
+			continue;
+		}
+		const newTarget = copyPart(ctx, notesSourceRels.resolveTarget(rel.id), isSharedByPageCopies(rel.type) ? void 0 : owned);
+		notesTargetRels.addWithId(rel.id, rel.type, relativePartName(newNotesPartName, newTarget));
+	}
+}
+/**
+* Resolve the notesMaster an imported `notesSlide` should bind to, honouring the
+* single-notesMaster-per-presentation rule (`p:notesMasterIdLst` holds 0..1
+* `p:notesMasterId`). If this deck already has a notesMaster it is reused and the
+* source's is *not* copied (the destination's notes styling wins); otherwise the
+* source notesMaster (and, via {@link copyPart}, its theme) is copied and
+* registered in `presentation.xml`. Returns the destination notesMaster partname.
+*/
+function ensureNotesMaster(dest, ctx, sourceNotesMasterPartName) {
+	const presPart = dest.presentationPart;
+	const presRels = dest.opc.relationshipsFor(presPart.partName);
+	const existing = presRels.byType(NOTES_MASTER_REL)[0];
+	if (existing) return presRels.resolveTarget(existing.id);
+	return registerNotesMaster(dest, copyPart(ctx, sourceNotesMasterPartName));
+}
+/**
+* Wire an already-added notesMaster part into `presentation.xml`: a `notesMaster`
+* relationship plus the single `p:notesMasterId` entry that `CT_NotesMasterIdList`
+* allows. Returns the partname, so callers can use it as a rel target.
+*
+* Split out of {@link ensureNotesMaster} because the two ways a notesMaster arrives
+* — copied from another `Presentation`, or authored by a generator and injected by
+* {@link Presentation.appendSlides} — differ only in how the *part* is created, not in how it is
+* registered.
+*/
+function registerNotesMaster(dest, notesMasterPartName) {
+	const presPart = dest.presentationPart;
+	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", [
+		"p:handoutMasterIdLst",
+		"p:sldIdLst",
+		"p:sldSz",
+		"p:notesSz",
+		"p:embeddedFontLst",
+		"p:custShowLst",
+		"p:photoAlbum",
+		"p:custDataLst",
+		"p:kinsoku",
+		"p:defaultTextStyle",
+		"p:modifyVerifier",
+		"p:extLst"
+	]);
+	removeChildrenByQName(lst, ["p:notesMasterId"]);
+	const entry = createElement(presPart.dom, "p:notesMasterId");
+	setAttr(entry, "r:id", relId);
+	lst.appendChild(entry);
+	presPart.markDirty();
+	return notesMasterPartName;
+}
+/**
+* Resolve the notesMaster an *appended* slide's notes should bind to. Same
+* single-notesMaster rule as {@link ensureNotesMaster}: this deck's own wins when it
+* has one, so the destination's notes styling is preserved and `master.xml` is
+* discarded. Otherwise the generator's notes master is installed, together with the
+* theme its `.rels` requires (the normal write path emits that as `theme2.xml`).
+*/
+function ensureNotesMasterFromXml(dest, master) {
+	const presPart = dest.presentationPart;
+	const presRels = dest.opc.relationshipsFor(presPart.partName);
+	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$3.encode(master.xml));
+	const themePartName = dest.opc.reservePartNameLike("/ppt/theme/theme1.xml");
+	dest.opc.addPart(themePartName, THEME_CONTENT_TYPE, textEncoder$3.encode(master.themeXml));
+	dest.opc.relationshipsFor(masterPartName).add(THEME_REL, relativePartName(masterPartName, themePartName));
+	return registerNotesMaster(dest, masterPartName);
+}
+/**
+* Resolve the notesMaster a *newly authored* notes slide should bind to
+* ({@link Slide.addNotes} on a loaded deck). Same single-notesMaster rule as
+* {@link ensureNotesMaster} and {@link ensureNotesMasterFromXml}: this deck's own
+* wins when it has one. The third way a notesMaster arrives, and the only one with
+* no source deck and no generator instance behind it, so it has to build both parts
+* itself.
+*
+* The *theme* is where it differs from the append path. `ensureNotesMasterFromXml`
+* installs the generator's `theme2.xml` because a generator deck's notes were
+* authored against it; there is no such theme here, so the deck's **own** theme
+* (reached through the annotated slide's layout → master → theme chain) is cloned
+* into a fresh part instead. That is both the closer match to "the destination's
+* notes styling wins" and the safer package: the notesMaster gets a theme part of
+* its own rather than a second relationship onto the slide master's, which is the
+* arrangement PowerPoint writes (`theme1.xml` for the master, `theme2.xml` for the
+* notes master).
+*
+* Throws when the deck has no theme to clone — a package that malformed cannot be
+* given a valid notesMaster, and silently emitting one without a resolvable theme
+* is what PowerPoint reports as a repair prompt rather than a bad edit.
+* @param {Presentation} dest - the deck being authored onto
+* @param {string} slidePartName - the slide whose notes are being authored, used to find the theme
+* @return {string} the destination notesMaster partname
+*/
+function ensureNotesMasterForAuthoring(dest, slidePartName) {
+	const presPart = dest.presentationPart;
+	const presRels = dest.opc.relationshipsFor(presPart.partName);
+	const existing = presRels.byType(NOTES_MASTER_REL)[0];
+	if (existing) return presRels.resolveTarget(existing.id);
+	const themePartName = resolveSlideThemeParts(dest.opc, slidePartName).themePartName;
+	const themePart = themePartName ? dest.opc.part(themePartName) : void 0;
+	if (!themePart) throw new PackageReadError("package/part-missing", `addNotes: no theme reachable from ${slidePartName} to bind a new notes master to`);
+	const masterPartName = dest.opc.reservePartNameLike("/ppt/notesMasters/notesMaster1.xml");
+	dest.opc.addPart(masterPartName, NOTES_MASTER_CONTENT_TYPE, textEncoder$3.encode(makeXmlNotesMaster()));
+	const notesThemePartName = dest.opc.reservePartNameLike("/ppt/theme/theme1.xml");
+	dest.opc.addPart(notesThemePartName, themePart.contentType, themePart.bytes);
+	dest.opc.relationshipsFor(masterPartName).add(THEME_REL, relativePartName(masterPartName, notesThemePartName));
+	return registerNotesMaster(dest, masterPartName);
+}
+//#endregion
+//#region src/read/api/ops/notes-author.ts
+/**
+* Authoring speaker notes onto a slide of a *loaded* deck ({@link Slide.addNotes}).
+*
+* The third way a notes slide comes into being, after the two in `notes-master.ts`
+* (carried from another `Presentation` by `importSlide({ importNotes: true })`, or
+* emitted by the generator and spliced on by `appendSlides`). Those two both *move*
+* an existing part; this one has no source part to move, so it builds one.
+*
+* The part it builds is the generator's, not a second design: the fixed three-
+* placeholder frame comes from {@link makeXmlNotesSlideSkeleton}, and the body
+* paragraphs carry the same elements and attributes the write path emits for a plain
+* `pptx.addSlide().addNotes(text)`. `test/read/add-notes.test.js` asserts that
+* equivalence, so the two cannot drift apart unnoticed — the same guarantee
+* `src/ooxml/` gives the constants both halves share.
+*
+* The one difference is empty-element *spelling*: the write path emits `a:rPr` as an
+* open/close pair and this emits it self-closed, because a part the read model
+* authors is reserialized through `read/oxml/dom.ts`, which self-closes every empty
+* element. Writing the open/close form here would not survive the first save, so the
+* form that does is written in the first place and the test normalizes the spelling
+* rather than pretending the bytes match.
+*
+* Notes text is split on `\n` into paragraphs, matching the write-side `addNotes`;
+* runs carry no formatting of their own. Per-run formatting, hyperlinks, and
+* multi-run paragraphs are reached afterwards through `slide.notesTextFrame`, which
+* is the read model's normal text-editing surface.
+*/
+const NOTES_SLIDE_CONTENT_TYPE$1 = "application/vnd.openxmlformats-officedocument.presentationml.notesSlide+xml";
+const A_NS = "http://schemas.openxmlformats.org/drawingml/2006/main";
+const textEncoder$2 = new TextEncoder();
+/**
+* The `a:p` children of a notes body, one per `\n`-separated line: the write path's
+* output for an unformatted note, modulo the empty-element spelling described above.
+* An empty line yields a paragraph with no run, exactly as `genXmlNotesParagraphs`
+* does.
+* @param {string} text - the note, `\n` separating paragraphs
+* @return {string} concatenated `a:p` XML
+*/
+function notesParagraphsXml(text) {
+	return text.split("\n").map((line) => line.replace(/\r/g, "")).map((line) => el("a:p", null, [raw(line === "" ? "" : el("a:r", null, [raw(voidEl("a:rPr", {
+		lang: "en-US",
+		dirty: 0
+	})), raw(el("a:t", null, line))])), raw(voidEl("a:endParaRPr", {
+		lang: "en-US",
+		dirty: 0
+	}))])).join("");
+}
+/**
+* Replace a notes body's paragraphs with `text`, in the body's own document.
+*
+* The path taken when the slide *already* has a notes part — an imported one, or one
+* an earlier `addNotes` wrote. Only the `a:p` children are replaced, so the part's
+* geometry, its `a:bodyPr`/`a:lstStyle`, and its other two placeholders survive. The
+* body's hyperlink relationships are deliberately *not* pruned: a caller replacing
+* text has not asked for its rels to be rewritten, and a now-unreferenced notes
+* hyperlink rel is inert (nothing resolves it on save).
+* @param {Element} txBody - the body placeholder's `p:txBody`
+* @param {string} text - the note, `\n` separating paragraphs
+*/
+function replaceNotesParagraphs(txBody, text) {
+	const doc = txBody.ownerDocument;
+	if (!doc) throw new InternalError("oxml/node-has-no-document", "Notes body has no owner document");
+	removeChildrenByQName(txBody, ["a:p"]);
+	const wrapper = parseXml(`<w xmlns:a="${A_NS}">${notesParagraphsXml(text)}</w>`).documentElement;
+	if (!wrapper) throw new InternalError("oxml/node-has-no-document", "Authored notes paragraphs did not parse to a root");
+	for (const paragraph of Array.from(wrapper.childNodes)) txBody.appendChild(doc.importNode(paragraph, true));
+}
+/**
+* The `p:txBody` of a notes slide's body placeholder (`p:ph type="body"`), or `null`
+* when the part carries none. A raw walk rather than a `NotesSlide`/`TextFrame` hop,
+* because the caller needs the element itself to rewrite and the modeled surface
+* would resolve a notes theme context it has no use for.
+* @param {Element | null} root - the notes slide's `p:notes` root
+* @return {Element | null} the body placeholder's text body
+*/
+function notesBodyTxBody(root) {
+	const cSld = root && firstChild(root, "p:cSld");
+	const spTree = cSld && firstChild(cSld, "p:spTree");
+	if (!spTree) return null;
+	for (const sp of getElements(spTree, "p:sp")) {
+		const nvSpPr = firstChild(sp, "p:nvSpPr");
+		const nvPr = nvSpPr && firstChild(nvSpPr, "p:nvPr");
+		const ph = nvPr && firstChild(nvPr, "p:ph");
+		if (ph && attr(ph, "type") === "body") return firstChild(sp, "p:txBody");
+	}
+	return null;
+}
+/**
+* Give `slide` the speaker notes `text`, creating its notes slide part when it has
+* none, and return the notes part's name.
+*
+* When the slide already has a notes part, only the body paragraphs are rewritten
+* (see {@link replaceNotesParagraphs}). When it has none, the part is built and
+* wired: `slide → notesSlide`, and on the new part the two relationships a notes
+* slide always carries — `notesMaster` as rId1 and a `slide` back-reference as rId2,
+* the ids and order the write path reserves.
+*
+* The notes master is resolved through {@link ensureNotesMasterForAuthoring}: this
+* deck's own when it has one, otherwise a fresh one bound to a clone of the deck's
+* theme. That is the single-notesMaster-per-presentation rule the import and append
+* paths already follow, so the three cannot produce a second master between them.
+* @param {Slide} slide - the slide to annotate
+* @param {string} text - the note, `\n` separating paragraphs
+* @return {string} the notes slide's partname
+*/
+function authorNotes(slide, text) {
+	const opc = slide.presentation.opc;
+	const existingRel = slide.relationships.byType(NOTES_SLIDE_REL)[0];
+	if (existingRel) {
+		const partName = slide.relationships.resolveTarget(existingRel.id);
+		const part = opc.part(partName);
+		if (!part) throw new PackageReadError("package/part-missing", `addNotes: slide ${slide.partName} has a notesSlide rel to a missing part ${partName}`);
+		const txBody = notesBodyTxBody(part.dom.documentElement);
+		if (!txBody) throw new PackageReadError("package/part-has-no-root", `addNotes: notes slide ${partName} has no body placeholder to write into`);
+		replaceNotesParagraphs(txBody, text);
+		part.markDirty();
+		return partName;
+	}
+	const slideNum = slide.index + 1;
+	const partName = opc.reservePartNameLike("/ppt/notesSlides/notesSlide1.xml");
+	opc.addPart(partName, NOTES_SLIDE_CONTENT_TYPE$1, textEncoder$2.encode(makeXmlNotesSlideSkeleton(notesParagraphsXml(text), slideNum)));
+	slide.relationships.add(NOTES_SLIDE_REL, relativePartName(slide.partName, partName));
+	const notesRels = opc.relationshipsFor(partName);
+	const masterPartName = ensureNotesMasterForAuthoring(slide.presentation, slide.partName);
+	notesRels.addWithId("rId1", NOTES_MASTER_REL, relativePartName(partName, masterPartName));
+	notesRels.addWithId("rId2", SLIDE_REL, relativePartName(partName, slide.partName));
+	return partName;
+}
 //#endregion
 //#region src/read/api/comments.ts
 /** The slide → comments-part relationship type (legacy comments). */
@@ -1440,6 +2144,13 @@ function placeholderShapes(spTree) {
 * and text style from. Geometry getters read the placeholder's *own* `a:xfrm`,
 * which a master/layout placeholder carries explicitly (so it round-trips, unlike a
 * notes placeholder's inherited geometry).
+*
+* This is the identity-and-geometry view. The same `p:sp` also appears in
+* {@link SlideMaster.shapes} / {@link SlideLayout.shapes} as an `AutoShape`, which
+* additionally carries the paint surface (`resolvedFill`, `resolvedLine`,
+* `presetGeometry`, `rotation`, `absoluteFrame`) and reports its `p:ph` through
+* `AutoShape.placeholder`. Read a placeholder here to *place* it; read it there to
+* *draw* it.
 */
 var Placeholder = class {
 	sp;
@@ -1513,9 +2224,9 @@ var Placeholder = class {
 /**
 * A deck's slide master (`slideMasterN.xml`) as a modeled object. Exposes the
 * property tiers a bound slide inherits: the {@link colorMap} (token → theme slot),
-* its {@link theme}, its {@link placeholders} (with geometry), its own
-* {@link background}, and the {@link layouts} that build on it. Reachable from
-* {@link SlideLayout.master} and `Slide.master`.
+* its {@link theme}, its {@link shapes} and the {@link placeholders} subset of them,
+* its own {@link background}, and the {@link layouts} that build on it. Reachable
+* from {@link SlideLayout.master} and `Slide.master`.
 */
 var SlideMaster = class {
 	opc;
@@ -1529,6 +2240,10 @@ var SlideMaster = class {
 	get partName() {
 		return this.part.partName;
 	}
+	/** This master part's relationships (its layouts, its theme, image embeds, …). */
+	get relationships() {
+		return this.opc.relationshipsFor(this.partName);
+	}
 	/** The master's authoring name (`p:cSld/@name`), or `''` when unnamed (the writer's default). */
 	get name() {
 		const cSld = this.#cSld();
@@ -1552,10 +2267,27 @@ var SlideMaster = class {
 		for (const token of COLOR_MAP_TOKENS) out[token] = parsed.get(token) ?? null;
 		return out;
 	}
+	/**
+	* Every shape in the master's `p:cSld/p:spTree`, in document order — the same
+	* `AnyShape` union `Slide.shapes` returns, so shape-walking code applies
+	* unchanged. This is where a template's non-placeholder furniture lives: the
+	* header band, the rule under the title, the logo. Whether a given slide draws
+	* them is `Slide.showMasterSp` (and, for a layout, {@link SlideLayout.showMasterSp}).
+	*
+	* {@link placeholders} is the filtered view of the same tree.
+	*/
+	get shapes() {
+		const spTree = this.#spTree();
+		return spTree ? buildShapes(spTree, this) : [];
+	}
+	/** The shape anywhere in the master's tree with the given drawing id, or `undefined`. */
+	shapeByIdDeep(id) {
+		return findShapeByIdDeep(this.shapes, id);
+	}
 	/** The master's placeholder shapes (`p:sp` carrying a `p:ph`), in document order. */
 	get placeholders() {
 		const ctx = this.themeContext();
-		const rels = this.opc.relationshipsFor(this.partName);
+		const rels = this.relationships;
 		return placeholderShapes(this.#spTree()).map((sp) => new Placeholder(sp, this.part, ctx, rels));
 	}
 	/** The layouts built on this master (via `p:sldLayoutIdLst` → its relationships), in list order. */
@@ -1563,7 +2295,7 @@ var SlideMaster = class {
 		const root = this.part.dom.documentElement;
 		const lst = root && firstChild(root, "p:sldLayoutIdLst");
 		if (!lst) return [];
-		const rels = this.opc.relationshipsFor(this.partName);
+		const rels = this.relationships;
 		const out = [];
 		for (const entry of getElements(lst, "p:sldLayoutId")) {
 			const relId = attr(entry, "r:id");
@@ -1581,7 +2313,7 @@ var SlideMaster = class {
 		const bg = backgroundElementOf(this.part.dom.documentElement);
 		if (!bg) return null;
 		const themePart = this.#relTarget(THEME_REL);
-		return readSlideBackground(bg, "master", this.themeContext(), this.opc.relationshipsFor(this.partName), themePart ? this.opc.relationshipsFor(themePart.partName) : null);
+		return readSlideBackground(bg, "master", this.themeContext(), this.relationships, themePart ? this.opc.relationshipsFor(themePart.partName) : null);
 	}
 	/**
 	* The master's colour/font context (its `p:clrMap` + theme), resolved once and
@@ -1591,7 +2323,7 @@ var SlideMaster = class {
 		return this.#themeContext ??= resolveMasterColorContext(this.opc, this.partName);
 	}
 	#relTarget(type) {
-		const rels = this.opc.relationshipsFor(this.partName);
+		const rels = this.relationships;
 		const rel = rels.byType(type)[0];
 		return rel ? this.opc.part(rels.resolveTarget(rel.id)) ?? null : null;
 	}
@@ -1608,8 +2340,8 @@ var SlideMaster = class {
 * A deck's slide layout (`slideLayoutN.xml`) as a modeled object — the gallery entry
 * a slide binds to. Exposes its {@link name}, its {@link type} (import-only; the
 * writer authors none), its {@link master} (and, through it, the {@link theme}), its
-* {@link placeholders} (with geometry), and its own {@link background}. Reachable
-* from `Slide.layout` and {@link SlideMaster.layouts}.
+* {@link shapes} and the {@link placeholders} subset of them, and its own
+* {@link background}. Reachable from `Slide.layout` and {@link SlideMaster.layouts}.
 */
 var SlideLayout = class {
 	opc;
@@ -1623,6 +2355,10 @@ var SlideLayout = class {
 	get partName() {
 		return this.part.partName;
 	}
+	/** This layout part's relationships (its master, image embeds, hyperlinks, …). */
+	get relationships() {
+		return this.opc.relationshipsFor(this.partName);
+	}
 	/** The layout's authoring name (`p:cSld/@name`, e.g. `Title and Content`), or `''` when unnamed. */
 	get name() {
 		const cSld = this.#cSld();
@@ -1637,9 +2373,21 @@ var SlideLayout = class {
 		const root = this.part.dom.documentElement;
 		return root ? attr(root, "type") : null;
 	}
+	/**
+	* Whether this layout draws the master's non-placeholder shapes
+	* (`p:sldLayout/@showMasterSp`). `xsd:boolean` defaulting to `true`, so an absent
+	* attribute means shown — the layout-tier counterpart of `Slide.showMasterSp`,
+	* and the one PowerPoint actually writes on a section-divider or full-bleed
+	* layout. A renderer resolving what to paint under a slide's own shapes has to
+	* consult both: the slide's flag, then its layout's.
+	*/
+	get showMasterSp() {
+		const root = this.part.dom.documentElement;
+		return boolValue(root && attr(root, "showMasterSp")) !== false;
+	}
 	/** 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 rels = this.relationships;
 		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;
@@ -1648,10 +2396,27 @@ var SlideLayout = class {
 	get theme() {
 		return this.master?.theme ?? null;
 	}
+	/**
+	* Every shape in the layout's `p:cSld/p:spTree`, in document order — the same
+	* `AnyShape` union `Slide.shapes` returns, so shape-walking code applies
+	* unchanged. The write API authors non-placeholder shapes here: every
+	* `defineSlideMaster({ objects })` member that is not a `placeholder` (a `rect`,
+	* a `line`, an `image`, a `chart`, a `text` box) lands in this tree.
+	*
+	* {@link placeholders} is the filtered view of the same tree.
+	*/
+	get shapes() {
+		const spTree = this.#spTree();
+		return spTree ? buildShapes(spTree, this) : [];
+	}
+	/** The shape anywhere in the layout's tree with the given drawing id, or `undefined`. */
+	shapeByIdDeep(id) {
+		return findShapeByIdDeep(this.shapes, id);
+	}
 	/** The layout's placeholder shapes (`p:sp` carrying a `p:ph`), in document order. */
 	get placeholders() {
 		const ctx = this.themeContext();
-		const rels = this.opc.relationshipsFor(this.partName);
+		const rels = this.relationships;
 		return placeholderShapes(this.#spTree()).map((sp) => new Placeholder(sp, this.part, ctx, rels));
 	}
 	/**
@@ -1664,7 +2429,7 @@ var SlideLayout = class {
 		const bg = backgroundElementOf(this.part.dom.documentElement);
 		if (!bg) return null;
 		const themePart = this.master?.theme?.part ?? null;
-		return readSlideBackground(bg, "layout", this.themeContext(), this.opc.relationshipsFor(this.partName), themePart ? this.opc.relationshipsFor(themePart.partName) : null);
+		return readSlideBackground(bg, "layout", this.themeContext(), this.relationships, themePart ? this.opc.relationshipsFor(themePart.partName) : null);
 	}
 	/**
 	* The layout's colour/font context (walked layout → master → theme), resolved once
@@ -2178,6 +2943,14 @@ var Slide = class {
 	get relationships() {
 		return this.presentation.opc.relationshipsFor(this.partName);
 	}
+	/**
+	* The deck's OPC package. Convenience for `presentation.opc`, and the member
+	* {@link ShapeHost} names so a shape can reach a referenced part (an image, a
+	* chart) the same way whether it lives on a slide, a layout, or a master.
+	*/
+	get opc() {
+		return this.presentation.opc;
+	}
 	#themeColors;
 	/**
 	* The slide's resolved theme context (`clrMap` + `clrScheme` + the theme
@@ -2223,6 +2996,22 @@ var Slide = class {
 		this.part.markDirty();
 	}
 	/**
+	* Whether this slide draws the master's non-placeholder shapes
+	* (`p:sld/@showMasterSp`). `xsd:boolean` defaulting to `true`, so an absent
+	* attribute means shown — the same shape as {@link hidden}.
+	*
+	* This is the switch that decides whether {@link SlideMaster.shapes} belongs on
+	* *this* slide. A slide the author gave a full-bleed image or a section divider
+	* usually sets it to `0`, and a renderer that paints the master's band and logo
+	* anyway puts the template's furniture on top of a slide that deliberately hid
+	* it. Placeholders are unaffected: the flag suppresses only the master's
+	* decorative shapes.
+	*/
+	get showMasterSp() {
+		const root = this.part.dom.documentElement;
+		return boolValue(root && attr(root, "showMasterSp")) !== false;
+	}
+	/**
 	* The slide's show transition (`p:transition`), decoded into a typed model, or
 	* `null` when the slide has none. Handles both PowerPoint forms: the bare
 	* `<p:transition>` and the `mc:AlternateContent` wrapper that carries the exact
@@ -2530,16 +3319,7 @@ var Slide = class {
 	* resolve a binding into a group that top-level {@link shapeById} cannot see.
 	*/
 	shapeByIdDeep(id) {
-		const walk = (shapes) => {
-			for (const shape of shapes) {
-				if (shape.id === id) return shape;
-				if (shape instanceof GroupShape) {
-					const found = walk(shape.shapes);
-					if (found) return found;
-				}
-			}
-		};
-		return walk(this.shapes);
+		return findShapeByIdDeep(this.shapes, id);
 	}
 	/** The first top-level shape with the given name (`p:cNvPr/@name`), or `undefined`. */
 	shapeByName(name) {
@@ -2624,6 +3404,34 @@ var Slide = class {
 		return new Picture(pic, this);
 	}
 	/**
+	* Give this slide the speaker notes `text`, and return the resulting
+	* {@link NotesSlide}. A `
+	` starts a new paragraph, matching the write-side
+	* `addNotes`; the runs carry no formatting of their own, so style them
+	* afterwards through {@link notesTextFrame}.
+	*
+	* The counterpart to the read side's `notesText`/`notesTextFrame`/`notesSlide`
+	* getters, and the way to annotate a slide that has **no notes part at all** —
+	* the state an `importSlide` without `{ importNotes: true }` leaves behind, and
+	* the one a `notesTextFrame` edit cannot reach because there is no frame to
+	* hand back. Calling it on a slide that already has notes replaces the body
+	* text and leaves the rest of the part (its geometry, its other two
+	* placeholders) alone.
+	*
+	* Creating the part pulls in what a notes slide must bind to: a `notesMaster`,
+	* of which a presentation may hold at most one. This deck's own is reused when
+	* it has one; otherwise one is installed, bound to a clone of this deck's theme
+	* so it resolves against the destination palette. That is the same
+	* single-master rule `importSlide({ importNotes: true })` and `appendSlides`
+	* follow, so mixing the three cannot produce a second notes master.
+	*/
+	addNotes(text) {
+		const partName = authorNotes(this, text);
+		const part = this.presentation.opc.part(partName);
+		if (!part) throw new InternalError("import/part-went-missing", `Authored notes part went missing: ${partName}`);
+		return new NotesSlide(this.presentation.opc, part);
+	}
+	/**
 	* @internal The slide's shape tree (`p:cSld/p:spTree`), or `null` if absent.
 	* Exposed for cross-slide composition (`Presentation.importShape`).
 	*/
@@ -3005,7 +3813,7 @@ function rescaleTableGrid(graphicFrame, t) {
 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}";
-const textEncoder$2 = new TextEncoder();
+const textEncoder$1 = new TextEncoder();
 /**
 * Copy any table style the restyled slide references from the source
 * `tableStyles.xml` into this deck's (the `remapLiterals` table leg). A restyled
@@ -3046,260 +3854,64 @@ function copySourceTableStyles(dest, sourceOpc, slideRoot) {
 * anything was added.
 */
 function addTableStyles(destList, styles) {
-	const present = new Set(getElements(destList, "a:tblStyle").map((st) => attr(st, "styleId")));
-	let added = false;
-	for (const style of styles) {
-		const id = attr(style, "styleId");
-		if (!id || present.has(id)) continue;
-		destList.appendChild(ownerDocumentOf(destList).importNode(style, true));
-		present.add(id);
-		added = true;
-	}
-	return added;
-}
-/**
-* Copy the source deck's **whole** `tableStyles.xml` into this deck: every
-* `<a:tblStyle>` it defines, plus its `a:tblStyleLst@def` (the default table
-* style). Presentation-level, so a separate traversal from the master/layout copy
-* chain — and whole-deck, since `tableStyles.xml` does not record which style
-* belongs to which master. See `ImportSlideMastersOptions.tableStyles`.
-*
-* Styles union by `styleId` (destination-wins per id, via {@link addTableStyles}),
-* but `def` is **source-wins**: a caller asking for the source's table styling
-* wants its default too, and the destination's `def` is typically a generator stub
-* rather than a deliberate choice. Carrying the styles without the `def` would be
-* the worse half-measure — the standard default GUID is one most templates also
-* define, so a new table would silently resolve to the wrong style rather than
-* visibly to none. Idempotent: a re-call re-adds nothing and re-sets `def` to the
-* same value.
-*/
-function carryTableStyles(dest, sourceOpc) {
-	const sourceList = tableStyleList(sourceOpc);
-	if (!sourceList) return;
-	const destPart = ensureTableStylesPart(dest);
-	const destList = destPart.dom.documentElement;
-	if (!destList) return;
-	let changed = addTableStyles(destList, getElements(sourceList, "a:tblStyle"));
-	const sourceDef = attr(sourceList, "def");
-	if (sourceDef && attr(destList, "def") !== sourceDef) {
-		destList.setAttribute("def", sourceDef);
-		changed = true;
-	}
-	if (changed) destPart.markDirty();
-}
-/** The `a:tblStyleLst` root of a package's `tableStyles.xml`, or `null` when it has none. */
-function tableStyleList(opc) {
-	const part = opc.partsByContentType(TABLE_STYLES_CONTENT_TYPE)[0];
-	return part ? part.dom.documentElement : null;
-}
-/**
-* The deck's `tableStyles.xml` part, creating an empty one (and wiring its
-* `presentation.xml` relationship + content type) when the deck has none.
-*/
-function ensureTableStylesPart(dest) {
-	const existing = dest.opc.partsByContentType(TABLE_STYLES_CONTENT_TYPE)[0];
-	if (existing) return existing;
-	const partName = dest.opc.reservePartNameLike("/ppt/tableStyles.xml");
-	const xml = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\r\n<a:tblStyleLst xmlns:a="${OOXML_NS.a}" def="${TABLE_STYLES_DEFAULT_GUID}"/>`;
-	const part = dest.opc.addPart(partName, TABLE_STYLES_CONTENT_TYPE, textEncoder$2.encode(xml));
-	dest.opc.relationshipsFor(dest.presentationPart.partName).add(TABLE_STYLES_REL, relativePartName(dest.presentationPart.partName, partName));
-	return part;
-}
-//#endregion
-//#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,
-* promoting masters to the front of the id list, allocating ids out of the shared
-* master/layout id space, and emptying a freshly-copied master's layout list.
-*
-* These are the destination-side half of the import machinery -- they read and
-* write only this deck, never a source package and never the copy registry -- so
-* they take a structural {@link DeckTarget} rather than a `Presentation`. The
-* source-side half that drives most of them is `part-copy.ts`.
-*/
-/**
-* Wire a freshly-copied slide master into `presentation.xml`: add a
-* presentation→master relationship and a `p:sldMasterId` entry in
-* `p:sldMasterIdLst`. A master that is reachable only through the
-* slide→layout→master rel chain but absent from `p:sldMasterIdLst` is treated
-* as inactive by renderers, so its background/graphics never paint. No-op when
-* the master is already registered (shared across imports from one source).
-*/
-function registerMaster(dest, masterPartName) {
-	const presPart = dest.presentationPart;
-	const presRels = dest.opc.relationshipsFor(presPart.partName);
-	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", [
-		"p:notesMasterIdLst",
-		"p:handoutMasterIdLst",
-		"p:sldIdLst",
-		"p:sldSz",
-		"p:notesSz",
-		"p:embeddedFontLst",
-		"p:custShowLst",
-		"p:photoAlbum",
-		"p:custDataLst",
-		"p:kinsoku",
-		"p:defaultTextStyle",
-		"p:modifyVerifier",
-		"p:extLst"
-	]);
-	const entry = createElement(presPart.dom, "p:sldMasterId");
-	setAttr(entry, "id", String(nextMasterLayoutId(dest)));
-	setAttr(entry, "r:id", relId);
-	lst.appendChild(entry);
-	presPart.markDirty();
-}
-/**
-* Move the `p:sldMasterId` entries for `masterPartNames` to the front of
-* `p:sldMasterIdLst`, preserving their existing relative order, so the first of
-* them becomes the deck's `Designs(1)` — the theme PowerPoint's Design tab shows.
-* Reorders the id list only; relationships, ids, and all other parts are left as
-* they are. A no-op when the named masters already lead (idempotent re-call).
-*/
-function promoteMasters(dest, masterPartNames) {
-	if (masterPartNames.length === 0) return;
-	const presPart = dest.presentationPart;
-	const root = presPart.dom.documentElement;
-	const lst = root && firstChild(root, "p:sldMasterIdLst");
-	if (!lst) return;
-	const rels = dest.opc.relationshipsFor(presPart.partName);
-	const promote = new Set(masterPartNames);
-	const entries = getElements(lst, "p:sldMasterId");
-	const isPromoted = (entry) => {
-		const relId = attr(entry, "r:id");
-		return relId ? promote.has(rels.resolveTarget(relId)) : false;
-	};
-	const desired = [...entries.filter(isPromoted), ...entries.filter((e) => !isPromoted(e))];
-	if (desired.every((entry, i) => entry === entries[i])) return;
-	for (const entry of desired) lst.appendChild(entry);
-	presPart.markDirty();
-}
-/**
-* The next free id in the presentation-wide slide-master / slide-layout id space.
-*
-* `p:sldMasterId/@id` and every master's `p:sldLayoutId/@id` draw from ONE shared
-* id space (both ST_SlideMasterId/ST_SlideLayoutId, floor 2147483648) and must be
-* unique across the WHOLE presentation, not just within their own list. A duplicate
-* anywhere in this space makes PowerPoint report the file as corrupt on open
-* ("found a problem with content" / 0x80070570), even though LibreOffice silently
-* tolerates it — so an imported master AND each of its layouts must take an id past
-* the max of both the master-id list and every layout-id list. Recomputed per
-* allocation so ids appended earlier in the same import are counted.
-*/
-function nextMasterLayoutId(dest) {
-	let max = 2147483647;
-	const presPart = dest.presentationPart;
-	const root = presPart.dom.documentElement;
-	const masterLst = root && firstChild(root, "p:sldMasterIdLst");
-	if (masterLst) for (const entry of getElements(masterLst, "p:sldMasterId")) {
-		const id = intValue(attr(entry, "id"));
-		if (id !== null && id > max) max = id;
-	}
-	const presRels = dest.opc.relationshipsFor(presPart.partName);
-	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;
-		for (const entry of getElements(layoutLst, "p:sldLayoutId")) {
-			const id = intValue(attr(entry, "id"));
-			if (id !== null && id > max) max = id;
-		}
-	}
-	return max + 1;
-}
-/** Empty a freshly-copied master's `p:sldLayoutIdLst`; copied layouts repopulate it. */
-function clearLayoutIdList(dest, masterPartName) {
-	const masterPart = dest.opc.part(masterPartName);
-	const root = masterPart?.dom.documentElement;
-	const lst = root && firstChild(root, "p:sldLayoutIdLst");
-	if (!masterPart || !lst) return;
-	removeChildrenByQName(lst, ["p:sldLayoutId"]);
-	masterPart.markDirty();
-}
-/**
-* Append a `p:sldLayoutId` entry for `layoutPartName` to `masterPartName`'s
-* `p:sldLayoutIdLst`, adding the master→layout relationship it points at. The
-* destination-side half of linking a copied layout into its copied master; the
-* caller resolves which master that is from the source-side rels.
-*/
-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, relativePartName(masterPartName, layoutPartName)).id;
-	const lst = getOrAddChild(root, "p:sldLayoutIdLst", [
-		"p:transition",
-		"p:timing",
-		"p:hf",
-		"p:txStyles",
-		"p:extLst"
-	]);
-	const entry = createElement(masterPart.dom, "p:sldLayoutId");
-	setAttr(entry, "id", String(nextMasterLayoutId(dest)));
-	setAttr(entry, "r:id", relId);
-	lst.appendChild(entry);
-	masterPart.markDirty();
+	const present = new Set(getElements(destList, "a:tblStyle").map((st) => attr(st, "styleId")));
+	let added = false;
+	for (const style of styles) {
+		const id = attr(style, "styleId");
+		if (!id || present.has(id)) continue;
+		destList.appendChild(ownerDocumentOf(destList).importNode(style, true));
+		present.add(id);
+		added = true;
+	}
+	return added;
 }
-//#endregion
-//#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";
 /**
-* Copy `sourcePartName` (and, recursively, every internal part it references)
-* from `ctx.source` into `ctx.dest`, returning the new partname. Idempotent
-* per source package via the copy registry. Relationship ids are preserved so
-* the copied part body's `r:id`/`r:embed` references stay valid; targets are
-* rewritten to the freshly-allocated partnames. Notes relationships are
-* dropped. A copied `slideMaster` does not drag in all its sibling layouts —
-* each imported `slideLayout` wires itself into the master instead (see
-* {@link linkLayoutIntoMaster}).
+* Copy the source deck's **whole** `tableStyles.xml` into this deck: every
+* `<a:tblStyle>` it defines, plus its `a:tblStyleLst@def` (the default table
+* style). Presentation-level, so a separate traversal from the master/layout copy
+* chain — and whole-deck, since `tableStyles.xml` does not record which style
+* belongs to which master. See `ImportSlideMastersOptions.tableStyles`.
+*
+* Styles union by `styleId` (destination-wins per id, via {@link addTableStyles}),
+* but `def` is **source-wins**: a caller asking for the source's table styling
+* wants its default too, and the destination's `def` is typically a generator stub
+* rather than a deliberate choice. Carrying the styles without the `def` would be
+* the worse half-measure — the standard default GUID is one most templates also
+* define, so a new table would silently resolve to the wrong style rather than
+* visibly to none. Idempotent: a re-call re-adds nothing and re-sets `def` to the
+* same value.
 */
-function copyPart(ctx, sourcePartName) {
-	const existing = ctx.registry.get(sourcePartName);
-	if (existing) return existing;
-	const sourcePart = ctx.source.part(sourcePartName);
-	if (!sourcePart) throw new PackageReadError("package/part-missing", `importSlide: source package has no part ${sourcePartName}`);
-	const newPartName = ctx.dest.opc.reservePartNameLike(sourcePartName);
-	ctx.dest.opc.addPart(newPartName, sourcePart.contentType, sourcePart.bytes);
-	ctx.registry.set(sourcePartName, newPartName);
-	const isMaster = sourcePart.contentType === SLIDE_MASTER_CONTENT_TYPE;
-	const sourceRels = ctx.source.relationshipsFor(sourcePartName);
-	const targetRels = ctx.dest.opc.relationshipsFor(newPartName);
-	for (const rel of sourceRels) {
-		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;
-		}
-		const newTargetPartName = copyPart(ctx, sourceRels.resolveTarget(rel.id));
-		targetRels.addWithId(rel.id, rel.type, relativePartName(newPartName, newTargetPartName));
-	}
-	if (isMaster) {
-		clearLayoutIdList(ctx.dest, newPartName);
-		registerMaster(ctx.dest, newPartName);
+function carryTableStyles(dest, sourceOpc) {
+	const sourceList = tableStyleList(sourceOpc);
+	if (!sourceList) return;
+	const destPart = ensureTableStylesPart(dest);
+	const destList = destPart.dom.documentElement;
+	if (!destList) return;
+	let changed = addTableStyles(destList, getElements(sourceList, "a:tblStyle"));
+	const sourceDef = attr(sourceList, "def");
+	if (sourceDef && attr(destList, "def") !== sourceDef) {
+		destList.setAttribute("def", sourceDef);
+		changed = true;
 	}
-	if (sourcePart.contentType === SLIDE_LAYOUT_CONTENT_TYPE) linkLayoutIntoMaster(ctx, sourceRels, newPartName);
-	return newPartName;
+	if (changed) destPart.markDirty();
+}
+/** The `a:tblStyleLst` root of a package's `tableStyles.xml`, or `null` when it has none. */
+function tableStyleList(opc) {
+	const part = opc.partsByContentType(TABLE_STYLES_CONTENT_TYPE)[0];
+	return part ? part.dom.documentElement : null;
 }
 /**
-* Wire a just-copied layout into its (already-copied) master. Resolves which
-* destination master that is by running the layout's *source* master rel through
-* the copy registry, then hands the destination-side wiring to
-* {@link addLayoutToMaster}. Called once per copied layout, so the master
-* accumulates exactly the imported layouts.
+* The deck's `tableStyles.xml` part, creating an empty one (and wiring its
+* `presentation.xml` relationship + content type) when the deck has none.
 */
-function linkLayoutIntoMaster(ctx, layoutSourceRels, layoutPartName) {
-	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);
+function ensureTableStylesPart(dest) {
+	const existing = dest.opc.partsByContentType(TABLE_STYLES_CONTENT_TYPE)[0];
+	if (existing) return existing;
+	const partName = dest.opc.reservePartNameLike("/ppt/tableStyles.xml");
+	const xml = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\r\n<a:tblStyleLst xmlns:a="${OOXML_NS.a}" def="${TABLE_STYLES_DEFAULT_GUID}"/>`;
+	const part = dest.opc.addPart(partName, TABLE_STYLES_CONTENT_TYPE, textEncoder$1.encode(xml));
+	dest.opc.relationshipsFor(dest.presentationPart.partName).add(TABLE_STYLES_REL, relativePartName(dest.presentationPart.partName, partName));
+	return part;
 }
 //#endregion
 //#region src/read/api/ops/carried-rels.ts
@@ -3325,8 +3937,9 @@ function linkLayoutIntoMaster(ctx, layoutSourceRels, layoutPartName) {
 * @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
+* @param {OwnedScope} [owned] - ownership scope of the thing being carried, so the chart or diagram under a carried shape is copied for it rather than shared with an earlier copy
 */
-function rewriteCarriedRels(node, ctx, sourceRels, destPartName, destRels, relIdMap) {
+function rewriteCarriedRels(node, ctx, sourceRels, destPartName, destRels, relIdMap, owned) {
 	const elements = [];
 	collectElements(node, elements);
 	for (const el of elements) {
@@ -3341,7 +3954,7 @@ function rewriteCarriedRels(node, ctx, sourceRels, destPartName, destRels, relId
 				id: a.value
 			});
 		}
-		for (const { local, id } of refs) setAttr(el, `r:${local}`, carryRel(ctx, sourceRels, id, destPartName, destRels, relIdMap));
+		for (const { local, id } of refs) setAttr(el, `r:${local}`, carryRel(ctx, sourceRels, id, destPartName, destRels, relIdMap, owned));
 	}
 }
 /**
@@ -3352,16 +3965,20 @@ function rewriteCarriedRels(node, ctx, sourceRels, destPartName, destRels, relId
 * @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
+* @param {OwnedScope} [owned] - ownership scope of the carried content, for the parts it owns
 * @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;
+function carryRel(ctx, sourceRels, id, destPartName, destRels, relIdMap, owned) {
 	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);
+	const ownsIt = owned !== void 0 && rel.targetMode !== "External" && !isSharedByPageCopies(rel.type);
+	const key = `${sourceRels.sourcePartName}|${id}`;
+	if (!ownsIt) {
+		const cached = relIdMap.get(key);
+		if (cached) return cached;
+	}
+	const newId = rel.targetMode === "External" ? destRels.add(rel.type, rel.target, "External").id : destRels.add(rel.type, relativePartName(destPartName, copyPart(ctx, sourceRels.resolveTarget(id), ownsIt ? owned : void 0))).id;
+	if (!ownsIt) relIdMap.set(key, newId);
 	return newId;
 }
 //#endregion
@@ -3743,6 +4360,7 @@ function importSlideRebind(dest, ctx, source, sourceSlide, carryGraphics) {
 	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);
+	const owned = newOwnedScope();
 	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") {
@@ -3753,10 +4371,10 @@ function importSlideRebind(dest, ctx, source, sourceSlide, carryGraphics) {
 			targetRels.addWithId(rel.id, rel.type, rel.target, "External");
 			continue;
 		}
-		const newTarget = copyPart(ctx, sourceRels.resolveTarget(rel.id));
+		const newTarget = copyPart(ctx, sourceRels.resolveTarget(rel.id), isSharedByPageCopies(rel.type) ? void 0 : owned);
 		targetRels.addWithId(rel.id, rel.type, relativePartName(newPartName, newTarget));
 	}
-	if (carryGraphics) carryMasterGraphics(dest, ctx, slideRoot, newPartName, sourceSlide.partName);
+	if (carryGraphics) carryMasterGraphics(dest, ctx, slideRoot, newPartName, sourceSlide.partName, owned);
 	return {
 		newPartName,
 		slideRoot,
@@ -3777,8 +4395,9 @@ function importSlideRebind(dest, ctx, source, sourceSlide, carryGraphics) {
 * @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
+* @param {OwnedScope} owned - the page's ownership scope, so a decoration's own parts land in it
 */
-function carryMasterGraphics(dest, ctx, slideRoot, newPartName, slidePartName) {
+function carryMasterGraphics(dest, ctx, slideRoot, newPartName, slidePartName, owned) {
 	const sourceOpc = ctx.source;
 	const layoutPartName = resolveSingleRel(sourceOpc, slidePartName, SLIDE_LAYOUT_REL);
 	const masterPartName = layoutPartName ? resolveSingleRel(sourceOpc, layoutPartName, SLIDE_MASTER_REL) : null;
@@ -3796,7 +4415,7 @@ function carryMasterGraphics(dest, ctx, slideRoot, newPartName, slidePartName) {
 		const sourceRels = sourceOpc.relationshipsFor(partName);
 		for (const deco of decorations) {
 			const imported = doc.importNode(deco, true);
-			rewriteCarriedRels(imported, ctx, sourceRels, newPartName, slideRels, relIdMap);
+			rewriteCarriedRels(imported, ctx, sourceRels, newPartName, slideRels, relIdMap, owned);
 			spTree.insertBefore(imported, anchor);
 		}
 	}
@@ -3819,138 +4438,6 @@ function destinationLayoutPartName(dest) {
 	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.
-*
-* A `notesSlide` is not self-contained: it back-references the slide it annotates and forward-
-* references the deck's notes master. `CT_NotesMasterIdList` allows at most one master per
-* presentation, so a deck that already has one keeps it — the destination's notes styling wins —
-* and a source master is copied only into a deck that has none. That single rule is why both the
-* `Presentation`-to-`Presentation` path and the generator-XML path funnel through
-* `registerNotesMaster`: they differ only in how the *part* comes into being.
-*/
-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();
-/**
-* Carry the source slide's speaker notes onto the just-imported slide (the
-* `importNotes` option). The slide copy itself dropped the `notesSlide` rel, so
-* this copies the source `notesSlide` part into a fresh partname, wires a
-* `slide → notesSlide` rel on the new slide, and rebuilds the copied notesSlide's
-* own relationships:
-*
-* - its `slide` back-rel is repointed at the new slide (`newSlidePartName`) — the
-*   source slide is *not* copied (that would be circular);
-* - its `notesMaster` rel is resolved through {@link ensureNotesMaster}, which
-*   reuses this deck's notesMaster when it has one and copies the source's only
-*   when it has none (a deck may have at most one notesMaster);
-* - any other internal target (media, etc.) is copied via {@link copyPart}.
-*
-* No-op when the source slide has no notes. Content-type registration for the
-* copied parts is handled by `addPart`/{@link copyPart}.
-*/
-function carryNotes(dest, source, ctx, sourceSlidePartName, newSlidePartName) {
-	const sourceSlideRels = source.opc.relationshipsFor(sourceSlidePartName);
-	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, relativePartName(newSlidePartName, newNotesPartName));
-	const notesSourceRels = source.opc.relationshipsFor(sourceNotesPartName);
-	const notesTargetRels = dest.opc.relationshipsFor(newNotesPartName);
-	for (const rel of notesSourceRels) {
-		if (rel.type === "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slide") {
-			notesTargetRels.addWithId(rel.id, SLIDE_REL, relativePartName(newNotesPartName, newSlidePartName));
-			continue;
-		}
-		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, relativePartName(newNotesPartName, notesMaster));
-			continue;
-		}
-		if (rel.targetMode === "External") {
-			notesTargetRels.addWithId(rel.id, rel.type, rel.target, "External");
-			continue;
-		}
-		const newTarget = copyPart(ctx, notesSourceRels.resolveTarget(rel.id));
-		notesTargetRels.addWithId(rel.id, rel.type, relativePartName(newNotesPartName, newTarget));
-	}
-}
-/**
-* Resolve the notesMaster an imported `notesSlide` should bind to, honouring the
-* single-notesMaster-per-presentation rule (`p:notesMasterIdLst` holds 0..1
-* `p:notesMasterId`). If this deck already has a notesMaster it is reused and the
-* source's is *not* copied (the destination's notes styling wins); otherwise the
-* source notesMaster (and, via {@link copyPart}, its theme) is copied and
-* registered in `presentation.xml`. Returns the destination notesMaster partname.
-*/
-function ensureNotesMaster(dest, ctx, sourceNotesMasterPartName) {
-	const presPart = dest.presentationPart;
-	const presRels = dest.opc.relationshipsFor(presPart.partName);
-	const existing = presRels.byType(NOTES_MASTER_REL)[0];
-	if (existing) return presRels.resolveTarget(existing.id);
-	return registerNotesMaster(dest, copyPart(ctx, sourceNotesMasterPartName));
-}
-/**
-* Wire an already-added notesMaster part into `presentation.xml`: a `notesMaster`
-* relationship plus the single `p:notesMasterId` entry that `CT_NotesMasterIdList`
-* allows. Returns the partname, so callers can use it as a rel target.
-*
-* Split out of {@link ensureNotesMaster} because the two ways a notesMaster arrives
-* — copied from another `Presentation`, or authored by a generator and injected by
-* {@link Presentation.appendSlides} — differ only in how the *part* is created, not in how it is
-* registered.
-*/
-function registerNotesMaster(dest, notesMasterPartName) {
-	const presPart = dest.presentationPart;
-	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", [
-		"p:handoutMasterIdLst",
-		"p:sldIdLst",
-		"p:sldSz",
-		"p:notesSz",
-		"p:embeddedFontLst",
-		"p:custShowLst",
-		"p:photoAlbum",
-		"p:custDataLst",
-		"p:kinsoku",
-		"p:defaultTextStyle",
-		"p:modifyVerifier",
-		"p:extLst"
-	]);
-	removeChildrenByQName(lst, ["p:notesMasterId"]);
-	const entry = createElement(presPart.dom, "p:notesMasterId");
-	setAttr(entry, "r:id", relId);
-	lst.appendChild(entry);
-	presPart.markDirty();
-	return notesMasterPartName;
-}
-/**
-* Resolve the notesMaster an *appended* slide's notes should bind to. Same
-* single-notesMaster rule as {@link ensureNotesMaster}: this deck's own wins when it
-* has one, so the destination's notes styling is preserved and `master.xml` is
-* discarded. Otherwise the generator's notes master is installed, together with the
-* theme its `.rels` requires (the normal write path emits that as `theme2.xml`).
-*/
-function ensureNotesMasterFromXml(dest, master) {
-	const presPart = dest.presentationPart;
-	const presRels = dest.opc.relationshipsFor(presPart.partName);
-	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));
-	const themePartName = dest.opc.reservePartNameLike("/ppt/theme/theme1.xml");
-	dest.opc.addPart(themePartName, THEME_CONTENT_TYPE, textEncoder$1.encode(master.themeXml));
-	dest.opc.relationshipsFor(masterPartName).add(THEME_REL, relativePartName(masterPartName, themePartName));
-	return registerNotesMaster(dest, masterPartName);
-}
-//#endregion
 //#region src/read/api/ops/prune.ts
 /**
 * Orphan pruning after a part stops being referenced.
@@ -4068,6 +4555,9 @@ function rescalePartGeometry(dest, rescaledParts, partName, transform) {
 */
 const HYPERLINK_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink";
 const CHART_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/chart";
+const CHARTEX_REL = "http://schemas.microsoft.com/office/2014/relationships/chartEx";
+const CHART_STYLE_REL = "http://schemas.microsoft.com/office/2011/relationships/chartStyle";
+const CHART_COLOR_STYLE_REL = "http://schemas.microsoft.com/office/2011/relationships/chartColorStyle";
 const PACKAGE_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/package";
 const AUDIO_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/audio";
 const VIDEO_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/video";
@@ -4075,6 +4565,9 @@ const MS_MEDIA_REL = "http://schemas.microsoft.com/office/2007/relationships/med
 const SLIDE_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.presentationml.slide+xml";
 const NOTES_SLIDE_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.presentationml.notesSlide+xml";
 const CHART_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.drawingml.chart+xml";
+const CHARTEX_CONTENT_TYPE = "application/vnd.ms-office.chartex+xml";
+const CHART_STYLE_CONTENT_TYPE = "application/vnd.ms-office.chartstyle+xml";
+const CHART_COLOR_STYLE_CONTENT_TYPE = "application/vnd.ms-office.chartcolorstyle+xml";
 const XLSX_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
 /** Content type of the main part in an editable `.pptx` package. */
 const PRESENTATION_MAIN_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.presentationml.presentation.main+xml";
@@ -4304,12 +4797,17 @@ var Presentation = class Presentation {
 	* Duplicate the slide at `index` and insert the copy at `options.at` (deck
 	* order; `0` = first), defaulting to appending at the end when `at` is omitted
 	* or out of range. Returns the new slide. The new slide part copies the source
-	* bytes verbatim and shares the source's relationship targets (layout, images,
-	* …) by copying its `.rels`; a new presentation→slide relationship and a
-	* `p:sldId` entry are wired up. Marks the presentation part dirty.
+	* bytes verbatim and shares the source's deck-wide relationship targets
+	* (layout, images, media) by copying its `.rels`; a new presentation→slide
+	* relationship and a `p:sldId` entry are wired up. Marks the presentation part
+	* dirty.
 	*
-	* Note: relationships are copied as-is, so a source slide that owns a
-	* one-to-one part (e.g. a notes slide) would end up shared with the clone.
+	* What the source page *owns* is copied rather than shared: its notes slide,
+	* charts, SmartArt diagrams and OLE embeddings, each with the subtree under it
+	* (a chart's embedded workbook comes along; the image inside its user-shapes
+	* drawing stays shared). PowerPoint refuses to open a deck where two slides
+	* resolve to one chart or diagram, so this is not tidiness — see
+	* `page-owned.ts` for the rule and the evidence behind it.
 	*/
 	cloneSlide(index, options = {}) {
 		const source = this.slides[index];
@@ -4318,8 +4816,10 @@ var Presentation = class Presentation {
 		const sourcePart = source.part;
 		const newPartName = opc.reservePartNameLike(sourcePart.partName);
 		const newPart = opc.addPart(newPartName, sourcePart.contentType, sourcePart.bytes);
-		const sourceRels = opc.part(relsPartNameFor(sourcePart.partName));
-		if (sourceRels) opc.addPart(relsPartNameFor(newPartName), sourceRels.contentType, sourceRels.bytes);
+		const sourceRels = opc.relationshipsFor(sourcePart.partName);
+		const cloneRels = opc.relationshipsFor(newPartName);
+		for (const rel of sourceRels) cloneRels.addWithId(rel.id, rel.type, rel.target, rel.targetMode);
+		duplicateOwnedTargets(opc, sourcePart.partName, newPartName);
 		return this.#insertSlidePart(newPart, options.at);
 	}
 	/**
@@ -4372,7 +4872,10 @@ var Presentation = class Presentation {
 	* Only the layout(s) actually used by imported slides are copied; the imported
 	* master's `p:sldLayoutIdLst` is pruned to exactly those, mirroring how
 	* PowerPoint's "Reuse Slides" brings a slide across. Parts shared by repeated
-	* imports from the same source deck are copied once and reused.
+	* imports from the same source deck are copied once and reused — every part
+	* except the page itself. Importing the same source slide twice yields two
+	* independent copies over one shared layout/master/theme, which is what lets a
+	* deck show one page twice (verbatim, then edited).
 	*
 	* With `{ theme: 'preserve' }` the slide's source theme is instead *flattened*
 	* into the slide XML and the slide is bound to this deck's existing
@@ -4397,7 +4900,7 @@ var Presentation = class Presentation {
 		}
 		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 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 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) : copySlidePart(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);
@@ -4407,6 +4910,140 @@ var Presentation = class Presentation {
 		return slide;
 	}
 	/**
+	* Import selected pages from one or more loaded source presentations as one
+	* batch. Each imported page lands at its `outputIndex` in the complete
+	* destination slide list after the batch, and the returned array is parallel
+	* to `requests` — `result[i]` is the page `requests[i]` asked for, whatever
+	* order the output positions were given in.
+	*
+	* Everything is checked before a single byte of this deck moves: every request
+	* names an existing source page, final output positions are unique, each source
+	* has this deck's slide size, and a read-only dry run of the copy proves every
+	* part it would reach is present. A batch therefore either applies in full or
+	* leaves this deck byte-identical, where a per-page loop of
+	* {@link importSlide} can leave a half-stitched deck behind.
+	*
+	* The batch also decides what a `slide → slide` link means: an internal link
+	* on a selected page must target another **selected** page (or one this deck
+	* already contains via an earlier import from that source), and is rewritten
+	* to the fresh partname — importing page 3 of 10 does not drag pages 1–2
+	* across as dependencies, and never strands the link. This mirrors
+	* `appendSlides`' `import/unresolved-slide-link`, which the write side already
+	* enforces for generator decks.
+	*
+	* One request is one output page, so naming the same source page in several
+	* requests is how you ask for several independent copies of it — the page part
+	* is the one thing an import never shares, exactly as in {@link importSlide}.
+	* Everything under it (layout, master, theme, media) is still copied once and
+	* shared. Where such a page is the target of a `slide → slide` link, the link
+	* resolves to one of its copies: pages duplicated together are copied in
+	* lockstep and link to their round-mates, and a link into a page requested only
+	* once always lands on that single copy.
+	*
+	* Speaker notes travel per request: `{ importNotes: true }` carries that page's
+	* `notesSlide` part across, wired to the new page and bound to a single
+	* `notesMaster` under the same 0..1 rule {@link importSlide} and
+	* {@link appendSlides} follow — the destination's own master wins when it has
+	* one. Notes are part of the up-front dry run too, so a batch that would fail
+	* carrying them is refused with the deck still byte-identical. A page named in
+	* several requests gets its own copy of its notes each time, as of everything
+	* else that page owns.
+	*
+	* Scope: pages come across under `'copy'` theme semantics (their own layout →
+	* master → theme subgraph, shared parts deduped via the copy registry).
+	* Embedded fonts are not carried, and sizes must match, since there is no batch
+	* spelling for `embedFonts` or `rescale`. Use {@link importSlide} when you need
+	* either of those.
+	*/
+	importSlides(requests) {
+		const resolved = requests.map((request, requestIndex) => {
+			if (!Number.isInteger(request.sourceIndex) || request.sourceIndex < 0) throw new InvalidOptionError("slide/index-out-of-range", `importSlides: sourceIndex must be a non-negative integer; received ${request.sourceIndex}`);
+			if (!Number.isInteger(request.outputIndex) || request.outputIndex < 0) throw new InvalidOptionError("import/output-index-out-of-range", `importSlides: outputIndex must be a non-negative integer; received ${request.outputIndex}`);
+			const sourceSlide = request.source.slides[request.sourceIndex];
+			if (!sourceSlide) throw new InvalidOptionError("slide/index-out-of-range", `importSlides: no slide at index ${request.sourceIndex} to import`);
+			return {
+				...request,
+				requestIndex,
+				sourceSlide
+			};
+		});
+		if (resolved.length === 0) return [];
+		if (!this.presentationPart.dom.documentElement) throw new PackageReadError("package/part-has-no-root", "presentation.xml has no document element to insert slides into");
+		const finalSlideCount = this.slides.length + resolved.length;
+		const selectedPages = /* @__PURE__ */ new Map();
+		const notesPages = /* @__PURE__ */ new Map();
+		for (const request of resolved) {
+			let pages = selectedPages.get(request.source.opc);
+			if (!pages) {
+				pages = /* @__PURE__ */ new Set();
+				selectedPages.set(request.source.opc, pages);
+			}
+			pages.add(request.sourceSlide.partName);
+			if (!request.importNotes) continue;
+			let withNotes = notesPages.get(request.source.opc);
+			if (!withNotes) {
+				withNotes = /* @__PURE__ */ new Set();
+				notesPages.set(request.source.opc, withNotes);
+			}
+			withNotes.add(request.sourceSlide.partName);
+		}
+		const target = this.slideSize;
+		const outputIndexes = /* @__PURE__ */ new Set();
+		for (const request of resolved) {
+			if (request.outputIndex >= finalSlideCount) throw new InvalidOptionError("import/output-index-out-of-range", `importSlides: outputIndex ${request.outputIndex} is outside the final slide list of ${finalSlideCount} slides`);
+			if (outputIndexes.has(request.outputIndex)) throw new InvalidOptionError("import/output-index-conflict", `importSlides: outputIndex ${request.outputIndex} is requested more than once`);
+			outputIndexes.add(request.outputIndex);
+			const incoming = request.source.slideSize;
+			if (!target || !incoming || target.widthEmu !== incoming.widthEmu || target.heightEmu !== incoming.heightEmu) {
+				const fmt = (size) => size ? `${size.widthEmu}×${size.heightEmu} EMU` : "unknown";
+				throw new InvalidOptionError("import/slide-size-mismatch", `importSlides requires equal slide sizes; target is ${fmt(target)}, source is ${fmt(incoming)}`);
+			}
+		}
+		const copyMaster = this.opc.relationshipsFor(this.presentationPart.partName).byType(NOTES_MASTER_REL).length === 0;
+		for (const [sourceOpc, pages] of selectedPages) checkSelectionCopyable(sourceOpc, this.#importContext(sourceOpc).registry, pages, {
+			pages: notesPages.get(sourceOpc) ?? /* @__PURE__ */ new Set(),
+			copyMaster
+		});
+		const destinationsBySource = /* @__PURE__ */ new Map();
+		const planned = resolved.map((request) => {
+			let destinations = destinationsBySource.get(request.source.opc);
+			if (!destinations) {
+				destinations = /* @__PURE__ */ new Map();
+				destinationsBySource.set(request.source.opc, destinations);
+			}
+			const sourcePart = request.sourceSlide.part;
+			const newPartName = this.opc.reservePartNameLike(request.sourceSlide.partName);
+			const destPart = this.opc.addPart(newPartName, sourcePart.contentType, sourcePart.bytes);
+			const reserved = destinations.get(request.sourceSlide.partName);
+			if (reserved) reserved.push(newPartName);
+			else destinations.set(request.sourceSlide.partName, [newPartName]);
+			return {
+				...request,
+				destPart
+			};
+		});
+		for (const [sourceOpc, destinations] of destinationsBySource) {
+			const base = this.#importContext(sourceOpc);
+			const rounds = Math.max(...[...destinations.values()].map((reserved) => reserved.length));
+			for (let round = 0; round < rounds; round++) {
+				const plan = /* @__PURE__ */ new Map();
+				for (const [sourcePartName, reserved] of destinations) plan.set(sourcePartName, reserved[round] ?? reserved[0]);
+				const ctx = {
+					...base,
+					selection: { destinations: plan }
+				};
+				for (const [sourcePartName, reserved] of destinations) if (round < reserved.length) copyPart(ctx, sourcePartName);
+			}
+		}
+		for (const request of planned) {
+			if (!request.importNotes) continue;
+			carryNotes(this, request.source, this.#importContext(request.source.opc), request.sourceSlide.partName, request.destPart.partName);
+		}
+		const added = [];
+		for (const request of [...planned].sort((left, right) => left.outputIndex - right.outputIndex)) added[request.requestIndex] = this.#insertSlidePart(request.destPart, request.outputIndex);
+		return added;
+	}
+	/**
 	* Graft slide master(s) from another open package into this one and return what
 	* was copied. Unlike {@link importSlide} — which brings a master across only as
 	* the dependency of an imported *slide* and prunes it to the one layout that
@@ -4516,7 +5153,10 @@ var Presentation = class Presentation {
 	*
 	* Charts and internal slide-to-slide hyperlinks are carried across: chart parts
 	* (chart XML + `.rels` + embedded workbook) are injected under fresh names, and a
-	* `slide:N` link is repointed at the Nth appended slide's new partname.
+	* `slide:N` link is repointed at the Nth appended slide's new partname. A chartEx
+	* (Office 2016 — waterfall, funnel, treemap, ...) chart carries too, as its own
+	* `chartEx{N}.xml` part behind the MS chartEx rel, with the style and color-style
+	* sidecars PowerPoint requires alongside it.
 	*
 	* The generator's presentation-level embedded fonts (`pptx.embedFont`) are also
 	* carried into this deck and merged into its `p:embeddedFontLst`, de-duped by
@@ -4612,13 +5252,23 @@ var Presentation = class Presentation {
 				for (const h of slide.notes.hyperlinks) notesRels.addWithId(`rId${h.rId}`, HYPERLINK_REL, h.target, "External");
 			}
 			for (const c of slide.charts) {
-				const chartPartName = this.opc.reservePartNameLike("/ppt/charts/chart1.xml");
-				this.opc.addPart(chartPartName, CHART_CONTENT_TYPE, textEncoder.encode(c.chartXml));
+				const isChartEx = c.chartEx !== void 0;
+				const chartPartName = this.opc.reservePartNameLike(isChartEx ? "/ppt/charts/chartEx1.xml" : "/ppt/charts/chart1.xml");
+				this.opc.addPart(chartPartName, isChartEx ? CHARTEX_CONTENT_TYPE : CHART_CONTENT_TYPE, textEncoder.encode(c.chartXml));
 				const embeddingPartName = this.opc.reservePartNameLike("/ppt/embeddings/Microsoft_Excel_Worksheet1.xlsx");
 				this.opc.contentTypes.ensureDefault("xlsx", XLSX_CONTENT_TYPE);
 				this.opc.addPart(embeddingPartName, XLSX_CONTENT_TYPE, c.embeddingBytes);
-				this.opc.relationshipsFor(chartPartName).addWithId("rId1", PACKAGE_REL, relativePartName(chartPartName, embeddingPartName));
-				rels.addWithId(`rId${c.rId}`, CHART_REL, relativePartName(partName, chartPartName));
+				const chartRels = this.opc.relationshipsFor(chartPartName);
+				chartRels.addWithId("rId1", PACKAGE_REL, relativePartName(chartPartName, embeddingPartName));
+				if (c.chartEx) {
+					const colorsPartName = this.opc.reservePartNameLike("/ppt/charts/colors1.xml");
+					this.opc.addPart(colorsPartName, CHART_COLOR_STYLE_CONTENT_TYPE, textEncoder.encode(c.chartEx.colorsXml));
+					chartRels.addWithId("rId2", CHART_COLOR_STYLE_REL, relativePartName(chartPartName, colorsPartName));
+					const stylePartName = this.opc.reservePartNameLike("/ppt/charts/style1.xml");
+					this.opc.addPart(stylePartName, CHART_STYLE_CONTENT_TYPE, textEncoder.encode(c.chartEx.styleXml));
+					chartRels.addWithId("rId3", CHART_STYLE_REL, relativePartName(chartPartName, stylePartName));
+				}
+				rels.addWithId(`rId${c.rId}`, isChartEx ? CHARTEX_REL : CHART_REL, relativePartName(partName, chartPartName));
 			}
 			for (const link of slide.slideLinks) {
 				const targetPartName = partBySourceNumber.get(link.sourceSlideNumber);
@@ -4701,7 +5351,7 @@ var Presentation = class Presentation {
 		const result = [];
 		for (const shapeEl of sourceElements) {
 			const imported = targetDoc.importNode(shapeEl, true);
-			rewriteCarriedRels(imported, importCtx, sourceRels, target.partName, targetRels, relIdMap);
+			rewriteCarriedRels(imported, importCtx, sourceRels, target.partName, targetRels, relIdMap, newOwnedScope());
 			if (ctx) {
 				const holder = createElement(targetDoc, "p:spTree");
 				holder.appendChild(imported);
@@ -4763,7 +5413,13 @@ var Presentation = class Presentation {
 	*/
 	#insertSlidePart(newPart, at) {
 		const presPart = this.presentationPart;
-		const relId = this.opc.relationshipsFor(presPart.partName).add(SLIDE_REL, relativePartName(presPart.partName, newPart.partName)).id;
+		const presRels = this.opc.relationshipsFor(presPart.partName);
+		for (const rel of presRels) {
+			if (rel.type !== "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slide" || rel.targetMode === "External") continue;
+			if (presRels.resolveTarget(rel.id) !== newPart.partName) continue;
+			throw new InternalError("slide/part-already-in-deck", `Slide part ${newPart.partName} is already in this deck's slide list; a second p:sldId entry for it would make the package unopenable`);
+		}
+		const relId = presRels.add(SLIDE_REL, relativePartName(presPart.partName, newPart.partName)).id;
 		const root = presPart.dom.documentElement;
 		if (!root) throw new PackageReadError("package/part-has-no-root", "presentation.xml has no document element to append a slide to");
 		const sldIdLst = getOrAddChild(root, "p:sldIdLst", PRESENTATION_SLD_ID_LST_SUCCESSORS);
@@ -4797,4 +5453,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-BP1B8PCF.js.map
+//# sourceMappingURL=presentation-DeKTJGHf.js.map