@shbernal/ts-pptx 3.1.0 → 3.3.0

package/dist/notes-SCvpJz0l.js

@@ -0,0 +1,1646 @@
+import { n as warn, r as warnOnce } from "./diagnostics-H1QzgRSw.js";
+import { n as InvalidOptionError, o as UnsupportedFeatureError } from "./errors-Bvln0H-7.js";
+import { D as DEF_TEXT_GLOW, I as REGEX_HEX_COLOR, K as SchemeColor, L as SLDNUMFLDID, O as DEF_TEXT_SHADOW, R as XML_DECL, a as lineWidthToEmu, at as EMU_PER_POINT, ct as PERCENT_SCALE, i as inch2Emu, l as transparencyToAlpha, n as convertRotationDegrees, nt as ANGLE_UNITS_PER_DEGREE, ot as FIXED_PCT_PER_PERCENT, s as opacityToAlpha, u as valToPts, x as DEF_FONT_COLOR, yt as ptToHundredths } from "./units-internal-CGf4VrXy.js";
+import { g as PACKAGE_REL_NS, h as OFFICE_REL } from "./st-enums-bVnezkMJ.js";
+//#region src/gen/utils.ts
+/**
+* ts-pptx: shared generator helpers.
+*
+* The small cross-cutting pieces the OOXML writers all need and that belong to
+* no single part:
+*   - XML text               encodeXmlEntities
+*   - Identifiers & naming    getUuid, validateObjectName, getDuplicateObjectNames
+*   - Slide relationships     getNewRelId, isHyperlinkRel
+*
+* DrawingML fragment builders moved to `gen/drawingml/{color,effect,fill,line}.ts`;
+* unit conversion to `units-internal.ts` (over the public primitives in `units.ts`);
+* base64/image-header decoding and media content types to `media/`.
+*/
+/**
+* Basic UUID Generator Adapted
+* @link https://stackoverflow.com/questions/105034/create-guid-uuid-in-javascript#answer-2117523
+* @param {string} uuidFormat - UUID format
+* @returns {string} UUID
+*/
+function getUuid(uuidFormat) {
+	return uuidFormat.replace(/[xy]/g, function(c) {
+		const r = Math.random() * 16 | 0;
+		return (c === "x" ? r : r & 3 | 8).toString(16);
+	});
+}
+/**
+* Replace special XML characters with HTML-encoded strings.
+*
+* ELEMENT TEXT ONLY. A literal tab, carriage return or line feed is left alone here because in
+* character data it *is* the content (`<a:t>` line breaks depend on it). Inside an attribute value
+* the same three characters are destroyed by the parser rather than preserved — see
+* {@link encodeXmlAttrValue}, which every attribute-emitting path must use instead.
+* @param {string | number} xml - value to encode (numbers are stringified, as callers pass counts/sizes)
+* @returns {string} escaped XML
+*/
+function encodeXmlEntities(xml) {
+	if (typeof xml === "undefined" || xml == null) return "";
+	const cc = String.fromCharCode;
+	const illegalXmlCharsRe = new RegExp(`[${cc(0)}-${cc(8)}${cc(11)}${cc(12)}${cc(14)}-${cc(31)}${cc(127)}]`, "g");
+	return xml.toString().replace(illegalXmlCharsRe, "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+/**
+* Escape a value destined for an XML **attribute**.
+*
+* Everything {@link encodeXmlEntities} does, plus the three whitespace characters that survive in
+* element text but not in an attribute: XML 1.0 section 3.3.3 requires a parser to normalise a
+* literal tab, carriage return or line feed inside an attribute value to a single space *before any
+* consumer sees it*. Carrying one across therefore requires a character reference, so a caller's
+* `objectName: 'Abschnitts-\nuberschrift'` reads back with its line break rather than a space.
+*
+* Deliberately a separate function rather than a widening of `encodeXmlEntities`: that helper also
+* escapes element text, where a raw newline is meaningful content emitted as-is, and escaping it
+* there would change bytes across every text-bearing part in the package.
+* @param {string | number} xml - value to encode (numbers are stringified, as callers pass ids/sizes)
+* @returns {string} escaped XML, safe to place between attribute quotes
+*/
+function encodeXmlAttrValue(xml) {
+	return encodeXmlEntities(xml).replace(/\t/g, "&#9;").replace(/\n/g, "&#10;").replace(/\r/g, "&#13;");
+}
+/**
+* Practical maximum length for a `p:cNvPr` object name. PowerPoint does not
+* enforce a hard spec limit, but very long names are a strong signal of a bug
+* and are unwieldy in the Selection Pane.
+*/
+const MAX_OBJECT_NAME_LENGTH = 255;
+/**
+* Validate a user-supplied object name and warn (does not throw) when the value
+* cannot be preserved as a stable PowerPoint Selection Pane identity. This keeps
+* semantic-identity bugs visible at generation time without breaking existing
+* decks that pass loose names.
+* - Empty/whitespace-only names provide no usable identity.
+* - Control characters are stripped by `encodeXmlEntities`, silently changing
+*   the stored name.
+* - Excessively long names may not round-trip through PowerPoint/consumers.
+* @param {string} name - the raw (pre-encoding) object name
+* @param {string} kind - object kind for the warning message (e.g. 'text')
+* @returns {string} the name unchanged (validation only)
+*/
+function validateObjectName(name, kind) {
+	if (typeof name !== "string") return name;
+	if (name.trim().length === 0) {
+		warn("object-name/empty", `${kind} objectName is empty or whitespace-only; it will not provide a stable Selection Pane identity.`);
+		return name;
+	}
+	const cc = String.fromCharCode;
+	if (new RegExp(`[${cc(0)}-${cc(8)}${cc(11)}${cc(12)}${cc(14)}-${cc(31)}${cc(127)}]`).test(name)) warn("object-name/control-characters", `${kind} objectName "${name}" contains control characters that will be stripped, changing the stored name.`);
+	if (name.length > MAX_OBJECT_NAME_LENGTH) warn("object-name/too-long", `${kind} objectName exceeds ${MAX_OBJECT_NAME_LENGTH} characters and may not be preserved by PowerPoint.`);
+	return name;
+}
+/**
+* Return object names that appear more than once in the given list. Used to warn
+* when duplicate Selection Pane identities would be emitted on a single slide,
+* which breaks consumers (e.g. semantic manifests) that rely on unique names.
+* @param {string[]} names - object names emitted on one slide
+* @returns {string[]} the duplicated names (each listed once)
+*/
+function getDuplicateObjectNames(names) {
+	const seen = /* @__PURE__ */ new Set();
+	const dupes = /* @__PURE__ */ new Set();
+	names.forEach((name) => {
+		if (typeof name !== "string" || name.length === 0) return;
+		if (seen.has(name)) dupes.add(name);
+		else seen.add(name);
+	});
+	return Array.from(dupes);
+}
+/**
+* Get a new rel ID (rId) for charts, media, etc.
+*
+* Counting is the normal case: a slide's rels are minted in order, so one past the
+* total is free. It is not enough on its own, because a rel can arrive on a slide
+* carrying an id minted somewhere else — auto-paging re-registers a repeated header
+* row's hyperlink on each overflow slide under the id stamped on the shared
+* hyperlink object (`gen/define/hyperlinks.ts`). That id is then held but not
+* counted-to, so the next mint could hand out the same number and the part would
+* declare two `Relationship` elements sharing an `Id` — invalid OPC, and PowerPoint
+* resolves such a reference to whichever comes first. Hence the scan: start where
+* the count says, then step over anything the slide already holds.
+* @param {PresSlideInternal} target - the slide to use
+* @returns {number} the lowest free rId at or above the current rel count plus 1
+*/
+function getNewRelId(target) {
+	const held = /* @__PURE__ */ new Set();
+	target._rels.forEach((rel) => held.add(rel.rId));
+	target._relsChart.forEach((rel) => held.add(rel.rId));
+	target._relsMedia.forEach((rel) => held.add(rel.rId));
+	let rId = target._rels.length + target._relsChart.length + target._relsMedia.length + 1;
+	while (held.has(rId)) rId++;
+	return rId;
+}
+/**
+* Whether a slide relationship is a hyperlink (external URL or internal slide
+* link). The relationship `type` is stringly-typed (`'hyperlink'`, `'online'`,
+* mixed-case variants), so this centralizes the case-insensitive predicate that
+* was duplicated across the slide-rels writer (`gen/slide/slide.ts`) and the inspect path
+* (presentation.ts). For an internal slide-to-slide link, `rel.data === 'slide'` and
+* `rel.Target` is the 1-based target slide number.
+* @param {{ type: string }} rel - a slide relationship
+* @returns {boolean} true if the rel is any kind of hyperlink
+*/
+function isHyperlinkRel(rel) {
+	return rel.type.toLowerCase().includes("hyperlink");
+}
+//#endregion
+//#region src/gen/oxml/el.ts
+/**
+* ts-pptx: XML element builder (write-side substrate)
+*
+* The write path historically concatenated template strings and called
+* `encodeXmlEntities` by hand at every interpolation — the source of escaping,
+* attribute-order and child-sequence bugs. This builder centralizes escaping
+* while reproducing today's exact byte layout, so a migration onto it can be
+* gated on strict byte-identity (`pnpm run byte-identity:check`) rather than on
+* looser schema equivalence.
+*
+* Mirrors `src/read/oxml/dom.ts` on the write side.
+*
+* Two rules make byte-identity achievable:
+*
+* 1. Self-closing is decided by ARITY, never by child value. `el()` always emits
+*    a paired tag; `voidEl()` always self-closes. This matters because
+*    `encodeXmlEntities(undefined)` returns `''`, so a value-based rule would
+*    turn today's `<dc:title></dc:title>` into `<dc:title/>` — a silent byte
+*    regression on every optional-text element in the tree.
+*
+*    Escaping is split to match: attribute values go through `encodeXmlAttrValue`
+*    (which adds the `&#9;`/`&#10;`/`&#13;` character references an XML parser
+*    would otherwise normalise to a space), text children through
+*    `encodeXmlEntities`, where those same characters are content.
+*
+* 2. Whitespace is explicit, per element, via `fmt`. Most emitted parts are flat
+*    (no `fmt` needed at all); the pretty-printed ones carry indentation that is
+*    not always depth-regular, so it is described rather than derived. Quirks
+*    like a misindented closing tag stay visible in the call site instead of
+*    being hidden inside a template literal.
+*/
+/** Wrap already-serialized XML so it is interpolated verbatim. */
+function raw(xml) {
+	return { raw: xml };
+}
+function isRaw(child) {
+	return typeof child === "object" && child !== null && typeof child.raw === "string";
+}
+function openTag(name, attrs, fmt) {
+	let out = (fmt?.openPrefix ?? "") + "<" + name;
+	for (const [key, value] of Object.entries(attrs ?? {})) {
+		if (value === void 0 || value === null) continue;
+		out += " " + key + "=\"" + encodeXmlAttrValue(value) + "\"";
+	}
+	return out;
+}
+/**
+* Paired element: `<name …>children</name>` — emitted even when `children` is
+* empty or `undefined`. Text children are escaped; `raw()` children are not.
+*/
+function el(name, attrs, children, fmt) {
+	let out = openTag(name, attrs, fmt) + ">";
+	const childPrefix = fmt?.childPrefix ?? "";
+	for (const child of Array.isArray(children) ? children : [children]) {
+		if (child === void 0 || child === null) continue;
+		out += childPrefix + (isRaw(child) ? child.raw : encodeXmlEntities(child));
+	}
+	return out + (fmt?.closePrefix ?? "") + "</" + name + ">";
+}
+/**
+* Self-closing element: `<name …/>`. `fmt.closePrefix` goes before the `/>` — a
+* handful of emitters write `<a:avLst />` with a space there, and that space is
+* byte-significant like any other.
+*/
+function voidEl(name, attrs, fmt) {
+	return openTag(name, attrs, fmt) + (fmt?.closePrefix ?? "") + "/>";
+}
+//#endregion
+//#region src/gen/drawingml/color.ts
+/**
+* ts-pptx: DrawingML color elements
+*
+* Emit the bare `<a:srgbClr>` / `<a:schemeClr>` color element that every other
+* color context builds on (solid fills, gradient stops, effect alphas, line
+* fills, highlights, patterns).
+*
+* The RGB->hex helpers this module used to carry now live in
+* `gen/table/html-dom.ts`, their only caller: they are reachable exclusively from
+* the browser-only `tableToSlides` path, so keeping them here made them permanent
+* dead weight in the Node chunk's coverage report (33% functions on a file that is
+* otherwise fully exercised) while html-dom.ts is coverage-excluded wholesale.
+*/
+/**
+* Opening delimiter of an `<a:alpha>` child, for detecting one a caller already
+* supplied. A prefix rather than a whole element: the value is the caller's, and
+* this asks only whether the element is present.
+*/
+const ALPHA_TAG = "<a:alpha";
+/**
+* Emit a bare DrawingML color element — either `<a:schemeClr>` (scheme color) or `<a:srgbClr>`
+* (hex RGB). This is a low-level primitive: it is the shared building block for every color
+* context (solid fills, gradient stops, `<a:alpha>` on shadows/glow, line fills, highlight,
+* underline, patterns, …), so it is intentionally NOT limited to solid fills and cannot be
+* folded into `genXmlColorSelection`.
+*
+* When you specifically want a *solid fill*, prefer `genXmlColorSelection` (`fill.ts`), which
+* wraps this in `<a:solidFill>…</a:solidFill>` and also handles `alpha`/`transparency` and the
+* gradient/pattern/image fill types — reach for `createColorElement` directly only when you
+* need the raw color element (e.g. inside `<a:ln>`, `<a:gs>`, an effect, or a highlight).
+* @param {string|SCHEME_COLORS} colorStr - hex RGB (e.g. "FFFF00") or a scheme color constant (e.g. SchemeColor.ACCENT1)
+* @param {string} [innerElements] - additional elements that adjust the color, nested inside the color element
+* @returns {string} XML string
+*/
+function createColorElement(colorStr, innerElements) {
+	if (typeof colorStr !== "string") {
+		warn("color/not-a-string", `createColorElement: expected a string color value, got ${typeof colorStr}. "${DEF_FONT_COLOR}" used instead.`);
+		colorStr = DEF_FONT_COLOR;
+	}
+	let colorVal = (colorStr || "").replace("#", "");
+	if (/^[0-9a-fA-F]{8}$/.test(colorVal)) {
+		if (!innerElements?.includes(ALPHA_TAG)) {
+			const alphaHex = colorVal.slice(6, 8);
+			innerElements = voidEl("a:alpha", { val: Math.round(parseInt(alphaHex, 16) / 255 * PERCENT_SCALE) }) + (innerElements || "");
+		}
+		colorVal = colorVal.slice(0, 6);
+	}
+	if (!REGEX_HEX_COLOR.test(colorVal) && !Object.values(SchemeColor).includes(colorVal)) {
+		warn("color/invalid-value", `"${colorVal}" is not a valid scheme color or hex RGB! "${DEF_FONT_COLOR}" used instead. Only provide 6-digit RGB or 'SchemeColor' values!`);
+		colorVal = DEF_FONT_COLOR;
+	}
+	const isHex = REGEX_HEX_COLOR.test(colorVal);
+	const name = isHex ? "a:srgbClr" : "a:schemeClr";
+	const attrs = { val: isHex ? colorVal.toUpperCase() : colorVal };
+	return innerElements ? el(name, attrs, raw(innerElements)) : voidEl(name, attrs);
+}
+//#endregion
+//#region src/gen/drawingml/effect.ts
+/**
+* ts-pptx: DrawingML effects (glow and shadow)
+*
+* Emit the `<a:glow>` / `<a:outerShdw>` / `<a:innerShdw>` children of an
+* `<a:effectLst>`, and normalize the user-facing `shadow` options into the
+* internal shape every emit site reads.
+* @see http://officeopenxml.com/drwSp-effects.php
+*/
+/**
+* Creates `a:glow` element
+* @param {TextGlowProps} options glow properties
+* @param {TextGlowProps} defaults defaults for unspecified properties in `opts`
+* @see http://officeopenxml.com/drwSp-effects.php
+* { size: 8, color: 'FFFFFF', opacity: 0.75 };
+*/
+function createGlowElement(options, defaults) {
+	const opts = {
+		...defaults,
+		...options
+	};
+	const size = Math.round(opts.size * EMU_PER_POINT);
+	const color = opts.color || "000000";
+	const opacity = opacityToAlpha(opts.opacity ?? 0);
+	return el("a:glow", { rad: size }, raw(createColorElement(color, alpha(opacity))));
+}
+/** The `<a:alpha>` child both effects hang off their color element. */
+function alpha(value) {
+	return voidEl("a:alpha", { val: value });
+}
+/**
+* Creates an `a:outerShdw`/`a:innerShdw` element for a text run, shape, image, or chart.
+* Returns the shadow element only (no wrapping `a:effectLst`) so callers can either combine
+* it with other effects (e.g. glow) inside one `a:effectLst`, or wrap a lone shadow via
+* {@link createShadowEffectLst}.
+*
+* Colors go through {@link createColorElement}, so scheme colors (e.g. `accent1`) are honored
+* — earlier per-site copies hardcoded `a:srgbClr` and silently emitted invalid OOXML for them.
+* @param {ShadowPropsInternal} options shadow properties
+* @param {ShadowPropsInternal} defaults defaults for unspecified properties in `options`
+* @see http://officeopenxml.com/drwSp-effects.php
+* @returns {string} XML string, or '' when type is 'none'
+*/
+function createShadowElement(options, defaults) {
+	const opts = {
+		...defaults,
+		...options
+	};
+	if (opts.type === "none") return "";
+	const type = opts.type || "outer";
+	const blur = valToPts(opts.blur ?? 0);
+	const offset = valToPts(opts.offset ?? 0);
+	const angle = Math.round((opts.angle ?? 0) * ANGLE_UNITS_PER_DEGREE);
+	const opacity = Math.round((opts._alpha ?? .75) * PERCENT_SCALE);
+	const color = opts.color || "000000";
+	const attrs = {
+		...type === "outer" ? {
+			sx: 1e5,
+			sy: 1e5,
+			kx: 0,
+			ky: 0,
+			algn: "bl",
+			rotWithShape: opts.rotateWithShape ? 1 : 0
+		} : {},
+		blurRad: blur,
+		dist: offset,
+		dir: angle
+	};
+	return el(`a:${type}Shdw`, attrs, raw(createColorElement(color, alpha(opacity))));
+}
+/**
+* Wraps a lone shadow in the `a:effectLst` that CT_ShapeProperties (shapes/images) and chart
+* marker/data-point properties require. Returns a self-closing `<a:effectLst/>` when there is
+* no shadow (missing/non-object options, or `type: 'none'`), matching the "no effects" element
+* PowerPoint emits. Use this instead of {@link createShadowElement} when the shadow is the only
+* effect; use `createShadowElement` directly when combining with other effects (e.g. glow).
+* @param {ShadowPropsInternal} options shadow properties
+* @param {ShadowPropsInternal} defaults defaults for unspecified properties in `options`
+* @returns {string} `<a:effectLst>…</a:effectLst>` or `<a:effectLst/>`
+*/
+function createShadowEffectLst(options, defaults) {
+	if (!options || typeof options !== "object") return voidEl("a:effectLst");
+	const inner = createShadowElement(options, defaults);
+	return inner ? el("a:effectLst", null, raw(inner)) : voidEl("a:effectLst");
+}
+/**
+* Checks shadow options passed by user and performs corrections if needed.
+* @param {ShadowProps} ShadowProps - shadow options
+*/
+function correctShadowOptions(ShadowProps) {
+	if (!ShadowProps || typeof ShadowProps !== "object") return;
+	const corrected = ShadowProps;
+	if (corrected.type !== "outer" && corrected.type !== "inner" && corrected.type !== "none") {
+		warn("shadow/invalid-type", "shadow.type options are `outer`, `inner` or `none`.");
+		corrected.type = "outer";
+	}
+	if (corrected.angle) {
+		if (isNaN(Number(corrected.angle)) || corrected.angle < 0 || corrected.angle > 359) {
+			warn("shadow/angle-out-of-range", "shadow.angle can only be 0-359");
+			corrected.angle = 270;
+		}
+		corrected.angle = Math.round(Number(corrected.angle));
+	}
+	if (corrected.transparency !== void 0) {
+		const pct = Number(corrected.transparency);
+		if (isNaN(pct) || pct < 0 || pct > 100) warn("shadow/transparency-out-of-range", "shadow.transparency can only be 0-100");
+		else corrected._alpha = 1 - pct / 100;
+	}
+	if (corrected.color) {
+		if (corrected.color.startsWith("#")) {
+			warn("shadow/color-has-hash", "shadow.color should not include hash (#) character, , e.g. \"FF0000\"");
+			corrected.color = corrected.color.replace("#", "");
+		}
+		if (/^[0-9a-fA-F]{8}$/.test(corrected.color)) {
+			const alphaHex = corrected.color.slice(6, 8);
+			if (corrected._alpha === void 0) corrected._alpha = parseInt(alphaHex, 16) / 255;
+			corrected.color = corrected.color.slice(0, 6);
+		}
+	}
+	return corrected;
+}
+//#endregion
+//#region src/embedded-fonts.ts
+/**
+* Shared model + serializer for PresentationML embedded fonts, used by both the
+* write side (author-side `pptx.embedFont`, `gen/pres/presentation.ts`) and the read side
+* (`importSlide({ embedFonts: true })`, `src/read/api/ops/embedded-fonts.ts`).
+*
+* Embedded fonts are three coordinated pieces (ECMA-376 transitional):
+*  1. binary font parts `/ppt/fonts/fontN.fntdata` — the **raw** TTF/OTF bytes
+*     (PresentationML does not obfuscate embedded fonts), content type
+*     `application/x-fontdata` via a single `fntdata` Default extension;
+*  2. one `font` relationship per face from `presentation.xml`;
+*  3. a `p:embeddedFontLst` in `presentation.xml`, at index 7 of the
+*     `CT_Presentation` child sequence (after `smartTags`, before `custShowLst`
+*     … `defaultTextStyle`).
+*
+* This module owns only the OOXML-shape knowledge; rId allocation and part
+* placement stay with each caller (their packaging models differ).
+*/
+/** Extension for the binary font parts (`/ppt/fonts/fontN.fntdata`). */
+const FONT_DATA_EXTENSION = "fntdata";
+/** Content type for a `.fntdata` part — one `Default` covers every font part. */
+const FONT_DATA_CONTENT_TYPE = "application/x-fontdata";
+/** Relationship type from `presentation.xml` to a font part (one per face). */
+const FONT_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/font";
+/**
+* The four face slots of `CT_EmbeddedFontListEntry`, in schema child order
+* (`font` first, then these). Iterate in this order everywhere so the read- and
+* write-side emitters agree on element order.
+*/
+const EMBEDDED_FONT_SLOTS = [
+	"regular",
+	"bold",
+	"italic",
+	"boldItalic"
+];
+/**
+* Flatten `fonts` into one ordered face list, assigning sequential part indices
+* (1-based) and relationship ids (starting at `firstRId`). Faces are emitted in
+* `fonts` order, each font's faces in {@link EMBEDDED_FONT_SLOTS} order. Faces
+* without `bytes` are skipped (nothing to write).
+*/
+function flattenEmbeddedFaces(fonts, firstRId) {
+	const flat = [];
+	let partIndex = 0;
+	let rId = firstRId;
+	fonts.forEach((font, fontIndex) => {
+		for (const slot of EMBEDDED_FONT_SLOTS) {
+			const face = font.faces.find((f) => f.slot === slot);
+			if (!face || !face.bytes) continue;
+			flat.push({
+				fontIndex,
+				slot,
+				bytes: face.bytes,
+				partIndex: ++partIndex,
+				rId: rId++
+			});
+		}
+	});
+	return flat;
+}
+/** Minimal XML attribute escaper (kept local so this module stays dependency-free). */
+function escapeAttr(value) {
+	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+/**
+* Serialize a `<p:embeddedFontLst>` from `fonts` and a `(fontIndex, slot) → rId`
+* lookup (typically backed by {@link flattenEmbeddedFaces}). Returns `''` when no
+* font has any face with an allocated rId, so callers can emit nothing. Assumes
+* the enclosing document declares the `p:` and `r:` prefixes (presentation.xml
+* does), so no namespace declarations are emitted here.
+*/
+function serializeEmbeddedFontLst(fonts, rIdForFace) {
+	const entries = [];
+	fonts.forEach((font, fontIndex) => {
+		const faceXml = [];
+		for (const slot of EMBEDDED_FONT_SLOTS) {
+			const rId = rIdForFace(fontIndex, slot);
+			if (rId === void 0) continue;
+			faceXml.push(`<p:${slot} r:id="rId${rId}"/>`);
+		}
+		if (faceXml.length === 0) return;
+		let fontAttrs = `typeface="${escapeAttr(font.typeface)}"`;
+		if (font.panose !== void 0) fontAttrs += ` panose="${escapeAttr(font.panose)}"`;
+		if (font.pitchFamily !== void 0) fontAttrs += ` pitchFamily="${font.pitchFamily}"`;
+		if (font.charset !== void 0) fontAttrs += ` charset="${font.charset}"`;
+		entries.push(`<p:embeddedFont><p:font ${fontAttrs}/>${faceXml.join("")}</p:embeddedFont>`);
+	});
+	if (entries.length === 0) return "";
+	return `<p:embeddedFontLst>${entries.join("")}</p:embeddedFontLst>`;
+}
+//#endregion
+//#region src/gen/drawingml/fill.ts
+/**
+* ts-pptx: DrawingML fills
+*
+* Emit the fill group a shape, cell, chart element, or line paint can carry:
+* `<a:solidFill>`, `<a:gradFill>`, `<a:pattFill>`, `<a:blipFill>`.
+* {@link genXmlColorSelection} is the dispatch every caller should reach for;
+* the per-kind builders are exported for the few sites that know their fill kind.
+*/
+function boolToXml(value) {
+	return value ? "1" : "0";
+}
+function normalizeGradientAngle(angle) {
+	const degrees = angle ?? 0;
+	if (typeof degrees !== "number" || !Number.isFinite(degrees)) throw new InvalidOptionError("gradient/angle-non-finite", "Gradient angle must be a finite number.");
+	return convertRotationDegrees((degrees % 360 + 360) % 360);
+}
+function alphaFromTransparency(transparency) {
+	return transparency ? voidEl("a:alpha", { val: transparencyToAlpha(transparency) }) : "";
+}
+function normalizeGradientStops(stops) {
+	if (!Array.isArray(stops) || stops.length < 2) throw new InvalidOptionError("gradient/too-few-stops", "Gradient fill requires at least two stops.");
+	return stops.map((stop) => {
+		if (!stop || typeof stop.position !== "number" || !Number.isFinite(stop.position)) throw new InvalidOptionError("gradient/stop-position-non-finite", "Gradient stop position must be a finite number from 0 to 100.");
+		if (stop.position < 0 || stop.position > 100) throw new InvalidOptionError("gradient/stop-position-out-of-range", "Gradient stop position must be from 0 to 100.");
+		return stop;
+	}).sort((a, b) => a.position - b.position);
+}
+/**
+* Create a native DrawingML gradient fill.
+* @param {GradientFillProps} gradient gradient fill options
+* @returns XML string
+*/
+function genXmlGradientFill(gradient) {
+	if (!gradient || gradient.kind !== "linear" && gradient.kind !== "radial") throw new UnsupportedFeatureError("gradient/type-unsupported", "Gradient fill currently supports only linear and radial gradients.");
+	if (typeof gradient.rotateWithShape !== "undefined" && typeof gradient.rotateWithShape !== "boolean") throw new InvalidOptionError("gradient/rotate-with-shape-not-boolean", "Gradient rotateWithShape must be a boolean.");
+	const stops = normalizeGradientStops(gradient.stops);
+	const rotWithShape = gradient.rotateWithShape ?? true;
+	const gsLst = el("a:gsLst", null, stops.map((stop) => raw(el("a:gs", { pos: Math.round(stop.position * FIXED_PCT_PER_PERCENT) }, raw(createColorElement(stop.color, alphaFromTransparency(stop.transparency)))))));
+	let shape;
+	if (gradient.kind === "radial") {
+		const cx = Math.max(0, Math.min(100, gradient.center?.x ?? 50));
+		const cy = Math.max(0, Math.min(100, gradient.center?.y ?? 50));
+		shape = el("a:path", { path: "circle" }, raw(voidEl("a:fillToRect", {
+			l: Math.round(cx * FIXED_PCT_PER_PERCENT),
+			t: Math.round(cy * FIXED_PCT_PER_PERCENT),
+			r: Math.round((100 - cx) * FIXED_PCT_PER_PERCENT),
+			b: Math.round((100 - cy) * FIXED_PCT_PER_PERCENT)
+		})));
+	} else {
+		if (typeof gradient.scaled !== "undefined" && typeof gradient.scaled !== "boolean") throw new InvalidOptionError("gradient/scaled-not-boolean", "Gradient scaled must be a boolean.");
+		shape = voidEl("a:lin", {
+			ang: normalizeGradientAngle(gradient.angle),
+			scaled: typeof gradient.scaled === "boolean" ? boolToXml(gradient.scaled) : void 0
+		});
+	}
+	return el("a:gradFill", { rotWithShape: boolToXml(rotWithShape) }, [raw(gsLst), raw(shape)]);
+}
+/**
+* Create a native DrawingML pattern fill.
+* @param {PatternFillProps} pattern pattern fill options
+* @returns XML string
+*/
+function genXmlPatternFill(pattern) {
+	if (!pattern) throw new InvalidOptionError("pattern-fill/missing-pattern", "Pattern fill requires a pattern object.");
+	const fgColor = pattern.fgColor ?? "000000";
+	const bgColor = pattern.bgColor ?? "FFFFFF";
+	return el("a:pattFill", { prst: pattern.preset }, [raw(el("a:fgClr", null, raw(createColorElement(fgColor)))), raw(el("a:bgClr", null, raw(createColorElement(bgColor))))]);
+}
+/**
+* Create a native DrawingML picture (image) fill.
+* The media relationship is registered when the object is added; this only emits
+* the `<a:blipFill>` referencing the pre-resolved rId.
+* @param {ShapeFillProps} props fill props (must carry a resolved `_imgRid`)
+* @returns XML string
+*/
+function genXmlImageFill(props) {
+	if (!props || typeof props._imgRid !== "number") {
+		warn("image-fill/unresolved-media", "image fill is missing its resolved media reference; falling back to no fill. Provide `image: { path }` or `image: { data }`.");
+		return voidEl("a:noFill");
+	}
+	const alpha = props.transparency;
+	const blipInner = alpha ? voidEl("a:alphaModFix", { amt: Math.round((100 - alpha) * FIXED_PCT_PER_PERCENT) }) : "";
+	return el("a:blipFill", {
+		dpi: 0,
+		rotWithShape: 1
+	}, [
+		raw(el("a:blip", { "r:embed": `rId${props._imgRid}` }, raw(blipInner))),
+		raw(voidEl("a:srcRect")),
+		raw(el("a:stretch", null, raw(voidEl("a:fillRect"))))
+	]);
+}
+/**
+* Create color selection
+* @param {Color | ShapeFillProps | ShapeLineProps} props fill props
+* @returns XML string
+*/
+function genXmlColorSelection(props) {
+	let fillType = "solid";
+	let colorVal = "";
+	let internalElements = "";
+	let outText = "";
+	if (props) {
+		if (typeof props === "string") colorVal = props;
+		else {
+			if (props.type) fillType = props.type;
+			if (props.color) colorVal = props.color;
+			internalElements += alphaFromTransparency(props.transparency);
+		}
+		switch (fillType) {
+			case "none":
+				outText += voidEl("a:noFill");
+				break;
+			case "inherit":
+				outText += "";
+				break;
+			case "solid":
+				outText += el("a:solidFill", null, raw(createColorElement(colorVal, internalElements)));
+				break;
+			case "gradient":
+				outText += genXmlGradientFill(typeof props === "string" ? void 0 : props.gradient);
+				break;
+			case "pattern":
+				outText += genXmlPatternFill(typeof props === "string" ? void 0 : props.pattern);
+				break;
+			case "image":
+				outText += genXmlImageFill(typeof props === "string" ? void 0 : props);
+				break;
+			default: outText += "";
+		}
+	}
+	return outText;
+}
+//#endregion
+//#region src/gen/drawingml/clamp.ts
+/**
+* ts-pptx: DrawingML value clamps
+*
+* Clamp font/character/line spacing values (points) into their ST_* schema
+* ranges and convert to the hundredths-of-a-point units the attributes expect.
+* Out-of-range values make PowerPoint report the package as needing repair.
+*/
+/**
+* Clamp a font size (points) into ST_TextFontSize (1-4000pt) and return it in
+* hundredths of a point for the `sz` attribute. Out-of-range sizes make
+* PowerPoint report the package as needing repair (e.g. `sz` > 400000 or < 100).
+*/
+function clampFontSizeSz(fontSizePts) {
+	const raw = ptToHundredths(fontSizePts);
+	const clamped = Math.min(4e5, Math.max(100, raw));
+	if (clamped !== raw) warnOnce("font/size-out-of-range", `fontSize ${fontSizePts} is outside the valid range 1-4000pt; using ${clamped / 100}.`);
+	return clamped;
+}
+/** Clamp character spacing (points) into ST_TextPoint (-4000..4000pt); returns hundredths for the `spc` attribute. */
+function clampCharSpacingSpc(charSpacingPts) {
+	const raw = ptToHundredths(charSpacingPts);
+	const clamped = Math.min(4e5, Math.max(-4e5, raw));
+	if (clamped !== raw) warnOnce("text/char-spacing-out-of-range", `charSpacing ${charSpacingPts} is outside the valid range -4000..4000pt; using ${clamped / 100}.`);
+	return clamped;
+}
+/**
+* Clamp a paragraph's left margin (points) into ST_TextMargin (0..4032pt, i.e. 0..51206400 EMU);
+* returns EMU for `a:pPr/@marL`. The type is unsigned — a negative margin is not a narrower one,
+* it is a value PowerPoint reports as needing repair.
+*/
+function clampParaMarginEmu(marginPts) {
+	const raw = valToPts(marginPts);
+	const clamped = Math.min(51206400, Math.max(0, raw));
+	if (clamped !== raw) warnOnce("text/paragraph-margin-out-of-range", `paraMarginLeft ${marginPts} is outside the valid range 0-4032pt; using ${clamped / EMU_PER_POINT}.`);
+	return clamped;
+}
+/**
+* Clamp a first-line indent (points) into ST_TextIndent (-4032..4032pt); returns EMU for
+* `a:pPr/@indent`. Unlike the margin this one is signed: a negative indent is the hanging
+* indent every bulleted paragraph uses.
+*/
+function clampParaIndentEmu(indentPts) {
+	const raw = valToPts(indentPts);
+	const clamped = Math.min(51206400, Math.max(-51206400, raw));
+	if (clamped !== raw) warnOnce("text/paragraph-indent-out-of-range", `paraIndent ${indentPts} is outside the valid range -4032..4032pt; using ${clamped / EMU_PER_POINT}.`);
+	return clamped;
+}
+/** Clamp line spacing (points) into ST_TextSpacingPoint (0..1584pt); returns hundredths for `<a:spcPts val>`. */
+function clampLineSpacingPts(lineSpacingPts) {
+	const raw = ptToHundredths(lineSpacingPts);
+	const clamped = Math.min(158400, Math.max(0, raw));
+	if (clamped !== raw) warnOnce("text/line-spacing-out-of-range", `lineSpacing ${lineSpacingPts} is outside the valid range 0-1584pt; using ${clamped / 100}.`);
+	return clamped;
+}
+//#endregion
+//#region src/gen/drawingml/math.ts
+/**
+* ts-pptx: DrawingML native equations (OMML)
+*
+* Wrap raw OMML markup into the `<a14:m>` marker PowerPoint uses for editable
+* equations — as a standalone display paragraph (`genXmlMathParagraph`) or as an
+* inline run that flows between the surrounding `<a:r>` runs (`genXmlInlineMath`).
+*/
+const M_NS = "http://schemas.openxmlformats.org/officeDocument/2006/math";
+const A14_NS = "http://schemas.microsoft.com/office/drawing/2010/main";
+/** The `<a14:m>` marker, carrying both namespace declarations so the supplied OMML needs none. */
+function a14Math(mathXml) {
+	return el("a14:m", {
+		"xmlns:a14": A14_NS,
+		"xmlns:m": M_NS
+	}, raw(mathXml));
+}
+/**
+* Build a native-equation paragraph (`<a:p>`) from raw OMML.
+*
+* PowerPoint stores an editable equation inside a text body as an `<a14:m>` marker wrapping
+* `<m:oMathPara><m:oMath>…`. We declare both the `a14` (drawing-2010) and `m` (math) namespaces
+* on the `<a14:m>` element so the supplied OMML needs no namespace declarations of its own, then
+* accept three input shapes: a full `<m:oMathPara>`, a full `<m:oMath>`, or the inner OMML
+* (children of `<m:oMath>`). A trailing `<a:endParaRPr>` matches what PowerPoint authors.
+*
+* @param {string} omml - raw OMML markup for the equation
+* @returns {string} an `<a:p>` math paragraph
+*/
+function genXmlMathParagraph(omml) {
+	const trimmed = (omml || "").trim();
+	const paraPr = el("m:oMathParaPr", null, raw(voidEl("m:jc", { "m:val": "centerGroup" })));
+	return el("a:p", null, [a14Math(trimmed.startsWith("<m:oMathPara") ? trimmed : trimmed.includes("<m:oMath") ? el("m:oMathPara", null, [paraPr, trimmed].map(raw)) : el("m:oMathPara", null, [paraPr, el("m:oMath", null, raw(trimmed))].map(raw))), voidEl("a:endParaRPr", { lang: "en-US" })].map(raw));
+}
+/**
+* Build an INLINE native-equation run (dn-inline-math) from raw OMML.
+*
+* Unlike the display form ({@link genXmlMathParagraph}), an inline equation is *not* its own
+* paragraph: PowerPoint authors an `<a14:m>` marker wrapping a bare `<m:oMath>` (no `<m:oMathPara>`,
+* no `<m:oMathParaPr>`/`<m:jc>`) that flows between the surrounding `<a:r>` runs in one `<a:p>` —
+* pinned by the `math-omml-inline.pptx` oracle. The `mc:AlternateContent` envelope stays at the
+* shape level (see `objectHasMath`), so nothing wraps the run itself. We declare the `a14` and `m`
+* namespaces on the `<a14:m>` element so the supplied OMML needs none of its own, and accept the
+* same three input shapes as the display helper: a full `<m:oMathPara>` (its inner `<m:oMath>` is
+* unwrapped, since a paragraph block cannot flow inline), a full `<m:oMath>`, or the inner OMML.
+*
+* @param {string} omml - raw OMML markup for the equation
+* @returns {string} an `<a14:m>` inline equation run
+*/
+function genXmlInlineMath(omml) {
+	const trimmed = (omml || "").trim();
+	const oMathMatch = trimmed.match(/<m:oMath[\s>][\s\S]*<\/m:oMath>/);
+	return a14Math(oMathMatch ? oMathMatch[0] : el("m:oMath", null, raw(trimmed)));
+}
+//#endregion
+//#region src/gen/drawingml/text-run.ts
+/** The 2018 hyperlink-color extension namespace, written on the `<ahyp:hlinkClr>` element itself. */
+const AHYP_NS = "http://schemas.microsoft.com/office/drawing/2018/hyperlinkcolor";
+/**
+* `<a:buChar>` cannot go through the element builder. Its `char` attribute carries a *pre-escaped*
+* numeric character reference (`&#x2022;` — see `BulletType`), and the builder escapes every
+* attribute value, which would emit `&amp;#x2022;` and render that text literally as the bullet.
+* There is no raw-attribute escape hatch, so this one stays a template.
+*/
+function buChar(char) {
+	return `<a:buChar char="${char}"/>`;
+}
+/**
+* `<a:extLst>` marking a hyperlink whose color should follow the text color rather than the
+* theme's hyperlink color. The leading spaces are byte-significant: this block was authored as
+* indented string concatenation and that indentation reaches the file, so it is described here
+* with `openPrefix`/`closePrefix` rather than being tidied away.
+*/
+const HLINK_TEXT_COLOR_EXT = el("a:extLst", null, raw(el("a:ext", { uri: "{A12FA001-AC4F-418D-AE19-62706E023703}" }, raw(voidEl("ahyp:hlinkClr", {
+	"xmlns:ahyp": AHYP_NS,
+	val: "tx"
+}, { openPrefix: "   " })), {
+	openPrefix: "  ",
+	closePrefix: "  "
+})), {
+	openPrefix: " ",
+	closePrefix: " "
+});
+/**
+* Whether a `bullet` value makes the paragraph DRAW a bullet (a glyph, a number or a picture).
+*
+* Two call sites downstream of the emitter act on "this paragraph has a bullet" rather than on
+* "this paragraph says something about its bullet", and both were plain truthiness tests until
+* `'inherit'` — a truthy string that draws nothing — joined the union. Left as truthiness they
+* would have broken the line grouping (every run starting its own paragraph) and eaten a real
+* leading `•` from text that emits no `a:buChar` to duplicate it.
+* @param {TextPropsOptions['bullet']} bullet - the option value
+* @return {boolean} true when bullet markup is emitted
+*/
+function emitsBulletMarkup(bullet) {
+	return !!bullet && bullet !== "inherit";
+}
+/**
+* One paragraph margin attribute's value in EMU, or `null` when the attribute is not written.
+*
+* Three inputs, because the option has three states and so does the attribute: an explicit
+* number is clamped and written, `'inherit'` writes nothing, and an absent option falls back to
+* whatever the `bullet` arm decided — which is also `null` for `bullet: 'inherit'`, the one arm
+* that states nothing on its own.
+* @param {number|'inherit'|undefined} option - `paraMarginLeft` / `paraIndent` as given
+* @param {number|null} fallbackEmu - the bullet arm's default, `null` for no attribute
+* @param {Function} clamp - the attribute's ST_* range clamp (points in, EMU out)
+* @return {number|null} the EMU value to write, or null to omit the attribute
+*/
+function resolveParagraphMargin(option, fallbackEmu, clamp) {
+	if (option === void 0) return fallbackEmu;
+	if (option === "inherit") return null;
+	return clamp(option);
+}
+/**
+* Generate XML Paragraph Properties
+* @param {SlideObject|TextProps} textObj - text object
+* @param {boolean} isDefault - array of default relations
+* @return {string} XML
+*/
+function genXmlParagraphProperties(textObj, isDefault) {
+	const opts = textObj.options ?? {};
+	let strXmlBullet = "";
+	let strXmlBulletColor = "";
+	let strXmlLnSpc = "";
+	let strXmlParaSpc = "";
+	let strXmlTabStops = "";
+	const tag = isDefault ? "a:lvl1pPr" : "a:pPr";
+	let bulletMarL = valToPts(27);
+	let defaultMarL = null;
+	let defaultIndent = null;
+	let indentBeforeMarL = false;
+	let paragraphPropXml = `<${tag}${opts.rtlMode ? " rtl=\"1\" " : ""}`;
+	{
+		if (opts.align) switch (opts.align) {
+			case "left":
+				paragraphPropXml += " algn=\"l\"";
+				break;
+			case "right":
+				paragraphPropXml += " algn=\"r\"";
+				break;
+			case "center":
+				paragraphPropXml += " algn=\"ctr\"";
+				break;
+			case "justify":
+				paragraphPropXml += " algn=\"just\"";
+				break;
+			default: paragraphPropXml += "";
+		}
+		if (opts.lineSpacing) strXmlLnSpc = el("a:lnSpc", null, raw(voidEl("a:spcPts", { val: clampLineSpacingPts(opts.lineSpacing) })));
+		else if (opts.lineSpacingMultiple) strXmlLnSpc = el("a:lnSpc", null, raw(voidEl("a:spcPct", { val: Math.round(opts.lineSpacingMultiple * PERCENT_SCALE) })));
+		if (opts.indentLevel && !isNaN(Number(opts.indentLevel)) && opts.indentLevel > 0) paragraphPropXml += ` lvl="${opts.indentLevel}"`;
+		if (opts.paraSpaceBefore && !isNaN(Number(opts.paraSpaceBefore)) && opts.paraSpaceBefore > 0) strXmlParaSpc += el("a:spcBef", null, raw(voidEl("a:spcPts", { val: ptToHundredths(opts.paraSpaceBefore) })));
+		if (opts.paraSpaceAfter && !isNaN(Number(opts.paraSpaceAfter)) && opts.paraSpaceAfter > 0) strXmlParaSpc += el("a:spcAft", null, raw(voidEl("a:spcPts", { val: ptToHundredths(opts.paraSpaceAfter) })));
+		if (typeof opts.bullet === "object") {
+			const bulletImage = opts.bullet.image;
+			const isPictureBullet = !!(bulletImage && (bulletImage.path || bulletImage.data));
+			if (opts.bullet?.indent) bulletMarL = valToPts(opts.bullet.indent);
+			defaultMarL = opts.indentLevel && opts.indentLevel > 0 ? bulletMarL + bulletMarL * opts.indentLevel : bulletMarL;
+			defaultIndent = -bulletMarL;
+			if (opts.bullet.color && !isPictureBullet) strXmlBulletColor = el("a:buClr", null, raw(createColorElement(opts.bullet.color)));
+			let bulletSizePct;
+			if (opts.bullet.size !== void 0) {
+				const bulletSize = Number(opts.bullet.size);
+				if (isNaN(bulletSize) || bulletSize < 25 || bulletSize > 400) warn("bullet/size-out-of-range", "`bullet.size` must be a percentage between 25 and 400!");
+				else bulletSizePct = Math.round(bulletSize * FIXED_PCT_PER_PERCENT);
+			}
+			const strXmlBulletSize = bulletSizePct === void 0 ? "" : voidEl("a:buSzPct", { val: bulletSizePct });
+			const strXmlBulletFont = opts.bullet.fontFace ? voidEl("a:buFont", { typeface: opts.bullet.fontFace }) : "";
+			if (isPictureBullet) {
+				if (opts.bullet._rId) {
+					const svgExt = opts.bullet._rIdSvg ? el("a:extLst", null, raw(el("a:ext", { uri: "{96DAC541-7B7A-43D3-8B79-37D633B846F1}" }, raw(voidEl("asvg:svgBlip", {
+						"xmlns:asvg": "http://schemas.microsoft.com/office/drawing/2016/SVG/main",
+						"r:embed": `rId${opts.bullet._rIdSvg}`
+					}))))) : "";
+					strXmlBullet = strXmlBulletSize + el("a:buBlip", null, raw(svgExt ? el("a:blip", { "r:embed": `rId${opts.bullet._rId}` }, raw(svgExt)) : voidEl("a:blip", { "r:embed": `rId${opts.bullet._rId}` })));
+				} else {
+					warn("bullet/image-embed-failed", "picture `bullet.image` could not be embedded; using a default bullet glyph");
+					strXmlBullet = strXmlBulletSize + strXmlBulletFont + buChar("&#x2022;");
+				}
+			} else if (opts.bullet.type && opts.bullet.type.toString().toLowerCase() === "number") strXmlBullet = strXmlBulletSize + (strXmlBulletFont || voidEl("a:buFont", { typeface: "+mj-lt" })) + voidEl("a:buAutoNum", {
+				type: opts.bullet.numberType || "arabicPeriod",
+				startAt: opts.bullet.numberStartAt || "1"
+			});
+			else if (opts.bullet.characterCode) {
+				let bulletCode = `&#x${opts.bullet.characterCode};`;
+				if (!/^[0-9A-Fa-f]{4}$/.test(opts.bullet.characterCode)) {
+					warn("bullet/invalid-character-code", "`bullet.characterCode` should be a 4-digit unicode character (ex: 22AB)!");
+					bulletCode = "&#x2022;";
+				}
+				strXmlBullet = strXmlBulletSize + strXmlBulletFont + buChar(bulletCode);
+			} else strXmlBullet = strXmlBulletSize + strXmlBulletFont + buChar("&#x2022;");
+		} else if (opts.bullet === "inherit") {} else if (opts.bullet) {
+			defaultMarL = opts.indentLevel && opts.indentLevel > 0 ? bulletMarL + bulletMarL * opts.indentLevel : bulletMarL;
+			defaultIndent = -bulletMarL;
+			strXmlBullet = buChar("&#x2022;");
+		} else if (!opts.bullet) {
+			defaultMarL = 0;
+			defaultIndent = 0;
+			indentBeforeMarL = true;
+			strXmlBullet = voidEl("a:buNone");
+		}
+		const marLEmu = resolveParagraphMargin(opts.paraMarginLeft, defaultMarL, clampParaMarginEmu);
+		const indentEmu = resolveParagraphMargin(opts.paraIndent, defaultIndent, clampParaIndentEmu);
+		const marLAttr = marLEmu === null ? "" : ` marL="${marLEmu}"`;
+		const indentAttr = indentEmu === null ? "" : ` indent="${indentEmu}"`;
+		paragraphPropXml += indentBeforeMarL ? indentAttr + marLAttr : marLAttr + indentAttr;
+		if (opts.tabStops && Array.isArray(opts.tabStops)) strXmlTabStops = el("a:tabLst", null, raw(opts.tabStops.map((stop) => voidEl("a:tab", {
+			pos: inch2Emu(stop.position || 1),
+			algn: stop.alignment || "l"
+		})).join("")));
+		paragraphPropXml += ">" + strXmlLnSpc + strXmlParaSpc + strXmlBulletColor + strXmlBullet + strXmlTabStops;
+		if (isDefault) paragraphPropXml += genXmlTextRunProperties(opts, true);
+		paragraphPropXml += "</" + tag + ">";
+	}
+	return paragraphPropXml;
+}
+/**
+* Generate XML Text Run Properties (`a:rPr`)
+* @param {ObjectOptions|TextPropsOptions} opts - text options
+* @param {boolean} isDefault - whether these are the default text run properties
+* @return {string} XML
+*/
+function genXmlTextRunProperties(opts, isDefault) {
+	let runProps = "";
+	const runPropsTag = isDefault ? "a:defRPr" : "a:rPr";
+	const underline = typeof opts.underline === "object" && opts.underline?.style ? opts.underline.style : opts.hyperlink ? "sng" : null;
+	const baseline = opts.baseline ? Math.round(opts.baseline * 50) : opts.subscript ? -4e4 : opts.superscript ? 3e4 : null;
+	const attrs = {
+		lang: opts.lang ? opts.lang : "en-US",
+		altLang: opts.lang ? "en-US" : null,
+		sz: opts.fontSize ? clampFontSizeSz(opts.fontSize) : null,
+		b: opts?.bold ? "1" : null,
+		i: opts?.italic ? "1" : null,
+		strike: opts?.strike ? typeof opts.strike === "string" ? opts.strike : "sngStrike" : null,
+		cap: opts?.caps ? opts.caps : null,
+		u: underline,
+		baseline,
+		spc: opts.charSpacing ? clampCharSpacingSpc(opts.charSpacing) : null,
+		kern: opts.charSpacing ? 0 : null,
+		dirty: "0"
+	};
+	const hasShadow = !!opts.shadow && opts.shadow.type !== "none";
+	if (opts.color || opts.fontFace || opts.outline || opts.glow || hasShadow || typeof opts.underline === "object" && opts.underline.color) {
+		if (opts.outline && typeof opts.outline === "object") runProps += el("a:ln", { w: lineWidthToEmu(opts.outline.size || .75) }, raw(genXmlColorSelection(opts.outline.color || "FFFFFF")));
+		if (opts.color) runProps += genXmlColorSelection({
+			color: opts.color,
+			transparency: opts.transparency
+		});
+		if (opts.glow || hasShadow) runProps += el("a:effectLst", null, [opts.glow ? raw(createGlowElement(opts.glow, DEF_TEXT_GLOW)) : null, hasShadow ? raw(createShadowElement(opts.shadow, DEF_TEXT_SHADOW)) : null]);
+		if (opts.highlight) runProps += el("a:highlight", null, raw(createColorElement(opts.highlight)));
+		if (typeof opts.underline === "object" && opts.underline.color) runProps += el("a:uFill", null, raw(genXmlColorSelection(opts.underline.color)));
+		if (opts.fontFace) {
+			runProps += voidEl("a:latin", {
+				typeface: opts.fontFace,
+				pitchFamily: "34",
+				charset: "0"
+			});
+			if (opts.fontFaceEA) runProps += voidEl("a:ea", { typeface: opts.fontFaceEA });
+			runProps += voidEl("a:cs", { typeface: opts.fontFace });
+		}
+	}
+	if (opts.hyperlink) {
+		if (typeof opts.hyperlink !== "object") throw new InvalidOptionError("hyperlink/not-an-object", "text `hyperlink` option should be an object. Ex: `hyperlink:{url:'https://github.com'}` ");
+		else if (!opts.hyperlink.url && !opts.hyperlink.slide && !opts.hyperlink.action) throw new InvalidOptionError("hyperlink/missing-target", "text `hyperlink` requires either `url`, `slide`, or `action`");
+		else if (opts.hyperlink.url || opts.hyperlink.slide) {
+			const linkAttrs = opts.hyperlink.url ? {
+				"r:id": `rId${opts.hyperlink._rId}`,
+				invalidUrl: "",
+				action: "",
+				tgtFrame: "",
+				tooltip: opts.hyperlink.tooltip ?? "",
+				history: "1",
+				highlightClick: "0",
+				endSnd: "0"
+			} : {
+				"r:id": `rId${opts.hyperlink._rId}`,
+				action: "ppaction://hlinksldjump",
+				tooltip: opts.hyperlink.tooltip ?? ""
+			};
+			runProps += opts.color ? el("a:hlinkClick", linkAttrs, raw(HLINK_TEXT_COLOR_EXT)) : voidEl("a:hlinkClick", linkAttrs);
+		}
+	}
+	return el(runPropsTag, attrs, raw(runProps));
+}
+/**
+* Build textBody text runs [`<a:r></a:r>`] for paragraphs [`<a:p>`]
+* @param {TextProps} textObj - Text object
+* @return {string} XML string
+*/
+function genXmlTextRun(textObj) {
+	if (textObj.text === void 0 || textObj.text === null) return "";
+	return el("a:r", null, [raw(genXmlTextRunProperties(textObj.options ?? {}, false)), raw(el("a:t", null, String(textObj.text)))]);
+}
+/**
+* Builds `<a:normAutofit>` with explicit fontScale/lnSpcReduction for "shrink text on overflow"
+* @param {TextFitShrinkProps} fit - shrink fit options
+* @return {string} XML string (`<a:normAutofit .../>`)
+* @see ECMA-376 CT_TextNormAutofit (attributes in 1000ths of a percent)
+*/
+function genXmlNormAutofit(fit) {
+	const pct = (val, name) => {
+		if (val === void 0 || val === null) return null;
+		if (typeof val !== "number" || isNaN(val) || val < 0 || val > 100) {
+			warn("text/invalid-fit-percentage", `fit.${name} must be a number between 0 and 100 (percent); received ${String(val)} - attribute ignored.`);
+			return null;
+		}
+		return Math.round(val * FIXED_PCT_PER_PERCENT);
+	};
+	return voidEl("a:normAutofit", {
+		fontScale: pct(fit.fontScale, "fontScale"),
+		lnSpcReduction: pct(fit.lnSpcReduction, "lnSpcReduction")
+	});
+}
+/**
+* Group the flat run list into paragraphs (lines): a new line starts on a display-math run,
+* an alignment change, or a bullet, and closes after a breakLine. Returns the per-line run arrays.
+*/
+function groupRunsIntoLines(arrTextObjects, opts) {
+	const arrLines = [];
+	let arrTexts = [];
+	arrTextObjects.forEach((textObj, idx) => {
+		if (textObj.math && !textObj.inline) {
+			if (arrTexts.length > 0) {
+				arrLines.push(arrTexts);
+				arrTexts = [];
+			}
+			arrLines.push([textObj]);
+			return;
+		}
+		if (arrTexts.length > 0 && (textObj.options.align || opts.align)) {
+			if (textObj.options.align !== arrTextObjects[idx - 1]?.options.align) {
+				arrLines.push(arrTexts);
+				arrTexts = [];
+			}
+		} else if (arrTexts.length > 0 && emitsBulletMarkup(textObj.options.bullet)) {
+			arrLines.push(arrTexts);
+			arrTexts = [];
+			textObj.options.breakLine = false;
+		}
+		arrTexts.push(textObj);
+		if (arrTexts.length > 0 && textObj.options.breakLine) {
+			if (idx + 1 < arrTextObjects.length) {
+				arrLines.push(arrTexts);
+				arrTexts = [];
+			}
+		}
+		if (idx + 1 === arrTextObjects.length) arrLines.push(arrTexts);
+	});
+	return arrLines;
+}
+/**
+* Render each grouped line to an `<a:p>` paragraph: paragraph props, inherited run options,
+* text runs (and inline/display math), and the closing endParaRPr.
+*/
+function renderTextParagraphsXml(arrLines, slideObj, opts) {
+	let strSlideXml = "";
+	arrLines.forEach((line) => {
+		const firstRun = line[0];
+		if (line.length === 1 && firstRun?.math && !firstRun.inline) {
+			strSlideXml += genXmlMathParagraph(firstRun.math);
+			return;
+		}
+		let reqsClosingFontSize = false;
+		let paraXml = "";
+		let paragraphPropEmitted = false;
+		line.forEach((textObj, idx) => {
+			textObj.options._lineIdx = idx;
+			if (idx > 0 && textObj.options.softBreakBefore) paraXml += voidEl("a:br");
+			textObj.options.align = textObj.options.align || opts.align;
+			textObj.options.lineSpacing = textObj.options.lineSpacing || opts.lineSpacing;
+			textObj.options.lineSpacingMultiple = textObj.options.lineSpacingMultiple || opts.lineSpacingMultiple;
+			textObj.options.indentLevel = textObj.options.indentLevel || opts.indentLevel;
+			textObj.options.paraSpaceBefore = textObj.options.paraSpaceBefore || opts.paraSpaceBefore;
+			textObj.options.paraSpaceAfter = textObj.options.paraSpaceAfter || opts.paraSpaceAfter;
+			textObj.options.paraMarginLeft = textObj.options.paraMarginLeft ?? opts.paraMarginLeft;
+			textObj.options.paraIndent = textObj.options.paraIndent ?? opts.paraIndent;
+			if (!paragraphPropEmitted) {
+				paragraphPropEmitted = true;
+				paraXml += genXmlParagraphProperties(textObj, false).replace("<a:pPr></a:pPr>", "");
+			}
+			const textOptions = textObj.options;
+			Object.entries(opts).filter(([key]) => !(textObj.options.hyperlink && key === "color")).forEach(([key, val]) => {
+				if (key !== "bullet" && !textOptions[key]) textOptions[key] = val;
+			});
+			let _textRunObj = textObj;
+			if (idx === 0 && emitsBulletMarkup(line[0]?.options.bullet) && typeof textObj.text === "string") {
+				const _stripped = textObj.text.replace(/^[\u2022\u25E6\u25AA\u25AB\u25CF\u25CB\u2023\u2043\u2219]\s*/, "");
+				if (_stripped !== textObj.text) _textRunObj = {
+					text: _stripped,
+					options: textObj.options
+				};
+			}
+			const isEmptyBreakArtifact = _textRunObj.text === "" && line.length > 1;
+			if (_textRunObj.math) paraXml += genXmlInlineMath(_textRunObj.math);
+			else if (!isEmptyBreakArtifact) paraXml += genXmlTextRun(_textRunObj);
+			if (!textObj.text && opts.fontSize || textObj.options.fontSize) {
+				reqsClosingFontSize = true;
+				opts.fontSize = opts.fontSize || textObj.options.fontSize;
+			}
+		});
+		const sizedAttrs = () => ({
+			lang: opts.lang || "en-US",
+			sz: opts.fontSize ? clampFontSizeSz(opts.fontSize) : null,
+			dirty: "0"
+		});
+		if (slideObj._type === "tablecell" && (opts.fontSize || opts.fontFace)) {
+			if (opts.fontFace) paraXml += el("a:endParaRPr", sizedAttrs(), [
+				raw(voidEl("a:latin", {
+					typeface: opts.fontFace,
+					charset: "0"
+				})),
+				opts.fontFaceEA ? raw(voidEl("a:ea", { typeface: opts.fontFaceEA })) : null,
+				raw(voidEl("a:cs", { typeface: opts.fontFace }))
+			]);
+			else paraXml += voidEl("a:endParaRPr", sizedAttrs());
+		} else if (reqsClosingFontSize) paraXml += voidEl("a:endParaRPr", sizedAttrs());
+		else paraXml += voidEl("a:endParaRPr", {
+			lang: opts.lang || "en-US",
+			dirty: "0"
+		});
+		strSlideXml += el("a:p", null, raw(paraXml));
+	});
+	return strSlideXml;
+}
+//#endregion
+//#region src/gen/slide/notes.ts
+/**
+* Collect the speaker-notes runs for a slide (flattened across any number of `addNotes()` calls).
+* @param {PresSlideInternal} slide - the slide object
+* @return {TextProps[]} notes text runs in document order
+*/
+function getNotesRuns(slide) {
+	const runs = [];
+	slide._slideObjects.forEach((obj) => {
+		if (obj._type === "notes" && obj.text) runs.push(...obj.text);
+	});
+	return runs;
+}
+/**
+* Build (and cache) the hyperlink relationships for a slide's notes part (`notesSlideN.xml.rels`).
+*
+* Notes rels use their own namespace, independent of `slide._rels` (which serialize to
+* `slideN.xml.rels`). The notes part always reserves rId1=notesMaster and rId2=slide, so
+* dynamic hyperlink rels are allocated starting at rId3. Each notes hyperlink run is tagged
+* with its `_rId` so the body serializer and the rels file agree.
+*
+* Idempotent: the result is cached on `slide._relsNotes` and reused by both callers.
+* Only external `url` hyperlinks are supported; `slide` targets are ignored with a warning.
+* @param {PresSlideInternal} slide - the slide object
+* @return {SlideRel[]} notes hyperlink relationships
+*/
+function buildNotesSlideRels(slide) {
+	if (slide._relsNotes) return slide._relsNotes;
+	const NOTES_REL_RESERVED = 2;
+	const rels = [];
+	let lastRid = NOTES_REL_RESERVED;
+	getNotesRuns(slide).forEach((run) => {
+		const hyperlink = run.options?.hyperlink;
+		if (!hyperlink) return;
+		if (!hyperlink.url) {
+			if (hyperlink.slide) warn("notes/hyperlink-slide-unsupported", "notes hyperlinks support `url` only (ignoring `slide` target)");
+			if (run.options) delete run.options.hyperlink;
+			return;
+		}
+		lastRid++;
+		hyperlink._rId = lastRid;
+		rels.push({
+			type: "hyperlink",
+			data: "dummy",
+			rId: lastRid,
+			Target: hyperlink.url
+		});
+	});
+	slide._relsNotes = rels;
+	return rels;
+}
+/**
+* Build the `<p:txBody>` paragraphs for the notes placeholder.
+* Runs are split into `<a:p>` paragraphs on newlines; each run is serialized with the standard
+* text-run generator so inline formatting and `<a:hlinkClick>` markup are emitted consistently.
+* @param {PresSlideInternal} slide - the slide object
+* @return {string} XML string of `<a:p>` paragraphs
+*/
+function genXmlNotesParagraphs(slide) {
+	const paragraphs = [[]];
+	getNotesRuns(slide).forEach((run) => {
+		String(run.text ?? "").split("\n").forEach((segment, idx) => {
+			if (idx > 0) paragraphs.push([]);
+			const text = segment.replace(/\r/g, "");
+			if (text !== "") paragraphs[paragraphs.length - 1]?.push({
+				text,
+				options: run.options || {}
+			});
+		});
+	});
+	return paragraphs.map((runs) => el("a:p", null, [raw(runs.map((run) => genXmlTextRun(run)).join("")), raw(voidEl("a:endParaRPr", {
+		lang: "en-US",
+		dirty: 0
+	}))])).join("");
+}
+/**
+* Generate XML for Notes Master (notesMaster1.xml)
+* @returns {string} XML
+*/
+function makeXmlNotesMaster() {
+	const xfrmOffExt = (x, y, cx, cy) => el("a:xfrm", null, [raw(voidEl("a:off", {
+		x,
+		y
+	})), raw(voidEl("a:ext", {
+		cx,
+		cy
+	}))]);
+	const prstGeomRect = el("a:prstGeom", { prst: "rect" }, raw(voidEl("a:avLst")));
+	const spLocks = (attrs) => el("p:cNvSpPr", null, raw(voidEl("a:spLocks", attrs)));
+	const nvPr = (phAttrs) => el("p:nvPr", null, raw(voidEl("p:ph", phAttrs)));
+	const bodyPr = (attrs) => voidEl("a:bodyPr", attrs);
+	const lstStyleLvl1 = (algn) => el("a:lstStyle", null, raw(el("a:lvl1pPr", { algn }, raw(voidEl("a:defRPr", { sz: 1200 })))));
+	const emptyPara = el("a:p", null, raw(voidEl("a:endParaRPr", { lang: "en-US" })));
+	const header = el("p:sp", null, [
+		raw(el("p:nvSpPr", null, [
+			raw(voidEl("p:cNvPr", {
+				id: 2,
+				name: "Header Placeholder 1"
+			})),
+			raw(spLocks({ noGrp: 1 })),
+			raw(nvPr({
+				type: "hdr",
+				sz: "quarter"
+			}))
+		])),
+		raw(el("p:spPr", null, [raw(xfrmOffExt(0, 0, 2971800, 458788)), raw(prstGeomRect)])),
+		raw(el("p:txBody", null, [
+			raw(bodyPr({
+				vert: "horz",
+				lIns: 91440,
+				tIns: 45720,
+				rIns: 91440,
+				bIns: 45720,
+				rtlCol: 0
+			})),
+			raw(lstStyleLvl1("l")),
+			raw(emptyPara)
+		]))
+	]);
+	const date = el("p:sp", null, [
+		raw(el("p:nvSpPr", null, [
+			raw(voidEl("p:cNvPr", {
+				id: 3,
+				name: "Date Placeholder 2"
+			})),
+			raw(spLocks({ noGrp: 1 })),
+			raw(nvPr({
+				type: "dt",
+				idx: 1
+			}))
+		])),
+		raw(el("p:spPr", null, [raw(xfrmOffExt(3884613, 0, 2971800, 458788)), raw(prstGeomRect)])),
+		raw(el("p:txBody", null, [
+			raw(bodyPr({
+				vert: "horz",
+				lIns: 91440,
+				tIns: 45720,
+				rIns: 91440,
+				bIns: 45720,
+				rtlCol: 0
+			})),
+			raw(lstStyleLvl1("r")),
+			raw(el("a:p", null, [raw(el("a:fld", {
+				id: "{5282F153-3F37-0F45-9E97-73ACFA13230C}",
+				type: "datetimeFigureOut"
+			}, [raw(voidEl("a:rPr", { lang: "en-US" })), raw(el("a:t", null, "7/23/19"))])), raw(voidEl("a:endParaRPr", { lang: "en-US" }))]))
+		]))
+	]);
+	const slideImg = el("p:sp", null, [
+		raw(el("p:nvSpPr", null, [
+			raw(voidEl("p:cNvPr", {
+				id: 4,
+				name: "Slide Image Placeholder 3"
+			})),
+			raw(spLocks({
+				noGrp: 1,
+				noRot: 1,
+				noChangeAspect: 1
+			})),
+			raw(nvPr({
+				type: "sldImg",
+				idx: 2
+			}))
+		])),
+		raw(el("p:spPr", null, [
+			raw(xfrmOffExt(685800, 1143e3, 5486400, 3086100)),
+			raw(prstGeomRect),
+			raw(voidEl("a:noFill")),
+			raw(el("a:ln", { w: 12700 }, raw(el("a:solidFill", null, raw(voidEl("a:prstClr", { val: "black" }))))))
+		])),
+		raw(el("p:txBody", null, [
+			raw(bodyPr({
+				vert: "horz",
+				lIns: 91440,
+				tIns: 45720,
+				rIns: 91440,
+				bIns: 45720,
+				rtlCol: 0,
+				anchor: "ctr"
+			})),
+			raw(voidEl("a:lstStyle")),
+			raw(emptyPara)
+		]))
+	]);
+	const notesPlaceholder = el("p:sp", null, [
+		raw(el("p:nvSpPr", null, [
+			raw(voidEl("p:cNvPr", {
+				id: 5,
+				name: "Notes Placeholder 4"
+			})),
+			raw(spLocks({ noGrp: 1 })),
+			raw(nvPr({
+				type: "body",
+				sz: "quarter",
+				idx: 3
+			}))
+		])),
+		raw(el("p:spPr", null, [raw(xfrmOffExt(685800, 4400550, 5486400, 3600450)), raw(prstGeomRect)])),
+		raw(el("p:txBody", null, [
+			raw(bodyPr({
+				vert: "horz",
+				lIns: 91440,
+				tIns: 45720,
+				rIns: 91440,
+				bIns: 45720,
+				rtlCol: 0
+			})),
+			raw(voidEl("a:lstStyle")),
+			raw([
+				"Click to edit Master text styles",
+				"Second level",
+				"Third level",
+				"Fourth level",
+				"Fifth level"
+			].map((text, lvl) => el("a:p", null, [raw(voidEl("a:pPr", { lvl })), raw(el("a:r", null, [raw(voidEl("a:rPr", { lang: "en-US" })), raw(el("a:t", null, text))]))])).join(""))
+		]))
+	]);
+	const footer = el("p:sp", null, [
+		raw(el("p:nvSpPr", null, [
+			raw(voidEl("p:cNvPr", {
+				id: 6,
+				name: "Footer Placeholder 5"
+			})),
+			raw(spLocks({ noGrp: 1 })),
+			raw(nvPr({
+				type: "ftr",
+				sz: "quarter",
+				idx: 4
+			}))
+		])),
+		raw(el("p:spPr", null, [raw(xfrmOffExt(0, 8685213, 2971800, 458787)), raw(prstGeomRect)])),
+		raw(el("p:txBody", null, [
+			raw(bodyPr({
+				vert: "horz",
+				lIns: 91440,
+				tIns: 45720,
+				rIns: 91440,
+				bIns: 45720,
+				rtlCol: 0,
+				anchor: "b"
+			})),
+			raw(lstStyleLvl1("l")),
+			raw(emptyPara)
+		]))
+	]);
+	const slideNum = el("p:sp", null, [
+		raw(el("p:nvSpPr", null, [
+			raw(voidEl("p:cNvPr", {
+				id: 7,
+				name: "Slide Number Placeholder 6"
+			})),
+			raw(spLocks({ noGrp: 1 })),
+			raw(nvPr({
+				type: "sldNum",
+				sz: "quarter",
+				idx: 5
+			}))
+		])),
+		raw(el("p:spPr", null, [raw(xfrmOffExt(3884613, 8685213, 2971800, 458787)), raw(prstGeomRect)])),
+		raw(el("p:txBody", null, [
+			raw(bodyPr({
+				vert: "horz",
+				lIns: 91440,
+				tIns: 45720,
+				rIns: 91440,
+				bIns: 45720,
+				rtlCol: 0,
+				anchor: "b"
+			})),
+			raw(lstStyleLvl1("r")),
+			raw(el("a:p", null, [raw(el("a:fld", {
+				id: "{CE5E9CC1-C706-0F49-92D6-E571CC5EEA8F}",
+				type: "slidenum"
+			}, [raw(voidEl("a:rPr", { lang: "en-US" })), raw(el("a:t", null, "‹#›"))])), raw(voidEl("a:endParaRPr", { lang: "en-US" }))]))
+		]))
+	]);
+	const spTree = el("p:spTree", null, [
+		raw(el("p:nvGrpSpPr", null, [
+			raw(voidEl("p:cNvPr", {
+				id: 1,
+				name: ""
+			})),
+			raw(voidEl("p:cNvGrpSpPr")),
+			raw(voidEl("p:nvPr"))
+		])),
+		raw(el("p:grpSpPr", null, raw(el("a:xfrm", null, [
+			raw(voidEl("a:off", {
+				x: 0,
+				y: 0
+			})),
+			raw(voidEl("a:ext", {
+				cx: 0,
+				cy: 0
+			})),
+			raw(voidEl("a:chOff", {
+				x: 0,
+				y: 0
+			})),
+			raw(voidEl("a:chExt", {
+				cx: 0,
+				cy: 0
+			}))
+		])))),
+		raw(header),
+		raw(date),
+		raw(slideImg),
+		raw(notesPlaceholder),
+		raw(footer),
+		raw(slideNum)
+	]);
+	const extLst = el("p:extLst", null, raw(el("p:ext", { uri: "{BB962C8B-B14F-4D97-AF65-F5344CB8AC3E}" }, raw(voidEl("p14:creationId", {
+		"xmlns:p14": "http://schemas.microsoft.com/office/powerpoint/2010/main",
+		val: 1024086991
+	})))));
+	const cSld = el("p:cSld", null, [
+		raw(el("p:bg", null, raw(el("p:bgRef", { idx: 1001 }, raw(voidEl("a:schemeClr", { val: "bg1" })))))),
+		raw(spTree),
+		raw(extLst)
+	]);
+	const clrMap = voidEl("p:clrMap", {
+		bg1: "lt1",
+		tx1: "dk1",
+		bg2: "lt2",
+		tx2: "dk2",
+		accent1: "accent1",
+		accent2: "accent2",
+		accent3: "accent3",
+		accent4: "accent4",
+		accent5: "accent5",
+		accent6: "accent6",
+		hlink: "hlink",
+		folHlink: "folHlink"
+	});
+	const notesStyleLevel = (n, marL) => el(`a:lvl${n}pPr`, {
+		marL,
+		algn: "l",
+		defTabSz: 914400,
+		rtl: 0,
+		eaLnBrk: 1,
+		latinLnBrk: 0,
+		hangingPunct: 1
+	}, raw(el("a:defRPr", {
+		sz: 1200,
+		kern: 1200
+	}, [
+		raw(el("a:solidFill", null, raw(voidEl("a:schemeClr", { val: "tx1" })))),
+		raw(voidEl("a:latin", { typeface: "+mn-lt" })),
+		raw(voidEl("a:ea", { typeface: "+mn-ea" })),
+		raw(voidEl("a:cs", { typeface: "+mn-cs" }))
+	])));
+	const notesStyle = el("p:notesStyle", null, raw([
+		0,
+		457200,
+		914400,
+		1371600,
+		1828800,
+		2286e3,
+		2743200,
+		3200400,
+		3657600
+	].map((marL, i) => notesStyleLevel(i + 1, marL)).join("")));
+	return XML_DECL + "\r\n" + el("p:notesMaster", {
+		"xmlns:a": "http://schemas.openxmlformats.org/drawingml/2006/main",
+		"xmlns:r": "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+		"xmlns:p": "http://schemas.openxmlformats.org/presentationml/2006/main"
+	}, [
+		raw(cSld),
+		raw(clrMap),
+		raw(notesStyle)
+	]);
+}
+/**
+* Creates Notes Slide (`ppt/notesSlides/notesSlide1.xml`)
+* @param {PresSlideInternal} slide - the slide object to transform into XML
+* @return {string} XML
+*/
+function makeXmlNotesSlide(slide) {
+	buildNotesSlideRels(slide);
+	return makeXmlNotesSlideSkeleton(genXmlNotesParagraphs(slide), slide._slideNum);
+}
+/**
+* The notes slide's fixed frame, with the only two slide-dependent strings passed in.
+*
+* A notes slide is the same three placeholders every time — the thumbnail (`sldImg`),
+* the notes body, and the slide-number field — so everything except the body's
+* paragraphs and the cached slide number is a constant. It is a parameter of its own
+* because the read model authors notes onto a *loaded* deck (`Slide.addNotes`), where
+* there is no `PresSlideInternal` to serialize but the part must come out identical:
+* a second private copy of this frame is exactly the drift `src/ooxml/` exists to
+* prevent (see docs/architecture.md).
+* @param {string} bodyParagraphsXml - `a:p` children of the body placeholder's `p:txBody`
+* @param {number} slideNum - cached value of the slide-number `a:fld`
+* @return {string} XML
+*/
+function makeXmlNotesSlideSkeleton(bodyParagraphsXml, slideNum) {
+	const slideImgPh = el("p:sp", null, [raw(el("p:nvSpPr", null, [
+		raw(voidEl("p:cNvPr", {
+			id: 2,
+			name: "Slide Image Placeholder 1"
+		})),
+		raw(el("p:cNvSpPr", null, raw(voidEl("a:spLocks", {
+			noGrp: 1,
+			noRot: 1,
+			noChangeAspect: 1
+		})))),
+		raw(el("p:nvPr", null, raw(voidEl("p:ph", { type: "sldImg" }))))
+	])), raw(voidEl("p:spPr"))]);
+	const notesPh = el("p:sp", null, [
+		raw(el("p:nvSpPr", null, [
+			raw(voidEl("p:cNvPr", {
+				id: 3,
+				name: "Notes Placeholder 2"
+			})),
+			raw(el("p:cNvSpPr", null, raw(voidEl("a:spLocks", { noGrp: 1 })))),
+			raw(el("p:nvPr", null, raw(voidEl("p:ph", {
+				type: "body",
+				idx: 1
+			}))))
+		])),
+		raw(voidEl("p:spPr")),
+		raw(el("p:txBody", null, [
+			raw(voidEl("a:bodyPr")),
+			raw(voidEl("a:lstStyle")),
+			raw(bodyParagraphsXml)
+		]))
+	]);
+	const slideNumPh = el("p:sp", null, [
+		raw(el("p:nvSpPr", null, [
+			raw(voidEl("p:cNvPr", {
+				id: 4,
+				name: "Slide Number Placeholder 3"
+			})),
+			raw(el("p:cNvSpPr", null, raw(voidEl("a:spLocks", { noGrp: 1 })))),
+			raw(el("p:nvPr", null, raw(voidEl("p:ph", {
+				type: "sldNum",
+				sz: "quarter",
+				idx: 10
+			}))))
+		])),
+		raw(voidEl("p:spPr")),
+		raw(el("p:txBody", null, [
+			raw(voidEl("a:bodyPr")),
+			raw(voidEl("a:lstStyle")),
+			raw(el("a:p", null, [raw(el("a:fld", {
+				id: SLDNUMFLDID,
+				type: "slidenum"
+			}, [raw(voidEl("a:rPr", { lang: "en-US" })), raw(el("a:t", null, slideNum))])), raw(voidEl("a:endParaRPr", { lang: "en-US" }))]))
+		]))
+	]);
+	const spTree = el("p:spTree", null, [
+		raw(el("p:nvGrpSpPr", null, [
+			raw(voidEl("p:cNvPr", {
+				id: 1,
+				name: ""
+			})),
+			raw(voidEl("p:cNvGrpSpPr")),
+			raw(voidEl("p:nvPr"))
+		])),
+		raw(el("p:grpSpPr", null, raw(el("a:xfrm", null, [
+			raw(voidEl("a:off", {
+				x: 0,
+				y: 0
+			})),
+			raw(voidEl("a:ext", {
+				cx: 0,
+				cy: 0
+			})),
+			raw(voidEl("a:chOff", {
+				x: 0,
+				y: 0
+			})),
+			raw(voidEl("a:chExt", {
+				cx: 0,
+				cy: 0
+			}))
+		])))),
+		raw(slideImgPh),
+		raw(notesPh),
+		raw(slideNumPh)
+	]);
+	const extLst = el("p:extLst", null, raw(el("p:ext", { uri: "{BB962C8B-B14F-4D97-AF65-F5344CB8AC3E}" }, raw(voidEl("p14:creationId", {
+		"xmlns:p14": "http://schemas.microsoft.com/office/powerpoint/2010/main",
+		val: 1024086991
+	})))));
+	const cSld = el("p:cSld", null, [raw(spTree), raw(extLst)]);
+	return XML_DECL + "\r\n" + el("p:notes", {
+		"xmlns:a": "http://schemas.openxmlformats.org/drawingml/2006/main",
+		"xmlns:r": "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+		"xmlns:p": "http://schemas.openxmlformats.org/presentationml/2006/main"
+	}, [raw(cSld), raw(el("p:clrMapOvr", null, raw(voidEl("a:masterClrMapping"))))]);
+}
+/**
+* Generates XML string for a notes-slide relation file (`ppt/notesSlides/_rels/notesSlideN.xml.rels`).
+* rId1=notesMaster and rId2=slide are always reserved; any notes hyperlink rels follow (rId3+).
+* @param {PresSlideInternal} slide - the slide whose notes part is being related
+* @param {number} slideNumber - 1-indexed slide number the notes part belongs to
+* @return {string} XML
+*/
+function makeXmlNotesSlideRel(slide, slideNumber) {
+	const hlinkRels = buildNotesSlideRels(slide).map((rel) => voidEl("Relationship", {
+		Id: `rId${rel.rId}`,
+		Type: OFFICE_REL + "hyperlink",
+		Target: rel.Target,
+		TargetMode: "External"
+	})).join("");
+	return XML_DECL + el("Relationships", { xmlns: PACKAGE_REL_NS }, [
+		raw(voidEl("Relationship", {
+			Id: "rId1",
+			Type: OFFICE_REL + "notesMaster",
+			Target: "../notesMasters/notesMaster1.xml"
+		})),
+		raw(voidEl("Relationship", {
+			Id: "rId2",
+			Type: OFFICE_REL + "slide",
+			Target: `../slides/slide${slideNumber}.xml`
+		})),
+		raw(hlinkRels)
+	], {
+		openPrefix: "\n		",
+		childPrefix: "\n			",
+		closePrefix: ""
+	});
+}
+/**
+* Creates `ppt/notesMasters/_rels/notesMaster1.xml.rels`
+* @return {string} XML
+*/
+function makeXmlNotesMasterRel() {
+	return XML_DECL + "\r\n" + el("Relationships", { xmlns: PACKAGE_REL_NS }, raw(voidEl("Relationship", {
+		Id: "rId1",
+		Type: OFFICE_REL + "theme",
+		Target: "../theme/theme2.xml"
+	})), {
+		childPrefix: "\n		",
+		closePrefix: "\n		"
+	});
+}
+//#endregion
+export { getNewRelId as A, createColorElement as C, encodeXmlAttrValue as D, voidEl as E, isHyperlinkRel as M, validateObjectName as N, encodeXmlEntities as O, createShadowEffectLst as S, raw as T, FONT_DATA_EXTENSION as _, makeXmlNotesSlideRel as a, serializeEmbeddedFontLst as b, genXmlParagraphProperties as c, clampFontSizeSz as d, genXmlColorSelection as f, FONT_DATA_CONTENT_TYPE as g, EMBEDDED_FONT_SLOTS as h, makeXmlNotesSlide as i, getUuid as j, getDuplicateObjectNames as k, groupRunsIntoLines as l, genXmlPatternFill as m, makeXmlNotesMaster as n, makeXmlNotesSlideSkeleton as o, genXmlGradientFill as p, makeXmlNotesMasterRel as r, genXmlNormAutofit as s, buildNotesSlideRels as t, renderTextParagraphsXml as u, FONT_REL_TYPE as v, el as w, correctShadowOptions as x, flattenEmbeddedFaces as y };
+
+//# sourceMappingURL=notes-SCvpJz0l.js.map