pptx-ts 3.7.0 → 4.0.1

package/dist/text-sN64Otf_.js

@@ -0,0 +1,3980 @@
+import { l as warn, n as InvalidOptionError, r as MediaError, t as InternalError, u as warnOnce } from "./errors-C4oENPcu.js";
+import { F as DEF_PRES_LAYOUT_NAME, J as SLDNUM_PLACEHOLDER_TEXT, P as DEF_PRES_LAYOUT, R as DEF_SLIDE_MARGIN_IN, U as LEVEL_MARGINS_EMU, V as LAYOUT_IDX_SERIES_BASE, X as MIN_SLIDE_MASTER_ID, a as convertRotationDegrees, n as clampRangedInput, q as SLDNUMFLDID, s as getSmartParseNumber, u as mapStated, v as resolveInsetsEmu } from "./units-internal-XJlf-hOl.js";
+import { A as inchesToEmu, D as emuToInches, F as EMU_PER_INCH, T as STANDARD_LAYOUTS } from "./table-cell-margins-EVg0EwxT.js";
+import { $t as THEME_REL, Bt as PRES_PROPS_CONTENT_TYPE, Dt as MS_MEDIA_REL, E as EMBEDDED_FONT_SLOTS, Ft as OFFICE_DOCUMENT_REL, Gt as SLIDE_LAYOUT_CONTENT_TYPE, Ht as RELATIONSHIPS_CONTENT_TYPE, Jt as SLIDE_MASTER_REL, Kt as SLIDE_LAYOUT_REL, Nt as NOTES_SLIDE_REL, Qt as THEME_CONTENT_TYPE, Vt as PRES_PROPS_REL, Wt as SLIDE_CONTENT_TYPE, Xt as TABLE_STYLES_CONTENT_TYPE, Yt as SLIDE_REL, Zt as TABLE_STYLES_REL, _t as CORE_PROPS_REL, a as textAlignToken, an as PML_ROOT_NS, at as CHARTEX_REL, bt as EXTENDED_PROPS_CONTENT_TYPE, c as checkEnumOrThrow, cn as decodeBase64ToBytes, d as xsdBool, dn as toMediaDataUri, en as VIDEO_REL, f as xsdBoolIfTrue, gt as CORE_PROPS_CONTENT_TYPE, h as stripHash, ht as COMMENT_AUTHORS_REL, in as OOXML_NS, jt as NOTES_MASTER_REL, l as checkEnumOrWarn, lt as CHART_REL, nn as VIEW_PROPS_REL, nt as TRANSITION_VARIANT_ATTRIBUTES, p as isHexColor, pt as COMMENTS_REL, qt as SLIDE_MASTER_CONTENT_TYPE, rt as AUDIO_REL, sn as bytesToBase64, tn as VIEW_PROPS_CONTENT_TYPE, tt as TRANSITION_TYPES, vt as CUSTOM_PROPS_CONTENT_TYPE, w as DEFAULT_COLOR_MAP, wt as IMAGE_REL, xt as EXTENDED_PROPS_REL, yt as CUSTOM_PROPS_REL, zt as PRESENTATION_MAIN_CONTENT_TYPE } from "./image-size-CvN2iCA4.js";
+import { a as avContentType, i as audioExtensionForSubtype, o as dataUriMediaType, s as imageContentType } from "./text-anchor-CrYXAfUu.js";
+import { At as getDuplicateObjectNames, C as targetBetweenPptSubparts, Ct as FONT_DATA_CONTENT_TYPE, D as cNvPrEl, Dt as serializeEmbeddedFontLst, Et as flattenEmbeddedFaces, G as clampParaMarginInchesEmu, It as preencodedPath, K as buAutoNumEl, N as spTreeEl, Nt as isHyperlinkRel, Ot as XML_DECL, Pt as isPreencodedPath, R as prstGeomRect, Rt as encodeXmlAttrValue, S as slidePath, St as voidEl, T as targetFromPresentation, Tt as FONT_REL_TYPE, U as clampFontSizeSz, W as clampParaIndentInchesEmu, _ as fontPath, at as fillNamesPaint, b as relsPath, bt as elOrVoid, c as themeFontDefRPr, f as relationshipsPart, g as commentPath, h as SLIDE_MASTER_PATH, ht as createColorElement, i as makeXmlNotesSlide, j as grpXfrmEl, jt as getNewRelId, kt as bracedGuid, l as externalHyperlinkRel, m as PRESENTATION_PATH, n as makeXmlNotesMaster, ot as genXmlColorSelection, p as NOTES_MASTER_PATH, q as buCharEl, s as lvlPPr, t as buildNotesSlideRels, u as relationshipEl, ut as STRETCH_FILL_RECT, v as notesSlidePath, vt as rejectEmptyColor, w as targetFromPptSubpart, wt as FONT_DATA_EXTENSION, x as slideLayoutPath, xt as raw, y as overrideName, yt as el } from "./notes-Dh12JAbn.js";
+import { A as renderedSlideObjects, B as pushMediaRel, C as msMediaRid, D as findLayoutPlaceholder, E as placeholderOptionsForSlide, F as warnUnauthoredChild, I as SLIDE_METHOD_FAMILIES, L as composeFamilies, M as shapeIdCount, N as addChildDefinition, O as resolveTextAnchor, P as isGroupableObject, R as familyMethodUnavailable, S as alternateContentEl, T as addTextDefinition, V as resolveImageSource, _ as chartPartNames, a as mediaFamily, b as GROUP_SHAPE_LOCK_ATTRS, c as commentsFamily, d as textFamily, f as shapeFamily, g as makeXmlCore, h as groupFamily, i as model3dFamily, j as resolveObjectNameToId, k as collectSlideShapeIds, l as chartFamily, m as imageFamily, n as tableFamily, o as measureFamily, p as notesFamily, r as oleFamily, s as connectorFamily, t as zoomFamily, u as animationsFamily, v as FMT_SCHEME_XML, w as previewRid, x as genXmlObjectLock, y as resolveImageExtent, z as requirePresentationAuthor } from "./zoom-DPUHh85d.js";
+import { n as setOrClear, t as pickDefined } from "./options-internal-WqgMf720.js";
+import { b as isFontCollection, g as FontMetricsRegistry, t as applyMeasuredFit, y as parseFontMetrics } from "./fit-Cb7naFj6.js";
+import { t as ZipWriter } from "./zip-CKd8ihcf.js";
+import { t as transitionSpeedForDuration } from "./transition-speed-kUEWDWTx.js";
+import { n as presentationFormatLabel, r as slideSizeType } from "./slide-size-BalTjFuv.js";
+//#region src/gen/define/background.ts
+/**
+* ts-pptx: Background Definition
+*
+* Registers an `addBackground()` image as a slide media rel (color backgrounds carry no rel);
+* the `<p:bg>` XML is emitted later at slide / layout serialize time.
+*/
+/**
+* Adds a background image or color to a slide definition.
+*
+* Only an image background does anything here: it is the one that needs a media relationship.
+* A colour — object or the bare-string shorthand — carries no rel and is emitted straight from
+* `slide.background` at serialize time.
+*
+* The rel id and the part name come from the shared allocators. This used to take the id as
+* `_relsMedia.length + 1`, which a hyperlink or chart rel could already hold, and to name the part
+* after the slide or layout title. Titles are caller-supplied and different ones sanitize alike,
+* so "A B" and "A-B", or a layout titled "Slide 1" beside slide 1, wrote one part that both
+* backgrounds pointed at. `nextMediaTarget` keys the name by slide, layout or master, never
+* by title, so it is unique and needs no sanitizing.
+*
+* Called on every assignment, so it replaces what an earlier one registered. A new image takes
+* over the earlier background's rel in place, keeping its id and its part name, rather than
+* pushing a second one; replacing it by removal would shift the media count every later part name
+* is read from. A colour clears the image rel id, which `slideBackgroundXml` checks before it looks
+* at a colour, so an image replaced by a colour stops painting.
+*
+* The image's rel stays in `_relsMedia` for the same reason, so a package whose image background
+* was replaced by a colour still carries the image part and an `image` relationship nothing
+* references. That is valid OPC, only unused bytes. Dropping it would need either a tombstone the
+* rel and part emitters skip, or media part names that do not depend on the count.
+*
+* An image whose `data` has no base64 header is dropped with a warning, as an image fill's is,
+* and leaves any colour the background states to paint. It used to be written as a part holding
+* the caller's text.
+* @param {BackgroundOption} props - a bare colour, or an object with a colour or image definition
+* @param {SlideLayoutInternal} target - slide or layout that the background is set on
+*/
+function addBackgroundDefinition(props, target) {
+	if (!(props && typeof props === "object" && (props.path || props.data))) {
+		delete target._bkgdImgRid;
+		return;
+	}
+	const source = resolveImageSource(props);
+	if (typeof source === "string") {
+		warn("background/missing-base64-header", "background `data` value lacks a base64 header (ex: 'image/png;base64,...'); ignoring the background image.");
+		delete target._bkgdImgRid;
+		return;
+	}
+	let strImgExtn = source.extn;
+	if (strImgExtn === "jpg") strImgExtn = "jpeg";
+	const type = imageContentType(strImgExtn);
+	const previous = target._relsMedia.findIndex((rel) => rel.rId === target._bkgdImgRid);
+	const replaced = target._relsMedia[previous];
+	if (replaced) {
+		target._relsMedia[previous] = {
+			path: source.path || preencodedPath(strImgExtn),
+			type,
+			extn: strImgExtn,
+			data: source.data,
+			rId: replaced.rId,
+			Target: replaced.Target.replace(/\.[^./]+$/, `.${strImgExtn}`)
+		};
+		return;
+	}
+	const slide = target;
+	const rId = getNewRelId(slide);
+	pushMediaRel(slide, {
+		kind: "image",
+		extn: strImgExtn,
+		type,
+		path: source.path,
+		data: source.data,
+		rId
+	});
+	target._bkgdImgRid = rId;
+}
+//#endregion
+//#region src/slide.ts
+/**
+* Project one authored render-object onto the public {@link SlideObjectInfo}, recursing into a
+* group's children.
+*
+* The name is the stored one, which is the caller's own spelling: only `cNvPrOpen` escapes it. So
+* a name read here resolves when it is handed back to `groupObjects()`.
+*
+* Every `add*Definition` also *generates* a name when the caller passed none, so the fallback below
+* is unreachable through the public API. It is there because the field is typed non-optional
+* internally only by convention, and an empty name would otherwise read back as `undefined` from a
+* surface that promises a string.
+*/
+function toSlideObjectInfo(obj) {
+	const stored = obj.options?.objectName;
+	return {
+		type: obj._type,
+		objectName: typeof stored === "string" && stored.length > 0 ? stored : "",
+		isPlaceholder: !!obj.options?.placeholder,
+		canGroup: isGroupableObject(obj),
+		children: (obj._groupObjects ?? []).map(toSlideObjectInfo)
+	};
+}
+var SlideBuilder = class {
+	_setSlideNum;
+	addSlide;
+	getSlide;
+	getSections;
+	_name;
+	_presLayout;
+	_rels;
+	_relsChart;
+	_relsMedia;
+	_rId;
+	_slideId;
+	_slideLayout;
+	_slideNum;
+	_slideNumberProps;
+	_slideObjects;
+	_comments = [];
+	_newAutoPagedSlides = [];
+	_animations = [];
+	/**
+	* The child-descriptor authors this presentation was composed with, for the group family: a
+	* group's children resolve through the same table a slide master's `objects` do, so a group can
+	* hold exactly the kinds this presentation can author.
+	*/
+	_childAuthors;
+	constructor(params) {
+		this.addSlide = params.addSlide;
+		this.getSlide = params.getSlide;
+		this.getSections = params.getSections ?? (() => []);
+		this._name = `Slide ${params.slideNumber}`;
+		this._presLayout = params.presLayout;
+		this._rId = params.slideRId;
+		this._rels = [];
+		this._relsChart = [];
+		this._relsMedia = [];
+		this._setSlideNum = params.setSlideNum;
+		this._slideId = params.slideId;
+		this._slideLayout = params.slideLayout || null;
+		this._slideNum = params.slideNumber;
+		this._slideObjects = [];
+		this._childAuthors = params.childAuthors;
+		this.#bindFamilyMethods(params.authors);
+		/** NOTE: Slide Numbers: In order for Slide Numbers to function they need to be in all 3 files: master/layout/slide
+		* `defineSlideMaster` and `addNewSlide.slideNumber` will add {slideNumber} to `this.masterSlide` and `this.slideLayouts`
+		* so, lastly, add to the Slide now.
+		*/
+		this._slideNumberProps = this._slideLayout?._slideNumberProps ? this._slideLayout._slideNumberProps : null;
+	}
+	/**
+	* Put this presentation's family methods on the slide.
+	*
+	* Per instance rather than on the prototype: the family set belongs to the presentation, not to
+	* the class, and two presentations composed differently in one process each get their own. A
+	* slide count is small enough that per-instance function properties are not a memory question.
+	*
+	* Chaining is applied here, once, rather than by each author: every `add*` answers the slide, so
+	* an author has nothing to say about the return value and cannot get it wrong.
+	*/
+	#bindFamilyMethods(authors) {
+		const slide = this;
+		for (const method of Object.keys(SLIDE_METHOD_FAMILIES)) {
+			const author = authors[method];
+			slide[method] = author ? (...args) => {
+				author(this, ...args);
+				return this;
+			} : () => familyMethodUnavailable(`slide.${method}`, SLIDE_METHOD_FAMILIES[method]);
+		}
+	}
+	/**
+	* Background color or image
+	* @type {BackgroundProps}
+	* @example solid color `background: { color:'FF0000' }`
+	* @example color+trans `background: { color:'FF0000', transparency:0.5 }`
+	* @example base64 `background: { data:'image/png;base64,ABC[...]123' }`
+	* @example url `background: { path:'https://some.url/image.jpg'}`
+	*/
+	_background;
+	set background(props) {
+		this._background = props;
+		addBackgroundDefinition(props, this);
+	}
+	get background() {
+		return this._background;
+	}
+	/**
+	* Default font color
+	* @type {HexColor}
+	*/
+	_color;
+	set color(value) {
+		this._color = value;
+	}
+	get color() {
+		return this._color;
+	}
+	/**
+	* @type {boolean}
+	*/
+	_hidden = false;
+	set hidden(value) {
+		this._hidden = value;
+	}
+	get hidden() {
+		return this._hidden;
+	}
+	/**
+	* Slide-show transition (`p:transition`) played when advancing to this slide.
+	* @type {TransitionProps}
+	*/
+	_transition;
+	set transition(value) {
+		this._transition = value;
+	}
+	get transition() {
+		return this._transition;
+	}
+	/**
+	* @type {SlideNumberProps}
+	*/
+	set slideNumber(value) {
+		this._slideNumberProps = value;
+		this._setSlideNum(value);
+	}
+	get slideNumber() {
+		return this._slideNumberProps ?? void 0;
+	}
+	/**
+	* Every continuation slide this slide's tables have spilled onto, in call order, each once.
+	*
+	* Across calls, not per call: a slide can carry more than one `addTable`, and each auto-paging
+	* one appends whatever it spilled onto. The list was assigned rather than appended, so a second
+	* table erased the first table's report while its slides stayed in the deck. "Spilled onto"
+	* rather than "created" because a later table lands on the earlier one's continuations instead
+	* of making its own, and those are reported once.
+	*/
+	get newAutoPagedSlides() {
+		return this._newAutoPagedSlides;
+	}
+	/**
+	* The objects authored on this slide so far, bottom-to-top in z-order.
+	*
+	* Built fresh on every access rather than cached: the underlying list is mutated in place by
+	* `addGroup`/`groupObjects` as well as appended to, so a cache would have to be invalidated from
+	* every authoring path and would go stale the first time one was added without remembering.
+	* Building it costs a walk of a list a slide-sized deck keeps in the dozens.
+	*/
+	get objects() {
+		return renderedSlideObjects(this._slideObjects).map(toSlideObjectInfo);
+	}
+	/** Slide width in inches (resolved from the active presentation layout). */
+	get width() {
+		return emuToInches(this._presLayout.width);
+	}
+	/** Slide height in inches (resolved from the active presentation layout). */
+	get height() {
+		return emuToInches(this._presLayout.height);
+	}
+};
+//#endregion
+//#region src/font-source.ts
+/**
+* ts-pptx: getting font bytes out of whatever the caller handed over.
+*
+* `registerFontMetrics` and `embedFont` are two public methods on one class, forty lines apart,
+* and each resolved its source itself. They agreed on `Uint8Array` and `ArrayBuffer` and
+* disagreed about what a `string` means: `registerFontMetrics('X', someBase64)` handed the
+* base64 to the runtime's file loader and failed to open it, while
+* `embedFont({ data: someBase64 })` decoded it. Neither doc said which, because each was only
+* describing its own half.
+*
+* The two really do want different string semantics -- `embedFont` names its path in `path` and
+* its bytes in `data`, so a string in `data` cannot be a filename -- so the answer is one
+* resolver with the difference stated as a flag rather than two resolvers with the difference
+* left implicit.
+*/
+/**
+* Resolve a caller's font source to bytes.
+*
+* A `Uint8Array` is used as it stands, an `ArrayBuffer` is wrapped, and a `string` is read
+* according to `base64`: **false or absent** means a path or URL for the runtime's loader (what
+* `registerFontMetrics(face, source)` and `embedFont({ path })` take), **true** means base64
+* text (what `embedFont({ data })` takes, with or without a `data:` prefix).
+* @param source - the caller's value
+* @param runtime - the entry point's adapter, for the path/URL case
+* @param opts - `base64: true` to read a string as base64 rather than as a path
+* @param opts.base64 - see above
+* @param label - how to name the offending argument if the source is unusable
+*/
+async function resolveFontBytes(source, runtime, opts, label) {
+	if (source instanceof Uint8Array) return source;
+	if (source instanceof ArrayBuffer) return new Uint8Array(source);
+	if (typeof source === "string") {
+		if (!opts?.base64) return await runtime.loadFontData(source);
+		const decoded = decodeBase64ToBytes(source);
+		if (!decoded) throw new InvalidOptionError("font/invalid-base64", `${label} is not valid base64`);
+		return decoded;
+	}
+	throw new InvalidOptionError("font/missing-source", `${label} must be a font path, raw bytes, or base64 data`);
+}
+//#endregion
+//#region src/gen/define/master.ts
+/**
+* Transforms a slide definition to a slide object that is then passed to the XML transformation process.
+* @param {SlideMasterProps} props - slide definition
+* @param {PresSlideInternal|SlideLayoutInternal} target - empty slide object that should be updated by the passed definition
+* @param {ChildAuthors} children - the child-descriptor authors this presentation was composed with
+*/
+function createSlideMaster(props, target, children) {
+	if (props.objects && Array.isArray(props.objects) && props.objects.length > 0) props.objects.forEach((object, idx) => {
+		const tgt = target;
+		if (addChildDefinition(tgt, object, children)) {} else if ("placeholder" in object) {
+			const placeholder = object.placeholder;
+			const { name, type, ...rawPlaceholderOptions } = placeholder.options;
+			const placeholderOptions = rawPlaceholderOptions;
+			placeholderOptions.placeholder = name;
+			placeholderOptions._placeholderType = type;
+			placeholderOptions._placeholderIdx = 100 + idx;
+			const placeholderRun = placeholder.text === void 0 ? {} : { text: placeholder.text };
+			addTextDefinition(tgt, [placeholderRun], placeholderOptions, true);
+		} else warnUnauthoredChild(object, "defineSlideMaster()");
+	});
+	if (props.slideNumber && typeof props.slideNumber === "object") target._slideNumberProps = props.slideNumber;
+}
+//#endregion
+//#region src/gen/define/placeholder.ts
+/**
+* Adds placeholder objects to slide
+* @param {PresSlideInternal} slide - slide object containing layouts
+*/
+function addPlaceholdersToSlideLayouts(slide) {
+	if (!slide._slideLayout) return;
+	(slide._slideLayout._slideObjects || []).forEach((slideLayoutObj) => {
+		if (slideLayoutObj._type === "placeholder") {
+			const slideLayoutOptions = slideLayoutObj.options || {};
+			if (!slide._slideObjects.some((slideObj) => slideObj.options && slideObj.options.placeholder === slideLayoutOptions.placeholder)) addTextDefinition(slide, [{ text: "" }], placeholderOptionsForSlide(slideLayoutOptions), true);
+		}
+	});
+}
+//#endregion
+//#region src/media/placeholders.ts
+/**
+* The base64 placeholder images the library falls back to when a real asset is unavailable.
+*
+* Their own module because of where the bundler puts them, not because they group naturally.
+* The chunker splits by module, so a constant is pulled into every chunk that reaches the module
+* declaring it — and these lived in `constants-internal.ts` beside `XML_DECL`, `DEF_FONT_SIZE`
+* and the rest of the vocabulary all of `src/gen/` imports. The rule that follows: a payload
+* measured in kilobytes does not share a module with vocabulary, however tidy that grouping reads.
+*
+* The default video poster obeys the same rule one size up. At 14 kB it does not share a module
+* with these two either: it lives alone in `src/media/playbtn.ts`, which is what lets the media
+* pass reach it dynamically instead of linking it into every consumer's entry chunk.
+*/
+/** Shown in place of media that failed to load, under `onMediaError: 'placeholder'`. */
+const IMG_BROKEN = "data:image/png;base64,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";
+/** 1x1 transparent PNG, standing in for an SVG the runtime could not rasterize. */
+const IMG_SVG_PLACEHOLDER = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==";
+//#endregion
+//#region src/gen/media.ts
+/**
+* ts-pptx: Media Methods
+*/
+function hasEncodingPath(rel) {
+	return typeof rel.path === "string" && rel.path.length > 0 && !isPreencodedPath(rel.path);
+}
+/**
+* Write an SVG rel's PNG fallback, applying `onMediaError` to a preview that fails.
+*
+* The one place that policy is applied to a preview. The adapter has already stamped the
+* placeholder and resolved with the failure, so only the PNG fallback is ever the placeholder:
+* the SVG part keeps its bytes under either policy. A preview used to reject instead, and an SVG
+* given inline then failed the whole write whatever `onMediaError` said, while one given by path
+* was reported as `media/load-failed` and had its SVG bytes replaced with a broken image.
+*/
+async function writeSvgPreview(rel, runtime, onMediaError) {
+	const failure = await runtime.createSvgPngPreview(rel);
+	if (failure === null) return "done";
+	if (onMediaError === "placeholder") {
+		warn("media/svg-preview-failed", `${failure.message}; the SVG is kept and its PNG fallback is a placeholder.`);
+		return "done";
+	}
+	throw failure;
+}
+/**
+* Encode Image/Audio/Video into base64
+* @param {PresSlideInternal | SlideLayoutInternal | SlideMasterInternal} layout - slide, layout or master
+* @param {RuntimeAdapter} runtime - runtime adapter (Node/browser media loader)
+* @param {'throw' | 'placeholder'} onMediaError - failure policy: reject the export (default) or substitute a placeholder and warn
+* @return {Promise} promise
+*/
+function encodeSlideMediaRels(layout, runtime, onMediaError = "throw") {
+	const imageProms = [];
+	const defaultCoverRels = layout._relsMedia.filter((rel) => rel.isDefaultCover && !rel.data);
+	if (defaultCoverRels.length > 0) imageProms.push((async () => {
+		const { IMG_PLAYBTN } = await import("./playbtn-CUqQdoDf.js");
+		for (const rel of defaultCoverRels) rel.data = IMG_PLAYBTN;
+		return "done";
+	})());
+	const candidateRels = layout._relsMedia.filter((rel) => rel.type !== "online" && !rel.data && hasEncodingPath(rel));
+	const unqPaths = [];
+	candidateRels.forEach((rel) => {
+		if (!unqPaths.includes(rel.path)) {
+			rel.isDuplicate = false;
+			unqPaths.push(rel.path);
+		} else rel.isDuplicate = true;
+	});
+	candidateRels.filter((rel) => !rel.isDuplicate).forEach((rel) => {
+		imageProms.push((async () => {
+			const dupes = candidateRels.filter((dupe) => dupe.isDuplicate && dupe.path === rel.path);
+			let data;
+			try {
+				data = toMediaDataUri(await runtime.loadMedia(rel), rel.type);
+			} catch (ex) {
+				if (Boolean(rel.oleRelType || rel.model3dRelType)) throw new MediaError("media/load-failed", `Failed to load the embedded payload "${rel.path}" during export; a placeholder picture cannot stand in for an OLE object or a 3D model.`, { cause: ex });
+				if (onMediaError === "placeholder") {
+					warn("media/load-failed", `Failed to load media "${rel.path}"; embedding a broken-image placeholder. (${String(ex)})`);
+					rel.data = IMG_BROKEN;
+					dupes.forEach((dupe) => dupe.data = IMG_BROKEN);
+					return "done";
+				}
+				throw new MediaError("media/load-failed", `Failed to load media "${rel.path}" during export.`, { cause: ex });
+			}
+			rel.data = data;
+			dupes.forEach((dupe) => dupe.data = data);
+			if (rel.isSvgPng) await writeSvgPreview(rel, runtime, onMediaError);
+			await Promise.all(dupes.filter((dupe) => dupe.isSvgPng).map((dupe) => writeSvgPreview(dupe, runtime, onMediaError)));
+			return "done";
+		})());
+	});
+	layout._relsMedia.filter((rel) => rel.isSvgPng && rel.data).forEach((rel) => {
+		imageProms.push(writeSvgPreview(rel, runtime, onMediaError));
+	});
+	return imageProms;
+}
+//#endregion
+//#region src/gen/prepare.ts
+/**
+* ts-pptx: the pre-serialization pass
+*
+* Everything that must happen to authored slide state *before* any XML is built. Two callers
+* reach serialization and both need it:
+*
+*   - `package/assemble.ts` — the normal `write`/`stream`/`writeFile` path, building a
+*     complete `.pptx`.
+*   - `PresentationCore.extractSlides()` — serializes slide bodies only, for splicing into
+*     an already-loaded deck via `Presentation.appendSlides()` (`pptx-ts/read`).
+*
+* The second used to reimplement the first inline, kept in step by a comment that said
+* "exactly as ... does". Nothing failed when they drifted: `extractSlides` would simply emit
+* slides that did not match what a normal write produces, and no test compares the two.
+*
+* Three steps rather than one combined pass, because the package path has work of its own that
+* must land between the last two: it de-duplicates identical media across the deck (which needs
+* the encoded bytes {@link encodeMediaForTargets} produces) and assigns package-unique chart part
+* filenames, both before any text is measured. Exposing the steps lets `assemble` keep that work
+* in place while still sharing the code.
+*
+* The order is load-bearing:
+*
+* 1. **Backfill placeholders first**, so a slide carries its layout's placeholder objects before
+*    anything reads its media. A seeded placeholder can register media of its own, an image fill,
+*    and when backfill ran after encoding that image was never loaded and its rel named a part
+*    that was never written.
+* 2. **Media.** It is the only asynchronous step, and the sync XML pass reads the `rel.data` it
+*    populates.
+* 3. **Bake measured fit last**, because it measures the text step 1 may have just added and
+*    writes the `fontScale` the sync XML pass then reads. The caller undoes it once that pass is
+*    done, so the next write measures from the authored values.
+*
+* The functions take different target sets on purpose: media lives on layouts and the master as
+* well as on slides, while placeholder backfill and measured fit apply only to slides.
+* `extractSlides` passes only its slides to all three, because it emits no layout or master
+* parts.
+*/
+/**
+* Before any step: refuse a link to a slide the deck does not have.
+*
+* A `hyperlink: { slide }` and a Slide Zoom's numeric `target` are checked for being slide numbers
+* when they are authored, but whether the slide exists is only known once the deck is complete: a
+* link to slide 3 can be authored before slide 3 is added. Both serializing callers check here,
+* before anything is built. Otherwise the link is written as a relationship to a part the package
+* never has.
+*
+* A layout and the master carry objects too, and an object given to `defineSlideLayout({ objects })`
+* or `defineSlideMaster({ objects })` takes the same `hyperlink: { slide }`. This used to read the
+* slides' relationships only, so a layout's number went unchecked and a link past the last slide
+* reached the package from there. `extractSlides` emits no layout or master part and so passes
+* neither, the same way it passes only slides to the three preparation steps below.
+* @param slides - every slide in the deck, in order
+* @param layouts - every slide layout, in order; omitted when no layout part is written
+* @param master - the deck's slide master; omitted when no master part is written
+*/
+function requireSlideLinksInDeck(slides, layouts = [], master) {
+	const sources = [
+		...slides.map((slide) => ({
+			label: `Slide ${slide._slideNum}`,
+			part: slide
+		})),
+		...layouts.map((layout, idx) => ({
+			label: `Slide layout ${idx + 1}`,
+			part: layout
+		})),
+		...master ? [{
+			label: "The slide master",
+			part: master
+		}] : []
+	];
+	for (const { label, part } of sources) for (const rel of part._rels) {
+		if (!isHyperlinkRel(rel) || rel.data !== "slide") continue;
+		if (!(Number(rel.Target) > slides.length)) continue;
+		throw new InvalidOptionError("slide/link-past-last-slide", `${label} links to slide ${String(rel.Target)}, but the deck has ${slides.length} slide${slides.length === 1 ? "" : "s"}.`);
+	}
+}
+/**
+* Step 2: load and base64-encode every media rel on the given targets, populating `rel.data`.
+* @param {ReadonlyArray<PresSlideInternal | SlideLayoutInternal | SlideMasterInternal>} targets - media-bearing targets (slides, layouts, master)
+* @param {RuntimeAdapter} runtime - runtime adapter used to load media
+* @param {'throw' | 'placeholder'} onMediaError - failure policy for unloadable media
+*/
+async function encodeMediaForTargets(targets, runtime, onMediaError) {
+	const promises = [];
+	for (const target of targets) promises.push(...encodeSlideMediaRels(target, runtime, onMediaError));
+	await Promise.all(promises);
+}
+/**
+* Step 1: seed each slide with the layout placeholders it leaves empty.
+* @param {PresSlideInternal[]} slides - the slides to prepare
+*/
+function backfillPlaceholders(slides) {
+	for (const slide of slides) if (slide._slideLayout) addPlaceholdersToSlideLayouts(slide);
+}
+/**
+* Step 3: bake measured text fit.
+* @param {PresSlideInternal[]} slides - the slides to prepare
+* @param {FontMetricsRegistry} fontMetrics - registered font metrics; an empty registry skips the fit bake
+* @returns the step that restores the authored values; call it once the slide XML is built
+*/
+function bakeMeasuredFit(slides, fontMetrics) {
+	return applyMeasuredFit(slides, fontMetrics);
+}
+//#endregion
+//#region src/gen/anim/animation.ts
+/**
+* Resolved animation target's shape id (`spid`), or `null` when it cannot be resolved — in which
+* case the effect is dropped, so every `null` warns rather than leaving the animation silently
+* missing from the deck.
+*
+* `objectName` resolves through `shapeIds`, which covers group children: they are `<p:cNvPr>`-named
+* on the slide and animate like any other shape, but are not in `_slideObjects`, so the old lookup
+* there dropped every animation targeting one. The name goes in raw, and `resolveObjectNameToId`
+* compares it with the raw name the slide object stores, so the warning below quotes the same
+* spelling the caller passed.
+*
+* `shapeIndex` is a 0-based index into the top-level objects that RENDER, which is the same
+* sequence `collectSlideShapeIds` allocates along; group children take ids past that range. It
+* counted `_slideObjects` itself, and four of that array's members draw nothing — so `addNotes`
+* before the first shape shifted every index by one and `shapeIndex: 0` addressed the notes.
+* An index outside `[0, renderedCount)` would emit a `<p:spTgt spid>` naming no shape on the
+* slide — a dangling spid PowerPoint reports as a repair (0x80070570) — so it warns and drops,
+* exactly like an unresolvable `objectName` does.
+* @param shapeIds - the slide's shape ids, from `collectSlideShapeIds`
+* @param slideObjects - the slide's top-level objects, which a `shapeIndex` addresses
+* @param anim - the animation to resolve
+* @returns the target's `<p:cNvPr>` id, or `null`
+*/
+function resolveAnimationSpid(shapeIds, slideObjects, anim) {
+	if (typeof anim.shapeIndex === "number") {
+		const targets = renderedSlideObjects(slideObjects);
+		const target = targets[anim.shapeIndex];
+		if (target) return shapeIds.get(target) ?? null;
+		warn("animation/target-index-out-of-range", `addAnimation: shapeIndex ${anim.shapeIndex} is out of range (slide has ${targets.length} top-level shape(s)), so its "${anim.preset}" effect was dropped.`);
+		return null;
+	}
+	if (anim.objectName) {
+		const id = resolveObjectNameToId(shapeIds, anim.objectName);
+		if (id !== null) return id;
+		warn("animation/target-not-found", `addAnimation: no object named "${anim.objectName}" on the slide, so its "${anim.preset}" effect was dropped.`);
+		return null;
+	}
+	warn("animation/target-missing", `addAnimation: the "${anim.preset}" effect names no target (pass shapeIndex or objectName), so it was dropped.`);
+	return null;
+}
+/**
+* Whether the effect names a preset this module has a template for. The `preset` type admits only
+* those, but a JavaScript caller can pass any string, so an unknown one warns and the effect is
+* dropped before its target is resolved, like an effect whose target cannot be found.
+* @param anim - the animation to check
+* @returns `true` when the preset can be written
+*/
+function hasKnownAnimationPreset(anim) {
+	if (Object.hasOwn(ANIM_PRESETS, anim.preset)) return true;
+	warn("animation/unknown-preset", `addAnimation: "${String(anim.preset)}" is not a preset this library writes (${Object.keys(ANIM_PRESETS).join(", ")}), so the effect was dropped.`);
+	return false;
+}
+const ANIM_SET_VISIBLE = (spid, next) => el("p:set", null, [raw(el("p:cBhvr", null, [
+	raw(el("p:cTn", {
+		id: next(),
+		dur: 1,
+		fill: "hold"
+	}, raw(el("p:stCondLst", null, raw(voidEl("p:cond", { delay: 0 })))))),
+	raw(el("p:tgtEl", null, raw(voidEl("p:spTgt", { spid })))),
+	raw(el("p:attrNameLst", null, raw(el("p:attrName", null, "style.visibility"))))
+])), raw(el("p:to", null, raw(voidEl("p:strVal", { val: "visible" }))))]);
+const ANIM_SET_HIDDEN = (spid, dur, next) => el("p:set", null, [raw(el("p:cBhvr", null, [
+	raw(el("p:cTn", {
+		id: next(),
+		dur: 1,
+		fill: "hold"
+	}, raw(el("p:stCondLst", null, raw(voidEl("p:cond", { delay: Math.max(0, dur - 1) })))))),
+	raw(el("p:tgtEl", null, raw(voidEl("p:spTgt", { spid })))),
+	raw(el("p:attrNameLst", null, raw(el("p:attrName", null, "style.visibility"))))
+])), raw(el("p:to", null, raw(voidEl("p:strVal", { val: "hidden" }))))]);
+/** `p:animEffect` filter transition (fade/wipe(down)/…), shared by entrance and exit presets. */
+const ANIM_EFFECT = (transition, filter, spid, dur, next) => el("p:animEffect", {
+	transition,
+	filter
+}, raw(el("p:cBhvr", null, [raw(voidEl("p:cTn", {
+	id: next(),
+	dur
+})), raw(el("p:tgtEl", null, raw(voidEl("p:spTgt", { spid }))))])));
+const ANIM_FADE = (transition, spid, dur, next) => ANIM_EFFECT(transition, "fade", spid, dur, next);
+/**
+* One `ppt_x`/`ppt_y` motion `<p:anim>` for Fly In (entrance) / Fly Out (exit).
+* PowerPoint authors the two directions differently (captured in
+* `slide-animation-presets.oracle.json`): the entrance form references the
+* hashed run-time variables (`#ppt_x`) and holds (`fill="hold"`) starting
+* off-screen and ending in place; the exit form uses the bare variables
+* (`ppt_x`, no `#`), omits `fill="hold"`, and ends off-screen.
+*/
+const ANIM_FLY_AXIS = (direction, axis, spid, dur, next) => {
+	const h = direction === "in" ? "#" : "";
+	let from;
+	let to;
+	if (axis === "x") {
+		from = `${h}ppt_x`;
+		to = `${h}ppt_x`;
+	} else if (direction === "in") {
+		from = `1+${h}ppt_h/2`;
+		to = `${h}ppt_y`;
+	} else {
+		from = `${h}ppt_y`;
+		to = `1+${h}ppt_h/2`;
+	}
+	const fill = direction === "in" ? "hold" : null;
+	return el("p:anim", {
+		calcmode: "lin",
+		valueType: "num"
+	}, [raw(el("p:cBhvr", { additive: "base" }, [
+		raw(voidEl("p:cTn", {
+			id: next(),
+			dur,
+			fill
+		})),
+		raw(el("p:tgtEl", null, raw(voidEl("p:spTgt", { spid })))),
+		raw(el("p:attrNameLst", null, raw(el("p:attrName", null, `ppt_${axis}`))))
+	])), raw(el("p:tavLst", null, [raw(el("p:tav", { tm: 0 }, raw(el("p:val", null, raw(voidEl("p:strVal", { val: from })))))), raw(el("p:tav", { tm: 1e5 }, raw(el("p:val", null, raw(voidEl("p:strVal", { val: to }))))))]))]);
+};
+const ANIM_PRESETS = {
+	fadeIn: {
+		presetID: 10,
+		presetClass: "entr",
+		presetSubtype: 0,
+		defaultDurationMs: 500,
+		behaviors: (spid, dur, next) => ANIM_SET_VISIBLE(spid, next) + ANIM_FADE("in", spid, dur, next)
+	},
+	flyIn: {
+		presetID: 2,
+		presetClass: "entr",
+		presetSubtype: 4,
+		defaultDurationMs: 500,
+		behaviors: (spid, dur, next) => ANIM_SET_VISIBLE(spid, next) + ANIM_FLY_AXIS("in", "x", spid, dur, next) + ANIM_FLY_AXIS("in", "y", spid, dur, next)
+	},
+	appear: {
+		presetID: 1,
+		presetClass: "entr",
+		presetSubtype: 0,
+		defaultDurationMs: 500,
+		behaviors: (spid, _dur, next) => ANIM_SET_VISIBLE(spid, next)
+	},
+	wipe: {
+		presetID: 22,
+		presetClass: "entr",
+		presetSubtype: 4,
+		defaultDurationMs: 500,
+		behaviors: (spid, dur, next) => ANIM_SET_VISIBLE(spid, next) + ANIM_EFFECT("in", "wipe(down)", spid, dur, next)
+	},
+	grow: {
+		presetID: 6,
+		presetClass: "emph",
+		presetSubtype: 0,
+		defaultDurationMs: 2e3,
+		behaviors: (spid, dur, next) => el("p:animScale", null, [raw(el("p:cBhvr", null, [raw(voidEl("p:cTn", {
+			id: next(),
+			dur,
+			fill: "hold"
+		})), raw(el("p:tgtEl", null, raw(voidEl("p:spTgt", { spid }))))])), raw(voidEl("p:by", {
+			x: 15e4,
+			y: 15e4
+		}))])
+	},
+	spin: {
+		presetID: 8,
+		presetClass: "emph",
+		presetSubtype: 0,
+		defaultDurationMs: 2e3,
+		behaviors: (spid, dur, next) => el("p:animRot", { by: 216e5 }, [raw(el("p:cBhvr", null, [
+			raw(voidEl("p:cTn", {
+				id: next(),
+				dur,
+				fill: "hold"
+			})),
+			raw(el("p:tgtEl", null, raw(voidEl("p:spTgt", { spid })))),
+			raw(el("p:attrNameLst", null, raw(el("p:attrName", null, "r"))))
+		]))])
+	},
+	fadeOut: {
+		presetID: 10,
+		presetClass: "exit",
+		presetSubtype: 0,
+		defaultDurationMs: 500,
+		behaviors: (spid, dur, next) => ANIM_FADE("out", spid, dur, next) + ANIM_SET_HIDDEN(spid, dur, next)
+	},
+	flyOut: {
+		presetID: 2,
+		presetClass: "exit",
+		presetSubtype: 4,
+		defaultDurationMs: 500,
+		behaviors: (spid, dur, next) => ANIM_FLY_AXIS("out", "x", spid, dur, next) + ANIM_FLY_AXIS("out", "y", spid, dur, next) + ANIM_SET_HIDDEN(spid, dur, next)
+	}
+};
+const ANIM_NODE_TYPE = {
+	onClick: "clickEffect",
+	withPrevious: "withEffect",
+	afterPrevious: "afterEffect"
+};
+/**
+* Assemble the `mainSeq` from preset effects. Effects are grouped into click
+* steps: an `onClick` effect opens a new click group; `afterPrevious` opens a new
+* sub-step within it, starting when the sub-step before it ends; `withPrevious`
+* joins the current sub-step. This reproduces PowerPoint's interactive build tree.
+*
+* A sub-step's delay counts from the click, not from the sub-step before it, and that sub-step
+* ends with its longest effect: PowerPoint writes 0, 500, 1250 and 3250 ms for effects of 500,
+* 750 and 1000 ms, a 2000 ms `withPrevious` beside the third, then a fourth.
+*/
+function buildAnimationSeq(animations, next) {
+	const groups = [];
+	for (const entry of animations) {
+		const meta = ANIM_PRESETS[entry.anim.preset];
+		if (!meta) continue;
+		const trigger = entry.anim.trigger ?? "onClick";
+		const duration = typeof entry.anim.durationMs === "number" ? entry.anim.durationMs : meta.defaultDurationMs;
+		const subs = groups[groups.length - 1]?.subs;
+		const lastSub = subs?.[subs.length - 1];
+		if (trigger === "onClick" || !subs || !lastSub) groups.push({ subs: [{
+			delay: 0,
+			longest: duration,
+			effects: [entry]
+		}] });
+		else if (trigger === "afterPrevious") subs.push({
+			delay: lastSub.delay + lastSub.longest,
+			longest: duration,
+			effects: [entry]
+		});
+		else {
+			lastSub.effects.push(entry);
+			lastSub.longest = Math.max(lastSub.longest, duration);
+		}
+	}
+	const emitEffect = (entry) => {
+		const meta = ANIM_PRESETS[entry.anim.preset];
+		if (!meta) return "";
+		const nodeType = ANIM_NODE_TYPE[entry.anim.trigger ?? "onClick"];
+		const duration = typeof entry.anim.durationMs === "number" ? entry.anim.durationMs : meta.defaultDurationMs;
+		const effectId = next();
+		const behaviors = meta.behaviors(entry.spid, duration, next);
+		return el("p:par", null, raw(el("p:cTn", {
+			id: effectId,
+			presetID: meta.presetID,
+			presetClass: meta.presetClass,
+			presetSubtype: meta.presetSubtype,
+			fill: "hold",
+			grpId: 0,
+			nodeType
+		}, [raw(el("p:stCondLst", null, raw(voidEl("p:cond", { delay: 0 })))), raw(el("p:childTnLst", null, raw(behaviors)))])));
+	};
+	const emitSub = (sub) => {
+		const subId = next();
+		const effects = sub.effects.map(emitEffect).join("");
+		return el("p:par", null, raw(el("p:cTn", {
+			id: subId,
+			fill: "hold"
+		}, [raw(el("p:stCondLst", null, raw(voidEl("p:cond", { delay: sub.delay })))), raw(el("p:childTnLst", null, raw(effects)))])));
+	};
+	const emitGroup = (group) => {
+		const groupId = next();
+		const subs = group.subs.map(emitSub).join("");
+		return el("p:par", null, raw(el("p:cTn", {
+			id: groupId,
+			fill: "hold"
+		}, [raw(el("p:stCondLst", null, raw(voidEl("p:cond", { delay: "indefinite" })))), raw(el("p:childTnLst", null, raw(subs)))])));
+	};
+	const clickGroups = groups.map(emitGroup).join("");
+	return el("p:seq", {
+		concurrent: 1,
+		nextAc: "seek"
+	}, [
+		raw(el("p:cTn", {
+			id: 2,
+			dur: "indefinite",
+			nodeType: "mainSeq"
+		}, raw(el("p:childTnLst", null, raw(clickGroups))))),
+		raw(el("p:prevCondLst", null, raw(el("p:cond", {
+			evt: "onPrev",
+			delay: 0
+		}, raw(el("p:tgtEl", null, raw(voidEl("p:sldTgt")))))))),
+		raw(el("p:nextCondLst", null, raw(el("p:cond", {
+			evt: "onNext",
+			delay: 0
+		}, raw(el("p:tgtEl", null, raw(voidEl("p:sldTgt"))))))))
+	]);
+}
+/** One `<p:bldP>` per animated shape, in order of first appearance. */
+function buildBldList(animations) {
+	const seen = /* @__PURE__ */ new Set();
+	const bldPs = [];
+	for (const { spid } of animations) {
+		if (seen.has(spid)) continue;
+		seen.add(spid);
+		bldPs.push(voidEl("p:bldP", {
+			spid,
+			grpId: 0
+		}));
+	}
+	return el("p:bldLst", null, raw(bldPs.join("")));
+}
+//#endregion
+//#region src/gen/anim/timing.ts
+/**
+* Build the slide-level `<p:timing>` tree that makes embedded media loop.
+* - PowerPoint stores playback looping as `repeatCount` on the media node's `<p:cTn>`
+*   (`indefinite` for "Loop until Stopped", or `N*1000` for a finite N plays), inside
+*   the slide timing tree rather than on the `<p:pic>` itself.
+* - A slide has at most one `<p:timing>`; all looping media share its `tmRoot` node.
+* - Audio loops via `<p:audio>`, video via `<p:video>` (both `CT_TLCommonMediaNodeData`).
+* - The media node targets the picture by `spid` (its `<p:cNvPr>` id = slide-object index + 2).
+* @param {PresSlideInternal} slide - the slide to inspect for looping media
+* @returns {string} the `<p:timing>` XML, or `''` when no media loops
+*/
+function slideTimingToXml(slide) {
+	const loopMedia = slide._slideObjects.filter((obj) => obj._type === "media" && obj.mtype !== "online" && typeof obj.mediaRid === "number" && (obj.loop === true || typeof obj.loopCount === "number" && obj.loopCount > 0));
+	const shapeIds = collectSlideShapeIds(slide._slideObjects);
+	const animations = (slide._animations ?? []).filter((anim) => hasKnownAnimationPreset(anim)).map((anim) => ({
+		anim,
+		spid: resolveAnimationSpid(shapeIds, slide._slideObjects, anim)
+	})).filter((entry) => entry.spid !== null);
+	const mediaNode = (obj, nodeId) => {
+		const spid = shapeIds.get(obj) ?? 2;
+		const repeatCount = obj.loop === true ? "indefinite" : String(Math.round(obj.loopCount * 1e3));
+		const mediaTag = obj.mtype === "audio" ? "p:audio" : "p:video";
+		return el(mediaTag, null, raw(el("p:cMediaNode", null, [raw(el("p:cTn", {
+			id: nodeId,
+			repeatCount,
+			fill: "hold",
+			display: 0
+		}, raw(el("p:stCondLst", null, raw(voidEl("p:cond", { delay: "indefinite" })))))), raw(el("p:tgtEl", null, raw(voidEl("p:spTgt", { spid }))))])));
+	};
+	if (animations.length === 0) {
+		if (loopMedia.length === 0) return "";
+		let nodeId = 1;
+		const mediaNodes = loopMedia.map((obj) => mediaNode(obj, nodeId += 1)).join("");
+		return el("p:timing", null, raw(el("p:tnLst", null, raw(el("p:par", null, raw(el("p:cTn", {
+			id: 1,
+			dur: "indefinite",
+			restart: "never",
+			nodeType: "tmRoot"
+		}, raw(el("p:childTnLst", null, raw(mediaNodes))))))))));
+	}
+	let id = 2;
+	const next = () => id += 1;
+	const seq = buildAnimationSeq(animations, next);
+	const mediaNodes = loopMedia.map((obj) => mediaNode(obj, next())).join("");
+	const bldLst = buildBldList(animations);
+	return el("p:timing", null, [raw(el("p:tnLst", null, raw(el("p:par", null, raw(el("p:cTn", {
+		id: 1,
+		dur: "indefinite",
+		restart: "never",
+		nodeType: "tmRoot"
+	}, raw(el("p:childTnLst", null, raw(seq + mediaNodes))))))))), raw(bldLst)]);
+}
+//#endregion
+//#region src/gen/anim/transition.ts
+/**
+* The attributes of a transition's type element, from the caller's `variant`.
+*
+* Each `variant` key is written as an attribute name, so a key the element does not declare would
+* be an attribute the schema does not allow there, and a key that is not a name at all would be
+* markup. Only the attributes the element declares are written, and the rest warn.
+*/
+function transitionVariantAttrs(type, variant) {
+	if (!variant) return null;
+	const allowed = TRANSITION_VARIANT_ATTRIBUTES[type];
+	const attrs = {};
+	for (const [name, value] of Object.entries(variant)) {
+		if (allowed.includes(name)) {
+			attrs[name] = value;
+			continue;
+		}
+		warnOnce("transition/unknown-variant", `slide transition \`${type}\` variant \`${name}\` is not an attribute of <p:${type}> and is ignored — ${allowed.length > 0 ? `use ${allowed.join(", ")}` : "it takes none"}.`, {
+			received: name,
+			valid: allowed
+		});
+	}
+	return attrs;
+}
+/**
+* Build the `p:sndAc` sound-action child of `p:transition` (positioned after the
+* transition-type element). A start sound is `<p:stSnd [loop="1"]><p:snd r:embed
+* name/></p:stSnd>` referencing the embedded audio by `soundRId`; the stop-previous form is
+* `<p:endSnd/>` (no rel). Returns `''` when the transition has no sound, or a start sound was
+* registered under no relationship on this slide.
+*/
+function transitionSoundToXml(transition, soundRId) {
+	const sound = transition.sound;
+	if (!sound) return "";
+	if (sound.stopPrevious) return el("p:sndAc", null, raw(voidEl("p:endSnd")));
+	if (soundRId === void 0) return "";
+	return el("p:sndAc", null, raw(el("p:stSnd", { loop: xsdBoolIfTrue(sound.loop) }, raw(voidEl("p:snd", {
+		"r:embed": `rId${soundRId}`,
+		name: sound.name || null
+	})))));
+}
+/**
+* Build the slide-show transition tree (`p:transition`), positioned in `CT_Slide`
+* between `p:clrMapOvr` and `p:timing`. Emits PowerPoint's `mc:AlternateContent`
+* form (a `p14` Choice carrying the exact `p14:dur`, plus a base `mc:Fallback`)
+* when `durationMs` is set, and the bare `<p:transition>` otherwise. See
+* `docs/contributing/design/animations.md`.
+* @param slide - the slide whose transition is emitted
+* @param soundRId - the relationship id this slide's start sound was registered under, if one was.
+*   It is the slide's, not the transition's: one transition object can sit on several slides, each
+*   declaring the sound under an id of its own.
+* @returns {string} the transition XML, or `''` when the slide has no transition the writer can emit
+*/
+function slideTransitionToXml(slide, soundRId) {
+	const transition = slide.transition;
+	if (!transition?.type) return "";
+	const type = checkEnumOrWarn(transition.type, TRANSITION_TYPES, "transition/unknown-type", "slide transition `type`");
+	if (!type) return "";
+	const typeEl = voidEl(`p:${type}`, transitionVariantAttrs(type, transition.variant));
+	const sndAc = transitionSoundToXml(transition, soundRId);
+	const hasDuration = typeof transition.durationMs === "number" && Number.isFinite(transition.durationMs);
+	const baseAttrs = {
+		spd: (transition.speed ?? (hasDuration ? transitionSpeedForDuration(transition.durationMs) : null)) || null,
+		advClick: transition.advanceOnClick === false ? "0" : null,
+		advTm: typeof transition.advanceAfterMs === "number" ? Math.round(transition.advanceAfterMs) : null
+	};
+	if (!hasDuration) return el("p:transition", baseAttrs, [raw(typeEl), raw(sndAc)]);
+	const dur = Math.round(transition.durationMs);
+	return alternateContentEl({
+		requires: {
+			prefix: "p14",
+			uri: OOXML_NS.p14
+		},
+		choice: el("p:transition", {
+			...baseAttrs,
+			"p14:dur": dur
+		}, [raw(typeEl), raw(sndAc)]),
+		fallback: el("p:transition", baseAttrs, [raw(typeEl), raw(sndAc)])
+	});
+}
+//#endregion
+//#region src/gen/slide/object.ts
+/** The four axes that make up an explicit group frame. All or nothing — see `givenGroupFrameAxes`. */
+const GROUP_FRAME_AXES = [
+	"x",
+	"y",
+	"w",
+	"h"
+];
+/**
+* Which of `x`/`y`/`w`/`h` a group's caller actually supplied.
+*
+* A group frame is explicit only when **all four** are given; anything less falls back to
+* auto-bounds on every axis. Partial frames used to be honoured per-axis, which let the unset ones
+* take the shared per-object defaults (`x=0`, `y=0`, `cx=75%` of the layout width, `cy=0`) — so
+* `addGroup([rect], { x: 5, y: 2 })` emitted a zero-height group whose width was a silent
+* slide-width fraction, and every child of it then re-read as `null` through the read path's
+* degenerate-`chExt` guard.
+*
+* Per-axis fallback was the other candidate, but it cannot mean what it reads like: the writer keeps
+* an identity child space (`chOff/chExt == off/ext`), so a group's frame never moves or scales its
+* children — it only places the selection handle and the rotate pivot. `{ x: 5 }` would leave the
+* children where they were and put the group's box somewhere they are not. Falling back whole, with
+* a warning, keeps the group box around its content and says so out loud.
+* @param options - the group object's options
+* @returns the supplied axis names, in `x`/`y`/`w`/`h` order
+*/
+const givenGroupFrameAxes = (options) => GROUP_FRAME_AXES.filter((axis) => typeof options[axis] !== "undefined");
+/**
+* Whether a group's frame is fully explicit (all four of `x`/`y`/`w`/`h`), and so should be used
+* verbatim instead of the children's bounding box. See `givenGroupFrameAxes`.
+* @param options - the group object's options
+* @returns true when every axis is supplied
+*/
+const hasCompleteGroupFrame = (options) => givenGroupFrameAxes(options).length === GROUP_FRAME_AXES.length;
+/**
+* Normalize one axis of a placement box so its extent is never negative.
+*
+* `<a:ext cx>`/`<a:ext cy>` are `ST_PositiveCoordinate` (ECMA-376 Part 1, `CT_PositiveSize2D`), so a
+* negative extent is schema-invalid. PowerPoint rejects the *whole* presentation with "The file or
+* directory is corrupted and unreadable" (0x80070570) and names no shape, part, or slide, while
+* LibreOffice renders the same package happily — so the defect is invisible until the deck reaches
+* PowerPoint.
+*
+* A signed delta is the natural way to write "draw from A to B" (`{ x: x0, y: y0, w: x1 - x0, h: y1 - y0 }`),
+* and it goes negative the moment the line runs leftward or upward. The correct encoding is the
+* normalized bounding box plus a flip, which is what `addConnector` already derives from its own
+* endpoints (`src/gen/define/connector.ts`); this gives every other shape kind the same treatment at
+* the one point where every `Coord` form ('50%', '2in', a number) has been resolved to EMU.
+*
+* The caller composes `flip` onto any `flipH`/`flipV` the author set, so an explicit flip plus a
+* negative extent cancel out rather than double-applying.
+* @param off - the axis origin in EMU (`a:off` `x` or `y`)
+* @param ext - the axis extent in EMU (`a:ext` `cx` or `cy`), possibly negative
+* @returns the min-corner origin, the absolute extent, and whether the axis was mirrored
+*/
+const normalizeAxisExtent = (off, ext) => ext < 0 ? {
+	off: off + ext,
+	ext: -ext,
+	flip: true
+} : {
+	off,
+	ext,
+	flip: false
+};
+/**
+* Resolve the frame a slide object is drawn in.
+*
+* The render pass and a group's bounding box both need it, and they used to resolve it apart. The
+* bounds pass defaulted a missing `w` or `h` to 0 and skipped placeholder inheritance, while the
+* render pass defaulted `cx` to 75% of the slide width and inherited the placeholder's frame, so a
+* group holding a text box with no `w` came out narrower than the text box.
+*
+* Each axis, most specific source first: what the caller stated on this object, else what the
+* layout placeholder it names states, else the default (`x`, `y` and `cy` 0, `cx` 75% of the slide
+* width). An explicit option beats an inherited one everywhere else in this library, and a
+* placeholder is an inherited one: applying it after the object's own values used to throw away a
+* stated frame with no diagnostic.
+*
+* Inheritance happens before normalization. A negative `w`/`h` becomes a min-corner origin, an
+* absolute extent and a flip, never a negative `<a:ext>`, which is out of range for
+* `ST_PositiveCoordinate` and costs the whole package (see `normalizeAxisExtent`). Doing it after
+* every `Coord` form has resolved to EMU means `'-2in'` and `'-25%'` normalize like a plain
+* negative number, and a placeholder's extents normalize with the object's own.
+* @param obj - the slide object
+* @param slide - the slide or layout holding it
+* @returns the object's frame
+*/
+function resolveObjectFrame(obj, slide) {
+	const itemOpts = obj.options ?? {};
+	const layout = slide._presLayout;
+	const placeholder = findLayoutPlaceholder(slide._slideLayout, itemOpts.placeholder);
+	const phOpts = placeholder?.options ?? {};
+	const inherited = (own, ph) => own !== void 0 ? own : ph ?? void 0;
+	const ownX = inherited(itemOpts.x, phOpts.x);
+	const ownY = inherited(itemOpts.y, phOpts.y);
+	const ownW = inherited(itemOpts.w, phOpts.w);
+	const ownH = inherited(itemOpts.h, phOpts.h);
+	const normX = normalizeAxisExtent(ownX !== void 0 ? getSmartParseNumber(ownX, "X", layout) : 0, ownW !== void 0 ? getSmartParseNumber(ownW, "X", layout) : getSmartParseNumber("75%", "X", layout));
+	const normY = normalizeAxisExtent(ownY !== void 0 ? getSmartParseNumber(ownY, "Y", layout) : 0, ownH !== void 0 ? getSmartParseNumber(ownH, "Y", layout) : 0);
+	return {
+		x: normX.off,
+		y: normY.off,
+		cx: normX.ext,
+		cy: normY.ext,
+		flipX: normX.flip,
+		flipY: normY.flip,
+		placeholder
+	};
+}
+/**
+* Whether this part has a real slide number to cache in a `slidenum` field.
+*
+* Only a slide does. A master leaves `_slideNum` null and a layout carries the internal 1000+
+* counter that keeps layout media keys from colliding with slide media — neither is a page
+* number, and neither belongs in the field's cached text.
+*/
+function hasRealSlideNumber(slide) {
+	return slide._slideNum != null && slide._slideNum < 1e3;
+}
+/**
+* Warn about duplicate Selection Pane identities on this slide.
+*
+* Unique `objectName` values are what consumers (e.g. semantic manifests) rely on, so
+* collisions are flagged loudly. Deliberately NOT `warnOnce`: this runs per emit, and two
+* `write()` calls are two separate exports — a caller capturing diagnostics around the second
+* would otherwise be told its deck is clean because the first one had already said otherwise. Groups are recursed into: a group's children are
+* `<p:cNvPr>`-named on this same slide, so a child colliding with a top-level object (or with a
+* child of another group) is a collision the Selection Pane shows, and checking only the top
+* level cannot see it.
+*/
+function warnDuplicateObjectNames(slide) {
+	const collectObjectNames = (objects) => objects.flatMap((obj) => [...typeof obj.options?.objectName === "string" ? [obj.options.objectName] : [], ...collectObjectNames(obj._groupObjects || [])]);
+	const duplicateObjectNames = getDuplicateObjectNames(collectObjectNames(slide._slideObjects));
+	if (duplicateObjectNames.length > 0) warn("object-name/duplicate", `duplicate objectName value(s) emitted on a single slide: ${duplicateObjectNames.join(", ")}. Selection Pane identities should be unique.`);
+}
+/**
+* The slide's `<p:bg>`, or `''` when it has none.
+*
+* Exactly one of the three forms is emitted: an image background (a rel the media pass resolved),
+* a colour or gradient, or the white default that only the built-in layout gets. They are
+* mutually exclusive because a master carrying both a `color` and a `path` must still produce a
+* single `<p:bg>`.
+*/
+function slideBackgroundXml(slide) {
+	let strSlideXml = "";
+	if (slide._bkgdImgRid) strSlideXml += el("p:bg", null, raw(el("p:bgPr", null, [raw(el("a:blipFill", {
+		dpi: "0",
+		rotWithShape: "1"
+	}, [
+		raw(el("a:blip", { "r:embed": `rId${slide._bkgdImgRid}` }, raw(voidEl("a:lum")))),
+		raw(voidEl("a:srcRect")),
+		raw(STRETCH_FILL_RECT)
+	])), raw(voidEl("a:effectLst"))])));
+	else if (fillNamesPaint(slide.background)) strSlideXml += el("p:bg", null, raw(el("p:bgPr", null, [raw(genXmlColorSelection(slide.background)), raw(voidEl("a:effectLst"))])));
+	else if (!slide.background && slide._name && slide._name === "DEFAULT") strSlideXml += el("p:bg", null, raw(el("p:bgRef", { idx: "1001" }, raw(voidEl("a:schemeClr", { val: "bg1" })))));
+	return strSlideXml;
+}
+/**
+* The slide-number placeholder shape.
+*
+* Emitted after every authored object, so its `<p:cNvPr>` id can come from the same monotonic
+* counter the walk has been advancing — the caller allocates it and passes it in.
+*
+* @param slide - the slide, layout or master being emitted
+* @param snProps - the part's slide-number properties, read but never written: a serializer
+*   does not normalize the authored model (see the contract on `RenderContext.itemOpts`)
+* @param slideNumberId - the `<p:cNvPr>` id to use, already allocated by the caller
+*/
+function slideNumberPlaceholderXml(slide, snProps, slideNumberId) {
+	let strSlideXml = "";
+	strSlideXml += "<p:sp>";
+	strSlideXml += " <p:nvSpPr>";
+	strSlideXml += voidEl("p:cNvPr", {
+		id: slideNumberId,
+		name: "Slide Number Placeholder 0"
+	}, { openPrefix: "  " }) + el("p:cNvSpPr", null, raw(voidEl("a:spLocks", { noGrp: "1" })));
+	strSlideXml += el("p:nvPr", null, raw(voidEl("p:ph", {
+		type: "sldNum",
+		sz: "quarter",
+		idx: "4294967295"
+	})), { openPrefix: "  " });
+	strSlideXml += " </p:nvSpPr>";
+	strSlideXml += " <p:spPr>";
+	strSlideXml += el("a:xfrm", null, [raw(voidEl("a:off", {
+		x: getSmartParseNumber(snProps.x, "X", slide._presLayout),
+		y: getSmartParseNumber(snProps.y, "Y", slide._presLayout)
+	})), raw(voidEl("a:ext", {
+		cx: snProps.w ? getSmartParseNumber(snProps.w, "X", slide._presLayout) : "800000",
+		cy: snProps.h ? getSmartParseNumber(snProps.h, "Y", slide._presLayout) : "300000"
+	}))]) + prstGeomRect({ openPrefix: " " }) + el("a:extLst", null, raw(el("a:ext", { uri: "{C572A759-6A51-4108-AA02-DFA0A04FC94B}" }, raw(voidEl("ma14:wrappingTextBoxFlag", {
+		val: "0",
+		"xmlns:ma14": "http://schemas.microsoft.com/office/mac/drawingml/2011/main"
+	})))), { openPrefix: " " }) + "</p:spPr>";
+	strSlideXml += "<p:txBody>";
+	const snInsets = resolveInsetsEmu(snProps.margin);
+	strSlideXml += voidEl("a:bodyPr", {
+		lIns: snInsets?.l ?? null,
+		tIns: snInsets?.t ?? null,
+		rIns: snInsets?.r ?? null,
+		bIns: snInsets?.b ?? null,
+		anchor: resolveTextAnchor(snProps.valign)
+	});
+	let defRPr = "";
+	rejectEmptyColor(snProps.color, "slideNumber color");
+	if (snProps.fontFace || snProps.fontSize || snProps.color) {
+		const face = snProps.fontFace;
+		defRPr = el("a:defRPr", { sz: clampFontSizeSz(snProps.fontSize || 12) }, [
+			snProps.color ? raw(genXmlColorSelection(snProps.color)) : null,
+			face ? raw(voidEl("a:latin", { typeface: face })) : null,
+			face ? raw(voidEl("a:ea", { typeface: face })) : null,
+			face ? raw(voidEl("a:cs", { typeface: face })) : null
+		]);
+	}
+	strSlideXml += el("a:lstStyle", null, raw(el("a:lvl1pPr", null, raw(defRPr))), { openPrefix: "  " });
+	const snAlignRaw = snProps.align ?? "left";
+	const snAlign = snAlignRaw.startsWith("c") ? "ctr" : snAlignRaw.startsWith("r") ? "r" : "l";
+	strSlideXml += el("a:p", null, [
+		raw(voidEl("a:pPr", { algn: snAlign })),
+		raw(el("a:fld", {
+			id: SLDNUMFLDID,
+			type: "slidenum"
+		}, [raw(voidEl("a:rPr", {
+			b: xsdBool(snProps.bold),
+			lang: "en-US"
+		})), raw(el("a:t", null, hasRealSlideNumber(slide) ? String(slide._slideNum) : SLDNUM_PLACEHOLDER_TEXT))])),
+		raw(voidEl("a:endParaRPr", { lang: "en-US" }))
+	]);
+	strSlideXml += "</p:txBody></p:sp>";
+	return strSlideXml;
+}
+/**
+* Transforms a slide or slideLayout to resulting XML string - Creates `ppt/slide*.xml`
+* @param slide - slide object created within createSlideObject
+* @param renderers - which renderer emits each shape family; see {@link RendererTable} for why
+*   this arrives as an argument rather than being imported here
+* @return XML string with `<p:cSld>` as the root
+*/
+function slideObjectToXml(slide, renderers) {
+	let strSlideXml = slide._name ? "<p:cSld name=\"" + encodeXmlAttrValue(slide._name) + "\">" : "<p:cSld>";
+	warnDuplicateObjectNames(slide);
+	strSlideXml += slideBackgroundXml(slide);
+	const spTreeChildren = [];
+	const shapeIds = collectSlideShapeIds(slide._slideObjects);
+	const resolveObjBounds = (obj) => {
+		const o = obj.options || {};
+		if (obj._type === "group" && !hasCompleteGroupFrame(o)) {
+			const kids = (obj._groupObjects || []).map(resolveObjBounds);
+			if (kids.length === 0) return {
+				x: 0,
+				y: 0,
+				cx: 0,
+				cy: 0
+			};
+			const minX = Math.min(...kids.map((b) => b.x));
+			const minY = Math.min(...kids.map((b) => b.y));
+			const maxX = Math.max(...kids.map((b) => b.x + b.cx));
+			const maxY = Math.max(...kids.map((b) => b.y + b.cy));
+			return {
+				x: minX,
+				y: minY,
+				cx: maxX - minX,
+				cy: maxY - minY
+			};
+		}
+		const frame = resolveObjectFrame(obj, slide);
+		if (obj._type === "image") {
+			const { drawnW, drawnH } = resolveImageExtent(obj, slide, frame);
+			return {
+				x: frame.x,
+				y: frame.y,
+				cx: drawnW,
+				cy: drawnH
+			};
+		}
+		return {
+			x: frame.x,
+			y: frame.y,
+			cx: frame.cx,
+			cy: frame.cy
+		};
+	};
+	const renderSlideObjectXml = (slideItemObj) => {
+		const shapeId = shapeIds.get(slideItemObj) ?? 2;
+		let strSlideXml = "";
+		const itemOpts = slideItemObj.options ?? {};
+		const { x, y, cx, cy, flipX, flipY, placeholder: placeholderObj } = resolveObjectFrame(slideItemObj, slide);
+		const locationAttrs = {
+			flipH: xsdBoolIfTrue(Boolean(itemOpts.flipH) !== flipX),
+			flipV: xsdBoolIfTrue(Boolean(itemOpts.flipV) !== flipY),
+			rot: mapStated(itemOpts.rotate, convertRotationDegrees) ?? null
+		};
+		const ctx = {
+			obj: slideItemObj,
+			shapeId,
+			shapeIds,
+			slide,
+			frame: {
+				x,
+				y,
+				cx,
+				cy
+			},
+			placeholder: placeholderObj,
+			locationAttrs,
+			itemOpts
+		};
+		switch (slideItemObj._type) {
+			case "chart":
+			case "connector":
+			case "image":
+			case "media":
+			case "model3d":
+			case "oleObject":
+			case "placeholder":
+			case "table":
+			case "text":
+			case "zoom": {
+				const render = renderers[slideItemObj._type];
+				if (!render) throw new InternalError("slide/object-type-not-routed", `slideObjectToXml: no renderer registered for slide object type "${slideItemObj._type}"`);
+				strSlideXml += render(ctx);
+				break;
+			}
+			case "group": {
+				const groupChildren = slideItemObj._groupObjects || [];
+				let innerXml = "";
+				groupChildren.forEach((child) => {
+					innerXml += renderSlideObjectXml(child);
+				});
+				const givenAxes = givenGroupFrameAxes(itemOpts);
+				if (givenAxes.length > 0 && givenAxes.length < GROUP_FRAME_AXES.length) {
+					const missingAxes = GROUP_FRAME_AXES.filter((axis) => !givenAxes.includes(axis));
+					warn("group/partial-frame", `addGroup: group "${itemOpts.objectName ?? ""}" has a partial frame (${givenAxes.join("/")} given, ${missingAxes.join("/")} missing); using auto-bounds (the bounding box of its children) instead. Pass all of x/y/w/h, or none.`);
+				}
+				const gb = hasCompleteGroupFrame(itemOpts) ? {
+					x,
+					y,
+					cx,
+					cy
+				} : resolveObjBounds(slideItemObj);
+				const gx = gb.x;
+				const gy = gb.y;
+				const gcx = gb.cx;
+				const gcy = gb.cy;
+				const grpLockXml = genXmlObjectLock("a:grpSpLocks", GROUP_SHAPE_LOCK_ATTRS, itemOpts.objectLock, itemOpts.objectName);
+				strSlideXml += "<p:grpSp>";
+				strSlideXml += el("p:nvGrpSpPr", null, [
+					raw(cNvPrEl(shapeId, itemOpts.objectName, itemOpts.altText || "")),
+					raw(elOrVoid("p:cNvGrpSpPr", null, grpLockXml)),
+					raw(voidEl("p:nvPr"))
+				]);
+				strSlideXml += el("p:grpSpPr", null, raw(grpXfrmEl({
+					x: gx,
+					y: gy,
+					cx: gcx,
+					cy: gcy
+				}, locationAttrs)));
+				strSlideXml += innerXml;
+				strSlideXml += "</p:grpSp>";
+				break;
+			}
+			case "notes": break;
+			case "tablecell": break;
+			case "hyperlink": break;
+			case "online": break;
+			default: slideItemObj._type;
+		}
+		return strSlideXml;
+	};
+	slide._slideObjects.forEach((slideItemObj) => {
+		spTreeChildren.push(renderSlideObjectXml(slideItemObj));
+	});
+	if (slide._slideNumberProps) {
+		let maxShapeId = 1;
+		for (const [obj, id] of shapeIds) {
+			const lastId = id + shapeIdCount(obj) - 1;
+			if (lastId > maxShapeId) maxShapeId = lastId;
+		}
+		spTreeChildren.push(slideNumberPlaceholderXml(slide, slide._slideNumberProps, maxShapeId + 1));
+	}
+	strSlideXml += spTreeEl(spTreeChildren);
+	strSlideXml += "</p:cSld>";
+	return strSlideXml;
+}
+/**
+* The relationship id a part's default relationships are numbered from: one past the highest id
+* among its hyperlink, chart and media relationships.
+*
+* Exported because the master's `<p:sldLayoutId r:id>` values have to name the ids its `.rels` part
+* gives the layouts, and `makeXmlMaster` derived them as `_rels.length + idx + 1`. The two agreed
+* only while nothing registered a chart or media relationship on the master, since that count
+* ignores both.
+* @param slide - the slide, layout or master whose relationships are numbered
+*/
+function defaultRelIdStart(slide) {
+	let lastRid = 0;
+	for (const rel of slide._rels) lastRid = Math.max(lastRid, rel.rId);
+	for (const rel of slide._relsChart || []) lastRid = Math.max(lastRid, rel.rId);
+	for (const rel of slide._relsMedia || []) lastRid = Math.max(lastRid, rel.rId);
+	return lastRid + 1;
+}
+/**
+* Transforms slide relations to XML string.
+* Extra relations that are not dynamic can be passed using the 2nd arg (e.g. theme relation in master file).
+* These relations are numbered from {@link defaultRelIdStart}.
+* `selfPath` is the emitting part's own path, and it is required because a relationship target
+* resolves against the part that states it. An internal slide link used to be written
+* `slide${n}.xml` whatever the part, which is right from `ppt/slides/` and names nothing from
+* `ppt/slideLayouts/` or `ppt/slideMasters/` — so a `hyperlink: { slide }` on an object given to
+* `defineSlideMaster({ objects })` wrote a dangling relationship.
+* @param {PresSlideInternal | SlideLayoutInternal | SlideMasterInternal} slide - slide, layout or master whose relations are being transformed
+* @param {{ target: string; type: string }[]} defaultRels - array of default relations
+* @param {string} selfPath - the emitting part's own path, e.g. `ppt/slideLayouts/slideLayout2.xml`
+* @return {string} XML
+*/
+function slideObjectRelationsToXml(slide, defaultRels, selfPath) {
+	const rels = [];
+	/**
+	* The Targets emitted so far *from the media loop below*, which is the only place the
+	* question is asked: a media item produces TWO rels sharing one Target, and the second is
+	* told from the first by the first already being there.
+	*
+	* Two things about the shape. It holds raw Targets rather than escaped ones, because this
+	* asks about the model and not about markup — the probe used to substring-scan the emitted
+	* XML for ` Target="…"`, which forced the caller to escape by hand with the same escaper the
+	* builder uses or the two drifted apart, and cost O(rels squared) in string scanning.
+	*
+	* And it is scoped to the media loop rather than to every rel. Scanning all of them meant a
+	* hyperlink could answer a question about media, which is not a hypothetical: an online video
+	* and a hyperlink to the same URL is an ordinary thing to author, and the hyperlink came
+	* first, so the video pair came out as two MS-media rels with no ECMA `video` rel at all and
+	* `<a:videoFile r:link>` pointing at the wrong type.
+	*/
+	const mediaTargets = /* @__PURE__ */ new Set();
+	slide._rels.forEach((rel) => {
+		if (isHyperlinkRel(rel)) {
+			if (rel.data === "slide") rels.push(relationshipEl(rel.rId, SLIDE_REL, targetBetweenPptSubparts(selfPath, slidePath(Number(rel.Target)))));
+			else rels.push(externalHyperlinkRel(rel.rId, rel.Target));
+		}
+	});
+	(slide._relsChart || []).forEach((rel) => {
+		rels.push(relationshipEl(rel.rId, rel.isChartEx ? CHARTEX_REL : CHART_REL, rel.Target));
+	});
+	(slide._relsMedia || []).forEach((rel) => {
+		const relType = rel.type.toLowerCase();
+		const seen = mediaTargets.has(rel.Target);
+		mediaTargets.add(rel.Target);
+		const media = (type, targetMode) => relationshipEl(rel.rId, type, rel.Target, { targetMode });
+		if (rel.oleRelType) rels.push(media(rel.oleRelType));
+		else if (rel.model3dRelType) rels.push(media(rel.model3dRelType));
+		else if (relType.includes("image")) rels.push(media(IMAGE_REL));
+		else if (relType.includes("audio")) rels.push(seen ? media(MS_MEDIA_REL) : media(AUDIO_REL));
+		else if (relType.includes("video")) rels.push(seen ? media(MS_MEDIA_REL) : media(VIDEO_REL));
+		else if (relType.includes("online")) rels.push(seen ? media(MS_MEDIA_REL, "External") : media(VIDEO_REL, "External"));
+	});
+	const start = defaultRelIdStart(slide);
+	defaultRels.forEach((rel, idx) => {
+		rels.push(relationshipEl(start + idx, rel.type, rel.target));
+	});
+	return relationshipsPart(rels);
+}
+//#endregion
+//#region src/gen/slide/slide.ts
+/**
+* ts-pptx: slide part + slide/layout rels
+*
+* Emit a slide (`ppt/slides/slideN.xml`) and the relationship files for slides
+* and layouts (`slideN.xml.rels`, `slideLayoutN.xml.rels`).
+*/
+/**
+* Generates XML for the slide file (`ppt/slides/slide1.xml`)
+* @param slide - the slide object to transform into XML
+* @param renderers - which renderer emits each shape family, passed through to the shape walk
+* @param transitionSoundRId - the relationship id package assembly registered this slide's transition
+*   start sound under, if it registered one
+* @return XML
+*/
+function makeXmlSlide(slide, renderers, transitionSoundRId) {
+	return XML_DECL + "\r\n" + el("p:sld", {
+		...PML_ROOT_NS,
+		show: slide?.hidden ? "0" : null
+	}, [
+		raw(slideObjectToXml(slide, renderers)),
+		raw(el("p:clrMapOvr", null, raw(voidEl("a:masterClrMapping")))),
+		raw(slideTransitionToXml(slide, transitionSoundRId)),
+		raw(slideTimingToXml(slide))
+	]);
+}
+/**
+* Generates XML string for a slide layout relation file
+* @param {number} layoutNumber - 1-indexed number of a layout that relations are generated for
+* @param {SlideLayoutInternal[]} slideLayouts - Slide Layouts
+* @return {string} XML
+*/
+function makeXmlSlideLayoutRel(layoutNumber, slideLayouts) {
+	const slideLayout = slideLayouts[layoutNumber - 1];
+	if (!slideLayout) throw new InternalError("slide/rel-index-out-of-range", `makeXmlSlideLayoutRel: no slide layout at index ${layoutNumber - 1}`);
+	return slideObjectRelationsToXml(slideLayout, [{
+		target: "../slideMasters/slideMaster1.xml",
+		type: SLIDE_MASTER_REL
+	}], slideLayoutPath(layoutNumber));
+}
+/**
+* Creates `ppt/_rels/slide*.xml.rels`
+* @param {PresSlideInternal[]} slides
+* @param {SlideLayoutInternal[]} slideLayouts - Slide Layout(s)
+* @param {number} `slideNumber` 1-indexed number of a layout that relations are generated for
+* @return {string} XML
+*/
+function makeXmlSlideRel(slides, slideLayouts, slideNumber) {
+	const slide = slides[slideNumber - 1];
+	if (!slide) throw new InternalError("slide/rel-index-out-of-range", `makeXmlSlideRel: no slide at index ${slideNumber - 1}`);
+	const defaultRels = [{
+		target: targetFromPptSubpart(slideLayoutPath(getLayoutIdxForSlide(slides, slideLayouts, slideNumber))),
+		type: SLIDE_LAYOUT_REL
+	}, {
+		target: targetFromPptSubpart(notesSlidePath(slideNumber)),
+		type: NOTES_SLIDE_REL
+	}];
+	if ((slide._comments || []).length > 0) defaultRels.push({
+		target: targetFromPptSubpart(commentPath(slideNumber)),
+		type: COMMENTS_REL
+	});
+	return slideObjectRelationsToXml(slide, defaultRels, slidePath(slideNumber));
+}
+/**
+* For the passed slide number, resolves name of a layout that is used for.
+* @param {PresSlideInternal[]} slides - srray of slides
+* @param {SlideLayoutInternal[]} slideLayouts - array of slideLayouts
+* @param {number} slideNumber
+* @return {number} slide number
+*/
+function getLayoutIdxForSlide(slides, slideLayouts, slideNumber) {
+	for (let i = 0; i < slideLayouts.length; i++) if (slideLayouts[i]?._name === slides[slideNumber - 1]?._slideLayout?._name) return i + 1;
+	return 1;
+}
+//#endregion
+//#region src/gen/pres/theme.ts
+/**
+* ts-pptx: `ppt/theme/theme1.xml`
+*
+* Emit the Office theme: the `<a:clrScheme>` (with any caller color overrides
+* over the default Office scheme) plus the fixed font/format schemes.
+*/
+/**
+* Theme `<a:clrScheme>` slots in OOXML document order, with their default Office color child.
+* `dk1`/`lt1` default to `sysClr` (windowText/window); the rest are `srgbClr`. A user override
+* for any slot is emitted as `<a:srgbClr>` (see `buildThemeClrScheme`).
+*/
+const THEME_CLR_SCHEME_DEFAULTS = [
+	["dk1", raw(voidEl("a:sysClr", {
+		val: "windowText",
+		lastClr: "000000"
+	}))],
+	["lt1", raw(voidEl("a:sysClr", {
+		val: "window",
+		lastClr: "FFFFFF"
+	}))],
+	["dk2", raw(voidEl("a:srgbClr", { val: "44546A" }))],
+	["lt2", raw(voidEl("a:srgbClr", { val: "E7E6E6" }))],
+	["accent1", raw(voidEl("a:srgbClr", { val: "4472C4" }))],
+	["accent2", raw(voidEl("a:srgbClr", { val: "ED7D31" }))],
+	["accent3", raw(voidEl("a:srgbClr", { val: "A5A5A5" }))],
+	["accent4", raw(voidEl("a:srgbClr", { val: "FFC000" }))],
+	["accent5", raw(voidEl("a:srgbClr", { val: "5B9BD5" }))],
+	["accent6", raw(voidEl("a:srgbClr", { val: "70AD47" }))],
+	["hlink", raw(voidEl("a:srgbClr", { val: "0563C1" }))],
+	["folHlink", raw(voidEl("a:srgbClr", { val: "954F72" }))]
+];
+/**
+* Build the theme `<a:clrScheme>` block, applying any caller-supplied color overrides over the
+* default Office scheme. Invalid (non 6-digit-hex) overrides warn and keep the default rather
+* than emitting a degenerate color.
+* @param {ThemeColorScheme} [scheme] - per-slot hex overrides
+* @return {string} the `<a:clrScheme>...</a:clrScheme>` XML
+*/
+function buildThemeClrScheme(scheme) {
+	return el("a:clrScheme", { name: "Office" }, THEME_CLR_SCHEME_DEFAULTS.map(([slot, defaultChild]) => {
+		const override = scheme?.[slot];
+		let child = defaultChild;
+		if (typeof override === "string" && override.length > 0) {
+			const hex = stripHash(override);
+			if (isHexColor(hex)) child = raw(voidEl("a:srgbClr", { val: hex.toUpperCase() }));
+			else warn("theme/invalid-color-override", `makeXmlTheme: colorScheme.${slot} "${override}" is not a 6-digit hex color; keeping the Office default.`);
+		}
+		return raw(el(`a:${slot}`, null, child));
+	}));
+}
+/**
+* The per-script theme font fallback table (`a:fontScheme`'s CT_TextFont lists), in OOXML
+* document order. Static Office defaults — no caller data, no escaping risk — unlike the
+* `<a:latin>`/`<a:ea>`/`<a:cs>` slots above.
+*
+* Forty-one of the forty-seven scripts take the same face in the major and minor lists, so the
+* shared table below is the whole thing and the two override maps hold the six-odd rows that
+* actually differ. Written out twice, ninety-four lines said less than these do, and one row
+* mistyped in one copy produces a theme that opens fine and paints a script in the wrong face —
+* a difference nobody reviewing a diff of two 47-row tables would see.
+*/
+const THEME_FONT_LIST = [
+	["Jpan", "游ゴシック"],
+	["Hang", "맑은 고딕"],
+	["Hans", "等线"],
+	["Hant", "新細明體"],
+	["Arab", "Arial"],
+	["Hebr", "Arial"],
+	["Thai", "Cordia New"],
+	["Ethi", "Nyala"],
+	["Beng", "Vrinda"],
+	["Gujr", "Shruti"],
+	["Khmr", "DaunPenh"],
+	["Knda", "Tunga"],
+	["Guru", "Raavi"],
+	["Cans", "Euphemia"],
+	["Cher", "Plantagenet Cherokee"],
+	["Yiii", "Microsoft Yi Baiti"],
+	["Tibt", "Microsoft Himalaya"],
+	["Thaa", "MV Boli"],
+	["Deva", "Mangal"],
+	["Telu", "Gautami"],
+	["Taml", "Latha"],
+	["Syrc", "Estrangelo Edessa"],
+	["Orya", "Kalinga"],
+	["Mlym", "Kartika"],
+	["Laoo", "DokChampa"],
+	["Sinh", "Iskoola Pota"],
+	["Mong", "Mongolian Baiti"],
+	["Viet", "Arial"],
+	["Uigh", "Microsoft Uighur"],
+	["Geor", "Sylfaen"],
+	["Armn", "Arial"],
+	["Bugi", "Leelawadee UI"],
+	["Bopo", "Microsoft JhengHei"],
+	["Java", "Javanese Text"],
+	["Lisu", "Segoe UI"],
+	["Mymr", "Myanmar Text"],
+	["Nkoo", "Ebrima"],
+	["Olck", "Nirmala UI"],
+	["Osma", "Ebrima"],
+	["Phag", "Phagspa"],
+	["Syrn", "Estrangelo Edessa"],
+	["Syrj", "Estrangelo Edessa"],
+	["Syre", "Estrangelo Edessa"],
+	["Sora", "Nirmala UI"],
+	["Tale", "Microsoft Tai Le"],
+	["Talu", "Microsoft New Tai Lue"],
+	["Tfng", "Ebrima"]
+];
+/**
+* The seven scripts whose *heading* face differs from the body one. Latin and CJK headings take
+* the Light weight; the scripts with no Light cut take a serif (or, for Khmer, a different face
+* entirely) where the body takes a sans. Every other script in {@link THEME_FONT_LIST} uses one
+* face for both.
+*/
+const MAJOR_FONT_OVERRIDES = {
+	Jpan: "游ゴシック Light",
+	Hans: "等线 Light",
+	Arab: "Times New Roman",
+	Hebr: "Times New Roman",
+	Thai: "Angsana New",
+	Khmr: "MoolBoran",
+	Viet: "Times New Roman"
+};
+/** The major (heading) and minor (body) lists, both derived from the one table. */
+const MAJOR_FONT_LIST = THEME_FONT_LIST.map(([script, face]) => [script, MAJOR_FONT_OVERRIDES[script] ?? face]);
+const MINOR_FONT_LIST = THEME_FONT_LIST;
+function fontListChildren(scriptFaces) {
+	return scriptFaces.map(([script, typeface]) => raw(voidEl("a:font", {
+		script,
+		typeface
+	})));
+}
+/**
+* Creates `ppt/theme/theme1.xml`
+* @return {string} XML
+*/
+function makeXmlTheme(pres) {
+	const majorLatin = pres.theme?.headFontFace ? raw(voidEl("a:latin", { typeface: pres.theme.headFontFace })) : raw(voidEl("a:latin", {
+		typeface: "Calibri Light",
+		panose: "020F0302020204030204"
+	}));
+	const minorLatin = pres.theme?.bodyFontFace ? raw(voidEl("a:latin", { typeface: pres.theme.bodyFontFace })) : raw(voidEl("a:latin", {
+		typeface: "Calibri",
+		panose: "020F0502020204030204"
+	}));
+	const majorEa = raw(voidEl("a:ea", { typeface: pres.theme?.headFontFaceEA ?? "" }));
+	const minorEa = raw(voidEl("a:ea", { typeface: pres.theme?.bodyFontFaceEA ?? "" }));
+	const majorCs = raw(voidEl("a:cs", { typeface: pres.theme?.headFontFaceCS ?? "" }));
+	const minorCs = raw(voidEl("a:cs", { typeface: pres.theme?.bodyFontFaceCS ?? "" }));
+	const fontScheme = el("a:fontScheme", { name: "Office" }, [raw(el("a:majorFont", null, [
+		majorLatin,
+		majorEa,
+		majorCs,
+		...fontListChildren(MAJOR_FONT_LIST)
+	])), raw(el("a:minorFont", null, [
+		minorLatin,
+		minorEa,
+		minorCs,
+		...fontListChildren(MINOR_FONT_LIST)
+	]))]);
+	const themeElements = el("a:themeElements", null, [
+		raw(buildThemeClrScheme(pres.theme?.colorScheme)),
+		raw(fontScheme),
+		raw(FMT_SCHEME_XML)
+	]);
+	const extLst = el("a:extLst", null, raw(el("a:ext", { uri: "{05A4C25C-085E-4340-85A3-A5531E510DB2}" }, raw(voidEl("thm15:themeFamily", {
+		"xmlns:thm15": "http://schemas.microsoft.com/office/thememl/2012/main",
+		name: "Office Theme",
+		id: "{62F939B6-93AF-4DB8-9C6B-D6C7DFDC589F}",
+		vid: "{4A3C46E8-61CC-4603-A589-7422A47A8E4A}"
+	})))));
+	return XML_DECL + el("a:theme", {
+		"xmlns:a": OOXML_NS.a,
+		name: "Office Theme"
+	}, [
+		raw(themeElements),
+		raw(voidEl("a:objectDefaults")),
+		raw(voidEl("a:extraClrSchemeLst")),
+		raw(extLst)
+	]);
+}
+//#endregion
+//#region src/gen/extract-slides.ts
+/**
+* Embedded audio/video. addMedia (`gen/define/media.ts`) pushes three consecutive
+* _relsMedia entries per item off `mediaRid`: the ECMA audio/video rel
+* (rId=mediaRid), the MS-2007 `media` rel (mediaRid+1, sharing one Target),
+* and the preview image rel (mediaRid+2). The body references all three; we
+* surface the descriptor so appendSlides can reproduce the rel graph. Online
+* media (external link) is excluded — it has a different rel shape and no part.
+*/
+function avMediaOf(slide, relByRid) {
+	return slide._slideObjects.filter((obj) => obj._type === "media" && obj.mtype !== "online" && typeof obj.mediaRid === "number").map((obj) => {
+		const mtype = obj.mtype === "audio" ? "audio" : "video";
+		const mediaRid = obj.mediaRid;
+		const mediaRel = relByRid.get(mediaRid);
+		const previewRel = relByRid.get(previewRid(mediaRid));
+		if (!mediaRel || !previewRel) return null;
+		const mediaBytes = decodeBase64ToBytes(typeof mediaRel.data === "string" ? mediaRel.data : "");
+		const previewBytes = decodeBase64ToBytes(typeof previewRel.data === "string" ? previewRel.data : "");
+		if (!mediaBytes || !previewBytes) return null;
+		const mediaExtn = relExtension(mediaRel, "mp4");
+		const previewExtn = relExtension(previewRel, "png");
+		return {
+			mtype,
+			mediaRid,
+			msMediaRid: msMediaRid(mediaRid),
+			previewRid: previewRid(mediaRid),
+			mediaBytes,
+			mediaExtn,
+			mediaContentType: avContentType(mediaExtn, mtype),
+			previewBytes,
+			previewExtn,
+			previewContentType: imageContentType(previewExtn)
+		};
+	}).filter((m) => m !== null);
+}
+/**
+* A media rel's lowercased file extension: its own `extn` when it has one, else the suffix of
+* its `Target`, else `fallback`.
+* @param rel - the media relationship
+* @param fallback - the extension to assume when neither source names one
+*/
+function relExtension(rel, fallback) {
+	return (rel.extn || rel.Target.split(".").pop() || fallback).toLowerCase();
+}
+/**
+* Plain image media, as decoded bytes keyed by the `rId` the body uses.
+*
+* `avPreviewRids` are the poster frames of {@link avMediaOf}'s items: they live in
+* `_relsMedia` as image rels too, and their descriptor already carries them, so they are
+* excluded here rather than surfaced twice.
+*/
+function imageMediaOf(slide, avPreviewRids) {
+	return slide._relsMedia.filter((rel) => rel.type.toLowerCase().includes("image") && !avPreviewRids.has(rel.rId)).map((rel) => {
+		const data = rel.data && typeof rel.data === "string" ? rel.data : "";
+		const bytes = decodeBase64ToBytes(data);
+		const extn = relExtension(rel, "png");
+		return bytes ? {
+			rId: rel.rId,
+			bytes,
+			extn,
+			contentType: imageContentType(extn)
+		} : null;
+	}).filter((m) => m !== null);
+}
+/**
+* Online (external-link) video. addMedia type:'online' pushes three rels off
+* mediaRid: the ECMA video rel (mediaRid, External), the MS-2007 media rel
+* (mediaRid+1, External, sharing the link Target), and the poster image rel
+* (mediaRid+2, carried by {@link imageMediaOf} as a normal image). No media binary
+* part exists; appendSlides reproduces only the two external rels + poster.
+*/
+function onlineMediaOf(slide, relByRid) {
+	return slide._slideObjects.filter((obj) => obj._type === "media" && obj.mtype === "online" && typeof obj.mediaRid === "number").map((obj) => {
+		const mediaRid = obj.mediaRid;
+		const videoRel = relByRid.get(mediaRid);
+		if (!videoRel || typeof videoRel.Target !== "string" || !videoRel.Target) return null;
+		return {
+			mediaRid,
+			msMediaRid: msMediaRid(mediaRid),
+			link: videoRel.Target
+		};
+	}).filter((m) => m !== null);
+}
+/** External hyperlink rels, keyed by the `rId` the body uses. */
+function hyperlinksOf(slide) {
+	return slide._rels.filter((rel) => isHyperlinkRel(rel) && rel.data !== "slide").map((rel) => ({
+		rId: rel.rId,
+		target: rel.Target
+	}));
+}
+/**
+* Internal slide-to-slide links: `rel.data === 'slide'`, and `rel.Target` is the 1-based
+* source slide number (see addText's hyperlink.slide handling).
+*
+* A Target that does not read as a slide number throws rather than passing `NaN` on to the
+* append path's rel-graph rebuild, where it surfaces as "links to source slide NaN" a whole
+* subsystem later. `addText` writes this Target itself, so the condition is a defect on this
+* side rather than bad input — an {@link InternalError}, like the chart router's own.
+*/
+function slideLinksOf(slide) {
+	return slide._rels.filter((rel) => isHyperlinkRel(rel) && rel.data === "slide").map((rel) => {
+		const sourceSlideNumber = Number(rel.Target);
+		if (!Number.isInteger(sourceSlideNumber) || sourceSlideNumber < 1) throw new InternalError("slide/link-target-not-a-number", `Internal slide link rId${rel.rId} targets "${String(rel.Target)}", which is not a slide number`);
+		return {
+			rId: rel.rId,
+			sourceSlideNumber
+		};
+	});
+}
+/**
+* Speaker notes, or `undefined` when the slide has none. The body and the hyperlinks come from one
+* resolution of the notes, because the two must agree on every hyperlink rId. Notes rels reserve
+* rId1=notesMaster and rId2=slide, both of which appendSlides wires itself.
+*/
+function notesOf(slide) {
+	if (!slide._slideObjects.some((obj) => obj._type === "notes")) return void 0;
+	const notes = buildNotesSlideRels(slide);
+	return {
+		xml: makeXmlNotesSlide(slide, notes),
+		hyperlinks: notes.rels.filter((rel) => typeof rel.Target === "string" && rel.Target).map((rel) => ({
+			rId: rel.rId,
+			target: rel.Target
+		}))
+	};
+}
+/**
+* Serialize a deck's authored slides as injectable descriptors, without producing a package.
+* @param source - the deck state to read; see {@link ExtractSource}
+* @param opts.onMediaError - what a media source that cannot be read does, as on `write()`
+*/
+async function extractSlides(source, opts = {}) {
+	const onMediaError = opts.onMediaError ?? "throw";
+	const { presentation } = source;
+	const deckSlides = presentation.slides;
+	requireSlideLinksInDeck(deckSlides);
+	backfillPlaceholders(deckSlides);
+	await encodeMediaForTargets(deckSlides, source.runtime, onMediaError);
+	const restoreAuthoredFit = bakeMeasuredFit(deckSlides, source.fontMetrics);
+	let slides;
+	try {
+		slides = deckSlides.map((slide) => {
+			const relByRid = new Map(slide._relsMedia.map((rel) => [rel.rId, rel]));
+			const avMedia = avMediaOf(slide, relByRid);
+			const notes = notesOf(slide);
+			return {
+				xml: makeXmlSlide(slide, source.renderers),
+				media: imageMediaOf(slide, new Set(avMedia.map((item) => item.previewRid))),
+				hyperlinks: hyperlinksOf(slide),
+				charts: source.extract.charts?.(slide) ?? [],
+				slideLinks: slideLinksOf(slide),
+				avMedia,
+				onlineMedia: onlineMediaOf(slide, relByRid),
+				...notes ? { notes } : {}
+			};
+		});
+	} finally {
+		restoreAuthoredFit();
+	}
+	const notesMaster = slides.some((s) => s.notes) ? {
+		xml: makeXmlNotesMaster(),
+		themeXml: makeXmlTheme(presentation)
+	} : void 0;
+	return {
+		widthEmu: presentation.presLayout.width,
+		heightEmu: presentation.presLayout.height,
+		slides,
+		embeddedFonts: presentation.embeddedFonts,
+		...notesMaster ? { notesMaster } : {}
+	};
+}
+//#endregion
+//#region src/gen/opc/app.ts
+/**
+* ts-pptx: `docProps/app.xml`
+*
+* Emit the extended-properties part (application, slide/notes counts, heading
+* pairs, titles of parts, company).
+*/
+/** This part is pretty-printed, one element per line, at three nesting depths. */
+const INDENT_1 = "\n	";
+const INDENT_2 = "\n		";
+const INDENT_3 = "\n			";
+const PROP = { openPrefix: INDENT_1 };
+const VECTOR = {
+	openPrefix: INDENT_2,
+	closePrefix: INDENT_2
+};
+const ITEM = { openPrefix: INDENT_3 };
+const NS = {
+	xmlns: OOXML_NS.ep,
+	"xmlns:vt": OOXML_NS.vt
+};
+/** One `<vt:variant>` of a heading pair: the section's name, then its count. */
+function headingPair(name, count) {
+	return [el("vt:variant", null, raw(el("vt:lpstr", null, name)), ITEM), el("vt:variant", null, raw(el("vt:i4", null, count)), ITEM)];
+}
+/**
+* Creates `docProps/app.xml`
+*
+* `PresentationFormat` and `HiddenSlides` were constants -- `On-screen Show (16:9)` and `0` --
+* whatever the deck. PowerPoint rewrites both on its first save, so nothing broke, but until then
+* a 4:3 deck and a deck with hidden slides each stated something false to anything reading the
+* package without opening it. Both are known here, so both are reported.
+* @param {PresSlideInternal[]} slides - Presenation Slides
+* @param {string} company - "Company" metadata
+* @param {PresLayout} presLayout - the deck's slide size, which names its presentation format
+* @returns XML
+*/
+function makeXmlApp(slides, company, presLayout) {
+	const headingPairs = el("vt:vector", {
+		size: 6,
+		baseType: "variant"
+	}, [
+		...headingPair("Fonts Used", 2),
+		...headingPair("Theme", 1),
+		...headingPair("Slide Titles", slides.length)
+	].map(raw), VECTOR);
+	const titlesOfParts = el("vt:vector", {
+		size: slides.length + 1 + 2,
+		baseType: "lpstr"
+	}, [
+		raw(el("vt:lpstr", null, "Arial", ITEM)),
+		raw(el("vt:lpstr", null, "Calibri", ITEM)),
+		raw(el("vt:lpstr", null, "Office Theme", ITEM)),
+		raw(INDENT_3),
+		...slides.map((_slideObj, idx) => raw(el("vt:lpstr", null, `Slide ${idx + 1}`)))
+	], VECTOR);
+	return XML_DECL + "\r\n" + el("Properties", NS, [
+		raw(el("TotalTime", null, 0, PROP)),
+		raw(el("Words", null, 0, PROP)),
+		raw(el("Application", null, "Microsoft Office PowerPoint", PROP)),
+		raw(el("PresentationFormat", null, presentationFormatLabel(presLayout.width, presLayout.height), PROP)),
+		raw(el("Paragraphs", null, 0, PROP)),
+		raw(el("Slides", null, slides.length, PROP)),
+		raw(el("Notes", null, slides.length, PROP)),
+		raw(el("HiddenSlides", null, slides.filter((slide) => slide.hidden).length, PROP)),
+		raw(el("MMClips", null, 0, PROP)),
+		raw(el("ScaleCrop", null, "false", PROP)),
+		raw(el("HeadingPairs", null, raw(headingPairs), {
+			...PROP,
+			closePrefix: INDENT_1
+		})),
+		raw(el("TitlesOfParts", null, raw(titlesOfParts), {
+			...PROP,
+			closePrefix: INDENT_1
+		})),
+		raw(el("Company", null, company, PROP)),
+		raw(el("LinksUpToDate", null, "false", PROP)),
+		raw(el("SharedDoc", null, "false", PROP)),
+		raw(el("HyperlinksChanged", null, "false", PROP)),
+		raw(el("AppVersion", null, "16.0000", PROP))
+	], { closePrefix: INDENT_1 });
+}
+//#endregion
+//#region src/gen/opc/content-types.ts
+/**
+* ts-pptx: `[Content_Types].xml`
+*
+* Emit the package content-types part: Default entries for the media extensions
+* actually used by the deck (plus the font default when faces are embedded) and
+* Override entries for every part the package skeleton writes.
+*
+* Entries that exist only because a construct family put a part in the package arrive as
+* {@link ContentTypeContributions} — already resolved to data and grouped by where they land.
+* The order below is a property of the format, not of whoever assembled that list, so a deck
+* written by a program that links three families and one that links ten emit the same bytes.
+*/
+/**
+* Some Override entries have always been emitted with a leading space. It is insignificant
+* whitespace, but it is in the bytes this library has shipped for years, so it is reproduced
+* verbatim rather than normalized (see AGENTS.md "Byte identity": whitespace diffs are a STOP).
+*/
+const LEADING_SPACE = { openPrefix: " " };
+/** Nothing beyond the skeleton — the shape a deck written with no construct families contributes. */
+const NO_CONTENT_TYPE_CONTRIBUTIONS = Object.freeze({
+	defaults: [],
+	presentation: [],
+	perSlide: [],
+	perLayout: [],
+	trailing: []
+});
+function contentDefault(extension, contentType) {
+	return voidEl("Default", {
+		Extension: extension,
+		ContentType: contentType
+	});
+}
+function override(partName, contentType, fmt) {
+	return voidEl("Override", {
+		PartName: partName,
+		ContentType: contentType
+	}, fmt);
+}
+/** Render a contributed Override, honouring its leading-space flag. */
+function contributedOverride(entry) {
+	return override(entry.partName, entry.contentType, entry.leadingSpace ? LEADING_SPACE : void 0);
+}
+/**
+* Generate XML ContentType
+* @param opts - the deck's parts, plus whatever the construct families it was written with add
+* @returns XML
+*/
+function makeXmlContTypes(opts) {
+	const { slides, slideLayouts, masterSlide, hasCustomProps, embeddedFonts } = opts;
+	const contributions = opts.contributions ?? NO_CONTENT_TYPE_CONTRIBUTIONS;
+	const parts = [contentDefault("xml", "application/xml"), contentDefault("rels", RELATIONSHIPS_CONTENT_TYPE)];
+	const extnTypeMap = /* @__PURE__ */ new Map();
+	const ctTargets = [];
+	(slides || []).forEach((s) => ctTargets.push(s));
+	(slideLayouts || []).forEach((l) => ctTargets.push(l));
+	if (masterSlide) ctTargets.push(masterSlide);
+	ctTargets.forEach((target) => {
+		(target._relsMedia || []).forEach((rel) => {
+			if (rel.type === "online" || !rel.extn || !rel.type) return;
+			const contentType = rel.type.startsWith("audio/") ? avContentType(rel.extn, "audio") : rel.type.startsWith("video/") ? avContentType(rel.extn, "video") : rel.type;
+			if (!extnTypeMap.has(rel.extn)) extnTypeMap.set(rel.extn, contentType);
+		});
+	});
+	extnTypeMap.forEach((type, extn) => {
+		parts.push(contentDefault(extn, type));
+	});
+	contributions.defaults.forEach((entry) => {
+		if (extnTypeMap.has(entry.extension)) return;
+		extnTypeMap.set(entry.extension, entry.contentType);
+		parts.push(contentDefault(entry.extension, entry.contentType));
+	});
+	if ((embeddedFonts || []).some((font) => font.faces.some((face) => face.bytes))) parts.push(contentDefault(FONT_DATA_EXTENSION, FONT_DATA_CONTENT_TYPE));
+	parts.push(override(overrideName(PRESENTATION_PATH), PRESENTATION_MAIN_CONTENT_TYPE));
+	contributions.presentation.forEach((entry) => parts.push(contributedOverride(entry)));
+	parts.push(override(overrideName(SLIDE_MASTER_PATH), SLIDE_MASTER_CONTENT_TYPE));
+	slides.forEach((_slide, idx) => {
+		parts.push(override(overrideName(slidePath(idx + 1)), SLIDE_CONTENT_TYPE));
+		(contributions.perSlide[idx] || []).forEach((entry) => parts.push(contributedOverride(entry)));
+	});
+	parts.push(override("/ppt/presProps.xml", PRES_PROPS_CONTENT_TYPE));
+	parts.push(override("/ppt/viewProps.xml", VIEW_PROPS_CONTENT_TYPE));
+	parts.push(override("/ppt/theme/theme1.xml", THEME_CONTENT_TYPE));
+	parts.push(override("/ppt/theme/theme2.xml", THEME_CONTENT_TYPE));
+	parts.push(override("/ppt/tableStyles.xml", TABLE_STYLES_CONTENT_TYPE));
+	slideLayouts.forEach((_layout, idx) => {
+		parts.push(override(overrideName(slideLayoutPath(idx + 1)), SLIDE_LAYOUT_CONTENT_TYPE));
+		(contributions.perLayout[idx] || []).forEach((entry) => parts.push(contributedOverride(entry)));
+	});
+	contributions.trailing.forEach((entry) => parts.push(contributedOverride(entry)));
+	parts.push(override("/docProps/core.xml", CORE_PROPS_CONTENT_TYPE, LEADING_SPACE));
+	parts.push(override("/docProps/app.xml", EXTENDED_PROPS_CONTENT_TYPE, LEADING_SPACE));
+	if (hasCustomProps) parts.push(override("/docProps/custom.xml", CUSTOM_PROPS_CONTENT_TYPE, LEADING_SPACE));
+	return XML_DECL + "\r\n" + el("Types", { xmlns: OOXML_NS.ct }, parts.map(raw));
+}
+//#endregion
+//#region src/gen/opc/custom-props.ts
+/**
+* ts-pptx: `docProps/custom.xml`
+*
+* Emit the custom-properties part from caller-supplied name/value pairs (bool,
+* date, number and string value types).
+*/
+const CUSTOM_PROPS_FMTID = "{D5CDD505-2E9C-101B-9397-08002B2CF9AE}";
+const PROPS_NS = {
+	xmlns: "http://schemas.openxmlformats.org/officeDocument/2006/custom-properties",
+	"xmlns:vt": OOXML_NS.vt
+};
+/** Serialize one custom-property value to its typed `vt:` element. */
+function valueEl(value) {
+	if (typeof value === "boolean") return el("vt:bool", null, String(value));
+	if (value instanceof Date) return el("vt:filetime", null, value.toISOString().replace(/\.\d{3}Z$/, "Z"));
+	if (typeof value === "number") return el(Number.isInteger(value) ? "vt:i4" : "vt:r8", null, value);
+	return el("vt:lpwstr", null, String(value));
+}
+/**
+* Creates `docProps/custom.xml`
+* @param props - custom property name/value pairs
+* @returns XML
+*/
+function makeXmlCustomProperties(props) {
+	const properties = props.map(({ name, value }, idx) => raw(el("property", {
+		fmtid: CUSTOM_PROPS_FMTID,
+		pid: idx + 2,
+		name
+	}, raw(valueEl(value)))));
+	return XML_DECL + "\r\n" + el("Properties", PROPS_NS, properties);
+}
+//#endregion
+//#region src/gen/opc/root-rels.ts
+/**
+* ts-pptx: `_rels/.rels`
+*
+* Emit the package root relationships (app/core/presentation, plus custom-props
+* when present).
+*/
+/** Each entry carries its own indent; the `<Relationships>` wrapper adds none of its own. */
+const INDENTED = { fmt: { openPrefix: "\n		" } };
+/**
+* Creates `_rels/.rels`
+* @returns XML
+*/
+function makeXmlRootRels(hasCustomProps) {
+	const rels = [
+		relationshipEl("rId1", EXTENDED_PROPS_REL, "docProps/app.xml", INDENTED),
+		relationshipEl("rId2", CORE_PROPS_REL, "docProps/core.xml", INDENTED),
+		relationshipEl("rId3", OFFICE_DOCUMENT_REL, "ppt/presentation.xml", INDENTED)
+	];
+	if (hasCustomProps) rels.push(relationshipEl("rId4", CUSTOM_PROPS_REL, "docProps/custom.xml", INDENTED));
+	return relationshipsPart(rels, { closePrefix: "\n		" });
+}
+//#endregion
+//#region src/gen/pres/presentation-rels.ts
+/**
+* Creates `ppt/_rels/presentation.xml.rels`
+* @param {PresSlideInternal[]} slides - Presenation Slides
+* @returns XML
+*/
+/**
+* The relationship ids `presentation.xml.rels` gives its fixed parts, and the first id free
+* after them.
+*
+* Layout: rId1 = slideMaster, rId2..(N+1) = N slides, then notesMaster/presProps/viewProps/
+* theme1/tableStyles, then commentAuthors when the deck has any comment, then the embedded
+* fonts.
+*
+* The rels writer and `makeXmlPresentation` both need these numbers — the presentation part
+* names the notesMaster and each embedded face by `r:id` — and each derived them separately,
+* one as `slides.length + 2` under a comment saying it copied the other's logic. Inserting a
+* relationship before `notesMaster` then broke the presentation's own reference with no
+* signal.
+* @param slides - the deck's slides, whose count and comments decide the layout
+*/
+function presentationFixedRelIds(slides) {
+	const first = (slides?.length ?? 0) + 2;
+	const hasComments = (slides || []).some((slide) => (slide._comments || []).length > 0);
+	return {
+		notesMaster: first,
+		presProps: first + 1,
+		viewProps: first + 2,
+		theme: first + 3,
+		tableStyles: first + 4,
+		commentAuthors: hasComments ? first + 5 : null,
+		fontStart: first + (hasComments ? 6 : 5)
+	};
+}
+/**
+* The first relationship id free for embedded-font rels — {@link presentationFixedRelIds}'
+* `fontStart`, kept as its own name because that is what the two font walks ask for.
+*/
+function presentationFontRelStart(slides) {
+	return presentationFixedRelIds(slides).fontStart;
+}
+function makeXmlPresentationRels(slides, embeddedFonts) {
+	const fixed = presentationFixedRelIds(slides);
+	const rels = [relationshipEl(1, SLIDE_MASTER_REL, targetFromPresentation(SLIDE_MASTER_PATH))];
+	for (let idx = 1; idx <= slides.length; idx++) rels.push(relationshipEl(idx + 1, SLIDE_REL, targetFromPresentation(slidePath(idx))));
+	rels.push(relationshipEl(fixed.notesMaster, NOTES_MASTER_REL, targetFromPresentation(NOTES_MASTER_PATH)), relationshipEl(fixed.presProps, PRES_PROPS_REL, "presProps.xml"), relationshipEl(fixed.viewProps, VIEW_PROPS_REL, "viewProps.xml"), relationshipEl(fixed.theme, THEME_REL, "theme/theme1.xml"), relationshipEl(fixed.tableStyles, TABLE_STYLES_REL, "tableStyles.xml"));
+	if (fixed.commentAuthors !== null) rels.push(relationshipEl(fixed.commentAuthors, COMMENT_AUTHORS_REL, "commentAuthors.xml"));
+	for (const face of flattenEmbeddedFaces(embeddedFonts || [], presentationFontRelStart(slides))) rels.push(relationshipEl(face.rId, FONT_REL_TYPE, targetFromPresentation(fontPath(face.partIndex))));
+	return relationshipsPart(rels);
+}
+//#endregion
+//#region src/gen/pres/presentation.ts
+/**
+* ts-pptx: `ppt/presentation.xml` + presProps/viewProps
+*
+* Emit the presentation part (masters/notes/slide id lists, sizes, embedded-font
+* list, default text styles, sections) and the small presProps/viewProps parts.
+*/
+function defaultTextStyleLevel(idy, marL) {
+	return lvlPPr(idy, {
+		marL,
+		algn: "l"
+	}, [raw(themeFontDefRPr("mn", {
+		sz: 1800,
+		kern: 1200
+	}))]);
+}
+function sectionsExtLst(sections) {
+	return el("p:extLst", null, [raw(el("p:ext", { uri: "{521415D9-36F7-43E2-AB2F-B90AF26B5E84}" }, raw(el("p14:sectionLst", { "xmlns:p14": OOXML_NS.p14 }, sections.map((sect) => raw(el("p14:section", {
+		name: sect.title,
+		id: sect._id
+	}, raw(el("p14:sldIdLst", null, sect._slides.map((slide) => raw(voidEl("p14:sldId", { id: slide._slideId })))))))))))), raw(el("p:ext", { uri: "{EFAFB233-063F-42B5-8137-9DF3F51BA10A}" }, raw(voidEl("p15:sldGuideLst", { "xmlns:p15": OOXML_NS.p15 }))))]);
+}
+/**
+* Create presentation file (`ppt/presentation.xml`)
+* @see https://docs.microsoft.com/en-us/office/open-xml/structure-of-a-presentationml-document
+* @see http://www.datypic.com/sc/ooxml/t-p_CT_Presentation.html
+* @param {PresentationPropsInternal} pres - presentation
+* @return {string} XML
+*/
+function makeXmlPresentation(pres) {
+	const openTag = `<p:presentation xmlns:a="${OOXML_NS.a}" xmlns:r="${OOXML_NS.r}" xmlns:p="${OOXML_NS.p}" ${pres.rtlMode ? "rtl=\"1\"" : ""} ${(pres.embeddedFonts || []).some((font) => font.faces.some((face) => face.bytes)) ? "embedTrueTypeFonts=\"1\" saveSubsetFonts=\"0\"" : "saveSubsetFonts=\"1\""} autoCompressPictures="0"${pres.firstSlideNum !== 1 ? ` firstSlideNum="${pres.firstSlideNum}"` : ""}>`;
+	const sldMasterIdLst = el("p:sldMasterIdLst", null, raw(voidEl("p:sldMasterId", {
+		id: MIN_SLIDE_MASTER_ID,
+		"r:id": "rId1"
+	})));
+	const notesMasterIdLst = el("p:notesMasterIdLst", null, raw(voidEl("p:notesMasterId", { "r:id": `rId${presentationFixedRelIds(pres.slides).notesMaster}` })));
+	const sldIdLst = el("p:sldIdLst", null, pres.slides.map((slide) => raw(voidEl("p:sldId", {
+		id: slide._slideId,
+		"r:id": `rId${slide._rId}`
+	}))));
+	const { width, height } = pres.presLayout;
+	const sldSz = voidEl("p:sldSz", {
+		cx: width,
+		cy: height,
+		type: slideSizeType(width, height)
+	});
+	const notesSz = voidEl("p:notesSz", {
+		cx: pres.presLayout.height,
+		cy: pres.presLayout.width
+	});
+	const fonts = pres.embeddedFonts || [];
+	const flat = flattenEmbeddedFaces(fonts, presentationFontRelStart(pres.slides));
+	const rIdOf = new Map(flat.map((face) => [`${face.fontIndex}:${face.slot}`, face.rId]));
+	const embeddedFontLst = serializeEmbeddedFontLst(fonts, (fontIndex, slot) => rIdOf.get(`${fontIndex}:${slot}`));
+	const defaultTextStyle = el("p:defaultTextStyle", null, LEVEL_MARGINS_EMU.map((marL, i) => raw(defaultTextStyleLevel(i + 1, marL))));
+	const extLst = pres.sections && pres.sections.length > 0 ? sectionsExtLst(pres.sections) : "";
+	return XML_DECL + "\r\n" + openTag + sldMasterIdLst + notesMasterIdLst + sldIdLst + sldSz + notesSz + embeddedFontLst + defaultTextStyle + extLst + "</p:presentation>";
+}
+/**
+* Create `ppt/presProps.xml`
+* @return {string} XML
+*/
+function makeXmlPresProps() {
+	return XML_DECL + "\r\n" + voidEl("p:presentationPr", { ...PML_ROOT_NS });
+}
+/**
+* Creates `ppt/viewProps.xml`
+* @return {string} XML
+*/
+function makeXmlViewProps() {
+	return XML_DECL + "\r\n" + el("p:viewPr", { ...PML_ROOT_NS }, [
+		raw(el("p:normalViewPr", { horzBarState: "maximized" }, [raw(voidEl("p:restoredLeft", { sz: 15611 })), raw(voidEl("p:restoredTop", { sz: 94610 }))])),
+		raw(el("p:slideViewPr", null, raw(el("p:cSldViewPr", {
+			snapToGrid: 0,
+			snapToObjects: 1
+		}, [raw(el("p:cViewPr", { varScale: 1 }, [raw(el("p:scale", null, [raw(voidEl("a:sx", {
+			n: 136,
+			d: 100
+		})), raw(voidEl("a:sy", {
+			n: 136,
+			d: 100
+		}))])), raw(voidEl("p:origin", {
+			x: 216,
+			y: 312
+		}))])), raw(voidEl("p:guideLst"))])))),
+		raw(el("p:notesTextViewPr", null, raw(el("p:cViewPr", null, [raw(el("p:scale", null, [raw(voidEl("a:sx", {
+			n: 1,
+			d: 1
+		})), raw(voidEl("a:sy", {
+			n: 1,
+			d: 1
+		}))])), raw(voidEl("p:origin", {
+			x: 0,
+			y: 0
+		}))])))),
+		raw(voidEl("p:gridSpacing", {
+			cx: 76200,
+			cy: 76200
+		}))
+	]);
+}
+//#endregion
+//#region src/gen/pres/table-styles.ts
+/**
+* Create `ppt/tableStyles.xml`
+* @see: http://openxmldeveloper.org/discussions/formats/f/13/p/2398/8107.aspx
+* @return {string} XML
+*/
+function makeXmlTableStyles() {
+	return XML_DECL + "\r\n" + voidEl("a:tblStyleLst", {
+		"xmlns:a": OOXML_NS.a,
+		def: "{5C22544A-7EE6-4342-B048-85BDC9FD1C3A}"
+	});
+}
+//#endregion
+//#region src/gen/slide/layout.ts
+/**
+* ts-pptx: slide-layout part
+*
+* Emit a slide layout (`ppt/slideLayouts/slideLayoutN.xml`) from a layout object.
+*/
+/**
+* Generates the XML layout resource from a layout object
+* @param layout - slide layout (master)
+* @param renderers - which renderer emits each shape family, passed through to the shape walk
+* @return XML
+*/
+function makeXmlLayout(layout, renderers) {
+	return XML_DECL + el("p:sldLayout", {
+		...PML_ROOT_NS,
+		preserve: "1"
+	}, [raw(slideObjectToXml(layout, renderers)), raw(el("p:clrMapOvr", null, raw(voidEl("a:masterClrMapping"))))], {
+		openPrefix: "\n		",
+		childPrefix: "\n		"
+	});
+}
+//#endregion
+//#region src/gen/slide/master.ts
+/**
+* ts-pptx: slide-master parts
+*
+* The slide master (`slideMaster1.xml`) and its `.rels`, plus the master text
+* styles (`<p:txStyles>`): per-level default values mirroring the built-in
+* Office master, with any `MasterTextStyleProps` overrides layered on top.
+*/
+const MASTER_TITLE_DEFAULT = {
+	marL: 0,
+	algn: "ctr",
+	spcBefPct: 0,
+	bu: "none",
+	sz: 4400,
+	font: "mj"
+};
+const MASTER_BODY_DEFAULTS = [
+	{
+		marL: 342900,
+		indent: -342900,
+		algn: "l",
+		spcBefPct: 2e4,
+		bu: {
+			char: "•",
+			font: "Arial"
+		},
+		sz: 3200,
+		font: "mn"
+	},
+	{
+		marL: 742950,
+		indent: -285750,
+		algn: "l",
+		spcBefPct: 2e4,
+		bu: {
+			char: "–",
+			font: "Arial"
+		},
+		sz: 2800,
+		font: "mn"
+	},
+	{
+		marL: 1143e3,
+		indent: -228600,
+		algn: "l",
+		spcBefPct: 2e4,
+		bu: {
+			char: "•",
+			font: "Arial"
+		},
+		sz: 2400,
+		font: "mn"
+	},
+	{
+		marL: 1600200,
+		indent: -228600,
+		algn: "l",
+		spcBefPct: 2e4,
+		bu: {
+			char: "–",
+			font: "Arial"
+		},
+		sz: 2e3,
+		font: "mn"
+	},
+	{
+		marL: 2057400,
+		indent: -228600,
+		algn: "l",
+		spcBefPct: 2e4,
+		bu: {
+			char: "»",
+			font: "Arial"
+		},
+		sz: 2e3,
+		font: "mn"
+	},
+	{
+		marL: 2514600,
+		indent: -228600,
+		algn: "l",
+		spcBefPct: 2e4,
+		bu: {
+			char: "•",
+			font: "Arial"
+		},
+		sz: 2e3,
+		font: "mn"
+	},
+	{
+		marL: 2971800,
+		indent: -228600,
+		algn: "l",
+		spcBefPct: 2e4,
+		bu: {
+			char: "•",
+			font: "Arial"
+		},
+		sz: 2e3,
+		font: "mn"
+	},
+	{
+		marL: 3429e3,
+		indent: -228600,
+		algn: "l",
+		spcBefPct: 2e4,
+		bu: {
+			char: "•",
+			font: "Arial"
+		},
+		sz: 2e3,
+		font: "mn"
+	},
+	{
+		marL: 3886200,
+		indent: -228600,
+		algn: "l",
+		spcBefPct: 2e4,
+		bu: {
+			char: "•",
+			font: "Arial"
+		},
+		sz: 2e3,
+		font: "mn"
+	}
+];
+const MASTER_OTHER_DEFAULTS = LEVEL_MARGINS_EMU.map((marL) => ({
+	marL,
+	algn: "l",
+	sz: 1800,
+	font: "mn"
+}));
+function masterAlignAttr(align) {
+	return align === void 0 ? "" : textAlignToken(align) ?? "";
+}
+/** Build the bullet element for a master level: caller override wins over the level default. */
+function masterBulletXml(bulletOverride, base) {
+	if (bulletOverride === false) return voidEl("a:buNone");
+	if (bulletOverride && typeof bulletOverride === "object") {
+		const font = bulletOverride.fontFace ? voidEl("a:buFont", { typeface: bulletOverride.fontFace }) : "";
+		if (bulletOverride.type === "number") {
+			const startAt = typeof bulletOverride.numberStartAt === "number" ? bulletOverride.numberStartAt : void 0;
+			return font + buAutoNumEl(bulletOverride.numberType || "arabicPeriod", startAt, "master textStyles bullet");
+		}
+		return (bulletOverride.fontFace ? font : voidEl("a:buFont", {
+			typeface: "Arial",
+			pitchFamily: 34,
+			charset: 0
+		})) + buCharEl(bulletOverride.characterCode, "•", "master textStyles bullet");
+	}
+	if (base === "none") return voidEl("a:buNone");
+	if (base && typeof base === "object") return voidEl("a:buFont", {
+		typeface: base.font,
+		pitchFamily: 34,
+		charset: 0
+	}) + buCharEl(void 0, base.char, "master textStyles bullet");
+	return "";
+}
+/**
+* One length-valued override on a master text-style level, in EMU, or the level's default when the
+* caller stated something we cannot use.
+*
+* `marginLeft` and `indent` used to reach their clamps only when they were finite numbers and fall
+* back in silence otherwise, so `NaN`, `Infinity` and a string such as `'0.5in'` all became the
+* Office default with nothing said -- while `fontSize` on the very same level warned for exactly
+* those inputs. Silent coercion of invalid input is a footgun: the deck comes out wrong and the
+* caller has nothing to go on.
+*
+* `undefined` is the caller stating nothing, which is not a problem and is not reported.
+* @param stated - the caller's value, in inches
+* @param option - the option's name, as `MasterTextStyleLevel` spells it
+* @param fallback - the level's default, already in EMU
+* @param resolve - the clamp that converts a usable value to EMU
+*/
+function masterLevelLength(stated, option, fallback, resolve) {
+	if (stated === void 0) return fallback;
+	if (typeof stated === "number" && Number.isFinite(stated)) return resolve(stated);
+	const kept = fallback === void 0 ? "the level default" : `${fallback / EMU_PER_INCH}in`;
+	warn("master/invalid-text-style-length", `master textStyles ${option} "${String(stated)}" is invalid; keeping ${kept}.`);
+	return fallback;
+}
+/** Serialize one `<a:lvlNpPr>` from its default, layering an optional caller override. */
+function masterLevelXml(levelNum, base, levelOverride = {}) {
+	const marL = masterLevelLength(levelOverride.marginLeft, "marginLeft", base.marL, (inches) => clampParaMarginInchesEmu(inches, "master textStyles marginLeft"));
+	const indentEmu = masterLevelLength(levelOverride.indent, "indent", base.indent, (inches) => clampParaIndentInchesEmu(inches, "master textStyles indent"));
+	const algn = levelOverride.align && masterAlignAttr(levelOverride.align) || base.algn;
+	let sz = base.sz;
+	if (levelOverride.fontSize !== void 0) {
+		if (typeof levelOverride.fontSize !== "number" || !Number.isFinite(levelOverride.fontSize) || levelOverride.fontSize <= 0) warn("master/invalid-text-style-font-size", `master textStyles fontSize "${String(levelOverride.fontSize)}" is invalid; keeping default ${base.sz / 100}pt.`);
+		else sz = clampFontSizeSz(levelOverride.fontSize, "master textStyles fontSize");
+	}
+	rejectEmptyColor(levelOverride.color, "textStyles color");
+	const colorXml = levelOverride.color ? createColorElement(levelOverride.color) : voidEl("a:schemeClr", { val: "tx1" });
+	const latinXml = levelOverride.fontFace ? voidEl("a:latin", { typeface: levelOverride.fontFace }) : voidEl("a:latin", { typeface: `+${base.font}-lt` });
+	return lvlPPr(levelNum, {
+		marL,
+		indent: indentEmu,
+		algn
+	}, [
+		typeof base.spcBefPct === "number" ? raw(el("a:spcBef", null, raw(voidEl("a:spcPct", { val: base.spcBefPct })))) : null,
+		raw(masterBulletXml(levelOverride.bullet, base.bu)),
+		raw(themeFontDefRPr(base.font, {
+			sz,
+			b: xsdBoolIfTrue(levelOverride.bold),
+			i: xsdBoolIfTrue(levelOverride.italic),
+			kern: 1200
+		}, colorXml, latinXml))
+	]);
+}
+/** Clamp a caller-provided per-level override array to the 9 valid list levels, warning on overflow. */
+function masterLevelOverrides(levels, group) {
+	if (!Array.isArray(levels)) return [];
+	if (levels.length > 9) warn("master/too-many-text-style-levels", `master textStyles.${group} has ${levels.length} levels; only the first 9 are used.`);
+	return levels.slice(0, 9);
+}
+/**
+* Build the `<p:txStyles>` block from caller overrides layered onto the Office master defaults.
+* Only invoked when `defineSlideMaster({ textStyles })` was set; the unconfigured deck keeps the
+* verbatim default literal in `makeXmlMaster` for byte-identical output.
+*/
+function makeXmlMasterTxStyles(textStyles) {
+	const title = masterLevelXml(1, MASTER_TITLE_DEFAULT, textStyles.title);
+	const bodyOverrides = masterLevelOverrides(textStyles.body, "body");
+	const body = MASTER_BODY_DEFAULTS.map((base, i) => masterLevelXml(i + 1, base, bodyOverrides[i])).join("");
+	const otherOverrides = masterLevelOverrides(textStyles.other, "other");
+	const other = MASTER_OTHER_DEFAULTS.map((base, i) => masterLevelXml(i + 1, base, otherOverrides[i])).join("");
+	return el("p:txStyles", null, [
+		raw(el("p:titleStyle", null, raw(title))),
+		raw(el("p:bodyStyle", null, raw(body))),
+		raw(el("p:otherStyle", null, [raw(el("a:defPPr", null, raw(voidEl("a:defRPr", { lang: "en-US" })))), raw(other)]))
+	]);
+}
+/**
+* The built-in Office master's `<p:txStyles>`, used verbatim when `defineSlideMaster({ textStyles })`
+* was never called. Deliberately NOT built via `masterLevelXml`: a configured title level always
+* carries `marL="0"` (from `MASTER_TITLE_DEFAULT.marL`), but the true unconfigured default titleStyle
+* has no `marL`/`indent` attribute at all — a pre-existing asymmetry between the two paths, preserved
+* exactly rather than unified.
+*/
+function makeXmlMasterDefaultTxStyles() {
+	const defaultLevel = (n, attrs, bullet, sz, font, spcBefPct) => lvlPPr(n, attrs, [
+		typeof spcBefPct === "number" ? raw(el("a:spcBef", null, raw(voidEl("a:spcPct", { val: spcBefPct })))) : null,
+		raw(bullet),
+		raw(themeFontDefRPr(font, {
+			sz,
+			kern: 1200
+		}))
+	]);
+	const title = defaultLevel(1, { algn: "ctr" }, voidEl("a:buNone"), 4400, "mj", 0);
+	const bodyLevels = MASTER_BODY_DEFAULTS.map((base, i) => {
+		const bu = base.bu;
+		return defaultLevel(i + 1, {
+			marL: base.marL,
+			indent: base.indent,
+			algn: base.algn
+		}, voidEl("a:buFont", {
+			typeface: bu.font,
+			pitchFamily: 34,
+			charset: 0
+		}) + voidEl("a:buChar", { char: bu.char }), base.sz, "mn", base.spcBefPct);
+	});
+	const otherLevels = MASTER_OTHER_DEFAULTS.map((base, i) => defaultLevel(i + 1, {
+		marL: base.marL,
+		algn: base.algn
+	}, "", base.sz, "mn"));
+	return el("p:txStyles", null, [
+		raw(el("p:titleStyle", null, raw(title), {
+			childPrefix: "  ",
+			closePrefix: " "
+		})),
+		raw(el("p:bodyStyle", null, bodyLevels.map(raw), {
+			childPrefix: "  ",
+			closePrefix: " "
+		})),
+		raw(el("p:otherStyle", null, [raw(el("a:defPPr", null, raw(voidEl("a:defRPr", { lang: "en-US" })))), ...otherLevels.map(raw)], {
+			childPrefix: "  ",
+			closePrefix: " "
+		}))
+	], { childPrefix: " " });
+}
+/**
+* Creates Slide Master 1 (`ppt/slideMasters/slideMaster1.xml`)
+* @param slide - slide object that represents master slide layout
+* @param layouts - slide layouts
+* @param renderers - which renderer emits each shape family, passed through to the shape walk
+* @return XML
+*/
+function makeXmlMaster(slide, layouts, renderers) {
+	const layoutRidStart = defaultRelIdStart(slide);
+	const layoutDefs = layouts.map((_layoutDef, idx) => voidEl("p:sldLayoutId", {
+		id: LAYOUT_IDX_SERIES_BASE + idx,
+		"r:id": `rId${layoutRidStart + idx}`
+	})).join("");
+	const clrMap = voidEl("p:clrMap", DEFAULT_COLOR_MAP);
+	const hf = voidEl("p:hf", {
+		sldNum: slide._slideNumberProps ? null : 0,
+		hdr: 0,
+		ftr: 0,
+		dt: 0
+	});
+	const txStyles = slide._txStyles ? makeXmlMasterTxStyles(slide._txStyles) : makeXmlMasterDefaultTxStyles();
+	return XML_DECL + "\r\n" + el("p:sldMaster", { ...PML_ROOT_NS }, [
+		raw(slideObjectToXml(slide, renderers)),
+		raw(clrMap),
+		raw(el("p:sldLayoutIdLst", null, raw(layoutDefs))),
+		raw(hf),
+		raw(txStyles)
+	]);
+}
+/**
+* Creates `ppt/slideMasters/_rels/slideMaster1.xml.rels`
+* @param {SlideMasterInternal} masterSlide - the deck's slide master
+* @param {SlideLayoutInternal[]} slideLayouts - Slide Layouts
+* @return {string} XML
+*/
+function makeXmlMasterRel(masterSlide, slideLayouts) {
+	const defaultRels = slideLayouts.map((_layoutDef, idx) => ({
+		target: targetFromPptSubpart(slideLayoutPath(idx + 1)),
+		type: SLIDE_LAYOUT_REL
+	}));
+	defaultRels.push({
+		target: "../theme/theme1.xml",
+		type: THEME_REL
+	});
+	return slideObjectRelationsToXml(masterSlide, defaultRels, SLIDE_MASTER_PATH);
+}
+//#endregion
+//#region src/package/parts/shared.ts
+/**
+* The contributors in emission order. Sorting here rather than trusting the caller's array is the
+* whole point of {@link PartContributor.order}; the sort is stable, so two families that share a
+* rank keep their listed order rather than swapping unpredictably.
+*/
+function orderedContributors(contributors) {
+	return [...contributors].sort((a, b) => a.order - b.order);
+}
+/**
+* Ask every contributor for its content-type entries and flatten them into the slot-keyed data
+* `makeXmlContTypes` emits. Takes the contributors already ordered — within a slot the entries
+* come out in the order they are collected here.
+*/
+function collectContentTypes(contributors, pres) {
+	const defaults = [];
+	const presentation = [];
+	const trailing = [];
+	const perSlide = pres.slides.map(() => []);
+	const perLayout = pres.slideLayouts.map(() => []);
+	for (const contributor of contributors) {
+		const hooks = contributor.contentTypes;
+		if (!hooks) continue;
+		if (hooks.defaults) defaults.push(...hooks.defaults(pres));
+		if (hooks.presentation) presentation.push(...hooks.presentation(pres));
+		if (hooks.perSlide) {
+			const perSlideHook = hooks.perSlide;
+			pres.slides.forEach((slide, idx) => perSlide[idx]?.push(...perSlideHook(slide, idx + 1)));
+		}
+		if (hooks.perLayout) {
+			const perLayoutHook = hooks.perLayout;
+			pres.slideLayouts.forEach((layout, idx) => perLayout[idx]?.push(...perLayoutHook(layout, idx + 1)));
+		}
+		if (hooks.trailing) trailing.push(...hooks.trailing(pres));
+	}
+	return {
+		defaults,
+		presentation,
+		perSlide,
+		perLayout,
+		trailing
+	};
+}
+//#endregion
+//#region src/package/assemble.ts
+/**
+* Package assembly: turn an authored presentation's internal state into the full set of
+* OOXML package parts and hand the bytes to the ZIP writer. This is the write-side
+* "packaging" layer — `[Content_Types].xml`, the `_rels` graph, docProps, theme, the
+* per-slide/layout/master parts, and media rels — split out of the authoring class
+* (`TsPptx`) so that class stays a façade over slide authoring. The parts a construct
+* family adds on top of that skeleton — charts, comments, notes — come from the part
+* contributors it is handed, so nothing here names a family.
+*
+* The entry point `writePackage` takes a structural {@link PackageSource} that the
+* authoring class satisfies; it does not depend on the class itself, so the same pipeline
+* can be driven from any assembled deck state.
+*/
+/**
+* Media extensions whose bytes are already entropy-coded, so running the ZIP's
+* DEFLATE pass over them costs CPU for a negligible size gain. For these we set
+* the per-entry ZIP compression to STORE while leaving XML parts on DEFLATE.
+* In image/video-heavy decks media dominates the byte count, so this is the
+* dominant cost when writing large presentations.
+* Formats that genuinely benefit from DEFLATE (bmp, wav, tiff, emf, wmf, svg)
+* are deliberately excluded so they keep inheriting the global compression.
+*/
+const ALREADY_COMPRESSED_MEDIA_EXTN = /* @__PURE__ */ new Set([
+	"jpg",
+	"jpeg",
+	"png",
+	"gif",
+	"webp",
+	"heic",
+	"heif",
+	"avif",
+	"mp4",
+	"m4v",
+	"mov",
+	"avi",
+	"mpg",
+	"mpeg",
+	"wmv",
+	"webm",
+	"mkv",
+	"mp3",
+	"m4a",
+	"aac",
+	"ogg",
+	"oga"
+]);
+/**
+* Extensions whose payload is itself a ZIP archive — the embedded OPC packages an OLE object can
+* carry (`addOleObject`). Deflating a zip inside a zip buys nothing, so these are STOREd like the
+* already-compressed media above. No media/image rel ever uses one of these extensions, so decks
+* without an OLE object are unaffected.
+*/
+const ZIP_CONTAINER_EXTN = /* @__PURE__ */ new Set([
+	"xlsx",
+	"xlsm",
+	"docx",
+	"docm",
+	"pptx",
+	"pptm"
+]);
+/**
+* Each slide's registered transition sound.
+*
+* Kept per slide, never on the transition: one transition object can be assigned to several slides,
+* and a relationship id means something only inside the slide part that declares it. Kept across
+* writes as well, so a deck written twice registers each sound once. An entry is reused only while
+* the slide still holds its relationship and still has the same sound assigned.
+*/
+const registeredTransitionSounds = /* @__PURE__ */ new WeakMap();
+/**
+* Register an audio media part + relationship for each slide-transition start sound
+* (`transition.sound` with `data`/`path`), and return the relationship id each slide's
+* `p:sndAc/p:snd r:embed` refers to. Runs before media encoding so the bytes are loaded. Re-export
+* is safe: a slide whose sound is already registered reuses that relationship. The stop-previous
+* form (`sound.stopPrevious`) needs no part and is skipped.
+*
+* Registered here, at write time, rather than when `slide.transition` is assigned. A slide's rel
+* ids and media part names are handed out in registration order, and a transition is often set
+* before the slide's pictures and media are added; registering the sound then would move every
+* later rel id and part name on the slide.
+*/
+function registerTransitionSounds(slides) {
+	const soundRIds = /* @__PURE__ */ new Map();
+	slides.forEach((slide) => {
+		const transition = slide.transition;
+		if (!transition || !TRANSITION_TYPES.includes(transition.type)) return;
+		const sound = transition.sound;
+		if (!sound || sound.stopPrevious) return;
+		if (!sound.data && !sound.path) return;
+		const registered = registeredTransitionSounds.get(slide);
+		if (registered && slide._relsMedia.includes(registered.rel) && registered.data === sound.data && registered.path === sound.path) {
+			soundRIds.set(slide, registered.rel.rId);
+			return;
+		}
+		const dataMime = dataUriMediaType(sound.data ?? "");
+		const pathFile = sound.path ? (sound.path.split("/").pop() ?? "").split("?")[0] ?? "" : "";
+		const extn = dataMime?.startsWith("audio/") ? audioExtensionForSubtype(dataMime.slice(6)) : (pathFile.split(".").pop() ?? "wav").toLowerCase();
+		const rId = getNewRelId(slide);
+		const rel = pushMediaRel(slide, {
+			kind: "audio",
+			extn,
+			type: `audio/${extn}`,
+			path: sound.path,
+			data: sound.data,
+			rId
+		});
+		registeredTransitionSounds.set(slide, {
+			rel,
+			data: sound.data,
+			path: sound.path
+		});
+		soundRIds.set(slide, rId);
+	});
+	return soundRIds;
+}
+/**
+* Write the media parts one target's rels point at. Images are how every deck carries a picture,
+* so this stays on the core path; the chart half of what used to be one function is a part
+* contributor (`parts/chart.ts`) and runs just before it, per target, so part order is unchanged.
+*
+* After media de-duplication many relationships share one `Target`, across targets as well as
+* within one: a logo on every slide is one part. Each used to be decoded and added once per
+* relationship. A path is now written the first time it decodes, and skipped after that. The zip
+* keys entries by path and a re-added key keeps its first position, and relationships sharing a
+* `Target` share its data and extension, so skipping cannot change a byte.
+* @param {PartTarget} slide - slide, layout or master carrying the rels
+* @param {ZipWriter} zip - zip writer
+* @param {Set<string>} written - the media paths already added, shared across every target of one package
+*/
+function createMediaParts(slide, zip, written) {
+	slide._relsMedia.forEach((rel) => {
+		if (rel.type !== "online" && rel.type !== "hyperlink") {
+			const path = rel.Target.replace("..", "ppt");
+			if (written.has(path)) return;
+			const data = rel.data && typeof rel.data === "string" ? rel.data : "";
+			const bytes = decodeBase64ToBytes(data);
+			if (!bytes) return;
+			const extn = (rel.extn || rel.Target.split(".").pop() || "").toLowerCase();
+			zip.add(path, bytes, { store: ALREADY_COMPRESSED_MEDIA_EXTN.has(extn) || ZIP_CONTAINER_EXTN.has(extn) });
+			written.add(path);
+		}
+	});
+}
+/**
+* Assemble every package part for `source` and return them in emission order, without zipping.
+* This runs the transition-sound registration, placeholder backfill, media encode, cross-deck
+* media de-dup, chart-part-id assignment, and measured-fit passes before the synchronous
+* XML pass reads slide state. The bytes are the same the ZIP writer would compress; splitting the
+* assembly from the zip lets the byte-identity harness (and a future parts API) read parts
+* directly. Only `onMediaError` is meaningful here — compression/output shape are zip concerns
+* handled by {@link zipPackageParts}.
+*/
+async function buildPackageParts(source, props) {
+	const pres = source.presentation;
+	const partPromises = [];
+	const contributors = orderedContributors(source.partContributors);
+	const zip = new ZipWriter();
+	requireSlideLinksInDeck(pres.slides, pres.slideLayouts, pres.masterSlide);
+	const transitionSoundRIds = registerTransitionSounds(pres.slides);
+	backfillPlaceholders(pres.slides);
+	const onMediaError = props.onMediaError ?? "throw";
+	const mediaTargets = [
+		...pres.slides,
+		...pres.slideLayouts,
+		pres.masterSlide
+	];
+	return await encodeMediaForTargets(mediaTargets, source.runtime, onMediaError).then(async () => {
+		const canonicalMediaTargets = /* @__PURE__ */ new Map();
+		for (const target of mediaTargets) for (const rel of target._relsMedia || []) {
+			if (rel.type === "online" || rel.type === "hyperlink" || typeof rel.data !== "string" || !rel.data) continue;
+			if (rel.oleRelType) continue;
+			const key = (rel.extn || "") + "\0" + rel.data;
+			const canonical = canonicalMediaTargets.get(key);
+			if (canonical) rel.Target = canonical;
+			else canonicalMediaTargets.set(key, rel.Target);
+		}
+		let chartPartIdx = 0;
+		for (const target of mediaTargets) for (const rel of target._relsChart || []) {
+			const chartId = ++chartPartIdx;
+			rel.globalId = chartId;
+			const { fileName, target } = chartPartNames(chartId, rel.isChartEx);
+			rel.fileName = fileName;
+			rel.Target = target;
+		}
+		const restoreAuthoredFit = bakeMeasuredFit(pres.slides, source.fontMetrics);
+		try {
+			const hasCustomProps = source.customProperties.length > 0;
+			zip.add("[Content_Types].xml", makeXmlContTypes({
+				slides: pres.slides,
+				slideLayouts: pres.slideLayouts,
+				masterSlide: pres.masterSlide,
+				hasCustomProps,
+				embeddedFonts: pres.embeddedFonts,
+				contributions: collectContentTypes(contributors, pres)
+			}));
+			zip.add("_rels/.rels", makeXmlRootRels(hasCustomProps));
+			zip.add("docProps/app.xml", makeXmlApp(pres.slides, pres.company, pres.presLayout));
+			zip.add("docProps/core.xml", makeXmlCore(pres.title, pres.subject, pres.author, pres.revision));
+			if (hasCustomProps) zip.add("docProps/custom.xml", makeXmlCustomProperties(source.customProperties));
+			zip.add(relsPath(PRESENTATION_PATH), makeXmlPresentationRels(pres.slides, pres.embeddedFonts));
+			for (const face of flattenEmbeddedFaces(pres.embeddedFonts, 1)) zip.add(fontPath(face.partIndex), face.bytes, { store: true });
+			const themeXml = makeXmlTheme(pres);
+			zip.add("ppt/theme/theme1.xml", themeXml);
+			zip.add("ppt/theme/theme2.xml", themeXml);
+			zip.add(PRESENTATION_PATH, makeXmlPresentation(pres));
+			zip.add("ppt/presProps.xml", makeXmlPresProps());
+			zip.add("ppt/tableStyles.xml", makeXmlTableStyles());
+			zip.add("ppt/viewProps.xml", makeXmlViewProps());
+			pres.slideLayouts.forEach((layout, idx) => {
+				zip.add(slideLayoutPath(idx + 1), makeXmlLayout(layout, source.renderers));
+				zip.add(relsPath(slideLayoutPath(idx + 1)), makeXmlSlideLayoutRel(idx + 1, pres.slideLayouts));
+			});
+			pres.slides.forEach((slide, idx) => {
+				zip.add(slidePath(idx + 1), makeXmlSlide(slide, source.renderers, transitionSoundRIds.get(slide)));
+				zip.add(relsPath(slidePath(idx + 1)), makeXmlSlideRel(pres.slides, pres.slideLayouts, idx + 1));
+				contributors.forEach((contributor) => contributor.parts?.withEachSlide?.(slide, idx + 1, zip));
+			});
+			zip.add(SLIDE_MASTER_PATH, makeXmlMaster(pres.masterSlide, pres.slideLayouts, source.renderers));
+			zip.add(relsPath(SLIDE_MASTER_PATH), makeXmlMasterRel(pres.masterSlide, pres.slideLayouts));
+			contributors.forEach((contributor) => contributor.parts?.afterMaster?.(pres, zip));
+			const writtenMediaPaths = /* @__PURE__ */ new Set();
+			const addTargetRelParts = (target) => {
+				contributors.forEach((contributor) => {
+					const pending = contributor.parts?.fromTargetRels?.(target, zip);
+					if (pending) partPromises.push(...pending);
+				});
+				createMediaParts(target, zip, writtenMediaPaths);
+			};
+			pres.slideLayouts.forEach(addTargetRelParts);
+			pres.slides.forEach(addTargetRelParts);
+			addTargetRelParts(pres.masterSlide);
+		} finally {
+			restoreAuthoredFit();
+		}
+		return await Promise.all(partPromises).then(() => zip.entries());
+	});
+}
+/**
+* Zip an ordered list of package parts into the output shape `props.outputType` selects. Re-adds
+* each part to a fresh {@link ZipWriter} in order — preserving each part's `store` hint — so the
+* archive is byte-identical to assembling straight into one writer. Compression and output type
+* are the only zip-level knobs; part assembly happened in {@link buildPackageParts}.
+*/
+async function zipPackageParts(parts, props) {
+	const zip = new ZipWriter();
+	for (const part of parts) zip.add(part.path, part.data, { store: part.store });
+	const compression = props.compression !== false;
+	if (props.outputType) return await zip.generate(props.outputType, { compression });
+	else return await zip.generate("blob", { compression });
+}
+/**
+* Assemble every package part for `source` and zip it into the output shape `props.outputType`
+* selects. Thin composition of {@link buildPackageParts} (the assembly pipeline) and
+* {@link zipPackageParts} (the zip pass), kept as the stable entry point the authoring class calls.
+*/
+async function writePackage(source, props) {
+	return await zipPackageParts(await buildPackageParts(source, props), props);
+}
+//#endregion
+//#region src/presentation.ts
+/**
+* ts-pptx: the presentation core
+*
+* Home of {@link PresentationCore}, the class every entry point subclasses with a runtime
+* adapter (`index.ts`, `node.ts`, `browser.ts`). See the class doc below for the layout of
+* its body and where package assembly actually happens.
+*
+* Units: this library takes user coordinates in inches and converts to EMU on output — see
+* `units.ts` for the conversions and `STANDARD_LAYOUTS` for the built-in slide sizes.
+*
+* Derived from PptxGenJS (C) 2015-present Brent Ely (MIT), which in turn took some code from
+* the OfficeGen project (Copyright 2013 Ziv Barber). This project is likewise MIT; the full
+* license text is in `LICENSE` at the repository root.
+*/
+const VERSION = "4.0.1";
+function standardLayoutToPresLayout(layout) {
+	return {
+		name: layout.name,
+		width: layout.widthEmu,
+		height: layout.heightEmu
+	};
+}
+/**
+* One side of a `defineLayout` definition, in inches, clamped to what `ST_SlideSizeCoordinate`
+* allows.
+*
+* `p:sldSz/@cx` and `@cy` are bounded 914400 to 51206400 EMU -- 1 to 56 inches -- and nothing
+* checked. Every arm of `defineLayout`'s guard chain is a `warn`, so
+* `{ name: 'Badge', width: 0.5, height: 0.5 }` produced no diagnostic at all (both values are
+* truthy and finite) and emitted a `sldSz` PowerPoint offers to repair; `width: -5` is truthy
+* too, so it reached the file as `cx="-4572000"`.
+*
+* `Number()` first, because the guard chain above deliberately accepts a numeric string as
+* advice rather than as an error, and `clampRangedInput` takes a number. A value with nothing
+* to coerce from is `NaN`, which it throws on -- as `coord/non-finite`, the code the unit
+* conversion used to raise one line later.
+* @param value - the caller's `width` or `height`
+* @param side - which one, for the diagnostic
+*/
+function layoutSideInches(value, side) {
+	return clampRangedInput(Number(value), 1, 56, "layout/size-out-of-range", `defineLayout ${side} (inches)`, "coord/non-finite");
+}
+/**
+* Main presentation class and package export flow — the public entry point consumers
+* instantiate (`new TsPptx()`). Owns presentation-level state and metadata, collects
+* slides, and drives `write`/`writeFile`/`stream`. The actual OOXML string building is
+* delegated to the `gen-*` modules; runtime file/stream output goes through the injected
+* `RuntimeAdapter`. Enums (`AlignH`, `ChartType`, `ShapeType`, …) are imported from the
+* package entry, not read off the instance.
+*
+* Rough layout of the class body:
+*   - Metadata accessors      layout / author / company / title / theme / sections getters+setters
+*   - Private slide helpers    addNewSlide, getSlide, setSlideNumber
+*   - Public export methods    stream / write / writeFile — delegate packaging to `writePackage`
+*   - Public authoring methods addSlide / defineLayout / defineSlideMaster / defineTableStyle
+*
+* Package assembly (`[Content_Types].xml`, the rels graph, per-part XML, the ZIP) lives in
+* `package/assemble.ts`; this class provides the deck state via {@link PresentationCore.packageSource}.
+* The live-DOM `tableToSlides()` is NOT here — it is added by the browser entry subclass
+* (`browser.ts`) so it stays out of the Node build and out of the core chunk.
+*/
+var PresentationCore = class {
+	/**
+	* Presentation layout name
+	* Standard layouts:
+	* - 'LAYOUT_4x3'   (10"    x 7.5")
+	* - 'LAYOUT_16x9'  (10"    x 5.625")
+	* - 'LAYOUT_16x10' (10"    x 6.25")
+	* - 'LAYOUT_WIDE'  (13.333" x 7.5")
+	* Custom layouts:
+	* Use `pptx.defineLayout()` to create custom layouts (e.g.: 'A4')
+	* @type {string}
+	* @see https://support.office.com/en-us/article/Change-the-size-of-your-slides-040a811c-be43-40b9-8d04-0de5ed79987e
+	*/
+	_layout = DEF_PRES_LAYOUT;
+	set layout(value) {
+		const layoutKey = typeof value === "string" ? value : value?.layout;
+		const newLayout = layoutKey ? this.LAYOUTS[layoutKey] : void 0;
+		if (newLayout) {
+			this._layout = layoutKey;
+			this._presLayout = newLayout;
+		} else throw new InvalidOptionError("layout/unknown", `Unknown layout ${JSON.stringify(layoutKey)}; pass a registered layout name (see LAYOUTS) or a STANDARD_LAYOUTS preset`);
+	}
+	get layout() {
+		return this._layout;
+	}
+	/**
+	* ts-pptx Library Version
+	*/
+	_version = VERSION;
+	get version() {
+		return this._version;
+	}
+	/**
+	* @type {string}
+	*/
+	_author;
+	set author(value) {
+		this._author = value;
+	}
+	get author() {
+		return this._author;
+	}
+	/**
+	* @type {string}
+	*/
+	_company;
+	set company(value) {
+		this._company = value;
+	}
+	get company() {
+		return this._company;
+	}
+	/**
+	* @type {string}
+	* @note the `revision` value must be a whole number only (without "." or "," - otherwise, PPT will throw errors upon opening!)
+	*/
+	_revision;
+	set revision(value) {
+		this._revision = value;
+	}
+	get revision() {
+		return this._revision;
+	}
+	/**
+	* @type {string}
+	*/
+	_subject;
+	set subject(value) {
+		this._subject = value;
+	}
+	get subject() {
+		return this._subject;
+	}
+	/**
+	* @type {ThemeProps}
+	*/
+	_theme = {};
+	set theme(value) {
+		this._theme = value;
+	}
+	get theme() {
+		return this._theme;
+	}
+	/**
+	* @type {string}
+	*/
+	_title;
+	set title(value) {
+		this._title = value;
+	}
+	get title() {
+		return this._title;
+	}
+	/**
+	* Slide number shown on the first slide (maps to firstSlideNum in presentation.xml)
+	* @throws {InvalidOptionError} when the value is not an integer `xsd:int` can hold
+	*/
+	_firstSlideNum;
+	set firstSlideNum(value) {
+		if (!Number.isInteger(value) || value < -2147483648 || value > 2147483647) throw new InvalidOptionError("presentation/first-slide-num-not-an-integer", `firstSlideNum must be an integer, got ${String(value)}`);
+		this._firstSlideNum = value;
+	}
+	get firstSlideNum() {
+		return this._firstSlideNum;
+	}
+	/**
+	* Whether Right-to-Left (RTL) mode is enabled
+	* @type {boolean}
+	*/
+	_rtlMode;
+	set rtlMode(value) {
+		this._rtlMode = value;
+	}
+	get rtlMode() {
+		return this._rtlMode;
+	}
+	/** the slide master the deck's master part is written from; not a `Slide`, so not handed out */
+	_masterSlide;
+	/** this Presentation's Slide objects */
+	_slides;
+	get slides() {
+		return this._slides;
+	}
+	/** this Presentation's sections */
+	_sections;
+	get sections() {
+		return this._sections;
+	}
+	/** custom document properties stored in docProps/custom.xml */
+	_customProperties;
+	/**
+	* slide layout definition objects, used for generating slide layout files.
+	* `protected` (not `private`) so the browser entry subclass can resolve
+	* `tableToSlides({ masterTitle })` against them — that method lives on the
+	* browser build only (it reads a live DOM), see `browser.ts`.
+	*/
+	_slideLayouts;
+	get slideLayouts() {
+		return this._slideLayouts;
+	}
+	get internalPresentation() {
+		return {
+			author: this.author,
+			company: this.company,
+			firstSlideNum: this.firstSlideNum,
+			layout: this.layout,
+			masterSlide: this._masterSlide,
+			presLayout: this.presLayout,
+			revision: this.revision,
+			rtlMode: this.rtlMode,
+			sections: this._sections,
+			slideLayouts: this._slideLayouts,
+			slides: this._slides,
+			subject: this.subject,
+			theme: this.theme,
+			title: this.title,
+			embeddedFonts: this._embeddedFonts
+		};
+	}
+	LAYOUTS;
+	/**
+	* The built-in default layout, or a throw. `LAYOUTS` is a string-keyed map, so the lookup is
+	* typed as possibly-missing at every call site even though the constructor registers it — and
+	* the two callers that need it were spelling the same guard and the same message.
+	*/
+	#requireDefaultLayout() {
+		const defLayout = this.LAYOUTS[DEF_PRES_LAYOUT];
+		if (!defLayout) throw new InternalError("layout/default-not-registered", `Default presentation layout "${DEF_PRES_LAYOUT}" is not registered`);
+		return defLayout;
+	}
+	_presLayout;
+	get presLayout() {
+		return this._presLayout;
+	}
+	_runtime;
+	/** The construct families this presentation was composed with, flattened per seam. */
+	#composition;
+	/**
+	* What a family's presentation-level author is handed. Assembled once: it carries the font
+	* metrics registry, which is private to this class and therefore unreachable from a family
+	* through the instance alone.
+	*/
+	#authorContext;
+	/** Write-side font metrics for measured text fit (`fit:'shrink'`). @see registerFontMetrics */
+	_fontMetrics = new FontMetricsRegistry();
+	/** Author-side embedded font faces, accumulated by {@link embedFont} and emitted at write time. */
+	_embeddedFonts = [];
+	constructor(runtime, families) {
+		this._runtime = runtime;
+		this.#composition = composeFamilies(families);
+		this.#authorContext = {
+			pres: this,
+			fontMetrics: this._fontMetrics
+		};
+		this.LAYOUTS = {
+			LAYOUT_4x3: standardLayoutToPresLayout(STANDARD_LAYOUTS.LAYOUT_4x3),
+			LAYOUT_16x9: standardLayoutToPresLayout(STANDARD_LAYOUTS.LAYOUT_16x9),
+			LAYOUT_16x10: standardLayoutToPresLayout(STANDARD_LAYOUTS.LAYOUT_16x10),
+			LAYOUT_WIDE: standardLayoutToPresLayout(STANDARD_LAYOUTS.LAYOUT_WIDE)
+		};
+		this._author = "ts-pptx";
+		this._company = "ts-pptx";
+		this._revision = "1";
+		this._subject = "ts-pptx Presentation";
+		this._title = "ts-pptx Presentation";
+		const defLayout = this.#requireDefaultLayout();
+		this._presLayout = {
+			name: defLayout.name,
+			width: defLayout.width,
+			height: defLayout.height
+		};
+		this._firstSlideNum = 1;
+		this._rtlMode = false;
+		this._slideLayouts = [{
+			_margin: DEF_SLIDE_MARGIN_IN,
+			_name: DEF_PRES_LAYOUT_NAME,
+			_presLayout: this._presLayout,
+			_rels: [],
+			_relsChart: [],
+			_relsMedia: [],
+			_slide: null,
+			_slideNum: 1e3,
+			_slideNumberProps: null,
+			_slideObjects: []
+		}];
+		this._slides = [];
+		this._sections = [];
+		this._customProperties = [];
+		this._masterSlide = {
+			_presLayout: this._presLayout,
+			_rels: [],
+			_relsChart: [],
+			_relsMedia: [],
+			_slideNum: null,
+			_slideNumberProps: null,
+			_slideObjects: []
+		};
+	}
+	/**
+	* Provides an API for `addTableDefinition` to create slides as needed for auto-paging
+	* @param layout - the layout of the slide the table is paged from
+	* @return {Slide} new Slide
+	*/
+	addNewSlide = (layout) => {
+		const nextOptions = {};
+		if (layout && this._slideLayouts.includes(layout)) setOrClear(nextOptions, "masterTitle", layout._name);
+		const lastSlide = this._slides[this._slides.length - 1];
+		const sourceSection = this._sections.find((sect) => sect._slides.some((s) => s._slideNum === lastSlide?._slideNum));
+		setOrClear(nextOptions, "sectionTitle", sourceSection?.title);
+		return this.addSlide(nextOptions);
+	};
+	/**
+	* Provides an API for `addTableDefinition` to get slide reference by number
+	* @param {number} slideNum - slide number
+	* @return {Slide} Slide
+	*/
+	getSlide = (slideNum) => this._slides.find((slide) => slide._slideNum === slideNum);
+	/**
+	* Provides the live section list to the `Slide` class so Section/Summary Zoom can resolve
+	* a section title to its stable GUID and enumerate sections in order.
+	* @return {SectionInternalProps[]} the presentation's sections
+	*/
+	getSections = () => this._sections;
+	/**
+	* Enables the `Slide` class to set ts-pptx [Presentation] master/layout slidenumbers
+	* @param {SlideNumberProps} slideNum - slide number config
+	*/
+	setSlideNumber = (slideNum) => {
+		this._masterSlide._slideNumberProps = slideNum;
+		const defLayout = this._slideLayouts.find((layout) => layout._name === DEF_PRES_LAYOUT_NAME);
+		if (defLayout) defLayout._slideNumberProps = slideNum;
+	};
+	/**
+	* Assemble the slice of internal state the packaging layer reads. `PresentationCore` owns the
+	* authored deck; `writePackage` (in `package/assemble.ts`) turns it into OOXML parts.
+	*/
+	packageSource() {
+		return {
+			runtime: this._runtime,
+			presentation: this.internalPresentation,
+			customProperties: this._customProperties,
+			fontMetrics: this._fontMetrics,
+			renderers: this.#composition.renderers,
+			partContributors: this.#composition.partContributors
+		};
+	}
+	/**
+	* Author + serialize this presentation's slides as injectable descriptors,
+	* WITHOUT producing a `.pptx` package. Runs the same media-encode, placeholder
+	* backfill, and measured-fit passes `write()` uses, then serializes each slide
+	* body and resolves its image media to decoded bytes — so a loaded deck can
+	* splice the slides in via `Presentation.appendSlides()` (see `pptx-ts/read`)
+	* while keeping its own masters/layouts/theme byte-identical.
+	*
+	* Returns the deck's slide size (EMU, for the destination size check) and one
+	* descriptor per authored slide. Charts, audio/video media, online media, and
+	* internal slide-to-slide hyperlinks are surfaced as descriptors alongside the
+	* serialized body — this method does not resolve them into a package; the append
+	* path consumes each descriptor to reserve the parts and rebuild the rel graph.
+	*/
+	extractSlides = async (opts = {}) => extractSlides({
+		runtime: this._runtime,
+		presentation: this.internalPresentation,
+		fontMetrics: this._fontMetrics,
+		renderers: this.#composition.renderers,
+		extract: this.#composition.extract
+	}, opts);
+	/**
+	* One of this presentation's family-supplied methods, or the failure that names the family it
+	* would have come from. The methods that call it stay on the class because their signatures are
+	* the public contract; what they reach is what a family owns.
+	*
+	* `protected` for the browser entry, whose `tableToSlides` is one of these and is declared on
+	* the subclass so that a Node build never links the DOM reader.
+	*/
+	familyAuthor(method) {
+		const author = requirePresentationAuthor(this.#composition.presentationAuthors, method);
+		return ((...args) => author(this.#authorContext, ...args));
+	}
+	/**
+	* Register a font's metrics so `fit:'shrink'` and `fit:'resize'` text is measured at
+	* export time: `'shrink'` bakes a real `fontScale` and `'resize'` a real box height, so
+	* the text renders fitted in headless renderers and on plain file-open, with no manual
+	* edit/resize.
+	*
+	* Without registered metrics, both write the bare flag (`<a:normAutofit/>` or
+	* `<a:spAutoFit/>`) that only PowerPoint recomputes on edit. Register the same
+	* face once per weight/style you use; bold/italic advances differ.
+	*
+	* **Font collections** (`.ttc`/`.otc`, how MS Gothic, Yu Gothic, SimSun, Microsoft
+	* YaHei and Cambria ship on Windows) hold several fonts in one file, so one has to be
+	* chosen. With no `font` option, `face` is used as the selector, which is usually what
+	* you meant; a `face` that names no font in the collection throws rather than falling
+	* back to the first, since measuring the wrong member is invisible downstream. Pass
+	* `font` when the deck-side name differs from the name inside the file, and use
+	* `listFontFaces` from `pptx-ts/measure` to see what a file holds.
+	* @param {string} face - font family name as used in `fontFace` (e.g. 'Aptos')
+	* @param {string | Uint8Array | ArrayBuffer} source - font file path/URL (Node/web) or raw TTF/OTF/TTC
+	*   bytes. A string is always a path or URL here; base64 text is `embedFont`'s `data`, not this.
+	* @param {object} [opts] - variant flags (advances differ per weight/style) and collection selection
+	* @param {boolean} [opts.bold] - these are the bold advances
+	* @param {boolean} [opts.italic] - these are the italic advances
+	* @param {number | string} [opts.font] - which font inside a collection: 0-based index, or a name
+	* @example await pptx.registerFontMetrics('Aptos', '/usr/share/fonts/Aptos.ttf')
+	* @example await pptx.registerFontMetrics('Aptos', aptosBoldBytes, { bold: true })
+	* @example await pptx.registerFontMetrics('MS PGothic', 'C:/Windows/Fonts/msgothic.ttc')
+	* @example await pptx.registerFontMetrics('Cambria Math', 'C:/Windows/Fonts/cambria.ttc', { font: 1 })
+	*/
+	async registerFontMetrics(face, source, opts) {
+		const bytes = await resolveFontBytes(source, this._runtime, void 0, "registerFontMetrics: `source`");
+		const font = opts?.font ?? (isFontCollection(bytes) ? face : void 0);
+		const metrics = await parseFontMetrics(bytes, font === void 0 ? void 0 : { font });
+		this._fontMetrics.set(face, metrics, pickDefined(opts ?? {}, ["bold", "italic"]));
+	}
+	/**
+	* Embed a font face so the deck renders with it even on machines that do not
+	* have it installed. The **whole** face is embedded (not glyph-subset) under
+	* `/ppt/fonts/` and wired into `presentation.xml` (`p:embeddedFontLst` +
+	* `embedTrueTypeFonts="1"`), exactly as PowerPoint's "Embed fonts in the file"
+	* does. Call once per face/weight you use.
+	*
+	* The declared `typeface` MUST match the family name used in your run/`fontFace`
+	* typefaces (e.g. `addText('hi', { fontFace: 'Silkscreen' })`) or PowerPoint
+	* will not bind the embedded bytes to the text. Repeated calls with the same
+	* `typeface` and different `style` accumulate into one `p:embeddedFont` entry.
+	*
+	* Font licensing is the caller's responsibility: the bytes are embedded as
+	* handed over; `OS/2.fsType` embedding-permission bits are not enforced.
+	* @param {object} opts - font source + identity
+	* @param {string} [opts.path] - font file path (Node) or URL (web) to a `.ttf`/`.otf`
+	* @param {ArrayBuffer | Uint8Array | string} [opts.data] - raw font bytes, or a base64 string (bare or a
+	*   whole `data:` URL), in lieu of `path`. Unlike `registerFontMetrics`, a string here is never a path.
+	* @param {string} opts.typeface - family name as referenced by run/`fontFace` typefaces
+	* @param {EmbeddedFontSlot} [opts.style] - face slot; defaults to `'regular'`
+	* @example await pptx.embedFont({ path: '/fonts/Silkscreen-Regular.ttf', typeface: 'Silkscreen' })
+	* @example await pptx.embedFont({ path: '/fonts/Silkscreen-Bold.ttf', typeface: 'Silkscreen', style: 'bold' })
+	*/
+	async embedFont(opts) {
+		if (!opts || typeof opts.typeface !== "string" || opts.typeface.trim() === "") throw new InvalidOptionError("font/missing-typeface", "embedFont: `typeface` is required (the family name your runs reference)");
+		const slot = opts.style ?? "regular";
+		if (!EMBEDDED_FONT_SLOTS.includes(slot)) throw new InvalidOptionError("font/invalid-style-slot", `embedFont: invalid style "${slot}"; expected one of ${EMBEDDED_FONT_SLOTS.join(", ")}`);
+		if (opts.path === void 0 && opts.data === void 0) throw new InvalidOptionError("font/missing-source", "embedFont: provide either `path` or `data`");
+		const bytes = typeof opts.path === "string" ? await resolveFontBytes(opts.path, this._runtime, void 0, "embedFont: `path`") : await resolveFontBytes(opts.data, this._runtime, { base64: true }, "embedFont: `data` string");
+		let font = this._embeddedFonts.find((f) => f.typeface === opts.typeface);
+		if (!font) {
+			font = {
+				typeface: opts.typeface,
+				faces: []
+			};
+			this._embeddedFonts.push(font);
+		}
+		const existing = font.faces.find((f) => f.slot === slot);
+		if (existing) existing.bytes = bytes;
+		else font.faces.push({
+			slot,
+			bytes
+		});
+	}
+	/**
+	* Measure how tall text wraps at a given width, using the **same** calibrated wrap
+	* model the export-time autofit bake uses — so a layout-time prediction matches the
+	* value `fit:'shrink'`/`'resize'` would bake. Synchronous: register the face's metrics
+	* first with {@link TsPptx.registerFontMetrics} (lookup is sync).
+	*
+	* Lets a consumer size its own geometry before export — grow a card to fit its text,
+	* reflow a grid, or detect overflow at layout time. Heights err **tall** (conservative),
+	* so the returned height is ≥ what PowerPoint/LibreOffice render.
+	* @param {string | TextProps[]} text - a string or run array (per-run options override the defaults in `opts`)
+	* @param {MeasureTextOptions} opts - width (inches), font size/face (points), and spacing
+	* @returns {TextMeasurement} laid-out height + line count + fit helpers
+	* @example const m = pptx.measureText('Long heading…', { wIn: 3, fontSize: 18, fontFace: 'Aptos' })
+	* @example if (pptx.measureText(runs, { wIn, fontSize, fontFace }).heightIn > cardHeightIn) growCard()
+	*/
+	measureText(text, opts) {
+		return this.familyAuthor("measureText")(text, opts);
+	}
+	/**
+	* Convenience overflow check: `true` if `text` does not fit a box of inner size
+	* `wIn`×`hIn` (inches) at full size. Because the model errs tall, this is a
+	* **conservative** (slightly over-reporting) check — appropriate for a build-time
+	* warning, not a hard gate. An unmeasurable (unnamed theme-default) face reports
+	* `false` (no overflow) so the linter does not false-positive on faces it cannot measure.
+	* @param {string | TextProps[]} text - a string or run array
+	* @param {OverflowBoxOptions} opts - {@link MeasureTextOptions} plus the box inner height `hIn`
+	* @returns {boolean} true if the text overflows the box
+	*/
+	overflowsBox(text, opts) {
+		return this.familyAuthor("overflowsBox")(text, opts);
+	}
+	/**
+	* Compute the per-cell geometry of a table laid out at `opts.x`/`y`/`w`, without
+	* adding it to a slide — so a consumer can place images or shapes precisely over
+	* cells. Column widths (cell `x`/`w`) are exact, derived from the same logic the
+	* writer uses. Row heights (`y`/`h`) are exact when pinned by `rowH` (array or
+	* scalar) or table `h`; an auto-height row is estimated with the same conservative
+	* (tall) text model as {@link TsPptx.measureText} and flagged `heightExact:false`
+	* (register the cell font via {@link TsPptx.registerFontMetrics} for an exact
+	* estimate). Geometry is for a single, un-paginated table — `autoPage` paging is
+	* not modeled.
+	* @param {TableRow[]} rows - the same `rows` passed to `slide.addTable`
+	* @param {TableProps} opts - the same table options (`x`, `y`, `w`, `colW`, `rowH`, `h`, …)
+	* @returns {TableLayoutResult} per-cell rectangles (inches) plus overall table bounds
+	* @example
+	* const g = pptx.tableLayout(rows, { x: 1, y: 1, w: 8, colW: [2, 3, 3] })
+	* const c = g.cells.find(c => c.row === 0 && c.col === 2)
+	* slide.addImage({ path: 'logo.png', x: c.xIn, y: c.yIn, w: c.wIn, h: c.hIn })
+	*/
+	tableLayout(rows, opts) {
+		return this.familyAuthor("tableLayout")(rows, opts);
+	}
+	/**
+	* Export the current presentation as portable ZIP bytes. Unlike the former
+	* `stream()` method, this does not imply incremental output or convert the
+	* archive to a Node `Buffer`: package assembly is synchronous and the returned
+	* `Uint8Array` works unchanged in Node, browsers, and workers.
+	* @param {WriteBaseProps} props - output properties
+	* @returns {Promise<Uint8Array>} complete `.pptx` archive bytes
+	*/
+	async toBytes(props) {
+		return await writePackage(this.packageSource(), {
+			...pickDefined(props ?? {}, ["compression", "onMediaError"]),
+			outputType: "uint8array"
+		});
+	}
+	/**
+	* Export the current Presentation as ZIP content with the selected type
+	* @param {WriteProps} props output properties
+	* @returns {Promise<string | ArrayBuffer | Blob | Uint8Array>} file content in selected type
+	*/
+	async write(props) {
+		return await writePackage(this.packageSource(), pickDefined(props ?? {}, [
+			"compression",
+			"outputType",
+			"onMediaError"
+		]));
+	}
+	/**
+	* Assemble the current Presentation into its OOXML package parts WITHOUT zipping — the raw
+	* `path → bytes` contents `write()` would compress into the `.pptx`. Use this to stream parts
+	* into a custom container, inspect individual parts, or feed a pipeline that does its own
+	* archiving. To produce a real `.pptx` file, use {@link write} / {@link writeFile} instead.
+	*
+	* The returned parts are byte-identical, per part, to what `write()` emits for the same deck,
+	* and their order is the package's emission order. Both are a stability-guaranteed observable
+	* contract: adding a new part in a later release is backward-compatible as long as existing
+	* part paths and their relative order do not shift; renaming or reordering an existing part is
+	* a breaking change. Each call returns fresh `Uint8Array` views over per-call buffers (a new
+	* assembly runs each time), so callers may retain or transfer them without defensive copying.
+	* @param {PartsProps} props - assembly options (`onMediaError` only; compression/output shape
+	*   are zip concerns that do not apply to unzipped parts)
+	* @returns {Promise<PackagePart[]>} the package parts in emission order
+	*/
+	async toParts(props) {
+		return (await buildPackageParts(this.packageSource(), { onMediaError: props?.onMediaError })).map(({ path, data }) => ({
+			path,
+			data
+		}));
+	}
+	/**
+	* Export the current Presentation.
+	* Write the generated presentation to disk (Node) or trigger a download (browser).
+	* @param {WriteFileProps} props - output file properties
+	* @returns {Promise<string>} the presentation name
+	*/
+	async writeFile(props) {
+		const rawName = props?.fileName ?? "Presentation.pptx";
+		const fileName = rawName.toLowerCase().endsWith(".pptx") ? rawName : `${rawName}.pptx`;
+		const writeProps = pickDefined(props ?? {}, ["compression", "onMediaError"]);
+		setOrClear(writeProps, "outputType", this._runtime.writeFileOutputType ?? void 0);
+		const data = await writePackage(this.packageSource(), writeProps);
+		return await this._runtime.writeFile(fileName, data);
+	}
+	/**
+	* Set a custom document property stored in `docProps/custom.xml`.
+	* Calling with the same name replaces the existing value.
+	* @param name - property name
+	* @param value - string, integer/float number, boolean, or Date
+	*/
+	setCustomProperty(name, value) {
+		this._customProperties = this._customProperties.filter((p) => p.name !== name);
+		this._customProperties.push({
+			name,
+			value
+		});
+	}
+	/**
+	* Add a new Section to Presentation
+	* @param {SectionProps} section - section properties
+	* @example pptx.addSection({ title:'Charts' });
+	*/
+	addSection(section) {
+		if (!section) {
+			warn("section/missing-argument", "addSection requires an argument");
+			return;
+		} else if (!section.title) {
+			warn("section/missing-title", "addSection requires a title");
+			return;
+		} else if (this._sections.some((sect) => sect.title === section.title)) {
+			warn("section/duplicate-title", `addSection: a section titled "${section.title}" already exists; ignoring duplicate`);
+			return;
+		}
+		const newSection = {
+			_type: "user",
+			_slides: [],
+			_id: bracedGuid(),
+			title: section.title
+		};
+		if (section.order === void 0) {
+			this._sections.push(newSection);
+			return;
+		}
+		if (!Number.isInteger(section.order) || section.order < 1) {
+			warn("section/invalid-order", `addSection: "order" must be a whole number of at least 1 (the first position); got ${String(section.order)}. Appending.`);
+			this._sections.push(newSection);
+			return;
+		}
+		this._sections.splice(section.order - 1, 0, newSection);
+	}
+	/**
+	* Add a new Slide to Presentation
+	* @param {AddSlideProps} options - slide options
+	* @returns {Slide} the new Slide
+	*/
+	addSlide(options) {
+		const masterTitle = options?.masterTitle ?? "";
+		let slideLayout = {
+			_name: this.#requireDefaultLayout().name,
+			_presLayout: this.presLayout,
+			_rels: [],
+			_relsChart: [],
+			_relsMedia: [],
+			_slideNum: this._slides.length + 1,
+			_slideObjects: []
+		};
+		if (masterTitle) {
+			const tmpLayout = this._slideLayouts.find((layout) => layout._name === masterTitle);
+			if (tmpLayout) slideLayout = tmpLayout;
+			else warn("slide/master-not-found", `addSlide: unable to find a slide master with title: "${masterTitle}"; using the default layout`);
+		}
+		const newSlide = new SlideBuilder({
+			addSlide: this.addNewSlide,
+			getSlide: this.getSlide,
+			getSections: this.getSections,
+			presLayout: this.presLayout,
+			authors: this.#composition.authors,
+			childAuthors: this.#composition.children,
+			setSlideNum: this.setSlideNumber,
+			slideId: this._slides.length + 256,
+			slideRId: this._slides.length + 2,
+			slideNumber: this._slides.length + 1,
+			slideLayout
+		});
+		this._slides.push(newSlide);
+		const namedSection = options?.sectionTitle ? this._sections.find((section) => section.title === options.sectionTitle) : void 0;
+		if (options?.sectionTitle && !namedSection) warn("slide/section-not-found", `addSlide: unable to find section with title: "${options.sectionTitle}"`);
+		if (namedSection) namedSection._slides.push(newSlide);
+		else if (this._sections.length > 0) {
+			const lastSect = this._sections[this._sections.length - 1];
+			if (lastSect?._type === "default") lastSect._slides.push(newSlide);
+			else this._sections.push({
+				title: `Default-${this._sections.filter((sect) => sect._type === "default").length + 1}`,
+				_type: "default",
+				_id: bracedGuid(),
+				_slides: [newSlide]
+			});
+		}
+		return newSlide;
+	}
+	/**
+	* Create a custom Slide Layout in any size
+	* @param {PresLayout} layout - layout properties
+	* @example pptx.defineLayout({ name:'A3', width:16.5, height:11.7 });
+	*/
+	defineLayout(layout) {
+		if (!layout || typeof layout !== "object") throw new InvalidOptionError("layout/invalid-definition", "defineLayout requires an object `{ name, width, height }` with the dimensions in inches");
+		if (!layout.name) throw new InvalidOptionError("layout/invalid-definition", "defineLayout requires a non-empty `name`: it is the key the layout is registered and selected under");
+		if (layout.width === void 0) warn("layout/invalid-definition", "defineLayout requires `width`");
+		else if (typeof layout.width !== "number") warn("layout/invalid-definition", "defineLayout `width` should be a number (inches)");
+		if (layout.height === void 0) warn("layout/invalid-definition", "defineLayout requires `height`");
+		else if (typeof layout.height !== "number") warn("layout/invalid-definition", "defineLayout `height` should be a number (inches)");
+		this.LAYOUTS[layout.name] = {
+			name: layout.name,
+			width: inchesToEmu(layoutSideInches(layout.width, "width")),
+			height: inchesToEmu(layoutSideInches(layout.height, "height"))
+		};
+	}
+	/**
+	* Create a new slide master [layout] for the Presentation
+	* @param {SlideMasterProps} props - layout properties
+	*/
+	defineSlideMaster(props) {
+		const propsClone = structuredClone(props);
+		if (!propsClone.title) throw new InvalidOptionError("master/missing-title", "defineSlideMaster() object argument requires a `title` value.");
+		const newLayout = {
+			_margin: propsClone.margin || DEF_SLIDE_MARGIN_IN,
+			_name: propsClone.title,
+			_presLayout: this.presLayout,
+			_rels: [],
+			_relsChart: [],
+			_relsMedia: [],
+			_slide: null,
+			_slideNum: 1e3 + this._slideLayouts.length + 1,
+			_slideNumberProps: propsClone.slideNumber || null,
+			_slideObjects: [],
+			background: propsClone.background
+		};
+		createSlideMaster(propsClone, newLayout, this.#composition.children);
+		if (propsClone.textStyles && typeof propsClone.textStyles === "object") this._masterSlide._txStyles = {
+			...this._masterSlide._txStyles,
+			...propsClone.textStyles
+		};
+		this._slideLayouts.push(newLayout);
+		if (propsClone.background) addBackgroundDefinition(propsClone.background, newLayout);
+		if (newLayout._slideNumberProps && !this._masterSlide._slideNumberProps) this._masterSlide._slideNumberProps = newLayout._slideNumberProps;
+	}
+};
+//#endregion
+//#region src/families/core.ts
+/**
+* ts-pptx: the construct families every presentation carries
+*
+* The core tier. A composed presentation gets these whether it asks for them or not, so
+* `createPresentation()` with no families still authors text, shapes, images, groups and speaker
+* notes -- a deck, rather than a slide-shaped hole.
+*
+* The line is a judgement rather than a measurement: these five are what "a slide" means to most
+* callers, they are cheap, and a surface that made someone compose `text` before it could write a
+* word would be a worse default than one that costs a few kilobytes more. A family is core when
+* leaving it out would make the result something other than a deck; everything else is asked for.
+*/
+/** Every family a composed presentation carries without being asked. */
+const CORE_CONSTRUCT_FAMILIES = [
+	textFamily,
+	shapeFamily,
+	imageFamily,
+	groupFamily,
+	notesFamily
+];
+//#endregion
+//#region src/entry-compose.ts
+/**
+* ts-pptx: composing a presentation from the construct families it actually needs
+*
+* The body behind each entry's `createPresentation`, and the types that describe what comes back.
+* It lives beside `entry-surface.ts` for the same reason that does: `index.ts`, `node.ts` and
+* `browser.ts` differ only in the runtime adapter they hand down, so the shared half is written
+* once and cannot drift between them.
+*
+* There is no second lean entry point, deliberately. A `pptx-ts/core` would need the same
+* three-condition treatment `.` gets, so three more source entries, three more `dist` files, three
+* more budget rows and a second place for the entries to diverge -- and it would buy nothing that
+* export-level shaking does not already give. `pptx-ts` is an intermediate module in a consumer's
+* graph: a program that imports only `createPresentation` drops the `TsPptx` class beside it and,
+* with it, every family that class names.
+*/
+/**
+* Build a presentation that carries the core tier plus `opts.use`, on the given runtime adapter.
+*
+* The cast is the one place this file is not type-safe, and it is unavoidable: the class is one
+* class whatever it was composed with, while the type says which of its methods are actually
+* there. The two are kept honest by the runtime, which raises `family/not-composed` naming the
+* family for any method the type has already refused.
+*/
+function composePresentation(runtime, opts) {
+	return new PresentationCore(runtime, [...CORE_CONSTRUCT_FAMILIES, ...opts?.use ?? []]);
+}
+//#endregion
+//#region src/entry-families.ts
+/**
+* ts-pptx: the construct families the three main entries are composed with
+*
+* The full authoring surface, as a list: `index.ts`, `node.ts` and `browser.ts` each compose every
+* family, so `TsPptx` authors everything it ever has; the browser entry adds the table family's
+* live-DOM half on top, because that one needs a `document` to read. The families a *composed*
+* presentation gets without asking are the shorter list in `families/core.ts`.
+*
+* It lives beside `entry-surface.ts`, and for the same reason: the three entries publish one API
+* and differ only in the runtime adapter they hand down, so what they are composed with is one
+* list rather than three that can drift.
+*
+* Naming a family here is what puts its code in the graph -- a named import inside a reachable
+* function body is retained unconditionally. That is the whole point of the seam
+* (`families/shared.ts`): a program composed with fewer families links fewer of them.
+*/
+/**
+* Every construct family the library can author with: the core tier, plus everything a composed
+* presentation would have to ask for. Built from `CORE_CONSTRUCT_FAMILIES` rather than restating
+* it, so the two lists cannot disagree about whether a family exists.
+*/
+const ALL_CONSTRUCT_FAMILIES = /* @__PURE__ */ Object.freeze([
+	textFamily,
+	shapeFamily,
+	imageFamily,
+	groupFamily,
+	notesFamily,
+	animationsFamily,
+	chartFamily,
+	commentsFamily,
+	connectorFamily,
+	measureFamily,
+	mediaFamily,
+	model3dFamily,
+	oleFamily,
+	tableFamily,
+	zoomFamily
+]);
+//#endregion
+//#region src/runtime/fetch-media.ts
+/**
+* The parts of a runtime adapter that are not runtime-specific.
+*
+* `fetch`, `btoa` and `TextEncoder` exist in Node, in every browser, and in the edge/worker
+* runtimes the neutral adapter serves, so the remote-load paths were the same code in all three
+* adapters — byte-identical in two of them and an inline branch in the third. What is genuinely
+* per-runtime stays in each adapter: `node:fs`, `FileReader`, the canvas rasterizer, the
+* `<a download>` writer.
+*
+* Nothing here touches a host global beyond `fetch`.
+*/
+/**
+* Whether `source` names something to `fetch` rather than something to read from a filesystem.
+*
+* A real scheme test, not `source.startsWith('http')`. That prefix matched a *relative path* —
+* `httpdocs/logo.png`, `http-icons/x.svg` — and sent it to `fetch`, which then failed with a
+* fetch error naming a file that exists on disk. It was also case-sensitive, so
+* `HTTPS://example.com/f.ttf` missed and went to `fs.readFile`.
+*
+* Only `http:` and `https:` count. A `file:` or `data:` URL falls through to the adapter's
+* local branch, where it fails — the same as before this was tightened, and deliberately left
+* that way: making either work is a feature with its own decisions (what a `file:` URL means
+* off Node, whether a `data:` URL should bypass loading entirely), not a side effect of fixing
+* a prefix test.
+*/
+function isRemote(source) {
+	const scheme = /^([a-z][a-z0-9+.-]*):/i.exec(source)?.[1]?.toLowerCase();
+	return scheme === "http" || scheme === "https";
+}
+/** Fetch a font file into raw bytes for `registerFontMetrics`. */
+async function fetchFontBytes(source) {
+	const response = await fetch(source);
+	if (!response.ok) throw new MediaError("font/fetch-failed", `Unable to load font (fetch): ${source}`);
+	return new Uint8Array(await response.arrayBuffer());
+}
+/**
+* Fetch a media file as raw base64 (no `data:` prefix) — see {@link RuntimeAdapter.loadMedia}
+* for why both encodings are accepted.
+*
+* Encodes through `bytesToBase64` rather than `Buffer`, so the same function serves a runtime
+* that has no `Buffer`. The Node adapter still uses `Buffer` on its *filesystem* branch, where
+* it is both available and faster on a large payload.
+*/
+async function fetchMediaBase64(path) {
+	const response = await fetch(path);
+	if (!response.ok) throw new MediaError("media/fetch-failed", `Unable to load image (fetch): ${path}`);
+	return bytesToBase64(new Uint8Array(await response.arrayBuffer()));
+}
+/**
+* The SVG-preview fallback for a runtime with no canvas: stamp the placeholder PNG.
+*
+* An SVG placed on a slide needs a raster fallback beside it for viewers that will not render
+* the SVG. Rasterizing needs a canvas, which only the browser adapter has, so everywhere else
+* the fallback is a fixed placeholder image rather than a missing part. That is this runtime's
+* output rather than a failure, so it resolves `null`: reporting one would fail every SVG under
+* the default `onMediaError`.
+*/
+async function placeholderSvgPreview(rel) {
+	rel.data = IMG_SVG_PLACEHOLDER;
+	return null;
+}
+//#endregion
+//#region src/clip.ts
+/**
+* ts-pptx: named clip silhouettes for images
+*
+* A `ClipShape` is declarative data — a named silhouette plus its options — and {@link clipPath}
+* resolves it to the freeform `points` path `addImage` emits as the `<a:custGeom>` clip mask on
+* the `<p:pic>`. Paired with `sizing: { type: 'cover' }` (an `<a:srcRect>` crop) it reproduces
+* what a PowerPoint *picture placeholder* does — a layout `custGeom` clipping an inherited
+* blipFill — but standalone, with no placeholder involved.
+*
+* These are silhouettes recurring often enough in real decks to be worth naming; hand-authored
+* `points` remain available for anything else. Nothing here is theme- or brand-aware: which
+* silhouette to use, and which edge it sits flush to, belongs to the caller.
+*
+* ## The coordinate trap
+*
+* Coordinates come back in the image box's OWN inch space (`0..w`, `0..h`), because `custGeom`
+* points expressed as `%` resolve against the SLIDE, not the box. A box-relative silhouette must
+* therefore be emitted in inches already scaled to the box, which is why {@link clipPath} takes
+* the box size: the fractions below are multiplied by `w` / `h` at build time, so one silhouette
+* scales with whatever region it is handed. Authoring the same shape as percentages would put
+* the clip in the wrong place on every box that is not the full slide.
+*/
+const HALF_DISC = {
+	deep: {
+		topEdgeX: .31788,
+		botEdgeX: .31788,
+		tipTopX: .30061,
+		tipTopY: .01078,
+		tipBotX: .30061,
+		tipBotY: .98922,
+		apexY: .5,
+		c1b: {
+			x: .11594,
+			y: .86833
+		},
+		c2b: {
+			x: 0,
+			y: .69392
+		},
+		c1t: {
+			x: 0,
+			y: .30609
+		},
+		c2t: {
+			x: .11594,
+			y: .13167
+		}
+	},
+	shallow: {
+		topEdgeX: .12611,
+		botEdgeX: .11128,
+		tipTopX: .09976,
+		tipTopY: .05448,
+		tipBotX: .09976,
+		tipBotY: .97617,
+		apexY: .51533,
+		c1b: {
+			x: .03522,
+			y: .83247
+		},
+		c2b: {
+			x: 0,
+			y: .67725
+		},
+		c1t: {
+			x: 0,
+			y: .3534
+		},
+		c2t: {
+			x: .03522,
+			y: .19818
+		}
+	}
+};
+/** The values each {@link ClipShape} field takes, for refusing one a JavaScript caller got wrong. */
+const CLIP_KINDS = ["half-disc"];
+const FLAT_SIDES = ["left", "right"];
+const HALF_DISC_PRESETS = Object.keys(HALF_DISC);
+/**
+* Half-disc clip path for a `w × h` box. Authored flat-right; `flat: 'left'` mirrors `x → 1 - x`.
+*/
+function halfDisc(w, h, flat, preset) {
+	const s = HALF_DISC[preset];
+	const fx = flat === "left" ? (x) => (1 - x) * w : (x) => x * w;
+	const fy = (y) => y * h;
+	return [
+		{
+			x: fx(s.topEdgeX),
+			y: fy(0),
+			moveTo: true
+		},
+		{
+			x: fx(1),
+			y: fy(0)
+		},
+		{
+			x: fx(1),
+			y: fy(1)
+		},
+		{
+			x: fx(s.botEdgeX),
+			y: fy(1)
+		},
+		{
+			x: fx(s.tipBotX),
+			y: fy(s.tipBotY)
+		},
+		{
+			x: fx(0),
+			y: fy(s.apexY),
+			curve: {
+				type: "cubic",
+				x1: fx(s.c1b.x),
+				y1: fy(s.c1b.y),
+				x2: fx(s.c2b.x),
+				y2: fy(s.c2b.y)
+			}
+		},
+		{
+			x: fx(s.tipTopX),
+			y: fy(s.tipTopY),
+			curve: {
+				type: "cubic",
+				x1: fx(s.c1t.x),
+				y1: fy(s.c1t.y),
+				x2: fx(s.c2t.x),
+				y2: fy(s.c2t.y)
+			}
+		},
+		{ close: true }
+	];
+}
+/**
+* Resolve a {@link ClipShape} to a freeform `points` path filling a `w × h` box, ready to hand
+* to `addImage({ points })`.
+*
+* `w`/`h` are the image box's size **in inches** and must match the `w`/`h` the picture is drawn
+* at — the path is emitted in the box's own coordinate space, not normalized (see the module
+* note above).
+* @param {ClipShape} shape - the named silhouette and its options
+* @param {number} w - image box width (inches)
+* @param {number} h - image box height (inches)
+* @returns {GeometryPoint[]} the freeform path, for `addImage({ points })`
+* @throws {InvalidOptionError} `clip/invalid-shape` when `kind`, `flat` or `preset` is not one the
+*   silhouette names. From JavaScript an unknown preset used to fail reading a field off
+*   `undefined`, an unknown kind returned nothing and an unknown flat side traced the right-flat path.
+* @example
+* const w = 5.22, h = 7.5
+* slide.addImage({
+*   path: 'cover.jpg', x: 0, y: 0, w, h,
+*   points: clipPath({ kind: 'half-disc', flat: 'right' }, w, h),
+*   sizing: { type: 'cover' },   // center-crop the photo into the "D"
+* })
+*/
+function clipPath(shape, w, h) {
+	switch (checkEnumOrThrow(String(shape?.kind), CLIP_KINDS, "clipPath `kind`", "clip/invalid-shape")) {
+		case "half-disc": return halfDisc(w, h, checkEnumOrThrow(shape.flat, FLAT_SIDES, "clipPath `flat`", "clip/invalid-shape"), checkEnumOrThrow(shape.preset ?? "deep", HALF_DISC_PRESETS, "clipPath `preset`", "clip/invalid-shape"));
+	}
+}
+//#endregion
+//#region src/types/text.ts
+/** Factory for a single inline text run. Prevents `as never` casts when building mixed-style run arrays. */
+function textRun(text, options) {
+	return options !== void 0 ? {
+		text,
+		options
+	} : { text };
+}
+/** Wraps a run array so TypeScript accepts it as `TextProps[]` without a cast. */
+function textRuns(runs) {
+	return runs;
+}
+//#endregion
+export { fetchMediaBase64 as a, ALL_CONSTRUCT_FAMILIES as c, IMG_SVG_PLACEHOLDER as d, fetchFontBytes as i, composePresentation as l, textRuns as n, isRemote as o, clipPath as r, placeholderSvgPreview as s, textRun as t, PresentationCore as u };
+
+//# sourceMappingURL=text-sN64Otf_.js.map