@shbernal/ts-pptx 3.4.0 → 3.5.0

package/dist/{shapes-Dyw5bxwO.js → shapes-Kt51vry6.js}

@@ -1,6 +1,6 @@
 import { r as warn } from "./diagnostics-CPVADSL1.js";
 import { i as PackageReadError, n as InvalidOptionError, o as UnsupportedFeatureError, t as InternalError } from "./errors-Bvln0H-7.js";
-import { A as TEXT_ANCHORS, M as TEXT_VERTICAL, N as checkEnumOrThrow, _ as THEME_REL, a as NOTES_MASTER_REL, b as getImageSizeFromBytes, c as OFFICE_DOCUMENT_REL, f as SLIDE_LAYOUT_REL, j as TEXT_HORZ_OVERFLOW, m as SLIDE_MASTER_REL, r as IMAGE_REL, t as OOXML_NS, v as fitSrcRectPercents } from "./namespaces-Sy_m7Nhd.js";
+import { M as TEXT_HORZ_OVERFLOW, N as TEXT_VERTICAL, P as checkEnumOrThrow, a as NOTES_MASTER_REL, c as OFFICE_DOCUMENT_REL, h as SLIDE_MASTER_REL, j as TEXT_ANCHORS, p as SLIDE_LAYOUT_REL, r as IMAGE_REL, t as OOXML_NS, v as THEME_REL, x as getImageSizeFromBytes, y as fitSrcRectPercents } from "./namespaces-CcKuzeuE.js";
 import { DOMParser, MIME_TYPE, XMLSerializer, onErrorStopParsing } from "@xmldom/xmldom";
 /** Parse an XML string strictly: any well-formedness error throws. */
 function parseXml(xml) {
@@ -2529,6 +2529,16 @@ var Paragraph = class {
 		}
 		return out;
 	}
+	/**
+	* Replace **this paragraph's** content with a single run, preserving the character
+	* formatting (`a:rPr`) of its first existing run and leaving its `a:pPr` (level,
+	* alignment, bullet) alone. Sibling paragraphs are untouched — the difference from
+	* {@link TextFrame.text}, which collapses the whole body to one paragraph.
+	*/
+	set text(value) {
+		setParagraphText(this.element, value);
+		this.part.markDirty();
+	}
 	/** Escape hatch: the underlying `a:p` element. After mutating it call {@link markDirty}, or `save()` writes the original bytes. */
 	get element_() {
 		return this.element;
@@ -2672,8 +2682,6 @@ function setTextBodyText(txBody, value) {
 	const doc = txBody.ownerDocument;
 	if (!doc) throw new InternalError("oxml/node-has-no-document", "Cannot set text: text body has no owner document");
 	const paragraphs = getElements(txBody, "a:p");
-	const firstRun = paragraphs[0] && firstChild(paragraphs[0], "a:r");
-	const rPrTemplate = firstRun && firstChild(firstRun, "a:rPr");
 	for (let i = paragraphs.length - 1; i >= 1; i--) {
 		const extra = paragraphs[i];
 		if (extra) txBody.removeChild(extra);
@@ -2683,6 +2691,21 @@ function setTextBodyText(txBody, value) {
 		p = createElement(doc, "a:p");
 		txBody.appendChild(p);
 	}
+	setParagraphText(p, value);
+}
+/**
+* Replace **one paragraph's** content with a single run, preserving the `a:rPr` of that
+* paragraph's first existing run and leaving its `a:pPr` (level, alignment, bullet) alone.
+* Sibling paragraphs are untouched, which is the whole difference from
+* {@link setTextBodyText} and the reason this exists: a SmartArt drawing cache packs several
+* nodes' text into one `dsp:txBody`, so collapsing the body there would delete the other
+* nodes' strings. Does **not** mark any part dirty — the caller owns the `Part`.
+*/
+function setParagraphText(p, value) {
+	const doc = p.ownerDocument;
+	if (!doc) throw new InternalError("oxml/node-has-no-document", "Cannot set text: paragraph has no owner document");
+	const firstRun = firstChild(p, "a:r");
+	const rPrTemplate = firstRun && firstChild(firstRun, "a:rPr");
 	for (const child of childElements(p)) if (child.localName === "r" || child.localName === "br" || child.localName === "fld") p.removeChild(child);
 	const run = createElement(doc, "a:r");
 	if (rPrTemplate) run.appendChild(rPrTemplate.cloneNode(true));
@@ -4468,6 +4491,55 @@ function floatValue(value) {
 }
 //#endregion
 //#region src/read/api/diagram.ts
+/**
+* Read proxies for a SmartArt diagram (`dgm:dataModel`) hosted in a `p:graphicFrame`.
+*
+* SmartArt is a four-part construct, and the frame itself holds none of it: the
+* `a:graphicData` carries only a `dgm:relIds` with four relationship ids pointing at the
+* data, layout, quick-style and colours parts under `/ppt/diagrams/`. The **data** part is
+* the one with content in it — a flat `dgm:ptLst` of points plus a `dgm:cxnLst` of
+* connections that give the points their tree — and it is what this surface decodes. The
+* other three are generated presets (`urn:microsoft.com/office/officeart/…`) describing how
+* PowerPoint *draws* the graph rather than what it says; they surface as parts, not getters.
+*
+* The text is ordinary DrawingML: `dgm:pt/dgm:t` is an `a:CT_TextBody`, the same type a
+* shape's `p:txBody` is, so a point's text reads back through the same
+* {@link TextFrame}/`Paragraph`/`Run` proxies as any other text on the slide, run formatting
+* included.
+*
+* **Not every point is content.** A saved data model interleaves the user's nodes with
+* points the layout engine generated (`pres`), the diagram root (`doc`), and the transition
+* points sitting on each edge (`parTrans`/`sibTrans`, which carry text only where a layout
+* labels its arrows). {@link Diagram.text} applies exactly that filter; {@link Diagram.points}
+* applies none, so a consumer that needs the raw graph gets it.
+*
+* **The structure is in the connections, and {@link Diagram.nodes} is the view of it.** A
+* `parOf` edge names the parent in `@srcId`, the child in `@destId` and the child's sibling
+* position in `@srcOrd`; `points` order is document order and says nothing about depth. Three
+* decisions that tree makes, each of which could defensibly have gone the other way:
+*
+* - **`asst` points are in it.** An assistant is user content, and an org chart merely draws
+*   it off the main branch rather than under it. {@link DiagramPoint.type} carries the
+*   distinction, so folding it silently in with `node` would hide something a consumer can
+*   act on while omitting it would lose authored text.
+* - **Transition points are not.** A `parTrans`/`sibTrans` labels an *edge*, not a node, and
+*   reaches its edge through {@link DiagramConnection.parentTransitionId} /
+*   `siblingTransitionId`. Hanging one off `children` would make the tree disagree with what
+*   PowerPoint's own text pane shows.
+* - **A cycle in `parOf` throws.** It is a corrupt model rather than a shape the format can
+*   express, and the walk would not terminate; see `diagram/parent-edge-cycle`.
+*
+* **A point's text is stored twice.** The data model is what PowerPoint reads, but a deck
+* also carries a *drawing* part (`dsp:drawing`) holding a copy of every drawn string, and
+* every renderer without a SmartArt layout engine — LibreOffice, Google Slides, thumbnailers
+* — paints that copy and nothing else. {@link DiagramPoint.drawnShape} is the link between
+* the two, and {@link DiagramPoint.text}'s setter is what keeps them in step.
+*
+* Authoring a SmartArt graphic from nothing is out of scope: the layout part is a
+* constraint-solver program PowerPoint executes, and the presentation tree it generates is
+* not derivable from the user's content. Editing the text of one that already exists is
+* supported — see {@link DiagramPoint.text}.
+*/
 const POINT_TYPES = [
 	"node",
 	"asst",
@@ -4484,17 +4556,100 @@ const CONNECTION_TYPES = [
 ];
 /** The MS extension (`dgm:extLst/a:ext`) whose `@relId` names the fallback drawing part. */
 const DRAWING_EXT_URI = "http://schemas.microsoft.com/office/drawing/2008/diagram";
+/**
+* The node → drawn-shape index of one diagram: the `presOf` edges of the data model and the
+* `dsp:sp` elements of the drawing part, both keyed for lookup.
+*
+* Built once per {@link Diagram}, and only when a point is actually asked what draws it — the
+* drawing part is a second XML DOM and a consumer reading node text should not pay to parse
+* it. The consequence of that memo: a consumer who *adds* or *removes* shapes in the drawing
+* part through the escape hatches must re-reach the diagram to see them here.
+*/
+var DrawingIndex = class {
+	drawingPart;
+	themeContext;
+	/** `presOf` arms out of each source point, in `@srcOrd` order. */
+	#arms = /* @__PURE__ */ new Map();
+	/** Each `dsp:sp` by the `pres` modelId it draws. */
+	#shapes = /* @__PURE__ */ new Map();
+	constructor(root, drawingPart, themeContext) {
+		this.drawingPart = drawingPart;
+		this.themeContext = themeContext;
+		const cxnLst = root && firstChild(root, "dgm:cxnLst");
+		for (const cxn of cxnLst ? getElements(cxnLst, "dgm:cxn") : []) {
+			if (attr(cxn, "type") !== "presOf") continue;
+			const srcId = attr(cxn, "srcId");
+			const destId = attr(cxn, "destId");
+			if (!srcId || !destId) continue;
+			const arm = {
+				destId,
+				destinationOrder: intValue(attr(cxn, "destOrd")) ?? 0,
+				sourceOrder: intValue(attr(cxn, "srcOrd")) ?? 0
+			};
+			const list = this.#arms.get(srcId);
+			if (list) list.push(arm);
+			else this.#arms.set(srcId, [arm]);
+		}
+		for (const list of this.#arms.values()) list.sort((a, b) => a.sourceOrder - b.sourceOrder);
+		const drawingRoot = drawingPart?.dom.documentElement ?? null;
+		for (const sp of drawingRoot ? descendantsByTag(drawingRoot, OOXML_NS.dsp, "sp") : []) {
+			const modelId = attr(sp, "modelId");
+			if (modelId !== null && !this.#shapes.has(modelId)) this.#shapes.set(modelId, sp);
+		}
+	}
+	/**
+	* Resolve one authored point to the `pres` point that presents it and to the drawn
+	* paragraph carrying its text.
+	*
+	* A point commonly has **several** `presOf` arms — an org-chart node's box and the
+	* connector beneath it are two presentations of one node — so the arm is chosen by what it
+	* reaches rather than by its `@srcOrd`: the first, in `@srcOrd` order, whose `pres` point
+	* draws a `dsp:sp` that has a `dsp:txBody`. That selector produced a unique hit for all 90
+	* authored points measured across five layout families, and it degrades to "no arm" rather
+	* than to "the wrong arm" on a layout that was not.
+	*/
+	resolve(modelId) {
+		const arms = (modelId === null ? void 0 : this.#arms.get(modelId)) ?? [];
+		const first = arms[0];
+		if (!first) return {
+			presentationId: null,
+			drawnShape: null
+		};
+		for (const arm of arms) {
+			const sp = this.#shapes.get(arm.destId);
+			const txBody = sp && firstChild(sp, "dsp:txBody");
+			if (!sp || !txBody || !this.drawingPart) continue;
+			const paragraph = getElements(txBody, "a:p")[arm.destinationOrder];
+			return {
+				presentationId: arm.destId,
+				drawnShape: paragraph ? {
+					part: this.drawingPart,
+					modelId: arm.destId,
+					paragraphIndex: arm.destinationOrder,
+					textFrame: new TextFrame(txBody, this.drawingPart, this.themeContext),
+					element_: sp
+				} : null
+			};
+		}
+		return {
+			presentationId: first.destId,
+			drawnShape: null
+		};
+	}
+};
 /** One point (`dgm:pt`) of a diagram's data model. */
 var DiagramPoint = class {
 	pt;
 	part;
 	themeContext;
 	relationships;
-	constructor(pt, part, themeContext, relationships) {
+	drawing;
+	constructor(pt, part, themeContext, relationships, drawing) {
 		this.pt = pt;
 		this.part = part;
 		this.themeContext = themeContext;
 		this.relationships = relationships;
+		this.drawing = drawing;
 	}
 	/** This point's id (`@modelId`), which connections reference. */
 	get modelId() {
@@ -4530,15 +4685,87 @@ var DiagramPoint = class {
 	* This point's text body (`dgm:t`) as a {@link TextFrame}, or `null` when the point
 	* carries none. It is an `a:CT_TextBody` like any other, so `paragraphs`, `runs` and the
 	* `resolved*` getters all apply.
+	*
+	* **Writing through this edits the data model only**, and leaves the drawing cache
+	* holding the old string — which is what PowerPoint-less renderers draw. It is the escape
+	* hatch for run-level formatting, so it does exactly what it is told and nothing more;
+	* {@link text}'s setter is the path that mirrors.
 	*/
 	get textFrame() {
 		const t = firstChild(this.pt, "dgm:t");
 		return t ? new TextFrame(t, this.part, this.themeContext, void 0, this.relationships) : null;
 	}
+	/**
+	* The generated `pres` point that presents this one (`dgm:cxn[@type="presOf"]/@destId`),
+	* or `null` when nothing presents it — the normal state of an unlabelled transition point.
+	*
+	* Where a point has several `presOf` arms the one named here is the arm that draws text;
+	* see {@link drawnShape}, which resolves both.
+	*/
+	get presentationId() {
+		return this.drawing?.().resolve(this.modelId).presentationId ?? null;
+	}
+	/**
+	* The paragraph of the fallback drawing part (`dsp:drawing`) that carries this point's
+	* text, or `null` when nothing draws it.
+	*
+	* The mapping runs through the `pres` point rather than directly: a `dsp:sp/@modelId` is
+	* always a `pres` point's id, so a lookup keyed on the authored point's own id finds
+	* nothing at all. It is many-to-one in both directions — one shape draws several points
+	* (`@destOrd` says which paragraph is whose, and it can contradict document order), and
+	* one point has several presentations, of which at most one holds text.
+	*
+	* `null` is a defined outcome, not a failure, and covers four real cases: the package
+	* carries no drawing part; the point has no `presOf` edge (every unlabelled
+	* `parTrans`/`sibTrans`); the `pres` point draws no `dsp:sp`; and the shape it draws has
+	* no `dsp:txBody` (a connector, or a picture node's filled rectangle).
+	*/
+	get drawnShape() {
+		return this.drawing?.().resolve(this.modelId).drawnShape ?? null;
+	}
 	/** This point's text, paragraphs joined by `\n`; `''` when it carries none. */
 	get text() {
 		return this.textFrame?.text ?? "";
 	}
+	/**
+	* Replace this point's text, in the data model **and** in the drawing cache.
+	*
+	* A diagram stores every string twice. `dgm:t` is what PowerPoint reads, and it recomputes
+	* the drawing from the data model on open; the `dsp:drawing` part is what every other
+	* renderer paints, and none of them recompute anything. Writing only the first is an edit
+	* that is invisible in LibreOffice, Google Slides, thumbnailers and web previews until
+	* someone opens the deck in PowerPoint and saves it.
+	*
+	* The data-model write always happens. The mirror is best-effort: when the point resolves
+	* to no drawn paragraph (see {@link drawnShape} for the four ways that occurs) the cache
+	* keeps the old string and a `diagram/drawing-cache-not-updated` diagnostic says so.
+	* Throwing instead would make the common case unusable in order to report the rare one,
+	* and returning a status would be a shape no other text setter here has.
+	*
+	* Two things it deliberately does not do. It does **not** recompute geometry: the drawn
+	* shape keeps its cached position and size, so a much longer string overflows its box in
+	* those same renderers until PowerPoint re-lays the diagram out. And it does not *create*
+	* a place to draw text — a transition point whose layout has no label slot has no
+	* `dsp:sp`, and PowerPoint strips text put on one, so the honest outcome is the
+	* diagnostic. Like every other `text` setter here it collapses the point to one run,
+	* keeping the first run's `a:rPr`; use {@link textFrame} for run-level work.
+	*/
+	set text(value) {
+		const frame = this.textFrame;
+		if (!frame) {
+			warn("diagram/point-has-no-text-body", `SmartArt point ${this.#label()} (type ${this.type}) has no dgm:t, so it is not a point text can be written to; nothing was changed`);
+			return;
+		}
+		frame.text = value;
+		const drawn = this.drawnShape;
+		const paragraph = drawn?.textFrame.paragraphs[drawn.paragraphIndex];
+		if (!drawn || !paragraph) {
+			warn("diagram/drawing-cache-not-updated", `SmartArt point ${this.#label()} resolves to no drawn paragraph, so ${this.part.partName} now holds the new text but the drawing cache still holds the old one; PowerPoint redraws it on open, other renderers do not`);
+			return;
+		}
+		setParagraphText(paragraph.element_, value);
+		drawn.part.markDirty();
+	}
 	/** Escape hatch: the underlying `dgm:pt` element. After mutating it call {@link Diagram.markDirty}. */
 	get element_() {
 		return this.pt;
@@ -4546,7 +4773,29 @@ var DiagramPoint = class {
 	#prSet() {
 		return firstChild(this.pt, "dgm:prSet");
 	}
+	/** How a diagnostic names this point: its `@modelId`, which is all a corrupt point may have. */
+	#label() {
+		return this.modelId ?? "(no modelId)";
+	}
 };
+/**
+* One user-authored point in its place in the diagram's tree — a `node` or an `asst`, never a
+* generated `pres` point or a transition label. See {@link Diagram.nodes}.
+*/
+var DiagramNode = class {
+	point;
+	parent;
+	level;
+	/** Child nodes, ordered by their `parOf` edge's `@srcOrd`. Empty for a leaf. */
+	children = [];
+	constructor(point, parent, level) {
+		this.point = point;
+		this.parent = parent;
+		this.level = level;
+	}
+};
+/** Sort key for a root with no `parOf` edge at all, so it lands after the ordered ones. */
+const MAX_ORDER = Number.MAX_SAFE_INTEGER;
 /** A SmartArt graphic frame's diagram, backed by its `dgm:dataModel` part. */
 var Diagram = class {
 	part;
@@ -4554,6 +4803,9 @@ var Diagram = class {
 	opc;
 	frameRelationships;
 	themeContext;
+	#relationships;
+	#docPrSetCache;
+	#drawing;
 	constructor(part, relIds, opc, frameRelationships, themeContext) {
 		this.part = part;
 		this.relIds = relIds;
@@ -4568,14 +4820,88 @@ var Diagram = class {
 	/**
 	* Every point (`dgm:ptLst/dgm:pt`) in document order, unfiltered — generated `pres`
 	* points and the `doc` root included. Filter on {@link DiagramPoint.type} for the user's
-	* nodes; {@link text} is the shortcut for the common case.
+	* nodes; {@link text} is the shortcut for the common case, {@link nodes} the structured one.
+	*
+	* Built per access like every other read proxy (`docs/reference/pptx-read.md`, "Object
+	* model"), so `points[0] !== points[0]` while both wrap the same `dgm:pt`. Key a `Map`
+	* on {@link DiagramPoint.modelId}, not on the point.
 	*/
 	get points() {
 		const root = this.#root();
 		const ptLst = root && firstChild(root, "dgm:ptLst");
 		if (!ptLst) return [];
-		const relationships = this.opc.relationshipsFor(this.part.partName);
-		return getElements(ptLst, "dgm:pt").map((pt) => new DiagramPoint(pt, this.part, this.themeContext, relationships));
+		const relationships = this.#relationships ??= this.opc.relationshipsFor(this.part.partName);
+		const drawing = () => this.#drawingIndex();
+		return getElements(ptLst, "dgm:pt").map((pt) => new DiagramPoint(pt, this.part, this.themeContext, relationships, drawing));
+	}
+	/**
+	* The authored tree — every `node` and `asst` point in its place, roots in `@srcOrd`
+	* order — as a view over {@link points} and {@link connections} rather than a replacement
+	* for either.
+	*
+	* A root is a content point whose `parOf` parent is not itself content, which in a
+	* PowerPoint-authored model means the `doc` point. Transition points are not members; see
+	* this module's header for that decision and the two beside it.
+	*
+	* @throws PackageReadError `diagram/parent-edge-cycle` when the `parOf` edges make a
+	* point its own ancestor, which is a corrupt model rather than a diagram shape.
+	*/
+	get nodes() {
+		const content = /* @__PURE__ */ new Map();
+		for (const point of this.points) {
+			const modelId = point.modelId;
+			if (modelId !== null && (point.type === "node" || point.type === "asst")) content.set(modelId, point);
+		}
+		const childrenOf = /* @__PURE__ */ new Map();
+		const edgeTo = /* @__PURE__ */ new Map();
+		for (const connection of this.connections) {
+			const { sourceId, destinationId } = connection;
+			if (connection.type !== "parOf" || sourceId === null || destinationId === null) continue;
+			if (!content.has(destinationId)) continue;
+			const edge = {
+				parentId: sourceId,
+				childId: destinationId,
+				order: connection.sourceOrder ?? 0
+			};
+			const list = childrenOf.get(sourceId);
+			if (list) list.push(edge);
+			else childrenOf.set(sourceId, [edge]);
+			edgeTo.set(destinationId, edge);
+		}
+		for (const list of childrenOf.values()) list.sort((a, b) => a.order - b.order);
+		const roots = [...content].filter(([modelId]) => {
+			const parentId = edgeTo.get(modelId)?.parentId;
+			return parentId === void 0 || !content.has(parentId);
+		});
+		roots.sort(([a], [b]) => (edgeTo.get(a)?.order ?? MAX_ORDER) - (edgeTo.get(b)?.order ?? MAX_ORDER));
+		const placed = /* @__PURE__ */ new Set();
+		const build = (point, parent, level, path) => {
+			const modelId = point.modelId;
+			if (modelId !== null && path.has(modelId)) throw this.#cycleError(modelId);
+			const node = new DiagramNode(point, parent, level);
+			if (modelId === null) return node;
+			placed.add(modelId);
+			path.add(modelId);
+			for (const edge of childrenOf.get(modelId) ?? []) {
+				const child = content.get(edge.childId);
+				if (child) node.children.push(build(child, node, level + 1, path));
+			}
+			path.delete(modelId);
+			return node;
+		};
+		const tree = roots.map(([, point]) => build(point, null, 0, /* @__PURE__ */ new Set()));
+		if (placed.size !== content.size) {
+			const orphan = [...content.keys()].find((modelId) => !placed.has(modelId));
+			throw this.#cycleError(orphan ?? "(unidentified)");
+		}
+		return tree;
+	}
+	/**
+	* The point with this `@modelId`, or `null` — the lookup every connection getter implies,
+	* since a `DiagramConnection` names its ends by id and nothing else resolves them.
+	*/
+	point(modelId) {
+		return this.points.find((candidate) => candidate.modelId === modelId) ?? null;
 	}
 	/** Every edge (`dgm:cxnLst/dgm:cxn`) in document order. */
 	get connections() {
@@ -4666,14 +4992,32 @@ var Diagram = class {
 	#root() {
 		return this.part.dom.documentElement;
 	}
-	#docPrSetAttr(name) {
+	#cycleError(modelId) {
+		return new PackageReadError("diagram/parent-edge-cycle", `Diagram ${this.part.partName} has a parOf cycle reaching point ${modelId}, so its points do not form a tree`);
+	}
+	/**
+	* The `doc` point's `dgm:prSet`, which carries all three preset ids — resolved once
+	* rather than once per getter, since each lookup is a scan of the whole `ptLst`.
+	* `undefined` means "not looked up yet"; `null` means "looked up, not there".
+	*/
+	#docPrSet() {
+		if (this.#docPrSetCache !== void 0) return this.#docPrSetCache;
 		const root = this.#root();
 		const ptLst = root && firstChild(root, "dgm:ptLst");
-		if (!ptLst) return null;
-		const doc = getElements(ptLst, "dgm:pt").find((pt) => attr(pt, "type") === "doc");
-		const prSet = doc && firstChild(doc, "dgm:prSet");
+		const doc = ptLst && getElements(ptLst, "dgm:pt").find((pt) => attr(pt, "type") === "doc");
+		return this.#docPrSetCache = doc && firstChild(doc, "dgm:prSet") || null;
+	}
+	#docPrSetAttr(name) {
+		const prSet = this.#docPrSet();
 		return prSet ? attr(prSet, name) : null;
 	}
+	/**
+	* The drawing index, built on first use and kept — see {@link DrawingIndex} for what that
+	* memo costs a consumer who mutates the drawing part's shape tree by hand.
+	*/
+	#drawingIndex() {
+		return this.#drawing ??= new DrawingIndex(this.#root(), this.drawingPart, this.themeContext);
+	}
 	#relPart(qname) {
 		return this.#partForRelId(attr(this.relIds, qname));
 	}
@@ -6242,6 +6586,6 @@ function findShapeByIdDeep(shapes, id) {
 	}
 }
 //#endregion
-export { collectElements as $, readPatternFill as A, zipPathToPartName as At, LST_STYLE_LEVELS as B, getOrAddChild as Bt, Picture as C, SPPR_SP3D_AFTER as Ct, Run as D, relsPartNameFor as Dt, Paragraph as E, relativePartName as Et, resolveMasterColorContext as F, descendantsByTag as Ft, placeholderInheritedRunProps as G, removeAttr as Gt, placeholderInheritedAnchor as H, intValue as Ht, resolveNotesColorContext as I, escapeXmlAttribute as It, slideDefinesColor as J, serializeXml as Jt, placeholderInheritedXfrm as K, removeChildrenByQName as Kt, resolveSlideColorContext as L, firstChild as Lt, readGradientFill as M, boolValue as Mt, resolveColorElement as N, childElements as Nt, TextFrame as O, resolveRelativePartName as Ot, resolveLayoutColorContext as P, createElement as Pt, carriedDecorations as Q, resolveSlideThemeParts as R, firstChildElement as Rt, Connector as S, SPPR_SCENE3D_AFTER as St, Shape as T, partNameToZipPath as Tt, placeholderInheritedColor as U, ownerDocumentOf as Ut, RUN_PROP_NAMES as V, insertInOrder as Vt, placeholderInheritedListStyles as W, parseXml as Wt, cSldName as X, slideDefinesProp as Y, setAttr as Yt, cSldOf as Z, ChartExAxis as _, SHAPE_AFTER_SPPR as _t, isConnector as a, fmtEntry as at, ChartAxis as b, SPPR_FILL_AFTER as bt, isPicture as c, parseClrMap as ct, Table as d, resolveSchemeToken as dt, firstShapeChild as et, TableCell as f, styleRefFill as ft, ChartEx as g, RPR_FILL_AFTER as gt, DiagramPoint as h, FILL_CHOICES as ht, isAutoShape as i, SCHEME_SLOTS as it, readPictureFill as j, attr as jt, spPrXfrmEmu as k, resolveSingleRel as kt, wrapShapeElement as l, parseClrScheme as lt, Diagram as m, substitutePhClr as mt, buildShapes as n, nvPrOf as nt, isGraphicFrame as o, intAttr as ot, TableRow as p, styleRefLine as pt, placeholderOf as q, replaceInParent as qt, findShapeByIdDeep as r, spTreeOf as rt, isGroupShape as s, isA as st, GroupShape as t, nthShapeChild as tt, GraphicFrame as u, resolveColor as ut, ChartExSeries as v, SPPR_AFTER_XFRM as vt, AutoShape as w, partNameExtension as wt, ChartSeries as x, SPPR_LN_AFTER as xt, Chart as y, SPPR_EFFECT_AFTER as yt, applyColorTransforms as z, getElements as zt };
+export { carriedDecorations as $, spPrXfrmEmu as A, resolveSingleRel as At, applyColorTransforms as B, getElements as Bt, Connector as C, SPPR_SCENE3D_AFTER as Ct, Paragraph as D, relativePartName as Dt, Shape as E, partNameToZipPath as Et, resolveLayoutColorContext as F, createElement as Ft, placeholderInheritedListStyles as G, parseXml as Gt, RUN_PROP_NAMES as H, insertInOrder as Ht, resolveMasterColorContext as I, descendantsByTag as It, placeholderOf as J, replaceInParent as Jt, placeholderInheritedRunProps as K, removeAttr as Kt, resolveNotesColorContext as L, escapeXmlAttribute as Lt, readPictureFill as M, attr as Mt, readGradientFill as N, boolValue as Nt, Run as O, relsPartNameFor as Ot, resolveColorElement as P, childElements as Pt, cSldOf as Q, resolveSlideColorContext as R, firstChild as Rt, ChartSeries as S, SPPR_LN_AFTER as St, AutoShape as T, partNameExtension as Tt, placeholderInheritedAnchor as U, intValue as Ut, LST_STYLE_LEVELS as V, getOrAddChild as Vt, placeholderInheritedColor as W, ownerDocumentOf as Wt, slideDefinesProp as X, setAttr as Xt, slideDefinesColor as Y, serializeXml as Yt, cSldName as Z, ChartEx as _, RPR_FILL_AFTER as _t, isConnector as a, SCHEME_SLOTS as at, Chart as b, SPPR_EFFECT_AFTER as bt, isPicture as c, isA as ct, Table as d, resolveColor as dt, collectElements as et, TableCell as f, resolveSchemeToken as ft, DiagramPoint as g, FILL_CHOICES as gt, DiagramNode as h, substitutePhClr as ht, isAutoShape as i, spTreeOf as it, readPatternFill as j, zipPathToPartName as jt, TextFrame as k, resolveRelativePartName as kt, wrapShapeElement as l, parseClrMap as lt, Diagram as m, styleRefLine as mt, buildShapes as n, nthShapeChild as nt, isGraphicFrame as o, fmtEntry as ot, TableRow as p, styleRefFill as pt, placeholderInheritedXfrm as q, removeChildrenByQName as qt, findShapeByIdDeep as r, nvPrOf as rt, isGroupShape as s, intAttr as st, GroupShape as t, firstShapeChild as tt, GraphicFrame as u, parseClrScheme as ut, ChartExAxis as v, SHAPE_AFTER_SPPR as vt, Picture as w, SPPR_SP3D_AFTER as wt, ChartAxis as x, SPPR_FILL_AFTER as xt, ChartExSeries as y, SPPR_AFTER_XFRM as yt, resolveSlideThemeParts as z, firstChildElement as zt };
 
-//# sourceMappingURL=shapes-Dyw5bxwO.js.map
+//# sourceMappingURL=shapes-Kt51vry6.js.map