@shbernal/ts-pptx 0.0.1

package/dist/presentation-B0JWdTN1.js

@@ -0,0 +1,4286 @@
+import { i as PackageReadError, n as InvalidOptionError, o as UnsupportedFeatureError, t as InternalError } from "./errors-DGE9zh3U.js";
+import { d as emuToInches } from "./units-B-JUKwCS.js";
+import { i as FONT_REL_TYPE, n as FONT_DATA_CONTENT_TYPE, r as FONT_DATA_EXTENSION, t as EMBEDDED_FONT_SLOTS } from "./embedded-fonts-MaynAHa9.js";
+import { ZipWriter, readZip } from "./zip.js";
+import { $ as escapeXmlAttribute, A as resolveMasterColorContext, B as restyleSlide, D as readGradientFill, E as readPictureFill, F as flattenShape, G as relsPartNameFor, H as partNameExtension, I as flattenSlide, J as OOXML_NS, K as resolveRelativePartName, L as parseClrMap, M as resolveSlideColorContext, N as resolveSlideThemeParts, O as resolveColorElement, Q as createElement, R as parseClrScheme, T as TextFrame, U as partNameToZipPath, V as styleRefFill, W as relativePartName, X as boolValue, Y as attr, Z as childElements, at as intValue, b as Picture, c as wrapShapeElement, ct as removeAttr, dt as setAttr, et as firstChild, it as insertInOrder, j as resolveNotesColorContext, k as resolveLayoutColorContext, l as GraphicFrame, lt as removeChildrenByQName, n as buildShapes, nt as getElements, ot as ownerDocumentOf, q as zipPathToPartName, rt as getOrAddChild, st as parseXml, t as GroupShape, tt as firstChildElement, ut as serializeXml, x as AutoShape, z as remapLiteralColors } from "./shapes-BZU8UTW2.js";
+//#region src/read/opc/content-types.ts
+/**
+* Overlay over `[Content_Types].xml`, used to resolve part content types at
+* load and to register new ones when parts are added. While clean, the original
+* bytes pass through verbatim on save (byte-identical); once a mutation marks it
+* dirty, `OpcPackage.save()` writes `serialize()` instead.
+*/
+var ContentTypes = class ContentTypes {
+	#defaults = /* @__PURE__ */ new Map();
+	#overrides = /* @__PURE__ */ new Map();
+	#dirty = false;
+	static parse(xml) {
+		const contentTypes = new ContentTypes();
+		const types = parseXml(xml).documentElement;
+		if (!types || types.localName !== "Types") throw new PackageReadError("package/content-types-invalid-root", "[Content_Types].xml: expected <Types> root element");
+		for (const element of getElements(types, "ct:Default")) {
+			const extension = element.getAttribute("Extension");
+			const contentType = element.getAttribute("ContentType");
+			if (!extension || !contentType) throw new PackageReadError("package/content-types-entry-incomplete", "[Content_Types].xml: <Default> missing Extension or ContentType");
+			contentTypes.#defaults.set(extension.toLowerCase(), contentType);
+		}
+		for (const element of getElements(types, "ct:Override")) {
+			const partName = element.getAttribute("PartName");
+			const contentType = element.getAttribute("ContentType");
+			if (!partName || !contentType) throw new PackageReadError("package/content-types-entry-incomplete", "[Content_Types].xml: <Override> missing PartName or ContentType");
+			contentTypes.#overrides.set(partName, contentType);
+		}
+		return contentTypes;
+	}
+	/** Exact `Override` match first, else `Default` by lowercased extension. */
+	contentTypeFor(partName) {
+		return this.#overrides.get(partName) ?? this.#defaults.get(partNameExtension(partName));
+	}
+	/** True once a registration changed the overlay; `serialize()` is then authoritative. */
+	get isDirty() {
+		return this.#dirty;
+	}
+	/**
+	* Ensure `partName` resolves to `contentType`, adding the minimum needed.
+	* A no-op when an existing `Default`/`Override` already resolves it to the
+	* same type; otherwise an `Override` is added (always valid, never conflicts
+	* with a differing `Default`).
+	*/
+	ensureRegistered(partName, contentType) {
+		if (this.contentTypeFor(partName) === contentType) return;
+		this.#overrides.set(partName, contentType);
+		this.#dirty = true;
+	}
+	/**
+	* Drop the `Override` for `partName` if present (e.g. when a part is removed).
+	* `Default` rules by extension are left untouched — they may still serve other
+	* parts. Marks the overlay dirty when something was removed.
+	*/
+	removeOverride(partName) {
+		if (this.#overrides.delete(partName)) this.#dirty = true;
+	}
+	/** Register a `Default` content type for a (lowercased) extension if absent. */
+	ensureDefault(extension, contentType) {
+		const ext = extension.toLowerCase();
+		if (this.#defaults.get(ext) === contentType) return;
+		this.#defaults.set(ext, contentType);
+		this.#dirty = true;
+	}
+	serialize() {
+		const lines = ["<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>", "<Types xmlns=\"http://schemas.openxmlformats.org/package/2006/content-types\">"];
+		for (const [extension, contentType] of this.#defaults) lines.push(`<Default Extension="${escapeXmlAttribute(extension)}" ContentType="${escapeXmlAttribute(contentType)}"/>`);
+		for (const [partName, contentType] of this.#overrides) lines.push(`<Override PartName="${escapeXmlAttribute(partName)}" ContentType="${escapeXmlAttribute(contentType)}"/>`);
+		lines.push("</Types>");
+		return lines.join("");
+	}
+};
+//#endregion
+//#region src/read/opc/part.ts
+const textDecoder$1 = new TextDecoder("utf-8");
+const textEncoder$4 = new TextEncoder();
+const XML_DECLARATION_RE = /^\uFEFF?<\?xml[^>]*\?>\s*/;
+/**
+* One OPC part. Holds the original bytes from the zip for its whole life;
+* parses to a DOM only on demand; serializes back to the original bytes
+* unless something mutated the DOM and called `markDirty()`.
+*
+* Untouched parts therefore round-trip byte-identically.
+*/
+var Part = class {
+	partName;
+	contentType;
+	#bytes;
+	#dom = null;
+	#dirty = false;
+	constructor(partName, contentType, bytes) {
+		this.partName = partName;
+		this.contentType = contentType;
+		this.#bytes = bytes;
+	}
+	/** Whether this part's body is XML (by content type). */
+	get isXmlPart() {
+		return this.contentType.endsWith("+xml") || this.contentType === "application/xml" || this.contentType === "text/xml";
+	}
+	/** True once the body has been materialized as a DOM. */
+	get isParsed() {
+		return this.#dom !== null;
+	}
+	/** The original bytes from the package. Do not mutate. */
+	get bytes() {
+		return this.#bytes;
+	}
+	/**
+	* Lazily parsed DOM for XML parts. Parsing alone does not mark the part
+	* dirty; call `markDirty()` after mutating the tree.
+	*/
+	get dom() {
+		if (!this.isXmlPart) throw new InvalidOptionError("part/not-xml", `Part ${this.partName} (${this.contentType}) is not an XML part and has no DOM`);
+		if (!this.#dom) this.#dom = parseXml(textDecoder$1.decode(this.#bytes));
+		return this.#dom;
+	}
+	/** Call after mutating the DOM so `serialize()` reserializes this part. */
+	markDirty() {
+		if (!this.isXmlPart) throw new InvalidOptionError("part/not-xml", `Part ${this.partName} (${this.contentType}) is not an XML part and cannot be marked dirty`);
+		this.#dirty = true;
+	}
+	get isDirty() {
+		return this.#dirty;
+	}
+	/**
+	* Bytes to write on save: the original bytes when clean (byte-identical),
+	* the serialized DOM when dirty (semantically equivalent, schema-valid).
+	*/
+	serialize() {
+		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);
+	}
+};
+//#endregion
+//#region src/read/opc/relationships.ts
+/**
+* Overlay over one `.rels` part, keyed by relationship id. While clean, the
+* `.rels` bytes pass through verbatim on save (byte-identical); once `add()`
+* (or another mutation) marks it dirty, `OpcPackage.save()` writes
+* `serialize()` into the owning `.rels` part instead.
+*/
+var Relationships = class Relationships {
+	/** Partname of the part owning these relationships ('/' for package-level). */
+	sourcePartName;
+	#byId = /* @__PURE__ */ new Map();
+	#dirty = false;
+	constructor(sourcePartName) {
+		this.sourcePartName = sourcePartName;
+	}
+	/**
+	* @param xml body of the `.rels` part
+	* @param sourcePartName partname of the owning part ('/' for `/_rels/.rels`)
+	*/
+	static parse(xml, sourcePartName) {
+		const relationships = new Relationships(sourcePartName);
+		const root = parseXml(xml).documentElement;
+		if (!root || root.localName !== "Relationships") throw new PackageReadError("package/relationships-invalid-root", `Relationships of ${sourcePartName}: expected <Relationships> root element`);
+		for (const element of getElements(root, "pr:Relationship")) {
+			const id = element.getAttribute("Id");
+			const type = element.getAttribute("Type");
+			const target = element.getAttribute("Target");
+			if (!id || !type || !target) throw new PackageReadError("package/relationship-incomplete", `Relationships of ${sourcePartName}: <Relationship> missing Id, Type, or Target`);
+			const targetModeAttribute = element.getAttribute("TargetMode");
+			const targetMode = targetModeAttribute === "Internal" || targetModeAttribute === "External" ? targetModeAttribute : void 0;
+			if (targetModeAttribute !== null && targetMode === void 0) throw new PackageReadError("package/relationship-invalid-target-mode", `Relationships of ${sourcePartName}: invalid TargetMode "${targetModeAttribute}" on ${id}`);
+			const relationship = {
+				id,
+				type,
+				target
+			};
+			if (targetMode) relationship.targetMode = targetMode;
+			if (relationships.#byId.has(id)) throw new PackageReadError("package/duplicate-relationship-id", `Relationships of ${sourcePartName}: duplicate relationship id ${id}`);
+			relationships.#byId.set(id, relationship);
+		}
+		return relationships;
+	}
+	/** Empty relationship set (for parts that have no `.rels`). */
+	static empty(sourcePartName) {
+		return new Relationships(sourcePartName);
+	}
+	get size() {
+		return this.#byId.size;
+	}
+	/** True once a relationship was added/changed; `serialize()` is then authoritative. */
+	get isDirty() {
+		return this.#dirty;
+	}
+	/**
+	* Add a relationship and return it. Allocates an id `rId<n>` with `n` one
+	* past the highest existing numeric id. `target` is relative to the source
+	* part's directory for internal targets (e.g. `../media/image1.png`), or an
+	* absolute URI for external ones. Marks this set dirty.
+	*/
+	add(type, target, targetMode) {
+		let max = 0;
+		for (const id of this.#byId.keys()) {
+			const match = /^rId(\d+)$/.exec(id);
+			if (match) max = Math.max(max, Number(match[1]));
+		}
+		const id = `rId${max + 1}`;
+		const relationship = {
+			id,
+			type,
+			target
+		};
+		if (targetMode) relationship.targetMode = targetMode;
+		this.#byId.set(id, relationship);
+		this.#dirty = true;
+		return relationship;
+	}
+	/**
+	* Add a relationship under a caller-chosen id and return it. Used when
+	* rebuilding a copied part's relationships across a package boundary: keeping
+	* each source id lets the copied part body's `r:id`/`r:embed` references stay
+	* valid without rewriting the body. Throws if the id is already present.
+	* Marks this set dirty.
+	*/
+	addWithId(id, type, target, targetMode) {
+		if (this.#byId.has(id)) throw new InvalidOptionError("relationship/duplicate-id", `Relationships of ${this.sourcePartName}: duplicate relationship id ${id}`);
+		const relationship = {
+			id,
+			type,
+			target
+		};
+		if (targetMode) relationship.targetMode = targetMode;
+		this.#byId.set(id, relationship);
+		this.#dirty = true;
+		return relationship;
+	}
+	/**
+	* Remove the relationship with `id` and return whether one was present. Used
+	* when a referenced part is deleted (e.g. removing a slide drops the
+	* presentation→slide relationship). Marks this set dirty when it removes one.
+	*/
+	remove(id) {
+		const removed = this.#byId.delete(id);
+		if (removed) this.#dirty = true;
+		return removed;
+	}
+	get(id) {
+		return this.#byId.get(id);
+	}
+	byType(type) {
+		return [...this.#byId.values()].filter((relationship) => relationship.type === type);
+	}
+	[Symbol.iterator]() {
+		return this.#byId.values();
+	}
+	/** Resolve an internal relationship's target to an absolute partname. */
+	resolveTarget(id) {
+		const relationship = this.#byId.get(id);
+		if (!relationship) throw new InvalidOptionError("relationship/not-found", `Relationships of ${this.sourcePartName}: no relationship with id ${id}`);
+		if (relationship.targetMode === "External") throw new InvalidOptionError("relationship/external-has-no-partname", `Relationships of ${this.sourcePartName}: ${id} is External (${relationship.target}) and has no partname`);
+		return resolveRelativePartName(this.sourcePartName, relationship.target);
+	}
+	serialize() {
+		const lines = ["<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>", "<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">"];
+		for (const { id, type, target, targetMode } of this.#byId.values()) {
+			const mode = targetMode ? ` TargetMode="${targetMode}"` : "";
+			lines.push(`<Relationship Id="${escapeXmlAttribute(id)}" Type="${escapeXmlAttribute(type)}" Target="${escapeXmlAttribute(target)}"${mode}/>`);
+		}
+		lines.push("</Relationships>");
+		return lines.join("");
+	}
+};
+//#endregion
+//#region src/read/opc/package.ts
+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();
+/**
+* An OPC package loaded from `.pptx` bytes.
+*
+* Fidelity contract: parts that are never mutated (`Part.markDirty()`) are
+* written back byte-identically by `save()`. Whole-zip byte-identity is not
+* promised — zip metadata and compression may differ — but part bodies, the
+* part-name set, and part order are preserved.
+*/
+var OpcPackage = class OpcPackage {
+	/** All parts, keyed by partname (e.g. `/ppt/slides/slide1.xml`), in original zip order. */
+	#parts;
+	/** Content-type resolution + registration overlay. */
+	contentTypes;
+	#contentTypesBytes;
+	#relationshipsCache = /* @__PURE__ */ new Map();
+	constructor(parts, contentTypes, contentTypesBytes) {
+		this.#parts = parts;
+		this.contentTypes = contentTypes;
+		this.#contentTypesBytes = contentTypesBytes;
+	}
+	/** All parts, keyed by partname, in zip/add order. */
+	get parts() {
+		return this.#parts;
+	}
+	static async load(input) {
+		const entries = await readZip(input);
+		const contentTypesBytes = entries.get(CONTENT_TYPES_ZIP_PATH);
+		if (!contentTypesBytes) throw new PackageReadError("package/not-an-opc-package", "Not an OPC package: missing [Content_Types].xml");
+		const contentTypes = ContentTypes.parse(textDecoder.decode(contentTypesBytes));
+		const parts = /* @__PURE__ */ new Map();
+		for (const [zipPath, bytes] of entries) {
+			if (zipPath === CONTENT_TYPES_ZIP_PATH) continue;
+			const partName = zipPathToPartName(zipPath);
+			if (partName.startsWith("/[trash]/")) continue;
+			const contentType = contentTypes.contentTypeFor(partName);
+			if (!contentType) throw new PackageReadError("package/part-content-type-missing", `No content type for part ${partName}: [Content_Types].xml has no matching Override or Default`);
+			parts.set(partName, new Part(partName, contentType, bytes));
+		}
+		return new OpcPackage(parts, contentTypes, contentTypesBytes);
+	}
+	part(partName) {
+		return this.parts.get(partName);
+	}
+	partsByContentType(contentType) {
+		return [...this.parts.values()].filter((part) => part.contentType === contentType);
+	}
+	/**
+	* Relationships owned by a part ('/' for the package-level
+	* `/_rels/.rels`). Parts without a `.rels` part get an empty set.
+	*/
+	relationshipsFor(sourcePartName = "/") {
+		const cached = this.#relationshipsCache.get(sourcePartName);
+		if (cached) return cached;
+		const relsPart = this.parts.get(relsPartNameFor(sourcePartName));
+		const relationships = relsPart ? Relationships.parse(textDecoder.decode(relsPart.bytes), sourcePartName) : Relationships.empty(sourcePartName);
+		this.#relationshipsCache.set(sourcePartName, relationships);
+		return relationships;
+	}
+	/**
+	* Add a new part and register its content type (`ensureRegistered`), so the
+	* package stays consistent. Throws if the partname is already taken.
+	*/
+	addPart(partName, contentType, bytes) {
+		if (this.#parts.has(partName)) throw new InvalidOptionError("package/duplicate-part-name", `Cannot add part ${partName}: a part with that name already exists`);
+		this.contentTypes.ensureRegistered(partName, contentType);
+		const part = new Part(partName, contentType, bytes);
+		this.#parts.set(partName, part);
+		return part;
+	}
+	/**
+	* Remove a part and return whether it existed. Drops its `Override` content-type
+	* registration and any cached relationship set it owned, so a later `save()`
+	* neither re-emits it nor flushes a stale `.rels` for it. Low-level: it does not
+	* touch references *to* this part (dangling rels are the caller's concern) nor
+	* cascade to parts this one referenced — see {@link Presentation.removeSlide}
+	* for the slide-aware variant that unwires the presentation and prunes orphans.
+	*/
+	removePart(partName) {
+		if (!this.#parts.delete(partName)) return false;
+		this.contentTypes.removeOverride(partName);
+		this.#relationshipsCache.delete(partName);
+		return true;
+	}
+	/**
+	* Reserve an unused media partname `/ppt/media/<base><n>.<ext>` (n one past
+	* the highest existing index for that base). Does not create the part.
+	*/
+	reserveMediaPartName(extension, base = "image") {
+		const ext = extension.toLowerCase().replace(/^\./, "");
+		const re = new RegExp(`^/ppt/media/${base}(\\d+)\\.${ext}$`, "i");
+		let max = 0;
+		for (const partName of this.#parts.keys()) {
+			const match = re.exec(partName);
+			if (match) max = Math.max(max, Number(match[1]));
+		}
+		return `/ppt/media/${base}${max + 1}.${ext}`;
+	}
+	/**
+	* Reserve an unused partname in the same directory and naming family as
+	* `templatePartName`, with a fresh index one past the highest existing one.
+	* The template's filename is split into a base (its stem minus any trailing
+	* digits) and an extension, e.g. `/ppt/slideLayouts/slideLayout1.xml` →
+	* `/ppt/slideLayouts/slideLayout<n>.xml`, `/ppt/media/image1.png` →
+	* `/ppt/media/image<n>.png`. Used when copying a part in from another package.
+	* Does not create the part.
+	*/
+	reservePartNameLike(templatePartName) {
+		const slash = templatePartName.lastIndexOf("/");
+		const dir = templatePartName.slice(0, slash);
+		const fileName = templatePartName.slice(slash + 1);
+		const dot = fileName.lastIndexOf(".");
+		const ext = dot > 0 ? fileName.slice(dot) : "";
+		const base = (dot > 0 ? fileName.slice(0, dot) : fileName).replace(/\d+$/, "");
+		const escape = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+		const re = new RegExp(`^${escape(`${dir}/${base}`)}(\\d+)${escape(ext)}$`);
+		let max = 0;
+		for (const partName of this.#parts.keys()) {
+			const match = re.exec(partName);
+			if (match) max = Math.max(max, Number(match[1]));
+		}
+		return `${dir}/${base}${max + 1}${ext}`;
+	}
+	/**
+	* Re-emit the package. Clean parts are written from their original bytes;
+	* dirty parts from their DOM. Dirty relationship sets and content types are
+	* flushed first. Part order is preserved from load; added parts append.
+	*/
+	async save() {
+		this.#flushRelationships();
+		const zip = new ZipWriter();
+		zip.add(CONTENT_TYPES_ZIP_PATH, this.contentTypes.isDirty ? this.contentTypes.serialize() : this.#contentTypesBytes);
+		for (const part of this.#parts.values()) zip.add(partNameToZipPath(part.partName), part.serialize());
+		return zip.toBytes();
+	}
+	/** Write each dirty `Relationships` set back into its `.rels` part (creating it if new). */
+	#flushRelationships() {
+		for (const relationships of this.#relationshipsCache.values()) {
+			if (!relationships.isDirty) continue;
+			const relsPartName = relsPartNameFor(relationships.sourcePartName);
+			const bytes = textEncoder$3.encode(relationships.serialize());
+			this.#parts.set(relsPartName, new Part(relsPartName, RELATIONSHIPS_CONTENT_TYPE, bytes));
+		}
+	}
+};
+//#endregion
+//#region src/read/api/slide-background.ts
+/**
+* Read a slide's effective background (`p:cSld/p:bg`), decoded into a typed union.
+*
+* A background lives on the slide itself, or is inherited from its slideLayout,
+* else its slideMaster — the {@link SlideBackground.source} field records which.
+* The writer authors solid-colour, gradient, and image backgrounds (all FAITHFUL);
+* pattern and theme-indexed (`p:bgRef`) backgrounds are read-only for imported
+* decks — surface them so a codegen pass can carry the part rather than fake it. A
+* `themeRef` additionally resolves its `idx` through the slide theme's `fmtScheme`
+* to a concrete {@link BackgroundFill} in `resolvedFill`, so a consumer can ask what
+* colour/gradient a theme-indexed background actually renders as.
+*/
+/** The `p:cSld/p:bg` element of a slide/layout/master root, or `null`. */
+function backgroundElementOf(root) {
+	const cSld = root && firstChild(root, "p:cSld");
+	return cSld ? firstChild(cSld, "p:bg") : null;
+}
+/**
+* Decode a colour-bearing container (`p:bgPr`, or a synthetic wrapper around a
+* `fmtScheme` fill entry) into a {@link BackgroundFill}. `a:noFill`, an empty
+* container, or an unrecognized fill all read as `{ type: 'none' }`.
+*/
+function decodeBackgroundFill(container, ctx, rels) {
+	const solid = firstChild(container, "a:solidFill");
+	if (solid) return {
+		type: "solid",
+		color: resolveColorElement(firstChildElement(solid), ctx)
+	};
+	if (firstChild(container, "a:gradFill")) return {
+		type: "gradient",
+		gradient: readGradientFill(container, ctx)
+	};
+	const picture = readPictureFill(container, rels);
+	if (picture) return {
+		type: "image",
+		picture,
+		relId: picture.relId,
+		partName: picture.partName
+	};
+	const patt = firstChild(container, "a:pattFill");
+	if (patt) {
+		const wrapColor = (qname) => {
+			const wrap = firstChild(patt, qname);
+			const colorEl = wrap && firstChildElement(wrap);
+			return colorEl ? resolveColorElement(colorEl, ctx) : null;
+		};
+		return {
+			type: "pattern",
+			preset: attr(patt, "prst") ?? null,
+			foreground: wrapColor("a:fgClr"),
+			background: wrapColor("a:bgClr")
+		};
+	}
+	return { type: "none" };
+}
+/**
+* Resolve a `p:bgRef`'s `idx` into the concrete {@link BackgroundFill} it renders
+* as, through the slide theme's `fmtScheme`. A `p:bgRef` is a
+* `CT_StyleMatrixReference` — the same shape as a shape's `a:fillRef` — so
+* {@link styleRefFill} builds the indexed `bgFillStyleLst`/`fillStyleLst` entry with
+* its `phClr` substituted by the bgRef's colour, and the resulting fill element is
+* decoded like a `p:bgPr`. `null` when the theme has no `fmtScheme`, the entry is
+* absent, or the colour cannot be resolved.
+*
+* `themeRels` — not the owning slide/layout/master's rels — is what an `a:blipFill`
+* entry's `r:embed` resolves against: the fill element is lifted out of the *theme*
+* part, so its relationship id is scoped to that part. Several stock Office themes
+* (Ion, Facet, …) put a picture in the third `bgFillStyleLst` slot, so a deck using
+* `p:bgRef idx="1003"` hits this.
+*/
+function resolveThemeRefFill(bgRef, ctx, themeRels) {
+	const fill = styleRefFill(bgRef, ctx);
+	if (!fill) return null;
+	const wrapper = createElement(ownerDocumentOf(bgRef), "p:bgPr");
+	wrapper.appendChild(fill);
+	return decodeBackgroundFill(wrapper, ctx, themeRels);
+}
+/**
+* Decode a `p:bg` element into a {@link SlideBackground}. `ctx` resolves colour
+* tokens and (for a `themeRef`) the theme `fmtScheme`; `rels` (the *owning* part's
+* relationships) resolves an image background's `r:embed` to an absolute part name.
+*
+* `themeRels` is the theme part's own relationships, used only for a `themeRef`'s
+* {@link SlideBackground.resolvedFill}: that fill comes out of the theme part, so an
+* image entry's `r:embed` is scoped to the theme, not to `rels`.
+*/
+function readSlideBackground(bg, source, ctx, rels, themeRels) {
+	const bgRef = firstChild(bg, "p:bgRef");
+	if (bgRef) return {
+		type: "themeRef",
+		source,
+		idx: intValue(attr(bgRef, "idx")),
+		color: resolveColorElement(firstChildElement(bgRef), ctx),
+		resolvedFill: resolveThemeRefFill(bgRef, ctx, themeRels)
+	};
+	const bgPr = firstChild(bg, "p:bgPr");
+	if (!bgPr) return {
+		type: "none",
+		source
+	};
+	return {
+		...decodeBackgroundFill(bgPr, ctx, rels),
+		source
+	};
+}
+//#endregion
+//#region src/read/api/notes.ts
+/** One EMU coordinate from a placeholder's `p:spPr/a:xfrm` child, or `null` when absent. */
+function xfrmEmu$1(sp, container, axis) {
+	const spPr = firstChild(sp, "p:spPr");
+	const xfrm = spPr && firstChild(spPr, "a:xfrm");
+	const el = xfrm && firstChild(xfrm, container);
+	return el ? intValue(attr(el, axis)) : null;
+}
+/**
+* One placeholder shape (`p:sp`) of a notes slide. A notes slide holds a fixed set:
+* the slide thumbnail (`type="sldImg"`), the notes body (`type="body"`), and the
+* slide number (`type="sldNum"`). Geometry getters read the placeholder's *own*
+* `a:xfrm` and are `null` when it inherits geometry from the notesMaster (the case
+* on an authored deck, whose `sldImg`/`sldNum` carry an empty `p:spPr`).
+*/
+var NotesPlaceholder = class {
+	sp;
+	part;
+	themeContext;
+	relationships;
+	constructor(sp, part, themeContext, relationships) {
+		this.sp = sp;
+		this.part = part;
+		this.themeContext = themeContext;
+		this.relationships = relationships;
+	}
+	#ph() {
+		const nvSpPr = firstChild(this.sp, "p:nvSpPr");
+		const nvPr = nvSpPr && firstChild(nvSpPr, "p:nvPr");
+		return nvPr ? firstChild(nvPr, "p:ph") : null;
+	}
+	#cNvPr() {
+		const nvSpPr = firstChild(this.sp, "p:nvSpPr");
+		return nvSpPr ? firstChild(nvSpPr, "p:cNvPr") : null;
+	}
+	/** Placeholder type (`p:ph/@type`: `sldImg` | `body` | `sldNum`), or `null` when absent. */
+	get type() {
+		const ph = this.#ph();
+		return ph ? attr(ph, "type") : null;
+	}
+	/** Placeholder index (`p:ph/@idx`), or `null` when unset. */
+	get idx() {
+		const ph = this.#ph();
+		return ph ? attr(ph, "idx") : null;
+	}
+	/** Shape name (`p:cNvPr/@name`), or `''` when unnamed. */
+	get name() {
+		const cNvPr = this.#cNvPr();
+		return (cNvPr && attr(cNvPr, "name")) ?? "";
+	}
+	/** Drawing id (`p:cNvPr/@id`), or `null` when absent. */
+	get id() {
+		const cNvPr = this.#cNvPr();
+		return cNvPr ? intValue(attr(cNvPr, "id")) : null;
+	}
+	/** Left edge in EMU (`a:off/@x`), or `null` when geometry is inherited (no own `a:xfrm`). */
+	get left() {
+		return xfrmEmu$1(this.sp, "a:off", "x");
+	}
+	/** Top edge in EMU (`a:off/@y`), or `null` when geometry is inherited. */
+	get top() {
+		return xfrmEmu$1(this.sp, "a:off", "y");
+	}
+	/** Width in EMU (`a:ext/@cx`), or `null` when geometry is inherited. */
+	get width() {
+		return xfrmEmu$1(this.sp, "a:ext", "cx");
+	}
+	/** Height in EMU (`a:ext/@cy`), or `null` when geometry is inherited. */
+	get height() {
+		return xfrmEmu$1(this.sp, "a:ext", "cy");
+	}
+	/**
+	* The placeholder's text as a navigable {@link TextFrame} (`p:txBody`), or `null`
+	* when it carries no text body (the `sldImg` thumbnail). The body placeholder's
+	* runs round-trip a slide's authored notes; the `sldNum` placeholder's frame
+	* holds the slide-number `a:fld`, whose value surfaces through `TextFrame.text`.
+	*/
+	get textFrame() {
+		const txBody = firstChild(this.sp, "p:txBody");
+		if (!txBody) return null;
+		const placeholder = this.type === "body" ? {
+			ph: {
+				type: this.type,
+				idx: this.idx ?? "0"
+			},
+			flatten: this.themeContext
+		} : void 0;
+		return new TextFrame(txBody, this.part, this.themeContext, placeholder, this.relationships);
+	}
+	/** The placeholder's flattened text (paragraphs joined by `\n`), or `''` when it has no text body. */
+	get text() {
+		return this.textFrame?.text ?? "";
+	}
+	/** Escape hatch: the underlying `p:sp` element. After mutating it call {@link markDirty}, or `save()` writes the original bytes. */
+	get element_() {
+		return this.sp;
+	}
+	/** Mark the owning notes-slide part dirty so `save()` reserializes it. Call after mutating {@link element_}. */
+	markDirty() {
+		this.part.markDirty();
+	}
+};
+/**
+* A slide's speaker-notes slide (`notesSlideN.xml`) as a modeled object — the deep
+* companion to {@link import('./slide.js').Slide.notesText}. Exposes the notes
+* shape tree as {@link NotesPlaceholder}s ({@link body}/{@link slideImage}/
+* {@link slideNumber}) plus the body {@link textFrame} the older getters flatten.
+*
+* The theme context (notesMaster → `theme2.xml`) is resolved once and shared across
+* every placeholder's text frame.
+*/
+var NotesSlide = class {
+	opc;
+	part;
+	#themeContext;
+	constructor(opc, part) {
+		this.opc = opc;
+		this.part = part;
+	}
+	/** Partname of the notes slide part. */
+	get partName() {
+		return this.part.partName;
+	}
+	/**
+	* The notes theme context, resolved through the notesMaster → `theme2.xml` chain
+	* and cached. Backs {@link NotesPlaceholder.textFrame}'s `Run.resolvedColor`.
+	*/
+	themeContext() {
+		return this.#themeContext ??= resolveNotesColorContext(this.opc, this.partName);
+	}
+	/** The placeholders (`p:sp`) in the notes shape tree, in document order. */
+	get placeholders() {
+		const spTree = this.#spTree();
+		if (!spTree) return [];
+		const ctx = this.themeContext();
+		const rels = this.opc.relationshipsFor(this.partName);
+		return getElements(spTree, "p:sp").map((sp) => new NotesPlaceholder(sp, this.part, ctx, rels));
+	}
+	/** The notes body placeholder (`p:ph type="body"`), or `null` when the notes slide has none. */
+	get body() {
+		return this.#byType("body");
+	}
+	/** The slide-thumbnail placeholder (`p:ph type="sldImg"`), or `null` when absent. */
+	get slideImage() {
+		return this.#byType("sldImg");
+	}
+	/** The slide-number placeholder (`p:ph type="sldNum"`, carrying the slide-number field), or `null`. */
+	get slideNumber() {
+		return this.#byType("sldNum");
+	}
+	/** The notes body as a navigable {@link TextFrame}, or `null` when there is no body text frame. */
+	get textFrame() {
+		return this.body?.textFrame ?? null;
+	}
+	/** The notes body text flattened (paragraphs joined by `\n`), or `''` when the body is empty/absent. */
+	get text() {
+		return this.body?.text ?? "";
+	}
+	#byType(type) {
+		return this.placeholders.find((ph) => ph.type === type) ?? null;
+	}
+	#spTree() {
+		const root = this.part.dom.documentElement;
+		const cSld = root && firstChild(root, "p:cSld");
+		return cSld ? firstChild(cSld, "p:spTree") : null;
+	}
+};
+//#endregion
+//#region src/read/api/comments.ts
+/** The slide → comments-part relationship type (legacy comments). */
+const COMMENTS_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments";
+/** The presentation → commentAuthors-part relationship type. */
+const COMMENT_AUTHORS_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/commentAuthors";
+/** Content type of a legacy per-slide comments part (`ppt/comments/commentN.xml`). */
+const LEGACY_COMMENTS_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.presentationml.comments+xml";
+/** The slide → modern-comments-part relationship type (2018 schema). */
+const MODERN_COMMENTS_REL_TYPE = "http://schemas.microsoft.com/office/2018/10/relationships/comments";
+/** The presentation → modern-authors-part relationship type (2018 schema). */
+const MODERN_AUTHORS_REL_TYPE = "http://schemas.microsoft.com/office/2018/10/relationships/authors";
+/** Content type of the modern per-slide comments part (`ppt/comments/modernComment_*.xml`). */
+const MODERN_COMMENTS_CONTENT_TYPE = "application/vnd.ms-powerpoint.comments+xml";
+/** Parse a `p:cmAuthorLst` root element into the author registry. */
+function parseCommentAuthors(root) {
+	if (!root) return [];
+	return getElements(root, "p:cmAuthor").map((el) => ({
+		id: intValue(attr(el, "id")),
+		name: attr(el, "name") ?? "",
+		initials: attr(el, "initials") ?? "",
+		lastIdx: intValue(attr(el, "lastIdx")),
+		clrIdx: intValue(attr(el, "clrIdx"))
+	}));
+}
+/**
+* Read the deck-wide comment authors from `ppt/commentAuthors.xml`, resolved via the
+* presentation part's `commentAuthors` relationship. `[]` when the deck has no comments.
+*/
+function readCommentAuthors(opc, presentationPartName) {
+	const rels = opc.relationshipsFor(presentationPartName);
+	const rel = rels.byType(COMMENT_AUTHORS_REL_TYPE)[0];
+	if (!rel) return [];
+	return parseCommentAuthors(opc.part(rels.resolveTarget(rel.id))?.dom.documentElement ?? null);
+}
+/**
+* Read one slide's legacy comments from its `comments/commentN.xml` part (resolved
+* via the slide's `comments` relationship), resolving each comment's `@authorId`
+* against `authors` (typically {@link readCommentAuthors}). `[]` when the slide has
+* no comments part.
+*/
+function readSlideComments(opc, slidePart, authors) {
+	const rels = opc.relationshipsFor(slidePart.partName);
+	const rel = rels.byType(COMMENTS_REL_TYPE)[0];
+	if (!rel) return [];
+	const root = opc.part(rels.resolveTarget(rel.id))?.dom.documentElement;
+	if (!root) return [];
+	const byId = new Map(authors.map((a) => [a.id, a]));
+	return getElements(root, "p:cm").map((cm) => {
+		const authorId = intValue(attr(cm, "authorId"));
+		const author = authorId !== null ? byId.get(authorId) ?? null : null;
+		const pos = firstChild(cm, "p:pos");
+		const textEl = firstChild(cm, "p:text");
+		return {
+			author: author ? author.name : null,
+			authorInitials: author ? author.initials : null,
+			authorId,
+			idx: intValue(attr(cm, "idx")),
+			text: textEl?.textContent ?? "",
+			x: pos ? intValue(attr(pos, "x")) : null,
+			y: pos ? intValue(attr(pos, "y")) : null,
+			date: attr(cm, "dt") ?? null
+		};
+	});
+}
+/** Concatenate a `p188:txBody`'s paragraphs into plain text, joining paragraphs with `\n`. */
+function modernCommentText(el) {
+	const txBody = firstChild(el, "p188:txBody");
+	if (!txBody) return "";
+	const paras = getElements(txBody, "a:p");
+	if (paras.length === 0) return txBody.textContent ?? "";
+	return paras.map((p) => p.textContent ?? "").join("\n");
+}
+/**
+* Decode one `p188:cm` (or `p188:reply`) element. Only the top-level comment
+* carries a position and a reply list; replies pass `withThread: false` so they
+* report `x`/`y` as `null` and never recurse (the schema forbids nested replies).
+*/
+function parseModernComment(el, byId, withThread) {
+	const authorId = attr(el, "authorId");
+	const author = authorId !== null ? byId.get(authorId) ?? null : null;
+	const pos = withThread ? firstChild(el, "p188:pos") : null;
+	const replyLst = withThread ? firstChild(el, "p188:replyLst") : null;
+	return {
+		id: attr(el, "id"),
+		author: author ? author.name : null,
+		authorInitials: author ? author.initials : null,
+		authorId,
+		created: attr(el, "created"),
+		text: modernCommentText(el),
+		x: pos ? intValue(attr(pos, "x")) : null,
+		y: pos ? intValue(attr(pos, "y")) : null,
+		replies: replyLst ? getElements(replyLst, "p188:reply").map((r) => parseModernComment(r, byId, false)) : []
+	};
+}
+/**
+* Read the deck-wide modern comment authors from `ppt/authors.xml`, resolved via
+* the presentation part's 2018 `authors` relationship. `[]` when the deck has no
+* modern authors part.
+*/
+function readModernCommentAuthors(opc, presentationPartName) {
+	const rels = opc.relationshipsFor(presentationPartName);
+	const rel = rels.byType(MODERN_AUTHORS_REL_TYPE)[0];
+	if (!rel) return [];
+	const root = opc.part(rels.resolveTarget(rel.id))?.dom.documentElement;
+	if (!root) return [];
+	return getElements(root, "p188:author").map((el) => ({
+		id: attr(el, "id"),
+		name: attr(el, "name") ?? "",
+		initials: attr(el, "initials") ?? "",
+		userId: attr(el, "userId"),
+		providerId: attr(el, "providerId")
+	}));
+}
+/**
+* Read one slide's modern comments from its `modernComment_*.xml` part (resolved
+* via the slide's 2018 `comments` relationship), resolving each comment's and
+* reply's `@authorId` GUID against `authors` (typically
+* {@link readModernCommentAuthors}). Replies are nested, not flattened. `[]` when
+* the slide has no modern comments part.
+*/
+function readModernSlideComments(opc, slidePart, authors) {
+	const rels = opc.relationshipsFor(slidePart.partName);
+	const rel = rels.byType(MODERN_COMMENTS_REL_TYPE)[0];
+	if (!rel) return [];
+	const root = opc.part(rels.resolveTarget(rel.id))?.dom.documentElement;
+	if (!root) return [];
+	const byId = new Map(authors.map((a) => [a.id, a]));
+	return getElements(root, "p188:cm").map((cm) => parseModernComment(cm, byId, true));
+}
+/**
+* Report which comment schema a deck uses: `'modern'` when it carries any 2018
+* `modernComment_*` part, else `'legacy'` when it carries any classic
+* `commentN.xml` part, else `'none'`. Lets a consumer pick the right accessor
+* ({@link readModernSlideComments} vs {@link readSlideComments}) without probing
+* both.
+*/
+function commentSchema(opc) {
+	if (opc.partsByContentType(MODERN_COMMENTS_CONTENT_TYPE).length > 0) return "modern";
+	if (opc.partsByContentType(LEGACY_COMMENTS_CONTENT_TYPE).length > 0) return "legacy";
+	return "none";
+}
+//#endregion
+//#region src/read/api/tags.ts
+/** The owner → tags-part relationship type. */
+const TAGS_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/tags";
+/**
+* Read every tag referenced by `ownerPartName` (a slide part or the presentation
+* part), resolving the owner's `tags` relationship(s) to their `ppt/tags/tagN.xml`
+* part(s) and flattening each part's `p:tag` children into `{ name, val }`. `[]`
+* when the owner references no tag part. Rel-driven rather than walking
+* `p:custDataLst`, so it is robust to element ordering in the owner.
+*/
+function readTagsForPart(opc, ownerPartName) {
+	const rels = opc.relationshipsFor(ownerPartName);
+	const out = [];
+	for (const rel of rels.byType(TAGS_REL_TYPE)) {
+		const root = opc.part(rels.resolveTarget(rel.id))?.dom.documentElement;
+		if (!root) continue;
+		for (const tag of getElements(root, "p:tag")) out.push({
+			name: attr(tag, "name") ?? "",
+			val: attr(tag, "val") ?? ""
+		});
+	}
+	return out;
+}
+//#endregion
+//#region src/read/api/chrome.ts
+const SLIDE_MASTER_REL$4 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideMaster";
+const THEME_REL$1 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme";
+const THEME_COLOR_SLOTS = [
+	"dk1",
+	"lt1",
+	"dk2",
+	"lt2",
+	"accent1",
+	"accent2",
+	"accent3",
+	"accent4",
+	"accent5",
+	"accent6",
+	"hlink",
+	"folHlink"
+];
+const COLOR_MAP_TOKENS = [
+	"bg1",
+	"tx1",
+	"bg2",
+	"tx2",
+	"accent1",
+	"accent2",
+	"accent3",
+	"accent4",
+	"accent5",
+	"accent6",
+	"hlink",
+	"folHlink"
+];
+/** Read `<a:latin>`/`<a:ea>`/`<a:cs>` typefaces of a theme font family; empty string ⇒ `null`. */
+function readThemeFontFace(font) {
+	const face = (child) => {
+		const el = font && firstChild(font, child);
+		return el && attr(el, "typeface") || null;
+	};
+	return {
+		latin: face("a:latin"),
+		ea: face("a:ea"),
+		cs: face("a:cs")
+	};
+}
+/**
+* A deck's theme part (`theme1.xml`) as a modeled object. Exposes the two property
+* tiers a slide resolves against: the {@link colorScheme} (the 12 `a:clrScheme`
+* slots as literal hex, `a:sysClr` resolved via its `lastClr`) and the
+* {@link fontScheme} (major/minor Latin/EA/CS faces). Reachable from
+* {@link SlideMaster.theme} and `Slide.theme`.
+*/
+var Theme = class {
+	part;
+	constructor(part) {
+		this.part = part;
+	}
+	/** Partname of the theme part. */
+	get partName() {
+		return this.part.partName;
+	}
+	/** Theme name (`a:theme/@name`, e.g. `Office Theme`), or `null` when unnamed. */
+	get name() {
+		const root = this.part.dom.documentElement;
+		return root ? attr(root, "name") : null;
+	}
+	/** Colour-scheme name (`a:clrScheme/@name`, e.g. `Office`), or `null`. */
+	get colorSchemeName() {
+		const clrScheme = this.#clrScheme();
+		return clrScheme ? attr(clrScheme, "name") : null;
+	}
+	/**
+	* The theme colour scheme: the 12 {@link ThemeColorSlot}s resolved to a 6-hex RGB
+	* (an `a:sysClr` slot resolves through its `lastClr`). A slot the theme does not
+	* define reads `null`. Use {@link color} to look one slot up.
+	*/
+	get colorScheme() {
+		const parsed = parseClrScheme(this.#clrScheme());
+		const out = {};
+		for (const slot of THEME_COLOR_SLOTS) out[slot] = parsed.get(slot) ?? null;
+		return out;
+	}
+	/** The 6-hex RGB of one colour-scheme slot, or `null` when the theme does not define it. */
+	color(slot) {
+		return parseClrScheme(this.#clrScheme()).get(slot) ?? null;
+	}
+	/** The theme's `a:fontScheme` (major/minor font families), or `null` when the theme declares none. */
+	get fontScheme() {
+		const themeElements = this.#themeElements();
+		const fontScheme = themeElements && firstChild(themeElements, "a:fontScheme");
+		if (!fontScheme) return null;
+		return {
+			name: attr(fontScheme, "name"),
+			major: readThemeFontFace(firstChild(fontScheme, "a:majorFont")),
+			minor: readThemeFontFace(firstChild(fontScheme, "a:minorFont"))
+		};
+	}
+	/** Escape hatch: the underlying `a:theme` element. After mutating it call {@link markDirty}, or `save()` writes the original bytes. */
+	get element_() {
+		return this.part.dom.documentElement;
+	}
+	/** Mark the theme part dirty so `save()` reserializes it. Call after mutating {@link element_}. */
+	markDirty() {
+		this.part.markDirty();
+	}
+	#themeElements() {
+		const root = this.part.dom.documentElement;
+		return root ? firstChild(root, "a:themeElements") : null;
+	}
+	#clrScheme() {
+		const themeElements = this.#themeElements();
+		return themeElements ? firstChild(themeElements, "a:clrScheme") : null;
+	}
+};
+/** One EMU coordinate from a placeholder's `p:spPr/a:xfrm` child, or `null` when absent. */
+function xfrmEmu(sp, container, axis) {
+	const spPr = firstChild(sp, "p:spPr");
+	const xfrm = spPr && firstChild(spPr, "a:xfrm");
+	const el = xfrm && firstChild(xfrm, container);
+	return el ? intValue(attr(el, axis)) : null;
+}
+/** The `p:ph` element of a shape (`p:sp/p:nvSpPr/p:nvPr/p:ph`), or `null` when it is not a placeholder. */
+function placeholderElement(sp) {
+	const nvSpPr = firstChild(sp, "p:nvSpPr");
+	const nvPr = nvSpPr && firstChild(nvSpPr, "p:nvPr");
+	return nvPr ? firstChild(nvPr, "p:ph") : null;
+}
+/** The placeholder shapes (`p:sp` carrying a `p:ph`) of a master/layout `p:spTree`, in document order. */
+function placeholderShapes(spTree) {
+	if (!spTree) return [];
+	return getElements(spTree, "p:sp").filter((sp) => placeholderElement(sp) !== null);
+}
+/**
+* One placeholder shape (`p:sp` with a `p:ph`) of a slide master or slide layout —
+* the definition a slide's placeholder of the same `type`/`idx` inherits geometry
+* 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).
+*/
+var Placeholder = class {
+	sp;
+	part;
+	themeContext;
+	relationships;
+	constructor(sp, part, themeContext, relationships) {
+		this.sp = sp;
+		this.part = part;
+		this.themeContext = themeContext;
+		this.relationships = relationships;
+	}
+	#cNvPr() {
+		const nvSpPr = firstChild(this.sp, "p:nvSpPr");
+		return nvSpPr ? firstChild(nvSpPr, "p:cNvPr") : null;
+	}
+	/** Placeholder type (`p:ph/@type`: `title` | `body` | `sldNum` | …), or `null` when absent (a body placeholder). */
+	get type() {
+		const ph = placeholderElement(this.sp);
+		return ph ? attr(ph, "type") : null;
+	}
+	/** Placeholder index (`p:ph/@idx`), or `null` when unset. */
+	get idx() {
+		const ph = placeholderElement(this.sp);
+		return ph ? attr(ph, "idx") : null;
+	}
+	/** Shape name (`p:cNvPr/@name`), or `''` when unnamed. */
+	get name() {
+		const cNvPr = this.#cNvPr();
+		return (cNvPr && attr(cNvPr, "name")) ?? "";
+	}
+	/** Drawing id (`p:cNvPr/@id`), or `null` when absent. */
+	get id() {
+		const cNvPr = this.#cNvPr();
+		return cNvPr ? intValue(attr(cNvPr, "id")) : null;
+	}
+	/** Left edge in EMU (`a:off/@x`), or `null` when the placeholder carries no own `a:xfrm`. */
+	get left() {
+		return xfrmEmu(this.sp, "a:off", "x");
+	}
+	/** Top edge in EMU (`a:off/@y`), or `null` when the placeholder carries no own `a:xfrm`. */
+	get top() {
+		return xfrmEmu(this.sp, "a:off", "y");
+	}
+	/** Width in EMU (`a:ext/@cx`), or `null` when the placeholder carries no own `a:xfrm`. */
+	get width() {
+		return xfrmEmu(this.sp, "a:ext", "cx");
+	}
+	/** Height in EMU (`a:ext/@cy`), or `null` when the placeholder carries no own `a:xfrm`. */
+	get height() {
+		return xfrmEmu(this.sp, "a:ext", "cy");
+	}
+	/**
+	* The placeholder's text as a navigable {@link TextFrame} (`p:txBody`), or `null`
+	* when it carries no text body. Threaded with the owning master/layout theme
+	* context so a run's own `schemeClr` resolves through `Run.resolvedColor`.
+	*/
+	get textFrame() {
+		const txBody = firstChild(this.sp, "p:txBody");
+		return txBody ? new TextFrame(txBody, this.part, this.themeContext, void 0, this.relationships) : null;
+	}
+	/** Escape hatch: the underlying `p:sp` element. After mutating it call {@link markDirty}, or `save()` writes the original bytes. */
+	get element_() {
+		return this.sp;
+	}
+	/** Mark the owning master/layout part dirty so `save()` reserializes it. Call after mutating {@link element_}. */
+	markDirty() {
+		this.part.markDirty();
+	}
+};
+/**
+* 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`.
+*/
+var SlideMaster = class {
+	opc;
+	part;
+	#themeContext;
+	constructor(opc, part) {
+		this.opc = opc;
+		this.part = part;
+	}
+	/** Partname of the master part. */
+	get partName() {
+		return this.part.partName;
+	}
+	/** The master's authoring name (`p:cSld/@name`), or `''` when unnamed (the writer's default). */
+	get name() {
+		const cSld = this.#cSld();
+		return (cSld && attr(cSld, "name")) ?? "";
+	}
+	/** The master's theme (via its `theme` relationship), or `null` when absent. */
+	get theme() {
+		const themePart = this.#relTarget(THEME_REL$1);
+		return themePart ? new Theme(themePart) : null;
+	}
+	/**
+	* The master's colour map (`p:clrMap`): each of the 12 {@link ColorMapToken}s
+	* mapped to the {@link ThemeColorSlot} it resolves through. This is the indirection
+	* that lets a slide's `schemeClr val="tx1"` reach a theme slot (e.g. `tx1` → `dk1`).
+	* A token the map omits reads `null`.
+	*/
+	get colorMap() {
+		const root = this.part.dom.documentElement;
+		const parsed = parseClrMap(root ? firstChild(root, "p:clrMap") : null);
+		const out = {};
+		for (const token of COLOR_MAP_TOKENS) out[token] = parsed.get(token) ?? null;
+		return out;
+	}
+	/** 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);
+		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. */
+	get layouts() {
+		const root = this.part.dom.documentElement;
+		const lst = root && firstChild(root, "p:sldLayoutIdLst");
+		if (!lst) return [];
+		const rels = this.opc.relationshipsFor(this.partName);
+		const out = [];
+		for (const entry of getElements(lst, "p:sldLayoutId")) {
+			const relId = attr(entry, "r:id");
+			const part = relId ? this.opc.part(rels.resolveTarget(relId)) : null;
+			if (part) out.push(new SlideLayout(this.opc, part));
+		}
+		return out;
+	}
+	/**
+	* The master's *own* background (`p:cSld/p:bg`), decoded, or `null` when it defines
+	* none. Scoped to the master's own element — a slide's *effective* background,
+	* resolved through the slide → layout → master chain, is `Slide.background`.
+	*/
+	get background() {
+		const bg = backgroundElementOf(this.part.dom.documentElement);
+		if (!bg) return null;
+		const themePart = this.#relTarget(THEME_REL$1);
+		return readSlideBackground(bg, "master", this.themeContext(), this.opc.relationshipsFor(this.partName), themePart ? this.opc.relationshipsFor(themePart.partName) : null);
+	}
+	/**
+	* The master's colour/font context (its `p:clrMap` + theme), resolved once and
+	* cached. Backs each {@link Placeholder}'s text frame.
+	*/
+	themeContext() {
+		return this.#themeContext ??= resolveMasterColorContext(this.opc, this.partName);
+	}
+	#relTarget(type) {
+		const rels = this.opc.relationshipsFor(this.partName);
+		const rel = rels.byType(type)[0];
+		return rel ? this.opc.part(rels.resolveTarget(rel.id)) ?? null : null;
+	}
+	#cSld() {
+		const root = this.part.dom.documentElement;
+		return root ? firstChild(root, "p:cSld") : null;
+	}
+	#spTree() {
+		const cSld = this.#cSld();
+		return cSld ? firstChild(cSld, "p:spTree") : null;
+	}
+};
+/**
+* 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}.
+*/
+var SlideLayout = class {
+	opc;
+	part;
+	#themeContext;
+	constructor(opc, part) {
+		this.opc = opc;
+		this.part = part;
+	}
+	/** Partname of the layout part. */
+	get partName() {
+		return this.part.partName;
+	}
+	/** The layout's authoring name (`p:cSld/@name`, e.g. `Title and Content`), or `''` when unnamed. */
+	get name() {
+		const cSld = this.#cSld();
+		return (cSld && attr(cSld, "name")) ?? "";
+	}
+	/**
+	* The layout type (`p:sldLayout/@type`, e.g. `title` | `obj` | `blank`), or `null`
+	* when the layout declares none. Import-only: the writer authors no `@type`, so an
+	* authored deck reads `null`; an imported deck carries PowerPoint's value.
+	*/
+	get type() {
+		const root = this.part.dom.documentElement;
+		return root ? attr(root, "type") : null;
+	}
+	/** The master this layout is built on (via its `slideMaster` relationship), or `null` when absent. */
+	get master() {
+		const rels = this.opc.relationshipsFor(this.partName);
+		const rel = rels.byType(SLIDE_MASTER_REL$4)[0];
+		const part = rel ? this.opc.part(rels.resolveTarget(rel.id)) : null;
+		return part ? new SlideMaster(this.opc, part) : null;
+	}
+	/** The theme this layout resolves against, via its {@link master}, or `null`. */
+	get theme() {
+		return this.master?.theme ?? null;
+	}
+	/** 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);
+		return placeholderShapes(this.#spTree()).map((sp) => new Placeholder(sp, this.part, ctx, rels));
+	}
+	/**
+	* The layout's *own* background (`p:cSld/p:bg`), decoded, or `null` when it defines
+	* none. A layout usually authors one — an explicit fill (`p:bgPr`) or a
+	* theme-indexed reference (`p:bgRef`). The slide's *effective* background is
+	* `Slide.background`.
+	*/
+	get background() {
+		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);
+	}
+	/**
+	* The layout's colour/font context (walked layout → master → theme), resolved once
+	* and cached. Backs each {@link Placeholder}'s text frame.
+	*/
+	themeContext() {
+		return this.#themeContext ??= resolveLayoutColorContext(this.opc, this.partName);
+	}
+	#cSld() {
+		const root = this.part.dom.documentElement;
+		return root ? firstChild(root, "p:cSld") : null;
+	}
+	#spTree() {
+		const cSld = this.#cSld();
+		return cSld ? firstChild(cSld, "p:spTree") : null;
+	}
+};
+//#endregion
+//#region src/read/api/transition.ts
+/**
+* Typed read/edit model for a slide's `p:transition` (slide-show transition).
+*
+* The element sits in `CT_Slide` between `p:clrMapOvr` and `p:timing` and comes
+* in two shapes PowerPoint emits:
+*
+* - **bare** `<p:transition spd=… advClick=… advTm=…><p:TYPE …/></p:transition>`
+*   when the duration matches a coarse `spd` speed bucket; and
+* - **wrapped** `<mc:AlternateContent>` carrying a `<mc:Choice Requires="p14">`
+*   whose `p:transition` adds the precise `p14:dur` (milliseconds), plus a base
+*   `<mc:Fallback>` without it — emitted for an off-bucket exact duration.
+*
+* The getter prefers the `p14` Choice (so `durationMs` is recovered); the setter
+* emits the `mc:AlternateContent` form when `durationMs` is set and the bare form
+* otherwise. See `docs/animations-and-transitions.md`.
+*/
+/** Child element names of `p:transition` that are not the transition-type choice. */
+const NON_TYPE_CHILDREN = /* @__PURE__ */ new Set(["sndAc", "extLst"]);
+/** The single transition-type child element (the choice), or `null`. */
+function typeElement(transition) {
+	for (const child of childElements(transition)) if (!NON_TYPE_CHILDREN.has(child.localName ?? "")) return child;
+	return null;
+}
+/** Namespace prefix for a URI, defaulting to `p` for the base presentationml namespace. */
+function prefixFor(uri) {
+	if (!uri) return "p";
+	for (const [prefix, ns] of Object.entries(OOXML_NS)) if (ns === uri) return prefix;
+	if (uri === "http://schemas.microsoft.com/office/powerpoint/2012/main") return "p15";
+	if (uri === "http://schemas.microsoft.com/office/powerpoint/2015/9/main") return "p159";
+	return "p";
+}
+/** Collect a transition-type element's non-namespace attributes by local name. */
+function variantAttrs(element) {
+	const out = {};
+	const attrs = element.attributes;
+	for (let i = 0; i < attrs.length; i++) {
+		const a = attrs[i];
+		if (!a || a.prefix === "xmlns" || a.name === "xmlns") continue;
+		out[a.localName ?? a.name] = a.value;
+	}
+	return out;
+}
+/**
+* Locate the slide's transition under the root `p:sld`, returning the
+* `p:transition` element to decode (the `p14` Choice when wrapped) and the
+* outermost node that represents it (the bare element or the `mc:AlternateContent`
+* wrapper), or `null` when the slide has no transition.
+*/
+function findTransition(root) {
+	const bare = firstChild(root, "p:transition");
+	if (bare) return {
+		transition: bare,
+		outer: bare
+	};
+	const altContent = firstChild(root, "mc:AlternateContent");
+	if (altContent) {
+		const choice = firstChild(altContent, "mc:Choice");
+		const transition = choice ? firstChild(choice, "p:transition") : null;
+		if (transition) return {
+			transition,
+			outer: altContent
+		};
+		const fallback = firstChild(altContent, "mc:Fallback");
+		const fbTransition = fallback ? firstChild(fallback, "p:transition") : null;
+		if (fbTransition) return {
+			transition: fbTransition,
+			outer: altContent
+		};
+	}
+	return null;
+}
+/** Decode a `p:transition` element into a {@link TransitionInfo}, or `null` when malformed. */
+function parseTransition(root) {
+	const found = findTransition(root);
+	if (!found) return null;
+	const { transition } = found;
+	const type = typeElement(transition);
+	if (!type) return null;
+	const advClick = boolValue(attr(transition, "advClick"));
+	const advTm = intValue(attr(transition, "advTm"));
+	const spd = attr(transition, "spd");
+	return {
+		type: type.localName ?? "",
+		namespace: prefixFor(type.namespaceURI),
+		speed: spd === "slow" || spd === "med" || spd === "fast" ? spd : "fast",
+		durationMs: intValue(attr(transition, "p14:dur")),
+		advanceOnClick: advClick ?? true,
+		advanceAfterMs: advTm,
+		variant: variantAttrs(type),
+		sound: parseSound(transition)
+	};
+}
+/** Decode the `p:sndAc` sound-action child of a transition into a {@link TransitionSoundInfo}, or `null`. */
+function parseSound(transition) {
+	const sndAc = firstChild(transition, "p:sndAc");
+	if (!sndAc) return null;
+	const stSnd = firstChild(sndAc, "p:stSnd");
+	if (stSnd) {
+		const snd = firstChild(stSnd, "p:snd");
+		return {
+			form: "start",
+			loop: boolValue(attr(stSnd, "loop")) ?? false,
+			embedRid: snd ? attr(snd, "r:embed") : null,
+			name: snd ? attr(snd, "name") : null
+		};
+	}
+	if (firstChild(sndAc, "p:endSnd")) return {
+		form: "stop",
+		loop: false,
+		embedRid: null,
+		name: null
+	};
+	return null;
+}
+/** Map an exact duration (ms) to PowerPoint's coarse speed bucket. */
+function speedForDuration(durationMs) {
+	if (durationMs <= 500) return "fast";
+	if (durationMs <= 1e3) return "med";
+	return "slow";
+}
+/** Build a `p:transition` element (without the `p14:dur` attribute) from an input. */
+function buildTransitionElement(doc, input, speed, withDur) {
+	const transition = createElement(doc, "p:transition");
+	if (speed) setAttr(transition, "spd", speed);
+	if (withDur && typeof input.durationMs === "number") setAttr(transition, "p14:dur", String(Math.round(input.durationMs)));
+	if (input.advanceOnClick === false) setAttr(transition, "advClick", "0");
+	if (typeof input.advanceAfterMs === "number") setAttr(transition, "advTm", String(Math.round(input.advanceAfterMs)));
+	const type = createElement(doc, `${input.namespace ?? "p"}:${input.type}`);
+	for (const [name, value] of Object.entries(input.variant ?? {})) setAttr(type, name, value);
+	transition.appendChild(type);
+	return transition;
+}
+/**
+* Build the DOM node for a transition: the bare `p:transition` when no exact
+* duration is requested, or an `mc:AlternateContent` wrapper (a `p14` Choice
+* carrying `p14:dur` plus a base `mc:Fallback`) when `durationMs` is set.
+*/
+function buildTransition(doc, input) {
+	const hasDuration = typeof input.durationMs === "number";
+	const speed = input.speed ?? (hasDuration ? speedForDuration(input.durationMs) : null);
+	if (!hasDuration) return buildTransitionElement(doc, input, speed, false);
+	const alt = createElement(doc, "mc:AlternateContent");
+	const choice = createElement(doc, "mc:Choice");
+	setAttr(choice, "Requires", "p14");
+	choice.appendChild(buildTransitionElement(doc, input, speed, true));
+	alt.appendChild(choice);
+	const fallback = createElement(doc, "mc:Fallback");
+	fallback.appendChild(buildTransitionElement(doc, input, speed, false));
+	alt.appendChild(fallback);
+	return alt;
+}
+/** Remove any existing transition node (bare or wrapped) from the slide root. */
+function removeTransition(root) {
+	const found = findTransition(root);
+	if (found) root.removeChild(found.outer);
+}
+//#endregion
+//#region src/read/api/animation.ts
+/**
+* Spid-aware, otherwise-opaque handling of a slide's build-animation tree
+* (`p:timing` / `p:bldLst`).
+*
+* The `p:timing` subtree is `CT_TimeNodeList` — deeply recursive and modeled
+* here as opaque DOM (an unmodified slide round-trips it byte-identically for
+* free). The only structured data we extract or rewrite is the set of `spid`
+* references — `<p:spTgt spid>` inside the timing tree and `<p:bldP spid>` in the
+* build list — so animations stay coherent when shape ids change. Three purely
+* structural operations: **enumerate**, **remap**, and **prune**. See
+* `docs/animations-and-transitions.md` ("spid-awareness").
+*/
+const P_NS = OOXML_NS.p;
+/** Every element carrying an animation `spid` reference, across the timing tree and build list. */
+function spidElements(root) {
+	const out = [];
+	for (const el of root.getElementsByTagNameNS(OOXML_NS.p, "spTgt")) out.push(el);
+	for (const el of root.getElementsByTagNameNS(OOXML_NS.p, "bldP")) out.push(el);
+	return out;
+}
+/**
+* Whether the slide carries build animations — a `<p:bldP>` entry or any timing
+* node with a `presetID` (distinguishing animation timing from the media-loop
+* timing that has neither).
+*/
+function hasAnimations(root) {
+	if (root.getElementsByTagNameNS(OOXML_NS.p, "bldP").length > 0) return true;
+	for (const cTn of root.getElementsByTagNameNS(OOXML_NS.p, "cTn")) if (attr(cTn, "presetID") !== null) return true;
+	return false;
+}
+/** The sorted, de-duplicated set of `spid`s referenced by the slide's animations. */
+function enumerateSpids(root) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const element of spidElements(root)) {
+		const spid = intValue(attr(element, "spid"));
+		if (spid !== null) seen.add(spid);
+	}
+	return [...seen].sort((a, b) => a - b);
+}
+/**
+* Rewrite every animation `spid` according to `mapping` (old → new). Returns
+* `true` when at least one reference changed, so callers can `markDirty()` only
+* when needed.
+*/
+function remapSpids(root, mapping) {
+	let changed = false;
+	for (const element of spidElements(root)) {
+		const spid = intValue(attr(element, "spid"));
+		if (spid === null) continue;
+		const next = mapping.get(spid);
+		if (next !== void 0 && next !== spid) {
+			setAttr(element, "spid", String(next));
+			changed = true;
+		}
+	}
+	return changed;
+}
+/** The nearest ancestor `<p:par>` whose `<p:cTn>` carries a `presetID` (the effect node), or `null`. */
+function effectParFor(spTgt) {
+	for (let node = spTgt.parentNode; node; node = node.parentNode) if (node.localName === "par" && node.namespaceURI === OOXML_NS.p) {
+		const cTn = firstChild(node, "p:cTn");
+		if (cTn && attr(cTn, "presetID") !== null) return node;
+	}
+	return null;
+}
+/** Whether a `<p:par>` wrapper node has become empty (its `p:cTn/p:childTnLst` has no element children). */
+function isEmptyWrapperPar(par) {
+	if (par.localName !== "par" || par.namespaceURI !== OOXML_NS.p) return false;
+	const cTn = firstChild(par, "p:cTn");
+	if (!cTn || attr(cTn, "presetID") !== null) return false;
+	const childTnLst = firstChild(cTn, "p:childTnLst");
+	return !childTnLst || childElements(childTnLst).length === 0;
+}
+/**
+* Remove all animation traces of the given `spid`s: each shape's `<p:bldP>` and
+* the effect-level `<p:par>` nodes whose `<p:spTgt>` targets it, then any wrapper
+* `<p:par>` left empty by the removal. Keeps the opaque timing tree free of
+* dangling references when shapes are deleted. Returns `true` when anything was
+* removed.
+*/
+function pruneSpids(root, spids) {
+	const drop = /* @__PURE__ */ new Set();
+	for (const s of spids) drop.add(s);
+	if (drop.size === 0) return false;
+	let changed = false;
+	const wrappersToCheck = /* @__PURE__ */ new Set();
+	const spTgts = Array.from(root.getElementsByTagNameNS(OOXML_NS.p, "spTgt"));
+	const effectPars = /* @__PURE__ */ new Set();
+	for (const spTgt of spTgts) {
+		const spid = intValue(attr(spTgt, "spid"));
+		if (spid === null || !drop.has(spid)) continue;
+		const effectPar = effectParFor(spTgt);
+		if (effectPar) effectPars.add(effectPar);
+	}
+	for (const effectPar of effectPars) {
+		const parent = effectPar.parentNode;
+		effectPar.parentNode?.removeChild(effectPar);
+		changed = true;
+		const wrapperPar = parent?.parentNode?.parentNode;
+		if (wrapperPar) wrappersToCheck.add(wrapperPar);
+	}
+	let progress = true;
+	while (progress) {
+		progress = false;
+		for (const wrapper of [...wrappersToCheck]) if (isEmptyWrapperPar(wrapper)) {
+			const grandWrapper = wrapper.parentNode?.parentNode?.parentNode;
+			wrapper.parentNode?.removeChild(wrapper);
+			wrappersToCheck.delete(wrapper);
+			if (grandWrapper) wrappersToCheck.add(grandWrapper);
+			progress = true;
+			changed = true;
+		}
+	}
+	const bldPs = Array.from(root.getElementsByTagNameNS(OOXML_NS.p, "bldP"));
+	for (const bldP of bldPs) {
+		const spid = intValue(attr(bldP, "spid"));
+		if (spid !== null && drop.has(spid)) {
+			bldP.parentNode?.removeChild(bldP);
+			changed = true;
+		}
+	}
+	const bldLsts = Array.from(root.getElementsByTagNameNS(OOXML_NS.p, "bldLst"));
+	for (const bldLst of bldLsts) if (childElements(bldLst).length === 0) bldLst.parentNode?.removeChild(bldLst);
+	return changed;
+}
+/**
+* Flatten the whole slide to its final static state by removing the build
+* animation timeline: drop the `<p:timing>` block (which carries the `<p:bldLst>`
+* and the effect tree) so every shape renders at once with no click-through
+* staging. Gated on {@link hasAnimations}: a `<p:timing>` that is purely a
+* media loop (no `<p:bldP>` and no `presetID`-bearing node) is left untouched so
+* media playback survives. Returns `true` when a timing block was removed.
+*
+* This is the whole-slide counterpart to {@link pruneSpids} (which drops the
+* builds of specific shapes). It only removes staging; it never deletes shapes,
+* so a slide that animated alternating states over the same region will show
+* them all at once after flattening — that is "drop animations", distinct from
+* "remove staged/duplicate shapes".
+*/
+function flattenAnimations(root) {
+	if (!hasAnimations(root)) return false;
+	const timing = firstChild(root, "p:timing");
+	if (!timing) return false;
+	timing.parentNode?.removeChild(timing);
+	return true;
+}
+const P_XMLNS = `xmlns:p="${P_NS}"`;
+/** A fresh `p:timing` carrying only an empty `tmRoot` (no effects yet). */
+const TIMING_SCAFFOLD = `<p:timing ${P_XMLNS}><p:tnLst><p:par><p:cTn id="1" dur="indefinite" restart="never" nodeType="tmRoot"><p:childTnLst/></p:cTn></p:par></p:tnLst></p:timing>`;
+/** A fresh `mainSeq` `p:seq` (its `cTn@id` is filled in by the caller). */
+const MAIN_SEQ_SCAFFOLD = `<p:seq ${P_XMLNS} concurrent="1" nextAc="seek"><p:cTn id="0" dur="indefinite" nodeType="mainSeq"><p:childTnLst/></p:cTn><p:prevCondLst><p:cond evt="onPrev" delay="0"><p:tgtEl><p:sldTgt/></p:tgtEl></p:cond></p:prevCondLst><p:nextCondLst><p:cond evt="onNext" delay="0"><p:tgtEl><p:sldTgt/></p:tgtEl></p:cond></p:nextCondLst></p:seq>`;
+/** Largest `<p:cTn @id>` in a subtree (0 when none). */
+function maxCTnId(scope) {
+	let max = 0;
+	for (const cTn of scope.getElementsByTagNameNS(P_NS, "cTn")) {
+		const id = intValue(attr(cTn, "id"));
+		if (id !== null && id > max) max = id;
+	}
+	return max;
+}
+/** Renumber every `<p:cTn @id>` in `node` (document order) starting at `start`; returns the next free id. */
+function renumberCTnIds(node, start) {
+	let id = start;
+	for (const cTn of node.getElementsByTagNameNS(P_NS, "cTn")) setAttr(cTn, "id", String(id++));
+	return id;
+}
+/** Whether `par`'s subtree targets any of `spids` via a `<p:spTgt>`. */
+function targetsAnySpid(par, spids) {
+	for (const spTgt of par.getElementsByTagNameNS(P_NS, "spTgt")) {
+		const spid = intValue(attr(spTgt, "spid"));
+		if (spid !== null && spids.has(spid)) return true;
+	}
+	return false;
+}
+/** Parse a namespaced scaffold string and import its root into `doc`. */
+function importScaffold(doc, xml) {
+	return doc.importNode(parseXml(xml).documentElement, true);
+}
+/** The destination `mainSeq` `p:childTnLst` to append click groups into, creating the timing/seq scaffold as needed. */
+function getOrCreateMainSeqChildTnLst(root, doc) {
+	let timing = firstChild(root, "p:timing");
+	if (!timing) {
+		timing = importScaffold(doc, TIMING_SCAFFOLD);
+		insertInOrder(root, timing, ["p:extLst"]);
+	}
+	const existingSeq = timing.getElementsByTagNameNS(P_NS, "seq")[0];
+	if (existingSeq) {
+		const seqCTn = firstChild(existingSeq, "p:cTn");
+		if (seqCTn) {
+			let childLst = firstChild(seqCTn, "p:childTnLst");
+			if (!childLst) {
+				childLst = createElement(doc, "p:childTnLst");
+				seqCTn.appendChild(childLst);
+			}
+			return childLst;
+		}
+	}
+	let tmRootChildLst = timing.getElementsByTagNameNS(P_NS, "childTnLst")[0];
+	if (!tmRootChildLst) {
+		const freshTnLst = firstChild(importScaffold(doc, TIMING_SCAFFOLD), "p:tnLst");
+		if (freshTnLst) insertInOrder(timing, freshTnLst, ["p:bldLst", "p:extLst"]);
+		tmRootChildLst = timing.getElementsByTagNameNS(P_NS, "childTnLst")[0];
+	}
+	if (!tmRootChildLst) throw new InternalError("animation/timing-scaffold-failed", "getOrCreateMainSeqChildTnLst: failed to resolve or create the tmRoot child list");
+	const seq = importScaffold(doc, MAIN_SEQ_SCAFFOLD);
+	setAttr(firstChild(seq, "p:cTn"), "id", String(maxCTnId(timing) + 1));
+	tmRootChildLst.insertBefore(seq, tmRootChildLst.firstChild);
+	return firstChild(firstChild(seq, "p:cTn"), "p:childTnLst");
+}
+/** The destination `p:bldLst` (under `p:timing`), creating it before any `p:extLst`. */
+function getOrCreateBldLst(timing, doc) {
+	let bldLst = firstChild(timing, "p:bldLst");
+	if (!bldLst) {
+		bldLst = createElement(doc, "p:bldLst");
+		insertInOrder(timing, bldLst, ["p:extLst"]);
+	}
+	return bldLst;
+}
+/**
+* Carry the build animation of one or more copied shapes from `sourceRoot`'s
+* timing into `targetRoot`'s, remapping shape ids via `spidMap` (source id → new
+* id on the destination). For each mapped shape: its mainSeq click-group `<p:par>`
+* (the whole click step) and `<p:bldP>` are cloned, their `spid`s remapped, their
+* `<p:cTn>` ids renumbered to stay collision-free in the destination, and appended
+* after any existing build — matching how PowerPoint merges a pasted shape's
+* animation. Returns `true` when anything was carried (so the caller can
+* `markDirty()`), `false` when the source shapes have no animation.
+*/
+function carryShapeAnimations(sourceRoot, targetRoot, spidMap) {
+	const sourceTiming = firstChild(sourceRoot, "p:timing");
+	if (!sourceTiming) return false;
+	const carriedSpids = new Set(spidMap.keys());
+	const sourceSeq = sourceTiming.getElementsByTagNameNS(P_NS, "seq")[0];
+	const groups = [];
+	if (sourceSeq) {
+		const seqCTn = firstChild(sourceSeq, "p:cTn");
+		const seqChildLst = seqCTn ? firstChild(seqCTn, "p:childTnLst") : null;
+		if (seqChildLst) {
+			for (const par of childElements(seqChildLst)) if (targetsAnySpid(par, carriedSpids)) groups.push(par);
+		}
+	}
+	const sourceBldLst = firstChild(sourceTiming, "p:bldLst");
+	const bldPs = [];
+	if (sourceBldLst) for (const bldP of childElements(sourceBldLst)) {
+		const spid = intValue(attr(bldP, "spid"));
+		if (spid !== null && carriedSpids.has(spid)) bldPs.push(bldP);
+	}
+	if (groups.length === 0 && bldPs.length === 0) return false;
+	const doc = targetRoot.ownerDocument;
+	const destChildLst = getOrCreateMainSeqChildTnLst(targetRoot, doc);
+	const destTiming = firstChild(targetRoot, "p:timing");
+	let nextId = maxCTnId(destTiming) + 1;
+	for (const par of groups) {
+		const clone = doc.importNode(par, true);
+		remapSpids(clone, spidMap);
+		nextId = renumberCTnIds(clone, nextId);
+		destChildLst.appendChild(clone);
+	}
+	if (bldPs.length > 0) {
+		const destBldLst = getOrCreateBldLst(destTiming, doc);
+		for (const bldP of bldPs) {
+			const clone = doc.importNode(bldP, true);
+			const spid = intValue(attr(clone, "spid"));
+			if (spid !== null && spidMap.has(spid)) setAttr(clone, "spid", String(spidMap.get(spid)));
+			destBldLst.appendChild(clone);
+		}
+	}
+	return true;
+}
+//#endregion
+//#region src/read/api/slide.ts
+const IMAGE_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image";
+const NOTES_SLIDE_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesSlide";
+const SLIDE_LAYOUT_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideLayout";
+/** Recognize a handful of common raster formats from their leading bytes. */
+function sniffImageType(bytes) {
+	const b = bytes;
+	if (b.length >= 8 && b[0] === 137 && b[1] === 80 && b[2] === 78 && b[3] === 71) return {
+		extension: "png",
+		contentType: "image/png"
+	};
+	if (b.length >= 3 && b[0] === 255 && b[1] === 216 && b[2] === 255) return {
+		extension: "jpeg",
+		contentType: "image/jpeg"
+	};
+	if (b.length >= 4 && b[0] === 71 && b[1] === 73 && b[2] === 70 && b[3] === 56) return {
+		extension: "gif",
+		contentType: "image/gif"
+	};
+	if (b.length >= 2 && b[0] === 66 && b[1] === 77) return {
+		extension: "bmp",
+		contentType: "image/bmp"
+	};
+	if (b.length >= 4 && (b[0] === 73 && b[1] === 73 && b[2] === 42 && b[3] === 0 || b[0] === 77 && b[1] === 77 && b[2] === 0 && b[3] === 42)) return {
+		extension: "tiff",
+		contentType: "image/tiff"
+	};
+	if (b.length >= 12 && b[0] === 82 && b[1] === 73 && b[2] === 70 && b[3] === 70 && b[8] === 87 && b[9] === 69 && b[10] === 66 && b[11] === 80) return {
+		extension: "webp",
+		contentType: "image/webp"
+	};
+	return null;
+}
+var Slide = class {
+	presentation;
+	part;
+	slideId;
+	index;
+	constructor(presentation, part, slideId, index) {
+		this.presentation = presentation;
+		this.part = part;
+		this.slideId = slideId;
+		this.index = index;
+	}
+	/** Partname of this slide's part. */
+	get partName() {
+		return this.part.partName;
+	}
+	/**
+	* Escape hatch: the underlying `p:sld` element. After mutating it call
+	* {@link markDirty}, or `save()` writes the original bytes. Slide-level DOM
+	* access is also reachable as `slide.part.dom`; this getter is the same node,
+	* on the same rung of the ladder as `Shape.element_` and the rest.
+	*/
+	get element_() {
+		const root = this.part.dom.documentElement;
+		if (!root) throw new PackageReadError("package/part-has-no-root", `Slide ${this.partName} has no root <p:sld> element`);
+		return root;
+	}
+	/** Mark this slide's part dirty so `save()` reserializes it. Call after mutating {@link element_}. */
+	markDirty() {
+		this.part.markDirty();
+	}
+	/** This slide part's relationships (image embeds, layout, hyperlinks, …). */
+	get relationships() {
+		return this.presentation.opc.relationshipsFor(this.partName);
+	}
+	#themeColors;
+	/**
+	* The slide's resolved theme context (`clrMap` + `clrScheme` + the theme
+	* `fmtScheme` + `fontScheme`, plus the layout/master roots), walked once from
+	* slide → layout → master → theme and cached on this proxy. Backs the read-model
+	* resolved getters ({@link Shape.resolvedFill}, `Run.resolvedColor`,
+	* `Run.resolvedSizePt`, `Run.resolvedFontFace`) so a `schemeClr` token — including
+	* one delivered through a shape's `p:style` `fillRef`/`lnRef` — resolves to a
+	* literal hex, and a placeholder run's inherited size/typeface (a `+mj-*`/`+mn-*`
+	* font token included) resolves to a literal value. The maps/roots are empty when
+	* the theme chain is incomplete, in which case tokens simply stay unresolved.
+	*/
+	themeContext() {
+		return this.#themeColors ??= resolveSlideColorContext(this.presentation.opc, this.partName);
+	}
+	/** Authoring name of the slide (`p:cSld/@name`), or `null` if unnamed. */
+	get name() {
+		const cSld = this.#cSld();
+		return cSld ? attr(cSld, "name") : null;
+	}
+	/**
+	* Whether this slide is hidden (`p:sld/@show="0"`). The attribute is
+	* `xsd:boolean` defaulting to `true`, so an absent attribute means shown.
+	* Hidden slides are dropped from PowerPoint/LibreOffice presentations and
+	* exported PDFs, so render order diverges from model order when any earlier
+	* slide is hidden.
+	*/
+	get hidden() {
+		const root = this.part.dom.documentElement;
+		const show = root ? attr(root, "show") : null;
+		return show === "0" || show === "false";
+	}
+	/**
+	* Hide or show this slide. Hiding writes `p:sld/@show="0"`; showing removes
+	* the attribute, restoring PowerPoint's canonical shown form (absent ⇒ shown).
+	* Marks the slide part dirty.
+	*/
+	set hidden(value) {
+		const root = this.part.dom.documentElement;
+		if (!root) throw new PackageReadError("package/part-has-no-root", `Slide ${this.partName} has no root <p:sld> element`);
+		if (value) setAttr(root, "show", "0");
+		else removeAttr(root, "show");
+		this.part.markDirty();
+	}
+	/**
+	* 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
+	* `p14:dur` duration (the `p14` Choice is preferred so `durationMs` is recovered).
+	*/
+	get transition() {
+		const root = this.part.dom.documentElement;
+		return root ? parseTransition(root) : null;
+	}
+	/**
+	* Set or clear the slide's show transition. Assigning `null` removes it.
+	* Writing a transition with `durationMs` emits the `mc:AlternateContent` form
+	* (a `p14` Choice carrying `p14:dur` plus a base `mc:Fallback`); otherwise the
+	* bare `<p:transition>` is written. The node is inserted at its schema slot —
+	* after `p:clrMapOvr`, before `p:timing`/`p:extLst`. Marks the slide part dirty.
+	*/
+	set transition(value) {
+		const root = this.part.dom.documentElement;
+		if (!root) throw new PackageReadError("package/part-has-no-root", `Slide ${this.partName} has no root <p:sld> element`);
+		removeTransition(root);
+		if (value) {
+			const doc = this.part.dom;
+			insertInOrder(root, buildTransition(doc, value), ["p:timing", "p:extLst"]);
+		}
+		this.part.markDirty();
+	}
+	/**
+	* Whether the slide carries build animations (`p:timing` with a `<p:bldP>` or a
+	* `presetID`-bearing time node). The animation tree itself is preserved opaquely;
+	* see {@link animationSpids}.
+	*/
+	get hasAnimations() {
+		const root = this.part.dom.documentElement;
+		return root ? hasAnimations(root) : false;
+	}
+	/**
+	* @internal The sorted, de-duplicated set of shape ids (`spid`) referenced by
+	* the slide's animations (`<p:spTgt spid>` and `<p:bldP spid>`). Exposed for the
+	* import paths' spid-coherence checks.
+	*/
+	animationSpids() {
+		const root = this.part.dom.documentElement;
+		return root ? enumerateSpids(root) : [];
+	}
+	/**
+	* @internal Rewrite every animation `spid` per `mapping` (old → new), keeping
+	* the opaque timing tree coherent when shape ids are reassigned. Marks the slide
+	* part dirty only when a reference changed.
+	*/
+	remapAnimationSpids(mapping) {
+		const root = this.part.dom.documentElement;
+		if (root && remapSpids(root, mapping)) this.part.markDirty();
+	}
+	/**
+	* @internal Remove the build animations targeting the given shape ids (their
+	* `<p:bldP>` and effect nodes), so deleting a shape never leaves a dangling
+	* `spid` reference. Marks the slide part dirty only when something was removed.
+	*/
+	pruneAnimationSpids(spids) {
+		const root = this.part.dom.documentElement;
+		if (root && pruneSpids(root, spids)) this.part.markDirty();
+	}
+	/**
+	* Flatten the slide's build animations: remove the `<p:timing>` block so the
+	* slide renders and edits as its final static state, with every shape shown at
+	* once. Gated like {@link hasAnimations} — a `<p:timing>` that is purely a media
+	* loop (no `<p:bldP>` or `presetID`) is preserved so media playback survives.
+	* Marks the slide part dirty and returns `true` only when a timing block was
+	* removed.
+	*
+	* This removes click-through staging only; it does not delete shapes. If a slide
+	* animated alternating states over the same region, the flattened render shows
+	* them all at once — keep that distinct from removing staged/duplicate shapes.
+	*/
+	flattenAnimations() {
+		const root = this.part.dom.documentElement;
+		if (root && flattenAnimations(root)) {
+			this.part.markDirty();
+			return true;
+		}
+		return false;
+	}
+	/** Top-level shapes in the slide's shape tree, in document order. */
+	get shapes() {
+		const spTree = this.#spTree();
+		return spTree ? buildShapes(spTree, this) : [];
+	}
+	/**
+	* All text on the slide, flattened in document order — the read-model
+	* counterpart to {@link TextFrame.text} one level up. Every text-bearing shape
+	* contributes its text, recursing into groups ({@link GroupShape}) and reading
+	* table cells ({@link GraphicFrame.table}); text-free shapes (pictures,
+	* connectors, empty boxes) contribute nothing. Blocks are joined by `\n`; within
+	* a table, cells in a row are joined by `\t` and rows by `\n`.
+	*
+	* This is deliberately scoped to the slide's own shape tree. It does **not**
+	* include speaker notes (read those via {@link notesText}) or chart data labels
+	* (read those via {@link GraphicFrame.chart}); folding those in would force
+	* ordering and separator choices a caller is better placed to make. Extract a
+	* whole deck with `deck.slides.map((s) => s.text)`.
+	*/
+	get text() {
+		const blocks = [];
+		const walk = (shapes) => {
+			for (const shape of shapes) if (shape instanceof GroupShape) walk(shape.shapes);
+			else if (shape instanceof GraphicFrame) {
+				const table = shape.table;
+				if (!table) continue;
+				for (const row of table.rows) {
+					const cells = row.cells.map((cell) => cell.text);
+					if (cells.some((cell) => cell.length > 0)) blocks.push(cells.join("	"));
+				}
+			} else {
+				const text = shape.text;
+				if (text.length > 0) blocks.push(text);
+			}
+		};
+		walk(this.shapes);
+		return blocks.join("\n");
+	}
+	/**
+	* The slide's speaker-note text — the companion to {@link text} for the notes
+	* that {@link text} deliberately excludes. Delegates to {@link notesSlide}: finds
+	* the notes body placeholder (`p:ph` `type="body"`) and flattens its text frame
+	* the same way {@link TextFrame.text} does (paragraphs joined by `\n`).
+	*
+	* Returns `null` when the slide has **no notes slide part at all** — distinct
+	* from `''`, which means a notes slide exists but its body is empty (PowerPoint
+	* often attaches an empty notes slide to every slide). Only the body placeholder
+	* is read; the slide-thumbnail (`sldImg`) and slide-number (`sldNum`)
+	* placeholders a notes slide also carries are read via {@link notesSlide}.
+	*/
+	get notesText() {
+		const notes = this.notesSlide;
+		return notes ? notes.text : null;
+	}
+	/**
+	* The slide's speaker-note body as a navigable {@link TextFrame} — the rich
+	* companion to {@link notesText}, which flattens the same body to a plain string.
+	* Walk `paragraphs → runs` to recover per-run formatting (bold/italic/underline,
+	* colour, size, face) and any notes hyperlink that {@link notesText} discards.
+	*
+	* `null` when the slide has **no notes slide part** (the same boundary
+	* {@link notesText} returns `null` at), and also when a notes part exists but
+	* carries no body-placeholder text frame — there is then no frame to hand back
+	* (whereas {@link notesText} reports `''` for that empty-body case). Convenience
+	* for `notesSlide.textFrame`; see {@link notesSlide} for the whole modeled notes
+	* slide (its `sldImg`/`sldNum` placeholders and their geometry).
+	*/
+	get notesTextFrame() {
+		return this.notesSlide?.textFrame ?? null;
+	}
+	/**
+	* The slide's speaker-notes slide (`notesSlideN.xml`) as a modeled
+	* {@link NotesSlide}, or `null` when the slide has no notes slide part. Beyond the
+	* body text {@link notesText}/{@link notesTextFrame} surface, this exposes the
+	* notes slide's three placeholders — the slide thumbnail (`slideImage`), the notes
+	* body, and the slide-number field (`slideNumber`) — each with its geometry and
+	* (where present) a navigable text frame.
+	*
+	* The writer authors all three placeholders but leaves `sldImg`/`sldNum` with an
+	* empty `p:spPr`, so on an authored deck their geometry reads `null` while an
+	* imported deck carries the notesMaster-derived geometry. The body text and the
+	* slide-number field round-trip either way.
+	*/
+	get notesSlide() {
+		const notesRel = this.relationships.byType(NOTES_SLIDE_REL_TYPE)[0];
+		if (!notesRel) return null;
+		const notesPart = this.presentation.opc.part(this.relationships.resolveTarget(notesRel.id));
+		if (!notesPart) return null;
+		return new NotesSlide(this.presentation.opc, notesPart);
+	}
+	/**
+	* The slide layout this slide is bound to (`slideLayout` relationship), as a
+	* modeled {@link SlideLayout}, or `null` when the slide has no layout. The layout
+	* carries the placeholder geometry and background a slide inherits; walk on to
+	* {@link master} and {@link theme} through it (`slide.layout.master.theme`).
+	*/
+	get layout() {
+		const rel = this.relationships.byType(SLIDE_LAYOUT_REL_TYPE)[0];
+		if (!rel) return null;
+		const part = this.presentation.opc.part(this.relationships.resolveTarget(rel.id));
+		return part ? new SlideLayout(this.presentation.opc, part) : null;
+	}
+	/**
+	* The slide master this slide resolves against, via its {@link layout}, as a
+	* modeled {@link SlideMaster}, or `null` when the layout/master chain is broken.
+	* The master owns the colour map (`schemeClr` token → theme slot) and the default
+	* text styles a placeholder inherits.
+	*/
+	get master() {
+		return this.layout?.master ?? null;
+	}
+	/**
+	* The theme this slide resolves colour and font tokens against, via its
+	* {@link layout} → {@link master} → theme, as a modeled {@link Theme}, or `null`.
+	* Read its {@link Theme.colorScheme}/{@link Theme.fontScheme} to see the literal
+	* palette and faces a `schemeClr`/`+mj-*` token resolves to.
+	*/
+	get theme() {
+		return this.layout?.master?.theme ?? null;
+	}
+	/**
+	* The slide's **legacy** review comments (`p:cm` in its `comments/commentN.xml`
+	* part), `[]` when it has none. Each {@link Comment} carries its body text, marker
+	* position (EMU), timestamp, and its author resolved through the deck-wide
+	* {@link Presentation.commentAuthors} registry (`@authorId` → name/initials). These
+	* are the comments the writer authors via `slide.addComment(...)`; the 2018 modern
+	* comment parts (`p188:cm`) are a separate schema, preserved but not decoded.
+	*/
+	get comments() {
+		return readSlideComments(this.presentation.opc, this.part, this.presentation.commentAuthors);
+	}
+	/**
+	* The slide's **modern** (2018) review comments (`p188:cm` in its
+	* `modernComment_*.xml` part), `[]` when it has none. Each {@link ModernComment}
+	* carries its body text, `created` timestamp, marker position (EMU), its author
+	* resolved through the deck-wide {@link Presentation.modernCommentAuthors}
+	* registry (`@authorId` GUID → name/initials), and its reply thread nested under
+	* `replies`. Read-only — the writer authors the legacy schema; see
+	* {@link Presentation.commentSchema} to tell which schema a deck uses.
+	*/
+	get modernComments() {
+		return readModernSlideComments(this.presentation.opc, this.part, this.presentation.modernCommentAuthors);
+	}
+	/**
+	* The slide's programmatic tags (`p:custDataLst/p:tags` on the slide part,
+	* resolved to `ppt/tags/tagN.xml`) as `{ name, val }` string pairs, `[]` when it
+	* has none. Host/add-in metadata with no visible rendering and no writer —
+	* read-only, preserved byte-for-byte on round-trip. Deck-level tags are
+	* {@link Presentation.tags}.
+	*/
+	get tags() {
+		return readTagsForPart(this.presentation.opc, this.partName);
+	}
+	/**
+	* The slide's effective background (`p:cSld/p:bg`), decoded into a typed
+	* {@link SlideBackground}. Resolved through the inheritance chain: the slide's
+	* own `p:bg` wins; failing that the slideLayout's, then the slideMaster's — the
+	* result's `source` records which supplied it. `null` when nothing in the chain
+	* defines a background.
+	*
+	* Colour tokens resolve against this slide's theme; an image background's
+	* `r:embed` resolves to an absolute part name through the *owning* part's
+	* relationships (the layout's rels for a layout-inherited image, etc.). Solid,
+	* gradient, and image backgrounds are the three the writer authors and so
+	* round-trip faithfully; `pattern`/`themeRef` are read-only for imported decks.
+	*/
+	get background() {
+		const opc = this.presentation.opc;
+		const parts = resolveSlideThemeParts(opc, this.partName);
+		const ctx = this.themeContext();
+		const candidates = [
+			{
+				root: parts.slideRoot,
+				source: "slide",
+				partName: this.partName
+			},
+			{
+				root: parts.layoutRoot,
+				source: "layout",
+				partName: parts.layoutPartName
+			},
+			{
+				root: parts.masterRoot,
+				source: "master",
+				partName: parts.masterPartName
+			}
+		];
+		const themeRels = parts.themePartName ? opc.relationshipsFor(parts.themePartName) : null;
+		for (const { root, source, partName } of candidates) {
+			const bg = backgroundElementOf(root);
+			if (!bg) continue;
+			return readSlideBackground(bg, source, ctx, partName ? opc.relationshipsFor(partName) : null, themeRels);
+		}
+		return null;
+	}
+	/**
+	* The slide's own slide-number placeholder (`p:sp` with `p:ph type="sldNum"`,
+	* carrying an `<a:fld type="slidenum">`), or `null` when the slide shows no slide
+	* number of its own. This is the concrete shape the writer emits for
+	* `pptx.setSlideNumber(...)` on a slide's layout; its geometry and run formatting
+	* read off the returned {@link AutoShape} the same as any placeholder.
+	*
+	* Scoped to the slide's *own* shape tree — a slide number inherited purely from
+	* the master's `p:hf`/placeholder (with no shape on the slide) is a master-level
+	* concern this getter does not resolve.
+	*/
+	get slideNumberPlaceholder() {
+		return this.placeholder("sldNum") ?? null;
+	}
+	/** The first top-level shape with the given drawing id (`p:cNvPr/@id`), or `undefined`. */
+	shapeById(id) {
+		return this.shapes.find((shape) => shape.id === id);
+	}
+	/**
+	* The first shape *anywhere* in the slide's shape tree with the given drawing id
+	* (`p:cNvPr/@id`), descending into groups — unlike {@link shapeById}, which scans
+	* only top-level shapes. Walked pre-order (a group is visited before its children),
+	* matching how the writer allocates ids. `undefined` when no shape carries that id.
+	*
+	* Drawing ids are unique within a slide, so the first match is the only match; the
+	* pre-order walk just fixes a deterministic order. This backs the connector-binding
+	* resolution ({@link import('./shapes.js').Connector.startConnection}), which must
+	* 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);
+	}
+	/** The first top-level shape with the given name (`p:cNvPr/@name`), or `undefined`. */
+	shapeByName(name) {
+		return this.shapes.find((shape) => shape.name === name);
+	}
+	/**
+	* The first placeholder of the given type (`p:ph/@type`, e.g. `title`,
+	* `ctrTitle`, `subTitle`, `body`), optionally narrowed by `idx`. Returns
+	* `undefined` when none match. Only `p:sp` shapes can be placeholders, so the
+	* result is an {@link AutoShape}.
+	*/
+	placeholder(type, idx) {
+		return this.shapes.find((shape) => {
+			const ph = shape instanceof AutoShape ? shape.placeholder : null;
+			return ph !== null && ph.type === type && (idx === void 0 || ph.idx === idx);
+		});
+	}
+	/**
+	* Append a text box (`p:sp` with `txBox="1"`) to the slide's shape tree and
+	* return it. Geometry is required (EMU); width and height must be positive.
+	* Allocates a drawing id unique within the slide. Marks the slide part dirty.
+	*/
+	addTextBox(options) {
+		const { left, top, width, height } = options;
+		requireFinite(left, "left");
+		requireFinite(top, "top");
+		requirePositive(width, "width");
+		requirePositive(height, "height");
+		const spTree = this.#spTree();
+		if (!spTree) throw new PackageReadError("slide/no-shape-tree", `Slide ${this.partName} has no spTree to add a shape to`);
+		const doc = spTree.ownerDocument;
+		if (!doc) throw new InternalError("oxml/node-has-no-document", "Slide DOM has no owner document");
+		const id = this.#nextShapeId();
+		const sp = buildTextBox(doc, {
+			id,
+			name: options.name ?? `TextBox ${id}`,
+			text: options.text ?? "",
+			left: Math.round(left),
+			top: Math.round(top),
+			width: Math.round(width),
+			height: Math.round(height)
+		});
+		this.#appendShape(spTree, sp);
+		return new AutoShape(sp, this);
+	}
+	/**
+	* Add a picture (`p:pic`) from raw image bytes and return it. Creates a media
+	* part under `/ppt/media/`, registers its content type, wires an `image`
+	* relationship from this slide, and appends the picture to the shape tree.
+	* Geometry is required (EMU); width and height must be positive. The image
+	* format is sniffed from the bytes unless `extension`/`contentType` are given.
+	*/
+	addPicture(image, options) {
+		const { left, top, width, height } = options;
+		requireFinite(left, "left");
+		requireFinite(top, "top");
+		requirePositive(width, "width");
+		requirePositive(height, "height");
+		const sniffed = sniffImageType(image);
+		const extension = (options.extension ?? sniffed?.extension)?.toLowerCase().replace(/^\./, "");
+		const contentType = options.contentType ?? sniffed?.contentType;
+		if (!extension || !contentType) throw new InvalidOptionError("image/undeterminable-type", "Could not determine image type; pass { extension, contentType } to addPicture");
+		const spTree = this.#spTree();
+		if (!spTree) throw new PackageReadError("slide/no-shape-tree", `Slide ${this.partName} has no spTree to add a picture to`);
+		const doc = spTree.ownerDocument;
+		if (!doc) throw new InternalError("oxml/node-has-no-document", "Slide DOM has no owner document");
+		const opc = this.presentation.opc;
+		const mediaPartName = opc.reserveMediaPartName(extension);
+		opc.addPart(mediaPartName, contentType, image);
+		const relId = this.relationships.add(IMAGE_REL_TYPE, relativePartName(this.partName, mediaPartName)).id;
+		const id = this.#nextShapeId();
+		const pic = buildPicture(doc, {
+			id,
+			name: options.name ?? `Picture ${id}`,
+			relId,
+			left: Math.round(left),
+			top: Math.round(top),
+			width: Math.round(width),
+			height: Math.round(height)
+		});
+		this.#appendShape(spTree, pic);
+		return new Picture(pic, this);
+	}
+	/**
+	* @internal The slide's shape tree (`p:cSld/p:spTree`), or `null` if absent.
+	* Exposed for cross-slide composition (`Presentation.importShape`).
+	*/
+	shapeTree() {
+		return this.#spTree();
+	}
+	/**
+	* @internal The smallest drawing id (`p:cNvPr/@id`) not already used on this
+	* slide. Exposed so `Presentation.importShape` can give a lifted shape (and its
+	* group children) collision-free ids on the host.
+	*/
+	nextShapeId() {
+		return this.#nextShapeId();
+	}
+	/** Insert a shape after grpSpPr and before any trailing p:extLst on the tree; mark dirty. */
+	#appendShape(spTree, shape) {
+		spTree.insertBefore(shape, firstChild(spTree, "p:extLst"));
+		this.part.markDirty();
+	}
+	/** The smallest drawing id (`p:cNvPr/@id`) not already used on the slide. */
+	#nextShapeId() {
+		const root = this.part.dom.documentElement;
+		let max = 1;
+		if (root) for (const cNvPr of root.getElementsByTagNameNS(OOXML_NS.p, "cNvPr")) {
+			const id = intValue(attr(cNvPr, "id"));
+			if (id !== null && id > max) max = id;
+		}
+		return max + 1;
+	}
+	#cSld() {
+		const root = this.part.dom.documentElement;
+		return root ? firstChild(root, "p:cSld") : null;
+	}
+	#spTree() {
+		const cSld = this.#cSld();
+		return cSld ? firstChild(cSld, "p:spTree") : null;
+	}
+};
+function requireFinite(value, name) {
+	if (!Number.isFinite(value)) throw new InvalidOptionError("coord/non-finite", `${name} must be a finite number of EMU, got ${value}`);
+}
+function requirePositive(value, name) {
+	requireFinite(value, name);
+	if (value <= 0) throw new InvalidOptionError("coord/not-positive", `${name} must be positive, got ${value}`);
+}
+/** Build a minimal, schema-valid text-box `p:sp` element (not yet attached). */
+function buildTextBox(doc, spec) {
+	const make = (qname) => createElement(doc, qname);
+	const append = (parent, qname) => {
+		const child = make(qname);
+		parent.appendChild(child);
+		return child;
+	};
+	const sp = make("p:sp");
+	const nvSpPr = append(sp, "p:nvSpPr");
+	const cNvPr = append(nvSpPr, "p:cNvPr");
+	setAttr(cNvPr, "id", String(spec.id));
+	setAttr(cNvPr, "name", spec.name);
+	setAttr(append(nvSpPr, "p:cNvSpPr"), "txBox", "1");
+	append(nvSpPr, "p:nvPr");
+	const spPr = append(sp, "p:spPr");
+	const xfrm = append(spPr, "a:xfrm");
+	const off = append(xfrm, "a:off");
+	setAttr(off, "x", String(spec.left));
+	setAttr(off, "y", String(spec.top));
+	const ext = append(xfrm, "a:ext");
+	setAttr(ext, "cx", String(spec.width));
+	setAttr(ext, "cy", String(spec.height));
+	const prstGeom = append(spPr, "a:prstGeom");
+	setAttr(prstGeom, "prst", "rect");
+	append(prstGeom, "a:avLst");
+	const txBody = append(sp, "p:txBody");
+	append(txBody, "a:bodyPr");
+	append(txBody, "a:lstStyle");
+	const p = append(txBody, "a:p");
+	if (spec.text !== "") {
+		const t = append(append(p, "a:r"), "a:t");
+		t.textContent = spec.text;
+		if (spec.text !== spec.text.trim()) setAttr(t, "xml:space", "preserve");
+	}
+	return sp;
+}
+/** Build a minimal, schema-valid `p:pic` element (not yet attached). */
+function buildPicture(doc, spec) {
+	const make = (qname) => createElement(doc, qname);
+	const append = (parent, qname) => {
+		const child = make(qname);
+		parent.appendChild(child);
+		return child;
+	};
+	const pic = make("p:pic");
+	const nvPicPr = append(pic, "p:nvPicPr");
+	const cNvPr = append(nvPicPr, "p:cNvPr");
+	setAttr(cNvPr, "id", String(spec.id));
+	setAttr(cNvPr, "name", spec.name);
+	setAttr(append(append(nvPicPr, "p:cNvPicPr"), "a:picLocks"), "noChangeAspect", "1");
+	append(nvPicPr, "p:nvPr");
+	const blipFill = append(pic, "p:blipFill");
+	setAttr(append(blipFill, "a:blip"), "r:embed", spec.relId);
+	append(append(blipFill, "a:stretch"), "a:fillRect");
+	const spPr = append(pic, "p:spPr");
+	const xfrm = append(spPr, "a:xfrm");
+	const off = append(xfrm, "a:off");
+	setAttr(off, "x", String(spec.left));
+	setAttr(off, "y", String(spec.top));
+	const ext = append(xfrm, "a:ext");
+	setAttr(ext, "cx", String(spec.width));
+	setAttr(ext, "cy", String(spec.height));
+	const prstGeom = append(spPr, "a:prstGeom");
+	setAttr(prstGeom, "prst", "rect");
+	append(prstGeom, "a:avLst");
+	return pic;
+}
+//#endregion
+//#region src/read/api/document-properties.ts
+/** Package-root rel to `/docProps/core.xml`. */
+const CORE_PROPS_REL_TYPE = "http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties";
+/** Content type of the core-properties part (fallback lookup when the rel is absent). */
+const CORE_PROPS_CONTENT_TYPE = "application/vnd.openxmlformats-package.core-properties+xml";
+/** Package-root rel to `/docProps/custom.xml`. */
+const CUSTOM_PROPS_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/custom-properties";
+/** Content type of the custom-properties part (fallback lookup when the rel is absent). */
+const CUSTOM_PROPS_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.custom-properties+xml";
+/** `dc:title`-style core-property fields, keyed by output field → element qname. */
+const CORE_FIELDS = [
+	["title", "dc:title"],
+	["subject", "dc:subject"],
+	["creator", "dc:creator"],
+	["keywords", "cp:keywords"],
+	["description", "dc:description"],
+	["lastModifiedBy", "cp:lastModifiedBy"],
+	["revision", "cp:revision"],
+	["category", "cp:category"],
+	["contentStatus", "cp:contentStatus"],
+	["created", "dcterms:created"],
+	["modified", "dcterms:modified"],
+	["lastPrinted", "cp:lastPrinted"]
+];
+/**
+* Read the deck's core document properties from `/docProps/core.xml`, resolved
+* via the package-root `core-properties` relationship (fallback: the part's
+* content type). Missing part → `{}` (all fields undefined). Present-but-empty
+* elements decode to the empty string.
+*/
+function readCoreProperties(opc) {
+	const rels = opc.relationshipsFor("/");
+	const rel = rels.byType(CORE_PROPS_REL_TYPE)[0];
+	const root = (rel ? opc.part(rels.resolveTarget(rel.id)) : opc.partsByContentType(CORE_PROPS_CONTENT_TYPE)[0])?.dom.documentElement;
+	if (!root) return {};
+	const out = {};
+	for (const [field, qname] of CORE_FIELDS) {
+		const el = firstChild(root, qname);
+		if (el) out[field] = el.textContent ?? "";
+	}
+	return out;
+}
+/**
+* Decode one `<property>`'s single `vt:` child into a typed value. String types
+* (`lpwstr`/`lpstr`/`bstr`) → string; integer types (`i1`..`i8`/`int`/`ui*`) →
+* number; real types (`r4`/`r8`/`decimal`) → number; `bool` → boolean;
+* `filetime`/`date` → the **raw string** (see {@link CoreProperties} on
+* timestamps). Any unrecognized `vt:` element falls back to its text content as a
+* string — lossy but never throws.
+*/
+function decodeValue(vt) {
+	const text = vt.textContent ?? "";
+	switch (vt.localName) {
+		case "lpwstr":
+		case "lpstr":
+		case "bstr": return text;
+		case "i1":
+		case "i2":
+		case "i4":
+		case "i8":
+		case "int":
+		case "ui1":
+		case "ui2":
+		case "ui4":
+		case "ui8":
+		case "uint": return intValue(text) ?? text;
+		case "r4":
+		case "r8":
+		case "decimal": {
+			const n = Number.parseFloat(text);
+			return Number.isFinite(n) ? n : text;
+		}
+		case "bool": return text.trim().toLowerCase() === "true" || text.trim() === "1";
+		case "filetime":
+		case "date": return text;
+		default: return text;
+	}
+}
+/**
+* Read the deck's user-defined custom properties from `/docProps/custom.xml`,
+* resolved via the package-root `custom-properties` relationship (fallback: the
+* part's content type). Each `<property name=...>` maps to `{ name, value }`,
+* with `value` typed from its single `vt:` child. Missing part → `[]`. A
+* `<property>` without a `@name` or without a `vt:` child is skipped.
+*
+* The `vt:` child and `<property>` element sit in namespaces outside the read
+* model's qname registry, so children are matched by local name rather than the
+* `firstChild`/`getElements` helpers.
+*/
+function readCustomProperties(opc) {
+	const rels = opc.relationshipsFor("/");
+	const rel = rels.byType(CUSTOM_PROPS_REL_TYPE)[0];
+	const root = (rel ? opc.part(rels.resolveTarget(rel.id)) : opc.partsByContentType(CUSTOM_PROPS_CONTENT_TYPE)[0])?.dom.documentElement;
+	if (!root) return [];
+	const out = [];
+	for (const property of childElements(root)) {
+		if (property.localName !== "property") continue;
+		const name = attr(property, "name");
+		const vt = firstChildElement(property);
+		if (name === null || !vt) continue;
+		out.push({
+			name,
+			value: decodeValue(vt)
+		});
+	}
+	return out;
+}
+//#endregion
+//#region src/read/api/slide-dom.ts
+/** The `p:cSld@name` of a slide/layout/master part (`''` when absent). */
+function cSldName(part) {
+	const root = part?.dom.documentElement;
+	const cSld = root && firstChild(root, "p:cSld");
+	return (cSld && attr(cSld, "name")) ?? "";
+}
+/** Whether `el` is a `p:spTree`'s own group properties (`p:nvGrpSpPr`/`p:grpSpPr`), not a shape. */
+function isSpTreeProperty(el) {
+	return el.namespaceURI === OOXML_NS.p && (el.localName === "nvGrpSpPr" || el.localName === "grpSpPr");
+}
+/** Whether a `p:spTree` child is a placeholder shape (its `*nvPr` carries a `p:ph`). */
+function isPlaceholderShape(shape) {
+	const nv = firstChildElement(shape);
+	const nvPr = nv && firstChild(nv, "p:nvPr");
+	return !!(nvPr && firstChild(nvPr, "p:ph"));
+}
+/** The decorative shapes on a layout/master `p:spTree`: every shape child except placeholders. */
+function carriedDecorations(root) {
+	if (!root) return [];
+	const cSld = firstChild(root, "p:cSld");
+	const spTree = cSld && firstChild(cSld, "p:spTree");
+	if (!spTree) return [];
+	const out = [];
+	for (let node = spTree.firstChild; node; node = node.nextSibling) {
+		if (node.nodeType !== 1) continue;
+		const el = node;
+		if (isSpTreeProperty(el) || isPlaceholderShape(el)) continue;
+		out.push(el);
+	}
+	return out;
+}
+/**
+* The `n`-th shape child of a `p:spTree` in document (z-)order, skipping the
+* tree's own `nvGrpSpPr`/`grpSpPr` and any trailing `p:extLst`. Returns `null`
+* when `n` is past the last shape (the caller then appends).
+*/
+function nthShapeChild(spTree, n) {
+	let i = 0;
+	for (let node = spTree.firstChild; node; node = node.nextSibling) {
+		if (node.nodeType !== 1) continue;
+		const el = node;
+		if (isSpTreeProperty(el)) continue;
+		if (el.namespaceURI === OOXML_NS.p && el.localName === "extLst") continue;
+		if (i === n) return el;
+		i++;
+	}
+	return null;
+}
+/** The first shape child of a `p:spTree` (skipping `nvGrpSpPr`/`grpSpPr`), or `null`. */
+function firstShapeChild(spTree) {
+	for (let node = spTree.firstChild; node; node = node.nextSibling) {
+		if (node.nodeType !== 1) continue;
+		const el = node;
+		if (!isSpTreeProperty(el)) return el;
+	}
+	return null;
+}
+/** Collect `node` and all its descendant elements (document order) into `out`. */
+function collectElements(node, out) {
+	out.push(node);
+	for (let child = node.firstChild; child; child = child.nextSibling) if (child.nodeType === 1) collectElements(child, out);
+}
+//#endregion
+//#region src/read/api/rescale.ts
+/** Build the EMU transform mapping source-canvas coordinates onto the target canvas (see {@link ImportSlideOptions.rescale}). */
+function computeRescale(source, target, mode) {
+	if (mode === "stretch") return {
+		sx: target.widthEmu / source.widthEmu,
+		sy: target.heightEmu / source.heightEmu,
+		dx: 0,
+		dy: 0
+	};
+	const scale = Math.min(target.widthEmu / source.widthEmu, target.heightEmu / source.heightEmu);
+	return {
+		sx: scale,
+		sy: scale,
+		dx: (target.widthEmu - source.widthEmu * scale) / 2,
+		dy: (target.heightEmu - source.heightEmu * scale) / 2
+	};
+}
+/**
+* Rescale every top-level transform on a `p:spTree`: shapes/pictures/connectors
+* (`p:spPr/a:xfrm`), groups (`p:grpSpPr/a:xfrm` — only the group's own off/ext, so
+* its children remap via the unchanged `chOff`/`chExt` rather than being recursed
+* into), and graphic frames (`p:graphicFrame/p:xfrm`, plus any inner table grid).
+* Placeholders that inherit geometry carry no `a:xfrm` and are left to inherit from
+* the (separately rescaled) layout/master.
+*/
+function rescaleSpTree(spTree, t) {
+	for (let node = spTree.firstChild; node; node = node.nextSibling) {
+		if (node.nodeType !== 1) continue;
+		const el = node;
+		if (el.namespaceURI !== OOXML_NS.p) continue;
+		switch (el.localName) {
+			case "sp":
+			case "pic":
+			case "cxnSp": {
+				const spPr = firstChild(el, "p:spPr");
+				rescaleXfrm(spPr && firstChild(spPr, "a:xfrm"), t);
+				break;
+			}
+			case "grpSp": {
+				const grpSpPr = firstChild(el, "p:grpSpPr");
+				rescaleXfrm(grpSpPr && firstChild(grpSpPr, "a:xfrm"), t);
+				break;
+			}
+			case "graphicFrame":
+				rescaleXfrm(firstChild(el, "p:xfrm"), t);
+				rescaleTableGrid(el, t);
+				break;
+		}
+	}
+}
+/** Rewrite an `a:xfrm`/`p:xfrm`: `a:off` is repositioned (scale + translate); `a:ext` is resized (scale only). */
+function rescaleXfrm(xfrm, t) {
+	if (!xfrm) return;
+	const off = firstChild(xfrm, "a:off");
+	if (off) {
+		const x = intValue(attr(off, "x"));
+		const y = intValue(attr(off, "y"));
+		if (x !== null) setAttr(off, "x", String(Math.round(x * t.sx + t.dx)));
+		if (y !== null) setAttr(off, "y", String(Math.round(y * t.sy + t.dy)));
+	}
+	const ext = firstChild(xfrm, "a:ext");
+	if (ext) {
+		const cx = intValue(attr(ext, "cx"));
+		const cy = intValue(attr(ext, "cy"));
+		if (cx !== null) setAttr(ext, "cx", String(Math.max(0, Math.round(cx * t.sx))));
+		if (cy !== null) setAttr(ext, "cy", String(Math.max(0, Math.round(cy * t.sy))));
+	}
+}
+/**
+* Scale a graphic-frame table's intrinsic dimensions — column widths by `sx`, row
+* heights by `sy` — so the table resizes with the slide (PowerPoint derives table
+* geometry from the grid, not the frame `a:ext`). No-op for non-table frames.
+*/
+function rescaleTableGrid(graphicFrame, t) {
+	const graphic = firstChild(graphicFrame, "a:graphic");
+	const graphicData = graphic && firstChild(graphic, "a:graphicData");
+	const tbl = graphicData && firstChild(graphicData, "a:tbl");
+	if (!tbl) return;
+	const grid = firstChild(tbl, "a:tblGrid");
+	if (grid) for (const col of getElements(grid, "a:gridCol")) {
+		const w = intValue(attr(col, "w"));
+		if (w !== null) setAttr(col, "w", String(Math.max(0, Math.round(w * t.sx))));
+	}
+	for (const tr of getElements(tbl, "a:tr")) {
+		const h = intValue(attr(tr, "h"));
+		if (h !== null) setAttr(tr, "h", String(Math.max(0, Math.round(h * t.sy))));
+	}
+}
+//#endregion
+//#region src/read/api/table-styles.ts
+const TABLE_STYLES_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/tableStyles";
+const TABLE_STYLES_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.presentationml.tableStyles+xml";
+const TABLE_STYLES_DEFAULT_GUID = "{5C22544A-7EE6-4342-B048-85BDC9FD1C3A}";
+const textEncoder$2 = 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
+* table resolves its `@tableStyleId` against the *destination* `tableStyles` and
+* silently falls back when that id is absent; the source `<a:tblStyle>` is itself
+* symbolic (scheme colours), so copying it verbatim under the **same** id lets the
+* table keep its structure while re-branding to this deck's theme — no table-XML
+* rewrite needed. Idempotent: an id this deck already defines is left as-is, and a
+* referenced id with no source definition is skipped. Creates and wires a
+* `tableStyles.xml` part if this deck has none.
+*/
+function copySourceTableStyles(dest, sourceOpc, slideRoot) {
+	const ids = /* @__PURE__ */ new Set();
+	for (const idEl of slideRoot.getElementsByTagNameNS(OOXML_NS.a, "tableStyleId")) {
+		const id = idEl.textContent?.trim();
+		if (id) ids.add(id);
+	}
+	if (ids.size === 0) return;
+	const sourceList = tableStyleList(sourceOpc);
+	if (!sourceList) return;
+	const sourceStyles = new Map(getElements(sourceList, "a:tblStyle").map((st) => [attr(st, "styleId"), st]));
+	const destPart = ensureTableStylesPart(dest);
+	const destList = destPart.dom.documentElement;
+	if (!destList) return;
+	const referenced = [];
+	for (const id of ids) {
+		const src = sourceStyles.get(id);
+		if (src) referenced.push(src);
+	}
+	if (addTableStyles(destList, referenced)) destPart.markDirty();
+}
+/**
+* Append each source `<a:tblStyle>` this deck does not already define, keyed by
+* `styleId` — the shared core of {@link copySourceTableStyles} (which offers only
+* the styles a restyled slide references) and {@link carryTableStyles} (which
+* offers the source's whole list). Destination-wins per id: a style this deck
+* already defines is left untouched, so a re-call adds nothing. Returns whether
+* 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/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`.
+*/
+const SLIDE_MASTER_REL$3 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideMaster";
+const SLIDE_LAYOUT_REL$3 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideLayout";
+const MIN_SLIDE_MASTER_ID = 2147483648;
+/**
+* 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$3)) if (presRels.resolveTarget(rel.id) === masterPartName) return;
+	const relId = presRels.add(SLIDE_MASTER_REL$3, 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 = MIN_SLIDE_MASTER_ID - 1;
+	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$3)) {
+		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$3, 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/part-copy.ts
+const SLIDE_LAYOUT_REL$2 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideLayout";
+const SLIDE_MASTER_REL$2 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideMaster";
+const NOTES_SLIDE_REL$2 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesSlide";
+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}).
+*/
+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 === NOTES_SLIDE_REL$2) continue;
+		if (isMaster && rel.type === SLIDE_LAYOUT_REL$2) 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);
+	}
+	if (sourcePart.contentType === SLIDE_LAYOUT_CONTENT_TYPE) linkLayoutIntoMaster(ctx, sourceRels, newPartName);
+	return newPartName;
+}
+/**
+* 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$2)[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/embedded-fonts.ts
+/**
+* Merging embedded font faces into a deck's `p:embeddedFontLst`.
+*
+* Fonts arrive two ways — copied out of another `Presentation`, or handed over as raw bytes by a
+* generator during an append — and the two differ only in how the binary part comes into being.
+* That difference is confined to a per-face thunk, so both paths share one merge core: entries
+* join by typeface, faces de-dupe by slot, and the thunk runs only for a face actually being
+* added, so a face the deck already embeds never mints an orphan part.
+*/
+/**
+* `p:embeddedFontLst`'s document-order successors in `CT_Presentation` (index 7,
+* after `smartTags`): everything that may legally follow it, so a created list
+* lands in the right slot when the deck has none yet.
+*/
+const PRESENTATION_EMBEDDED_FONT_LST_SUCCESSORS = [
+	"p:custShowLst",
+	"p:photoAlbum",
+	"p:custDataLst",
+	"p:kinsoku",
+	"p:defaultTextStyle",
+	"p:modifyVerifier",
+	"p:extLst"
+];
+/**
+* A face slot's document-order successors in `CT_EmbeddedFontListEntry`
+* (`font`, `regular`, `bold`, `italic`, `boldItalic`), so a newly-inserted face
+* keeps the schema's child order regardless of which slots already exist.
+*/
+const EMBEDDED_FONT_FACE_SUCCESSORS = {
+	regular: [
+		"p:bold",
+		"p:italic",
+		"p:boldItalic"
+	],
+	bold: ["p:italic", "p:boldItalic"],
+	italic: ["p:boldItalic"],
+	boldItalic: []
+};
+/**
+* Copy `source`'s embedded fonts into this deck and merge them into our
+* `p:embeddedFontLst`. Font binaries come across via {@link copyPart} (so the
+* per-source registry dedupes faces shared across repeated imports); entries are
+* merged by `typeface` + face slot, so a face this deck already embeds is reused
+* rather than duplicated. No-op when the source embeds no fonts. See
+* {@link ImportSlideOptions.embedFonts}.
+*/
+function carryEmbeddedFonts(dest, source, ctx) {
+	const sourceRoot = source.presentationPart.dom.documentElement;
+	const sourceLst = sourceRoot && firstChild(sourceRoot, "p:embeddedFontLst");
+	const sourceEntries = sourceLst ? getElements(sourceLst, "p:embeddedFont") : [];
+	if (sourceEntries.length === 0) return;
+	const sourcePresRels = source.opc.relationshipsFor(source.presentationPart.partName);
+	const incoming = [];
+	for (const srcEntry of sourceEntries) {
+		const srcFont = firstChild(srcEntry, "p:font");
+		const typeface = srcFont ? attr(srcFont, "typeface") : null;
+		if (!srcFont || !typeface) continue;
+		const identity = [];
+		for (const name of [
+			"panose",
+			"pitchFamily",
+			"charset"
+		]) {
+			const value = attr(srcFont, name);
+			if (value !== null) identity.push({
+				name,
+				value
+			});
+		}
+		const faces = [];
+		for (const slot of EMBEDDED_FONT_SLOTS) {
+			const srcFace = firstChild(srcEntry, `p:${slot}`);
+			const srcRid = srcFace && attr(srcFace, "r:id");
+			if (!srcFace || !srcRid) continue;
+			faces.push({
+				slot,
+				createPart: () => copyPart(ctx, sourcePresRels.resolveTarget(srcRid))
+			});
+		}
+		incoming.push({
+			typeface,
+			identity,
+			faces
+		});
+	}
+	mergeEmbeddedFontEntries(dest, incoming);
+}
+/**
+* Carry a generator's presentation-level embedded fonts ({@link ExtractedSlides.embeddedFonts},
+* from `pptx.embedFont`) into this deck during {@link Presentation.appendSlides}. Each face's raw bytes are
+* written as a fresh `/ppt/fonts/fontN.fntdata` part; merge/de-dupe by typeface + slot is shared
+* with {@link carryEmbeddedFonts} via {@link mergeEmbeddedFontEntries}, so appending the same
+* generator twice (or onto a deck that already embeds the face) carries each face once.
+*/
+function carryGeneratedEmbeddedFonts(dest, fonts) {
+	const incoming = [];
+	for (const font of fonts) {
+		if (!font.typeface) continue;
+		const identity = [];
+		if (font.panose !== void 0) identity.push({
+			name: "panose",
+			value: font.panose
+		});
+		if (font.pitchFamily !== void 0) identity.push({
+			name: "pitchFamily",
+			value: String(font.pitchFamily)
+		});
+		if (font.charset !== void 0) identity.push({
+			name: "charset",
+			value: String(font.charset)
+		});
+		const faces = [];
+		for (const slot of EMBEDDED_FONT_SLOTS) {
+			const face = font.faces.find((f) => f.slot === slot);
+			if (!face?.bytes) continue;
+			const bytes = face.bytes;
+			faces.push({
+				slot,
+				createPart: () => {
+					const partName = dest.opc.reservePartNameLike("/ppt/fonts/font1.fntdata");
+					dest.opc.addPart(partName, FONT_DATA_CONTENT_TYPE, bytes);
+					return partName;
+				}
+			});
+		}
+		if (faces.length > 0) incoming.push({
+			typeface: font.typeface,
+			identity,
+			faces
+		});
+	}
+	mergeEmbeddedFontEntries(dest, incoming);
+}
+/**
+* Merge normalized {@link IncomingEmbeddedFont} entries into this deck's
+* `p:embeddedFontLst` — the shared core of {@link carryEmbeddedFonts} (import-side)
+* and {@link carryGeneratedEmbeddedFonts} (append-side). Entries merge by `typeface`,
+* faces de-dupe by slot (a face this deck already embeds is left as is). For each newly
+* added face the `fntdata` Default is ensured, the binary part is created via the face's
+* `createPart` thunk, a `font` rel is added to presentation.xml, and the `p:<slot>` element
+* is inserted in schema child order. The list is created at CT_Presentation index 7 when
+* the deck has none yet. No-op for empty input.
+*/
+function mergeEmbeddedFontEntries(dest, entries) {
+	if (entries.length === 0) return;
+	const presPart = dest.presentationPart;
+	const presRoot = presPart.dom.documentElement;
+	if (!presRoot) throw new PackageReadError("package/part-has-no-root", "presentation.xml has no document element to carry embedded fonts into");
+	const presRels = dest.opc.relationshipsFor(presPart.partName);
+	const targetLst = getOrAddChild(presRoot, "p:embeddedFontLst", PRESENTATION_EMBEDDED_FONT_LST_SUCCESSORS);
+	const targetByTypeface = /* @__PURE__ */ new Map();
+	for (const entry of getElements(targetLst, "p:embeddedFont")) {
+		const font = firstChild(entry, "p:font");
+		const typeface = font && attr(font, "typeface");
+		if (typeface) targetByTypeface.set(typeface, entry);
+	}
+	let copiedAny = false;
+	for (const incoming of entries) {
+		let targetEntry = targetByTypeface.get(incoming.typeface);
+		if (!targetEntry) {
+			targetEntry = createElement(presPart.dom, "p:embeddedFont");
+			const targetFont = createElement(presPart.dom, "p:font");
+			setAttr(targetFont, "typeface", incoming.typeface);
+			for (const { name, value } of incoming.identity) setAttr(targetFont, name, value);
+			targetEntry.appendChild(targetFont);
+			targetLst.appendChild(targetEntry);
+			targetByTypeface.set(incoming.typeface, targetEntry);
+		}
+		for (const face of incoming.faces) {
+			if (firstChild(targetEntry, `p:${face.slot}`)) continue;
+			dest.opc.contentTypes.ensureDefault(FONT_DATA_EXTENSION, FONT_DATA_CONTENT_TYPE);
+			const newFontPart = face.createPart();
+			const relId = presRels.add(FONT_REL_TYPE, relativePartName(presPart.partName, newFontPart)).id;
+			const targetFace = createElement(presPart.dom, `p:${face.slot}`);
+			setAttr(targetFace, "r:id", relId);
+			insertInOrder(targetEntry, targetFace, EMBEDDED_FONT_FACE_SUCCESSORS[face.slot]);
+			copiedAny = true;
+		}
+	}
+	if (copiedAny) presPart.markDirty();
+}
+//#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 SLIDE_REL$1 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slide";
+const NOTES_SLIDE_REL$1 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesSlide";
+const NOTES_MASTER_REL$1 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesMaster";
+const THEME_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme";
+const NOTES_MASTER_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.presentationml.notesMaster+xml";
+const THEME_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.theme+xml";
+const textEncoder$1 = new TextEncoder();
+/**
+* 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$1)[0];
+	if (!notesRel) return;
+	const sourceNotesPartName = sourceSlideRels.resolveTarget(notesRel.id);
+	const sourceNotesPart = source.opc.part(sourceNotesPartName);
+	if (!sourceNotesPart) return;
+	const newNotesPartName = dest.opc.reservePartNameLike(sourceNotesPartName);
+	dest.opc.addPart(newNotesPartName, sourceNotesPart.contentType, sourceNotesPart.bytes);
+	dest.opc.relationshipsFor(newSlidePartName).add(NOTES_SLIDE_REL$1, relativePartName(newSlidePartName, newNotesPartName));
+	const notesSourceRels = source.opc.relationshipsFor(sourceNotesPartName);
+	const notesTargetRels = dest.opc.relationshipsFor(newNotesPartName);
+	for (const rel of notesSourceRels) {
+		if (rel.type === SLIDE_REL$1) {
+			notesTargetRels.addWithId(rel.id, SLIDE_REL$1, relativePartName(newNotesPartName, newSlidePartName));
+			continue;
+		}
+		if (rel.type === NOTES_MASTER_REL$1) {
+			const notesMaster = ensureNotesMaster(dest, ctx, notesSourceRels.resolveTarget(rel.id));
+			notesTargetRels.addWithId(rel.id, NOTES_MASTER_REL$1, 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$1)[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$1, 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$1)[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/part-index.ts
+/**
+* Walking a deck's master/layout spine by partname.
+*
+* The `p:sldMasterIdLst` / `p:sldLayoutIdLst` entries hold relationship ids, not partnames, so
+* every traversal has to resolve through the owning part's relationships. These are the
+* source-side reads that do it — used against a *foreign* presentation as often as against this
+* one, which is why they take the deck rather than living on it.
+*/
+/** Master partnames in `p:sldMasterIdLst` order. */
+function slideMasterPartNames(pres) {
+	const root = pres.presentationPart.dom.documentElement;
+	const lst = root && firstChild(root, "p:sldMasterIdLst");
+	if (!lst) return [];
+	const rels = pres.opc.relationshipsFor(pres.presentationPart.partName);
+	const out = [];
+	for (const entry of getElements(lst, "p:sldMasterId")) {
+		const relId = attr(entry, "r:id");
+		if (relId) out.push(rels.resolveTarget(relId));
+	}
+	return out;
+}
+/** A master's layout partnames in `p:sldLayoutIdLst` order. */
+function layoutPartNamesOf(pres, masterPartName) {
+	const root = pres.opc.part(masterPartName)?.dom.documentElement;
+	const lst = root && firstChild(root, "p:sldLayoutIdLst");
+	if (!lst) return [];
+	const rels = pres.opc.relationshipsFor(masterPartName);
+	const out = [];
+	for (const entry of getElements(lst, "p:sldLayoutId")) {
+		const relId = attr(entry, "r:id");
+		if (relId) out.push(rels.resolveTarget(relId));
+	}
+	return out;
+}
+/** Resolve the single relationship of `type` owned by `partName`, or `null`. */
+function resolveSingleRel(opc, partName, type) {
+	const rels = opc.relationshipsFor(partName);
+	const rel = rels.byType(type)[0];
+	return rel ? rels.resolveTarget(rel.id) : null;
+}
+//#endregion
+//#region src/read/api/ops/prune.ts
+/**
+* Orphan pruning after a part stops being referenced.
+*
+* Removing a slide can strand the parts only it used — its notes slide, media, chart parts. This
+* walks that fringe: a part is dropped when nothing left in the package (or the package root)
+* still resolves an internal relationship to it, and the parts *it* referenced are then examined
+* the same way. Shared chrome (masters, layouts, themes, the notes master) is exempt, so a deck
+* that momentarily has no slides does not lose its design.
+*/
+/**
+* Content types that are shared deck chrome: reachable through the
+* presentation → master → layout → theme graph, not owned by any one slide.
+* {@link Presentation.removeSlide} never prunes these as a removed slide's
+* orphan, even while momentarily unreferenced.
+*/
+const SHARED_CHROME_CONTENT_TYPES = /* @__PURE__ */ new Set([
+	"application/vnd.openxmlformats-officedocument.presentationml.slideMaster+xml",
+	"application/vnd.openxmlformats-officedocument.presentationml.slideLayout+xml",
+	"application/vnd.openxmlformats-officedocument.theme+xml",
+	"application/vnd.openxmlformats-officedocument.themeOverride+xml",
+	"application/vnd.openxmlformats-officedocument.presentationml.notesMaster+xml",
+	"application/vnd.openxmlformats-officedocument.presentationml.handoutMaster+xml",
+	"application/vnd.openxmlformats-officedocument.presentationml.presProps+xml",
+	"application/vnd.openxmlformats-officedocument.presentationml.viewProps+xml",
+	"application/vnd.openxmlformats-officedocument.presentationml.tableStyles+xml",
+	"application/vnd.openxmlformats-officedocument.presentationml.presentation.main+xml"
+]);
+/**
+* Remove `partName` if it is neither shared chrome nor still referenced by any
+* remaining part, then recurse into the parts it referenced. The pruning a
+* removed slide triggers (notes/media/charts the slide alone used).
+*/
+function pruneIfOrphan(pres, partName) {
+	const part = pres.opc.part(partName);
+	if (!part || SHARED_CHROME_CONTENT_TYPES.has(part.contentType)) return;
+	if (isReferenced(pres, partName)) return;
+	const rels = pres.opc.relationshipsFor(partName);
+	const childTargets = [...rels].filter((rel) => rel.targetMode !== "External").map((rel) => rels.resolveTarget(rel.id));
+	pres.opc.removePart(relsPartNameFor(partName));
+	pres.opc.removePart(partName);
+	for (const child of childTargets) pruneIfOrphan(pres, child);
+}
+/** Whether any remaining part (or the package root) resolves an internal relationship to `partName`. */
+function isReferenced(pres, partName) {
+	for (const owner of [...pres.opc.parts.keys(), "/"]) {
+		if (owner.endsWith(".rels")) continue;
+		const rels = pres.opc.relationshipsFor(owner);
+		for (const rel of rels) {
+			if (rel.targetMode === "External") continue;
+			if (rels.resolveTarget(rel.id) === partName) return true;
+		}
+	}
+	return false;
+}
+//#endregion
+//#region src/read/api/ops/rescale-import.ts
+/**
+* Rescaling an imported slide's geometry onto the destination canvas.
+*
+* The memo of already-rescaled parts is the load-bearing part: a layout or master shared by
+* several imports from one source deck must be rescaled exactly once, or the second import
+* scales it again on top of the first. It is owned by the calling `Presentation` and threaded
+* through here, so it lives as long as the deck does rather than as long as one call.
+*/
+const SLIDE_LAYOUT_REL$1 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideLayout";
+const SLIDE_MASTER_REL$1 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideMaster";
+/**
+* Rescale an imported slide's geometry onto this deck's canvas (the `rescale`
+* option of {@link Presentation.importSlide}). Rewrites every top-level shape/group/
+* graphicFrame transform and table grid on the slide; in `copy` mode also
+* rescales the imported layout and master shape trees (resolved via the
+* slide → layout → master rel chain) so inherited placeholder/background geometry
+* stays aligned. `preserve`/`restyle` rebind to this deck's own master/layout —
+* already the destination size — so only the slide is touched. Geometry only:
+* font sizes and line widths are left as authored.
+*/
+function rescaleImportedGeometry(dest, rescaledParts, slidePartName, theme, source, target, mode) {
+	const transform = computeRescale(source, target, mode);
+	rescalePartGeometry(dest, rescaledParts, slidePartName, transform);
+	if (theme === void 0 || theme === "copy") {
+		const layout = resolveSingleRel(dest.opc, slidePartName, SLIDE_LAYOUT_REL$1);
+		const master = layout ? resolveSingleRel(dest.opc, layout, SLIDE_MASTER_REL$1) : null;
+		if (layout) rescalePartGeometry(dest, rescaledParts, layout, transform);
+		if (master) rescalePartGeometry(dest, rescaledParts, master, transform);
+	}
+}
+/**
+* Rescale one part's `p:spTree` geometry in place. Idempotent per part
+* (`rescaledParts`), so a layout/master shared across repeated imports from one
+* source is rescaled exactly once.
+*/
+function rescalePartGeometry(dest, rescaledParts, partName, transform) {
+	if (rescaledParts.has(partName)) return;
+	rescaledParts.add(partName);
+	const part = dest.opc.part(partName);
+	const root = part?.dom.documentElement;
+	const cSld = root && firstChild(root, "p:cSld");
+	const spTree = cSld && firstChild(cSld, "p:spTree");
+	if (!part || !spTree) return;
+	rescaleSpTree(spTree, transform);
+	part.markDirty();
+}
+//#endregion
+//#region src/read/api/presentation.ts
+/**
+* Read-model entry point: `Presentation` wraps an `OpcPackage` and exposes a
+* navigable, typed view of the deck (slides → shapes → text), backed by the
+* live DOM so the same nodes can later be mutated.
+*/
+const OFFICE_DOCUMENT_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument";
+const SLIDE_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slide";
+const SLIDE_LAYOUT_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideLayout";
+const SLIDE_MASTER_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideMaster";
+const NOTES_SLIDE_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesSlide";
+const NOTES_MASTER_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesMaster";
+const IMAGE_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image";
+const HYPERLINK_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink";
+const CHART_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/chart";
+const PACKAGE_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/package";
+const AUDIO_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/audio";
+const VIDEO_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/video";
+const MS_MEDIA_REL = "http://schemas.microsoft.com/office/2007/relationships/media";
+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 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";
+/** Content type of the main part in a `.potx` template package — flipped to {@link PRESENTATION_MAIN_CONTENT_TYPE} by {@link Presentation.fromTemplate}. */
+const PRESENTATION_TEMPLATE_MAIN_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.presentationml.template.main+xml";
+const textEncoder = new TextEncoder();
+/**
+* `p:sldIdLst`'s document-order successors in `CT_Presentation` (ECMA-376):
+* everything that may legally follow it, so an inserted `p:sldIdLst` lands in the
+* right position when a template omitted it (zero slides).
+*/
+const PRESENTATION_SLD_ID_LST_SUCCESSORS = [
+	"p:sldSz",
+	"p:notesSz",
+	"p:smartTags",
+	"p:embeddedFontLst",
+	"p:custShowLst",
+	"p:photoAlbum",
+	"p:custDataLst",
+	"p:kinsoku",
+	"p:defaultTextStyle",
+	"p:modifyVerifier",
+	"p:extLst"
+];
+/** ST_SlideId minimum (ECMA-376): slide ids live in [256, 2147483647]. */
+const MIN_SLIDE_ID = 256;
+var Presentation = class Presentation {
+	opc;
+	#presentationPart;
+	/**
+	* Per-source copy registry for {@link importSlide}: source `OpcPackage` →
+	* (source partname → partname allocated in this package). Lets parts shared
+	* across imports from the same source deck (layout, master, theme, media) be
+	* copied once and reused on later calls.
+	*/
+	#importRegistry = /* @__PURE__ */ new Map();
+	/**
+	* Parts whose geometry {@link importSlide}'s `rescale` has already rewritten, so a
+	* layout/master shared across repeated imports from one source is not scaled twice.
+	*/
+	#rescaledParts = /* @__PURE__ */ new Set();
+	constructor(opc) {
+		this.opc = opc;
+	}
+	/** Open a `.pptx` from bytes and wrap it as a navigable `Presentation`. */
+	static async load(input) {
+		return new Presentation(await OpcPackage.load(input));
+	}
+	/** Wrap an already-loaded OPC package (e.g. from the lower-level API). */
+	static fromPackage(opc) {
+		return new Presentation(opc);
+	}
+	/**
+	* Open a PowerPoint template (`.pptx` or `.potx`) and return it as an empty
+	* deck shell ready to author onto: its slide masters, layouts, and theme are
+	* kept **byte-identical**, while any sample slides the template carried are
+	* stripped so only the shared chrome remains.
+	*
+	* Use it to build a fresh deck on a corporate template without rebuilding the
+	* masters in code: discover the bindable layouts with {@link layouts}, then
+	* author slides with a generator sized to match the template and graft them in
+	* with {@link appendSlides} (which enforces an equal slide size). Saving yields
+	* an editable `.pptx` that reuses the template's authored chrome verbatim.
+	*
+	* ```ts
+	* const deck = await Presentation.fromTemplate(templateBytes) // .pptx or .potx
+	* deck.layouts().map(l => l.name)                             // discover layouts
+	* await deck.appendSlides(pptx, { layout: 'Title and Content' })
+	* const out = await deck.save()                               // editable .pptx
+	* ```
+	*
+	* A `.potx` package declares its main part with the template content type; by
+	* default that override is flipped to the editable presentation type so the
+	* saved output opens as a normal deck. Pass `keepTemplateContentType: true` to
+	* preserve the template type. A `.pptx` input needs no flip, and a template
+	* that already carries zero slides makes the strip a no-op.
+	*/
+	static async fromTemplate(input, options = {}) {
+		const pres = new Presentation(await OpcPackage.load(input));
+		if (!options.keepTemplateContentType) {
+			const mainPart = pres.presentationPart;
+			if (mainPart.contentType === PRESENTATION_TEMPLATE_MAIN_CONTENT_TYPE) pres.opc.contentTypes.ensureRegistered(mainPart.partName, PRESENTATION_MAIN_CONTENT_TYPE);
+		}
+		while (pres.slides.length > 0) pres.removeSlide(0);
+		return pres;
+	}
+	/** The main presentation part (`/ppt/presentation.xml`), resolved via the package `officeDocument` relationship. */
+	get presentationPart() {
+		if (this.#presentationPart) return this.#presentationPart;
+		const packageRels = this.opc.relationshipsFor("/");
+		const officeDocument = packageRels.byType(OFFICE_DOCUMENT_REL);
+		const officeDocumentRel = officeDocument[0];
+		if (officeDocument.length !== 1 || !officeDocumentRel) throw new PackageReadError("package/office-document-relationship-invalid", `Expected exactly one officeDocument relationship, found ${officeDocument.length}`);
+		const partName = packageRels.resolveTarget(officeDocumentRel.id);
+		const part = this.opc.part(partName);
+		if (!part) throw new PackageReadError("package/relationship-target-missing", `officeDocument relationship targets a missing part: ${partName}`);
+		this.#presentationPart = part;
+		return part;
+	}
+	/** The slides in presentation order (resolved from `p:sldIdLst` + the presentation's relationships). */
+	get slides() {
+		const root = this.presentationPart.dom.documentElement;
+		const sldIdLst = root && firstChild(root, "p:sldIdLst");
+		if (!sldIdLst) return [];
+		const rels = this.opc.relationshipsFor(this.presentationPart.partName);
+		const slides = [];
+		let index = 0;
+		for (const sldId of getElements(sldIdLst, "p:sldId")) {
+			const relId = attr(sldId, "r:id");
+			if (!relId) continue;
+			const partName = rels.resolveTarget(relId);
+			const part = this.opc.part(partName);
+			if (!part) throw new PackageReadError("package/relationship-target-missing", `Slide relationship ${relId} targets a missing part: ${partName}`);
+			slides.push(new Slide(this, part, intValue(attr(sldId, "id")) ?? 0, index++));
+		}
+		return slides;
+	}
+	/** Slide dimensions (`p:sldSz`), or `null` if the presentation declares none. */
+	get slideSize() {
+		const root = this.presentationPart.dom.documentElement;
+		const sldSz = root && firstChild(root, "p:sldSz");
+		if (!sldSz) return null;
+		const widthEmu = intValue(attr(sldSz, "cx"));
+		const heightEmu = intValue(attr(sldSz, "cy"));
+		if (widthEmu === null || heightEmu === null) return null;
+		return {
+			widthEmu,
+			heightEmu,
+			widthIn: emuToInches(widthEmu),
+			heightIn: emuToInches(heightEmu)
+		};
+	}
+	/**
+	* The deck's embedded font families (`p:embeddedFontLst` in `presentation.xml`),
+	* `[]` when it embeds none. Each entry names the typeface and resolves every
+	* embedded face's `r:id` to the absolute partname of its `.fntdata` binary — the
+	* read counterpart to the write-side `pptx.embedFont` / `importSlide({ embedFonts })`
+	* carry. An entry whose `p:font` has no `@typeface`, or a face whose `r:id` is
+	* missing or dangling, is skipped (faithful degradation, no throw). Read-only.
+	*/
+	get embeddedFonts() {
+		const root = this.presentationPart.dom.documentElement;
+		const lst = root && firstChild(root, "p:embeddedFontLst");
+		if (!lst) return [];
+		const rels = this.opc.relationshipsFor(this.presentationPart.partName);
+		const fonts = [];
+		for (const entry of getElements(lst, "p:embeddedFont")) {
+			const font = firstChild(entry, "p:font");
+			const typeface = font && attr(font, "typeface");
+			if (!typeface) continue;
+			const faces = [];
+			for (const slot of EMBEDDED_FONT_SLOTS) {
+				const face = firstChild(entry, `p:${slot}`);
+				const relId = face && attr(face, "r:id");
+				if (!relId || !rels.get(relId)) continue;
+				faces.push({
+					slot,
+					partName: rels.resolveTarget(relId)
+				});
+			}
+			fonts.push({
+				typeface,
+				panose: font ? attr(font, "panose") : null,
+				faces
+			});
+		}
+		return fonts;
+	}
+	/**
+	* The deck-wide **legacy** comment-author registry (`p:cmAuthorLst` in
+	* `ppt/commentAuthors.xml`), `[]` when the deck has no comments. Each slide's
+	* {@link Slide.comments} resolves its `@authorId` against this list. The 2018
+	* modern comment authors (`ppt/authors.xml`) are a separate part, not decoded here.
+	*/
+	get commentAuthors() {
+		return readCommentAuthors(this.opc, this.presentationPart.partName);
+	}
+	/**
+	* The deck-wide **modern** (2018) comment-author registry (`p188:authorLst` in
+	* `ppt/authors.xml`), `[]` when the deck carries no modern comments. Unlike the
+	* legacy {@link commentAuthors}, each entry is keyed by a GUID `id` (plus
+	* `userId`/`providerId`); each slide's {@link Slide.modernComments} resolves its
+	* `@authorId` against this list. Read-only — the writer emits legacy comments.
+	*/
+	get modernCommentAuthors() {
+		return readModernCommentAuthors(this.opc, this.presentationPart.partName);
+	}
+	/**
+	* Which comment schema this deck uses: `'modern'` when it carries any 2018
+	* `modernComment_*` part (read via {@link Slide.modernComments} /
+	* {@link modernCommentAuthors}), `'legacy'` when it carries classic
+	* `commentN.xml` parts (read via {@link Slide.comments} / {@link commentAuthors}),
+	* or `'none'`. The two schemas do not coexist in practice, so this tells a
+	* consumer which accessor to read without probing both.
+	*/
+	get commentSchema() {
+		return commentSchema(this.opc);
+	}
+	/**
+	* The deck's core document properties (`docProps/core.xml`): title, subject,
+	* creator, keywords, revision, and the created/modified/lastPrinted timestamps
+	* (kept as raw W3CDTF strings). `{}` when the deck carries no core-properties
+	* part. The read counterpart of the write-side `pptx.title`/`subject`/`author`
+	* (→ `creator`)/`revision` setters.
+	*/
+	get coreProperties() {
+		return readCoreProperties(this.opc);
+	}
+	/**
+	* The deck's user-defined custom document properties (`docProps/custom.xml`) as
+	* `{ name, value }` pairs, each value typed from its `vt:` element (string,
+	* number, boolean, or a raw filetime string). `[]` when the deck carries no
+	* custom-properties part. The read counterpart of `pptx.setCustomProperty(...)`.
+	*/
+	get customProperties() {
+		return readCustomProperties(this.opc);
+	}
+	/**
+	* The deck-level programmatic tags (`p:custDataLst/p:tags` on `presentation.xml`,
+	* resolved to `ppt/tags/tagN.xml`) as `{ name, val }` string pairs, `[]` when the
+	* deck carries none. These are add-in/host metadata with no visible rendering and
+	* no writer — read-only, preserved byte-for-byte on round-trip. Per-slide tags are
+	* {@link Slide.tags}.
+	*/
+	get tags() {
+		return readTagsForPart(this.opc, this.presentationPart.partName);
+	}
+	/**
+	* 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.
+	*
+	* 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.
+	*/
+	cloneSlide(index, options = {}) {
+		const source = this.slides[index];
+		if (!source) throw new InvalidOptionError("slide/index-out-of-range", `No slide at index ${index} to clone`);
+		const opc = this.opc;
+		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);
+		return this.#insertSlidePart(newPart, options.at);
+	}
+	/**
+	* Remove the slide at `index` (deck order) and return its former partname. The
+	* `p:sldId` entry and the presentation→slide relationship are dropped, the slide
+	* part and its `.rels` are deleted, and any part the slide *privately* owned
+	* (its notes slide, slide-only media, charts/embeddings) that no remaining part
+	* references is pruned too — recursively. Shared deck chrome (layout, master,
+	* theme, …) is never pruned, so the deck stays renderable; removing every slide
+	* leaves a valid master/layout-only package (a template shell).
+	*
+	* Untouched parts stay byte-identical, matching the package fidelity contract.
+	* Throws when there is no slide at `index`.
+	*/
+	removeSlide(index) {
+		const slide = this.slides[index];
+		if (!slide) throw new InvalidOptionError("slide/index-out-of-range", `No slide at index ${index} to remove`);
+		const partName = slide.partName;
+		const slideRels = this.opc.relationshipsFor(partName);
+		const formerTargets = [...slideRels].filter((rel) => rel.targetMode !== "External").map((rel) => slideRels.resolveTarget(rel.id));
+		const presPart = this.presentationPart;
+		const presRels = this.opc.relationshipsFor(presPart.partName);
+		const root = presPart.dom.documentElement;
+		const sldIdLst = root && firstChild(root, "p:sldIdLst");
+		if (sldIdLst) for (const sldId of getElements(sldIdLst, "p:sldId")) {
+			const relId = attr(sldId, "r:id");
+			if (relId && presRels.get(relId) && presRels.resolveTarget(relId) === partName) {
+				sldIdLst.removeChild(sldId);
+				presRels.remove(relId);
+				break;
+			}
+		}
+		presPart.markDirty();
+		this.opc.removePart(relsPartNameFor(partName));
+		this.opc.removePart(partName);
+		for (const target of formerTargets) pruneIfOrphan(this, target);
+		return partName;
+	}
+	/**
+	* Append a copy of `source.slides[index]` to this presentation and return it.
+	*
+	* Unlike {@link cloneSlide} (same-deck duplicate), this copies a slide across
+	* a package boundary: it brings the connected sub-graph the slide depends on —
+	* its `slideLayout` → `slideMaster` → `theme`, plus any media, charts, and
+	* embeddings — into this package under fresh partnames, rewriting every
+	* partname, relationship id, and content-type registration so the result is a
+	* self-consistent OPC package. Parts of this (target) package that are not
+	* touched stay byte-identical, matching `cloneSlide`'s fidelity contract.
+	*
+	* 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.
+	*
+	* 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
+	* master/layout; with `{ theme: 'restyle' }` the slide is bound to this deck's
+	* master/layout with its theme references left symbolic, so it re-brands to the
+	* destination palette — see {@link ImportSlideOptions}.
+	*
+	* v1 limitations: by default the source slide size must equal this
+	* presentation's — pass `{ rescale: 'fit' | 'stretch' }` to rescale the imported
+	* geometry onto this deck's canvas instead (geometry only, not fonts/line
+	* widths). Source notes are dropped unless you pass `{ importNotes: true }`.
+	*/
+	importSlide(source, index, options = {}) {
+		const sourceSlide = source.slides[index];
+		if (!sourceSlide) throw new InvalidOptionError("slide/index-out-of-range", `No slide at index ${index} to import`);
+		const target = this.slideSize;
+		const incoming = source.slideSize;
+		const sizesDiffer = !target || !incoming || target.widthEmu !== incoming.widthEmu || target.heightEmu !== incoming.heightEmu;
+		if (sizesDiffer && !options.rescale) {
+			const fmt = (s) => s ? `${s.widthEmu}×${s.heightEmu} EMU` : "unknown";
+			throw new InvalidOptionError("import/slide-size-mismatch", `importSlide requires equal slide sizes (pass { rescale: 'fit' | 'stretch' } to rescale); target is ${fmt(target)}, source is ${fmt(incoming)}`);
+		}
+		if (sizesDiffer && options.rescale && (!target || !incoming)) throw new InvalidOptionError("import/slide-size-unknown", "importSlide rescale requires both decks to declare a slide size (p:sldSz)");
+		const newPartName = options.theme === "preserve" ? this.#importSlidePreserve(source, sourceSlide, options.carryMasterGraphics === true) : options.theme === "restyle" ? this.#importSlideRestyle(source, sourceSlide, options.carryMasterGraphics === true, options.remapLiterals === true) : copyPart(this.#importContext(source.opc), sourceSlide.partName);
+		const newPart = this.opc.part(newPartName);
+		if (!newPart) throw new InternalError("import/part-went-missing", `Imported slide part went missing: ${newPartName}`);
+		if (sizesDiffer && options.rescale && target && incoming) rescaleImportedGeometry(this, this.#rescaledParts, newPartName, options.theme, incoming, target, options.rescale === true ? "fit" : options.rescale);
+		const slide = this.#insertSlidePart(newPart, options.at);
+		if (options.importNotes) carryNotes(this, source, this.#importContext(source.opc), sourceSlide.partName, newPartName);
+		if (options.embedFonts) carryEmbeddedFonts(this, source, this.#importContext(source.opc));
+		return slide;
+	}
+	/**
+	* 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
+	* slide uses — this copies a master together with its **whole** layout family
+	* and attaches it to no slide: the master and its layouts land in this deck's
+	* layout gallery (PowerPoint's *Insert ▸ New Slide* / *Layout* picker) without
+	* changing any existing slide.
+	*
+	* It is the "ship a brand template's layouts into a generated deck" capability,
+	* kept brand-agnostic here: the caller supplies the source `.pptx`. Each grafted
+	* master is wired into `p:sldMasterIdLst` (so renderers treat it as active) and
+	* its `p:sldLayoutIdLst` is rebuilt to list exactly the copied layouts; the
+	* connected theme/media/tag parts come across under fresh partnames, and parts
+	* shared with earlier imports from the same source are reused (the copy
+	* registry), so a re-call is idempotent. Untouched parts of this package stay
+	* byte-identical, matching {@link importSlide}'s fidelity contract.
+	*
+	* `options.masters` / `options.layouts` narrow what is grafted; by default every
+	* master and every layout comes across. The source and destination slide sizes
+	* must match unless `options.requireEqualSize` is `false` (see
+	* {@link ImportSlideMastersOptions}).
+	*
+	* Presentation-level parts are carried only on request: embedded fonts via
+	* `options.embedFonts` and table styles via `options.tableStyles`. By default a
+	* grafted master is appended after the deck's existing masters; `options.primary`
+	* moves the grafted masters to the front so the deck presents as their theme (see
+	* {@link ImportSlideMastersOptions}). The v1 limitation mirroring
+	* {@link importSlide} is that geometry is not rescaled.
+	*/
+	importSlideMasters(source, options = {}) {
+		if (options.requireEqualSize !== false) {
+			const target = this.slideSize;
+			const incoming = source.slideSize;
+			if (!target || !incoming || target.widthEmu !== incoming.widthEmu || target.heightEmu !== incoming.heightEmu) {
+				const fmt = (s) => s ? `${s.widthEmu}×${s.heightEmu} EMU` : "unknown";
+				throw new InvalidOptionError("import/slide-size-mismatch", `importSlideMasters requires equal slide sizes (pass { requireEqualSize: false } to override); target is ${fmt(target)}, source is ${fmt(incoming)}`);
+			}
+		}
+		const pickMaster = options.masters ?? (() => true);
+		const pickLayout = options.layouts ?? (() => true);
+		const ctx = this.#importContext(source.opc);
+		const imported = [];
+		slideMasterPartNames(source).forEach((masterPartName, masterIndex) => {
+			if (!pickMaster(cSldName(source.opc.part(masterPartName)), masterIndex)) return;
+			const newMasterPartName = copyPart(ctx, masterPartName);
+			const layoutPartNames = [];
+			layoutPartNamesOf(source, masterPartName).forEach((layoutPartName, layoutIndex) => {
+				if (!pickLayout(cSldName(source.opc.part(layoutPartName)), layoutIndex)) return;
+				layoutPartNames.push(copyPart(ctx, layoutPartName));
+			});
+			imported.push({
+				partName: newMasterPartName,
+				layoutPartNames
+			});
+		});
+		if (options.embedFonts) carryEmbeddedFonts(this, source, this.#importContext(source.opc));
+		if (options.tableStyles) carryTableStyles(this, source.opc);
+		if (options.primary) promoteMasters(this, imported.map((m) => m.partName));
+		return imported;
+	}
+	/**
+	* The deck's slide masters, in `p:sldMasterIdLst` order, as modeled
+	* {@link SlideMaster}s — the typed read model over the shared chrome (each
+	* master's colour map, theme, placeholders, and the layouts built on it). Walk
+	* `pres.masters()[i].layouts` for the rich layout model, or use {@link layouts}
+	* for the flat {@link LayoutHandle} gallery {@link appendSlides} binds to.
+	* Read-only: it copies nothing and leaves the package byte-identical.
+	*/
+	masters() {
+		return slideMasterPartNames(this).map((partName) => this.opc.part(partName)).filter((part) => part !== void 0).map((part) => new SlideMaster(this.opc, part));
+	}
+	/**
+	* The deck's slide layouts, in master then layout order — the gallery a new
+	* slide can bind to. Each {@link LayoutHandle} addresses one layout for
+	* {@link appendSlides}; the `name` is its `p:cSld@name`. Read-only enumeration:
+	* it copies nothing and leaves the package byte-identical.
+	*/
+	layouts() {
+		const out = [];
+		slideMasterPartNames(this).forEach((masterPartName, masterIndex) => {
+			layoutPartNamesOf(this, masterPartName).forEach((layoutPartName, layoutIndex) => {
+				out.push({
+					partName: layoutPartName,
+					name: cSldName(this.opc.part(layoutPartName)),
+					masterPartName,
+					masterIndex,
+					layoutIndex
+				});
+			});
+		});
+		return out;
+	}
+	/**
+	* Append generator-produced slides onto this deck, binding each to an existing
+	* layout, and return the new {@link Slide}s. This is the hybrid
+	* "generate-onto-existing" path: the deck's masters, layouts, theme — and every
+	* other untouched part — stay **byte-identical** (only `presentation.xml`, its
+	* `.rels`, `[Content_Types].xml`, and the freshly-added slide/media parts
+	* change), because the existing chrome is never regenerated.
+	*
+	* `source` is any slide producer (a `TsPptx` instance); its authored slides
+	* are serialized via {@link SlideSource.extractSlides} and spliced in under
+	* fresh partnames, with each slide's `slideLayout` relationship pointed at the
+	* layout named by `options.layout` and its image/hyperlink relationships rebuilt
+	* (preserving the body's relationship ids). Insert position follows
+	* `options.at` (see {@link AppendSlidesOptions}).
+	*
+	* 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.
+	*
+	* The generator's presentation-level embedded fonts (`pptx.embedFont`) are also
+	* carried into this deck and merged into its `p:embeddedFontLst`, de-duped by
+	* typeface + face slot — so author-side embedded fonts survive the append onto a
+	* template that may itself already embed fonts.
+	*
+	* Embedded audio/video is carried too: the media part backs the ECMA audio/video rel
+	* and the MS-2007 `media` rel sharing one Target, plus a separate preview image part,
+	* with the media content type registered as a Default extension entry (what PowerPoint
+	* authors). Online (external-link) video rides as two External rels over the link.
+	*
+	* Speaker notes ride across too: a slide authored with `addNotes` gets a `notesSlide`
+	* part wired back to it, with its hyperlink rels preserved. A notes slide must bind to
+	* a notes master, and a template commonly has none, so the generator's is installed
+	* (with the theme its `.rels` needs) — but only when this deck has none of its own, so
+	* an existing notes master and its styling always win.
+	*
+	* Limitations:
+	* - An internal link to a source slide outside the appended batch throws (its
+	*   target has no counterpart in the destination).
+	* - Appended slides are concrete absolute-positioned content with no placeholder
+	*   inheritance from the bound layout; the binding governs theme/`clrMap`
+	*   resolution and the "based on" link, not placeholder geometry. Author with
+	*   concrete colours — any `schemeClr` re-resolves against the destination theme.
+	* - Source and destination slide sizes must match (no geometry rescale).
+	*/
+	async appendSlides(source, options) {
+		const gallery = this.layouts();
+		let target;
+		if (typeof options.layout === "string") {
+			const matches = gallery.filter((l) => l.name === options.layout);
+			if (matches.length > 1) throw new InvalidOptionError("layout/ambiguous-name", `appendSlides: layout name ${JSON.stringify(options.layout)} is ambiguous (${matches.length} layouts share it); pass a LayoutHandle from layouts() instead`);
+			const [only] = matches;
+			if (!only) {
+				const names = gallery.map((l) => JSON.stringify(l.name)).join(", ");
+				throw new InvalidOptionError("layout/not-found", `appendSlides: no layout named ${JSON.stringify(options.layout)}; available: ${names || "(none)"}`);
+			}
+			target = only;
+		} else {
+			const handle = options.layout;
+			if (!gallery.some((l) => l.partName === handle.partName)) throw new InvalidOptionError("layout/foreign-handle", `appendSlides: layout ${handle.partName} does not belong to this presentation`);
+			target = handle;
+		}
+		const extracted = await source.extractSlides({ onMediaError: options.onMediaError });
+		const size = this.slideSize;
+		if (!size || size.widthEmu !== extracted.widthEmu || size.heightEmu !== extracted.heightEmu) {
+			const fmt = (w, h) => `${w}×${h} EMU`;
+			throw new InvalidOptionError("import/slide-size-mismatch", `appendSlides requires equal slide sizes; target is ${size ? fmt(size.widthEmu, size.heightEmu) : "unknown"}, source is ${fmt(extracted.widthEmu, extracted.heightEmu)}`);
+		}
+		const slideTemplate = this.slides[0]?.partName ?? "/ppt/slides/slide1.xml";
+		const placed = extracted.slides.map((slide) => {
+			const partName = this.opc.reservePartNameLike(slideTemplate);
+			return {
+				slide,
+				part: this.opc.addPart(partName, SLIDE_CONTENT_TYPE, textEncoder.encode(slide.xml)),
+				partName
+			};
+		});
+		const partBySourceNumber = new Map(placed.map((p, i) => [i + 1, p.partName]));
+		const added = [];
+		placed.forEach(({ slide, part, partName }, i) => {
+			const rels = this.opc.relationshipsFor(partName);
+			for (const m of slide.media) {
+				const mediaPartName = this.opc.reserveMediaPartName(m.extn);
+				this.opc.addPart(mediaPartName, m.contentType, m.bytes);
+				rels.addWithId(`rId${m.rId}`, IMAGE_REL, relativePartName(partName, mediaPartName));
+			}
+			for (const av of slide.avMedia) {
+				const mediaPartName = this.opc.reserveMediaPartName(av.mediaExtn, "media");
+				this.opc.contentTypes.ensureDefault(av.mediaExtn, av.mediaContentType);
+				this.opc.addPart(mediaPartName, av.mediaContentType, av.mediaBytes);
+				const mediaTarget = relativePartName(partName, mediaPartName);
+				rels.addWithId(`rId${av.mediaRid}`, av.mtype === "audio" ? AUDIO_REL : VIDEO_REL, mediaTarget);
+				rels.addWithId(`rId${av.msMediaRid}`, MS_MEDIA_REL, mediaTarget);
+				const previewPartName = this.opc.reserveMediaPartName(av.previewExtn);
+				this.opc.contentTypes.ensureDefault(av.previewExtn, av.previewContentType);
+				this.opc.addPart(previewPartName, av.previewContentType, av.previewBytes);
+				rels.addWithId(`rId${av.previewRid}`, IMAGE_REL, relativePartName(partName, previewPartName));
+			}
+			for (const ov of slide.onlineMedia) {
+				rels.addWithId(`rId${ov.mediaRid}`, VIDEO_REL, ov.link, "External");
+				rels.addWithId(`rId${ov.msMediaRid}`, MS_MEDIA_REL, ov.link, "External");
+			}
+			for (const h of slide.hyperlinks) rels.addWithId(`rId${h.rId}`, HYPERLINK_REL, h.target, "External");
+			if (slide.notes) {
+				const notesPartName = this.opc.reservePartNameLike("/ppt/notesSlides/notesSlide1.xml");
+				this.opc.addPart(notesPartName, NOTES_SLIDE_CONTENT_TYPE, textEncoder.encode(slide.notes.xml));
+				rels.add(NOTES_SLIDE_REL, relativePartName(partName, notesPartName));
+				const notesRels = this.opc.relationshipsFor(notesPartName);
+				const notesMasterPartName = extracted.notesMaster ? ensureNotesMasterFromXml(this, extracted.notesMaster) : null;
+				if (notesMasterPartName) notesRels.addWithId("rId1", NOTES_MASTER_REL, relativePartName(notesPartName, notesMasterPartName));
+				notesRels.addWithId("rId2", SLIDE_REL, relativePartName(notesPartName, partName));
+				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 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));
+			}
+			for (const link of slide.slideLinks) {
+				const targetPartName = partBySourceNumber.get(link.sourceSlideNumber);
+				if (!targetPartName) throw new InvalidOptionError("import/unresolved-slide-link", `appendSlides: slide ${i} links to source slide ${link.sourceSlideNumber}, which is not among the appended slides`);
+				rels.addWithId(`rId${link.rId}`, SLIDE_REL, relativePartName(partName, targetPartName));
+			}
+			rels.add(SLIDE_LAYOUT_REL, relativePartName(partName, target.partName));
+			const at = options.at === void 0 ? void 0 : options.at + i;
+			added.push(this.#insertSlidePart(part, at));
+		});
+		carryGeneratedEmbeddedFonts(this, extracted.embeddedFonts || []);
+		return added;
+	}
+	/**
+	* Copy one shape — an autoshape, picture, table/chart graphic frame, connector,
+	* or group — from `source.shapes[shapeIndex]` onto `target`, returning the new
+	* {@link Shape}. `target` must be a slide of *this* presentation; `source` may
+	* belong to any open presentation.
+	*
+	* The lifted subtree is copied self-consistently: every media/chart/embedding it
+	* depends on is dragged into this package (deduped against earlier imports from
+	* the same source), its `r:embed`/`r:id`/… are rewritten to fresh host-slide
+	* relationships, and its drawing ids (including a group's children) are reassigned
+	* so they cannot collide with the host. With `theme: 'preserve'` (default) the
+	* shape's theme references are baked to literals against the *source* theme so it
+	* renders the same on a foreign host; `restyle` leaves them symbolic to re-brand;
+	* `copy` brings the XML across untouched — see {@link ImportShapeOptions}.
+	*
+	* Differing slide sizes need `{ rescale }` (see {@link ImportShapeOptions.rescale});
+	* a lifted `preserve` placeholder is baked self-contained and demoted to a plain
+	* shape (see {@link ImportShapeOptions.theme}), so it neither re-inherits from nor
+	* collides with the host. A shape's build animation lives in the slide-scoped
+	* `p:timing`, not in its subtree, so the shape lands static unless
+	* `{ carryAnimation: true }` opts in (see {@link ImportShapeOptions.carryAnimation}).
+	*/
+	importShape(target, source, shapeIndex, options = {}) {
+		const [shape] = this.importShapes(target, source, [shapeIndex], options);
+		if (!shape) throw new InvalidOptionError("shape/index-out-of-range", `importShape: source slide has no shape at index ${shapeIndex}`);
+		return shape;
+	}
+	/**
+	* Batch form of {@link importShape}: copy several shapes from one source slide
+	* onto `target` in the given order. Media/chart/embedding parts shared by the
+	* lifted shapes (and by earlier imports from the same source deck) are copied
+	* once via the copy registry, and shared images resolve to a single host-slide
+	* relationship. Returns the new {@link Shape}s in `shapeIndices` order.
+	*/
+	importShapes(target, source, shapeIndices, options = {}) {
+		if (target.presentation !== this) throw new InvalidOptionError("slide/foreign-target", "importShape: target slide must belong to this presentation");
+		const targetSize = this.slideSize;
+		const sourceSize = source.presentation.slideSize;
+		const sizesMatch = !!targetSize && !!sourceSize && targetSize.widthEmu === sourceSize.widthEmu && targetSize.heightEmu === sourceSize.heightEmu;
+		let transform = null;
+		if (!sizesMatch) {
+			if (!options.rescale || !targetSize || !sourceSize) {
+				const fmt = (s) => s ? `${s.widthEmu}×${s.heightEmu} EMU` : "unknown";
+				throw new InvalidOptionError("import/slide-size-mismatch", `importShape requires equal slide sizes (or { rescale }); target is ${fmt(targetSize)}, source is ${fmt(sourceSize)}`);
+			}
+			transform = computeRescale(sourceSize, targetSize, options.rescale === "stretch" ? "stretch" : "fit");
+		}
+		const sourceShapes = source.shapes;
+		const sourceElements = shapeIndices.map((i) => {
+			const shape = sourceShapes[i];
+			if (!shape) throw new InvalidOptionError("shape/index-out-of-range", `No shape at index ${i} on the source slide (it has ${sourceShapes.length})`);
+			return shape.element_;
+		});
+		const spTree = target.shapeTree();
+		if (!spTree) throw new PackageReadError("slide/no-shape-tree", `importShape: target slide ${target.partName} has no shape tree`);
+		const targetDoc = spTree.ownerDocument;
+		if (!targetDoc) throw new InternalError("oxml/node-has-no-document", "importShape: target slide DOM has no owner document");
+		const theme = options.theme ?? "preserve";
+		const sourceOpc = source.presentation.opc;
+		const sourceRels = sourceOpc.relationshipsFor(source.partName);
+		const targetRels = this.opc.relationshipsFor(target.partName);
+		const relIdMap = /* @__PURE__ */ new Map();
+		const ctx = theme === "preserve" ? this.#sourceFlattenContext(sourceOpc, source.partName) : null;
+		const importCtx = this.#importContext(sourceOpc);
+		const extLst = firstChild(spTree, "p:extLst");
+		const anchor = options.at == null ? extLst : nthShapeChild(spTree, options.at) ?? extLst;
+		const result = [];
+		for (const shapeEl of sourceElements) {
+			const imported = targetDoc.importNode(shapeEl, true);
+			this.#rewriteCarriedRels(imported, importCtx, sourceRels, target.partName, targetRels, relIdMap);
+			if (ctx) {
+				const holder = createElement(targetDoc, "p:spTree");
+				holder.appendChild(imported);
+				flattenShape(holder, ctx);
+			}
+			if (transform) {
+				const holder = createElement(targetDoc, "p:spTree");
+				holder.appendChild(imported);
+				rescaleSpTree(holder, transform);
+			}
+			let nextId = target.nextShapeId();
+			const spidMap = /* @__PURE__ */ new Map();
+			for (const cNvPr of imported.getElementsByTagNameNS(OOXML_NS.p, "cNvPr")) {
+				const oldId = intValue(attr(cNvPr, "id"));
+				if (oldId !== null) spidMap.set(oldId, nextId);
+				setAttr(cNvPr, "id", String(nextId++));
+			}
+			spTree.insertBefore(imported, anchor);
+			if (options.carryAnimation) {
+				const sourceRoot = source.part.dom.documentElement;
+				const targetRoot = target.part.dom.documentElement;
+				if (sourceRoot && targetRoot) carryShapeAnimations(sourceRoot, targetRoot, spidMap);
+			}
+			const shape = wrapShapeElement(imported, target);
+			if (!shape) throw new UnsupportedFeatureError("shape/element-unsupported", `importShape: unsupported shape element <${imported.localName}>`);
+			if (options.left != null) shape.left = options.left;
+			if (options.top != null) shape.top = options.top;
+			if (options.width != null) shape.width = options.width;
+			if (options.height != null) shape.height = options.height;
+			result.push(shape);
+		}
+		target.part.markDirty();
+		return result;
+	}
+	/**
+	* Import a slide in `preserve` mode: rebind it to this deck's master/layout
+	* (see {@link #importSlideRebind}), then flatten its source theme into the slide
+	* XML (scheme colours + style-matrix fills baked to literals). Returns the new
+	* partname.
+	*
+	* The flatten context is gathered from the *source* subgraph, so it can be read
+	* before or after the rebind; the rebind injects any carried decorations before
+	* we flatten, so a single sweep resolves the theme references on the slide's own
+	* content and on the carried decorations together.
+	*/
+	#importSlidePreserve(source, sourceSlide, carryGraphics) {
+		const ctx = this.#sourceFlattenContext(source.opc, sourceSlide.partName);
+		const { newPartName, slideRoot, newPart } = this.#importSlideRebind(source, sourceSlide, carryGraphics);
+		flattenSlide(slideRoot, ctx);
+		newPart.markDirty();
+		return newPartName;
+	}
+	/**
+	* Import a slide in `restyle` mode: rebind it to this deck's master/layout (see
+	* {@link #importSlideRebind}) and then {@link restyleSlide} it — drop its colour
+	* map override but bake *nothing*, so its symbolic theme references re-resolve
+	* against the destination theme and the slide re-brands. Returns the new
+	* partname.
+	*
+	* The deliberate inverse of `preserve`: no flatten, no inherited-background
+	* bake, no placeholder colour/size/geometry bake — every one of those would pin
+	* the slide to its source look, the opposite of re-branding. Carried
+	* decorations are left symbolic too, so they re-brand along with the slide.
+	*
+	* With `remapLiterals` it additionally force-remaps the slide's source-theme
+	* literal colours back to symbolic scheme colours and copies any referenced
+	* source table style into this deck — the two things plain `restyle` cannot
+	* re-brand (see {@link ImportSlideOptions.remapLiterals}).
+	*/
+	#importSlideRestyle(source, sourceSlide, carryGraphics, remapLiterals) {
+		const { newPartName, slideRoot, newPart } = this.#importSlideRebind(source, sourceSlide, carryGraphics);
+		restyleSlide(slideRoot);
+		if (remapLiterals) {
+			const parts = resolveSlideThemeParts(source.opc, sourceSlide.partName);
+			remapLiteralColors(slideRoot, {
+				clrMap: parts.clrMap,
+				clrScheme: parts.clrScheme
+			});
+			copySourceTableStyles(this, source.opc, slideRoot);
+		}
+		newPart.markDirty();
+		return newPartName;
+	}
+	/**
+	* The rebind shared by `preserve` and `restyle`: copy the slide bytes into a
+	* fresh part, rebuild its relationships (drop notes, repoint the `slideLayout`
+	* rel at this deck's existing layout, copy every other internal target —
+	* media/charts — and pass externals through), and optionally bake the source
+	* master/layout decorations onto the slide. Returns the new part, its name, and
+	* its live root element for the caller's mode-specific pass (flatten vs restyle).
+	*
+	* This carries *no* theme baking of its own — not even the inherited background.
+	* `preserve` adds that via {@link flattenSlide}'s context; `restyle` must not,
+	* so the background stays symbolic and re-brands.
+	*/
+	#importSlideRebind(source, sourceSlide, carryGraphics) {
+		const destLayout = this.#destinationLayoutPartName();
+		const sourcePart = source.opc.part(sourceSlide.partName);
+		if (!sourcePart) throw new PackageReadError("package/part-missing", `importSlide: source package has no part ${sourceSlide.partName}`);
+		const newPartName = this.opc.reservePartNameLike(sourceSlide.partName);
+		const newPart = this.opc.addPart(newPartName, sourcePart.contentType, sourcePart.bytes);
+		const slideRoot = newPart.dom.documentElement;
+		if (!slideRoot) throw new PackageReadError("package/part-has-no-root", `Imported slide ${newPartName} has no root element`);
+		const ctx = this.#importContext(source.opc);
+		const sourceRels = source.opc.relationshipsFor(sourceSlide.partName);
+		const targetRels = this.opc.relationshipsFor(newPartName);
+		for (const rel of sourceRels) {
+			if (rel.type === NOTES_SLIDE_REL) continue;
+			if (rel.type === SLIDE_LAYOUT_REL) {
+				targetRels.addWithId(rel.id, SLIDE_LAYOUT_REL, relativePartName(newPartName, destLayout));
+				continue;
+			}
+			if (rel.targetMode === "External") {
+				targetRels.addWithId(rel.id, rel.type, rel.target, "External");
+				continue;
+			}
+			const newTarget = copyPart(ctx, sourceRels.resolveTarget(rel.id));
+			targetRels.addWithId(rel.id, rel.type, relativePartName(newPartName, newTarget));
+		}
+		if (carryGraphics) this.#carryMasterGraphics(ctx, slideRoot, newPartName, sourceSlide.partName);
+		return {
+			newPartName,
+			slideRoot,
+			newPart
+		};
+	}
+	/**
+	* Bake the source `slideLayout`/`slideMaster` shape-tree decorations onto the
+	* imported slide (the `carryMasterGraphics` path). Every shape on those trees
+	* *except* placeholders is deep-copied into the slide's `p:spTree` ahead of its
+	* own content — master decorations first, then layout, then the slide's shapes —
+	* so document (z-)order keeps the master furthest back. Each decoration's media
+	* and other relationship targets are copied into this package and its
+	* `r:embed`/`r:id`/… references rewritten to fresh slide-local ids. The injected
+	* shapes are left for the caller's {@link flattenSlide} pass to resolve any
+	* theme references they carry.
+	*/
+	#carryMasterGraphics(ctx, slideRoot, newPartName, slidePartName) {
+		const sourceOpc = ctx.source;
+		const layoutPartName = resolveSingleRel(sourceOpc, slidePartName, SLIDE_LAYOUT_REL);
+		const masterPartName = layoutPartName ? resolveSingleRel(sourceOpc, layoutPartName, SLIDE_MASTER_REL) : null;
+		const cSld = firstChild(slideRoot, "p:cSld");
+		const spTree = cSld && firstChild(cSld, "p:spTree");
+		if (!spTree) return;
+		const doc = ownerDocumentOf(slideRoot);
+		const slideRels = this.opc.relationshipsFor(newPartName);
+		const relIdMap = /* @__PURE__ */ new Map();
+		const anchor = firstShapeChild(spTree);
+		for (const partName of [masterPartName, layoutPartName]) {
+			if (!partName) continue;
+			const decorations = carriedDecorations(sourceOpc.part(partName)?.dom.documentElement ?? null);
+			if (decorations.length === 0) continue;
+			const sourceRels = sourceOpc.relationshipsFor(partName);
+			for (const deco of decorations) {
+				const imported = doc.importNode(deco, true);
+				this.#rewriteCarriedRels(imported, ctx, sourceRels, newPartName, slideRels, relIdMap);
+				spTree.insertBefore(imported, anchor);
+			}
+		}
+	}
+	/**
+	* Rewrite every relationship reference (`r:embed`, `r:id`, `r:link`, …) inside a
+	* carried decoration so it points at a fresh slide-local relationship, copying
+	* the referenced part into this package on first sight. `relIdMap` (keyed by
+	* source part + source rel id) dedupes references shared within one import call.
+	*/
+	#rewriteCarriedRels(node, ctx, sourceRels, newPartName, slideRels, relIdMap) {
+		const elements = [];
+		collectElements(node, elements);
+		for (const el of elements) {
+			const refs = [];
+			const attrs = el.attributes;
+			for (let i = 0; i < attrs.length; i++) {
+				const a = attrs.item(i);
+				if (!a || a.namespaceURI !== OOXML_NS.r || !a.value) continue;
+				if (!sourceRels.get(a.value)) continue;
+				refs.push({
+					local: a.localName ?? a.name,
+					id: a.value
+				});
+			}
+			for (const { local, id } of refs) setAttr(el, `r:${local}`, this.#carryRel(ctx, sourceRels, id, newPartName, slideRels, relIdMap));
+		}
+	}
+	/** Resolve a carried decoration's source relationship to a fresh slide-local id, copying its internal target. */
+	#carryRel(ctx, sourceRels, id, newPartName, slideRels, relIdMap) {
+		const key = `${sourceRels.sourcePartName}|${id}`;
+		const cached = relIdMap.get(key);
+		if (cached) return cached;
+		const rel = sourceRels.get(id);
+		if (!rel) throw new InvalidOptionError("relationship/not-found", `Relationships of ${sourceRels.sourcePartName}: no relationship with id ${id}`);
+		const newId = rel.targetMode === "External" ? slideRels.add(rel.type, rel.target, "External").id : slideRels.add(rel.type, relativePartName(newPartName, copyPart(ctx, sourceRels.resolveTarget(id)))).id;
+		relIdMap.set(key, newId);
+		return newId;
+	}
+	/**
+	* The partname of the layout this deck's slides should attach to in `preserve`
+	* mode: the first layout of the first slide master. Throws when the deck has no
+	* master/layout to attach to (a deck ts-pptx always provides).
+	*/
+	#destinationLayoutPartName() {
+		const presRels = this.opc.relationshipsFor(this.presentationPart.partName);
+		const masterRel = presRels.byType(SLIDE_MASTER_REL)[0];
+		if (!masterRel) throw new InvalidOptionError("import/destination-missing-master", "importSlide preserve mode requires a slide master in the destination deck");
+		const masterPartName = presRels.resolveTarget(masterRel.id);
+		const masterRels = this.opc.relationshipsFor(masterPartName);
+		const layoutRel = masterRels.byType(SLIDE_LAYOUT_REL)[0];
+		if (!layoutRel) throw new InvalidOptionError("import/destination-missing-layout", "importSlide preserve mode requires a slide layout in the destination deck");
+		return masterRels.resolveTarget(layoutRel.id);
+	}
+	/**
+	* Gather the flatten context for a source slide: walk slide → layout → master →
+	* theme, reading the effective colour map (the slide's `clrMapOvr` override, or
+	* the master `clrMap`), the theme `clrScheme`, and the theme `fmtScheme`.
+	*/
+	#sourceFlattenContext(sourceOpc, slidePartName) {
+		const parts = resolveSlideThemeParts(sourceOpc, slidePartName);
+		const themeElements = parts.themeElements;
+		return {
+			clrMap: parts.clrMap,
+			clrScheme: parts.clrScheme,
+			fmtScheme: themeElements ? firstChild(themeElements, "a:fmtScheme") : null,
+			inheritedBackground: this.#effectiveBackground(sourceOpc, parts.slideRoot, parts.layoutPartName, parts.masterPartName),
+			layoutRoot: parts.layoutRoot,
+			masterRoot: parts.masterRoot
+		};
+	}
+	/**
+	* The background the slide effectively inherits from its source subgraph: the
+	* layout's `p:bg`, else the master's. Returns `null` when the slide carries its
+	* own `p:bg` (it stays on the slide and is flattened directly) or none exists.
+	*/
+	#effectiveBackground(sourceOpc, slideRoot, layoutPartName, masterPartName) {
+		if (slideRoot && this.#backgroundOf(slideRoot)) return null;
+		const layoutRoot = layoutPartName ? sourceOpc.part(layoutPartName)?.dom.documentElement ?? null : null;
+		const masterRoot = masterPartName ? sourceOpc.part(masterPartName)?.dom.documentElement ?? null : null;
+		return (layoutRoot && this.#backgroundOf(layoutRoot)) ?? (masterRoot && this.#backgroundOf(masterRoot)) ?? null;
+	}
+	/** The `p:cSld/p:bg` element of a slide/layout/master root, or `null`. */
+	#backgroundOf(root) {
+		const cSld = firstChild(root, "p:cSld");
+		return cSld ? firstChild(cSld, "p:bg") : null;
+	}
+	/**
+	* Open an import out of `source`: this deck as the destination, paired with the
+	* copy registry for that package (created on first use). The registry is held on
+	* the class rather than in the context because it must outlive any one call —
+	* that is what makes a second import from the same source reuse the layout,
+	* master, theme, and media it already copied instead of duplicating them.
+	*/
+	#importContext(source) {
+		let registry = this.#importRegistry.get(source);
+		if (!registry) {
+			registry = /* @__PURE__ */ new Map();
+			this.#importRegistry.set(source, registry);
+		}
+		return {
+			dest: this,
+			source,
+			registry
+		};
+	}
+	/**
+	* Wire a new slide part into `p:sldIdLst` (rel + `p:sldId`) at zero-based
+	* position `at` and return it. `p:sldIdLst` order *is* deck order, so the
+	* insertion point is the only bookkeeping needed. An `at` that is omitted,
+	* negative, or `>=` the current slide count appends (the prior behaviour).
+	*/
+	#insertSlidePart(newPart, at) {
+		const presPart = this.presentationPart;
+		const relId = this.opc.relationshipsFor(presPart.partName).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);
+		const existing = getElements(sldIdLst, "p:sldId");
+		const newSlideId = this.#nextSlideId(existing);
+		const sldId = createElement(presPart.dom, "p:sldId");
+		setAttr(sldId, "id", String(newSlideId));
+		setAttr(sldId, "r:id", relId);
+		const inRange = at !== void 0 && at >= 0 && at < existing.length;
+		const newIndex = inRange ? at : existing.length;
+		const before = inRange ? existing[at] : null;
+		if (before) sldIdLst.insertBefore(sldId, before);
+		else sldIdLst.appendChild(sldId);
+		presPart.markDirty();
+		return new Slide(this, newPart, newSlideId, newIndex);
+	}
+	/** A slide id one past the highest existing, but at least ST_SlideId's minimum. */
+	#nextSlideId(sldIds) {
+		let max = MIN_SLIDE_ID - 1;
+		for (const sldId of sldIds) {
+			const id = intValue(attr(sldId, "id"));
+			if (id !== null && id > max) max = id;
+		}
+		return max + 1;
+	}
+	/** Re-emit the package; untouched parts stay byte-identical (see `OpcPackage.save`). */
+	async save() {
+		return this.opc.save();
+	}
+};
+//#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-B0JWdTN1.js.map