@shbernal/ts-pptx 0.0.1 → 2.0.0

package/dist/{shapes-BZU8UTW2.js → shapes-CaOgR0i1.js}

@@ -1,6 +1,6 @@
 import { n as warn } from "./diagnostics-DYQC7xLV.js";
 import { i as PackageReadError, n as InvalidOptionError, o as UnsupportedFeatureError, t as InternalError } from "./errors-DGE9zh3U.js";
-import { r as getImageSizeFromBytes, t as fitSrcRectPercents } from "./image-size-C5Z1sKof.js";
+import { r as getImageSizeFromBytes, t as fitSrcRectPercents } from "./image-size-C8uYE8GJ.js";
 import { DOMParser, MIME_TYPE, XMLSerializer, onErrorStopParsing } from "@xmldom/xmldom";
 /** Parse an XML string strictly: any well-formedness error throws. */
 function parseXml(xml) {
@@ -1484,7 +1484,6 @@ function applyColorTransforms(baseHex, transforms) {
 			if (f !== null) alpha = clamp01((alpha ?? 1) + f);
 			break;
 		}
-		default: break;
 	}
 	return alpha === void 0 ? { hex: toHex(rgb) } : {
 		hex: toHex(rgb),
@@ -2011,6 +2010,38 @@ function readPictureFill(container, rels = null) {
 	};
 }
 //#endregion
+//#region src/read/api/pattern-fill.ts
+/**
+* Shared pattern-fill reader for DrawingML colour-bearing containers: a shape's `p:spPr`, a
+* slide's `p:bg/p:bgPr`, and a table's `a:tblPr` / cell's `a:tcPr`.
+*
+* `a:pattFill` is a preset hatch name plus two wrapped colours, and decoding it is three
+* lines — which is exactly why it had been open-coded in each place that needed it. Sharing
+* it is what keeps the three from drifting into different answers for the same element, the
+* same reason {@link import('./gradient.js').readGradientFill} and
+* {@link import('./picture-fill.js').readPictureFill} are shared.
+*/
+/**
+* Read a container's `a:pattFill`, or `null` when its fill is not a pattern.
+* @param {Element} container - the fill-bearing parent (`p:spPr`, `p:bgPr`, `a:tblPr`, `a:tcPr`, …)
+* @param {ColorContext} ctx - the theme colour context each colour resolves against
+* @returns {PatternFill | null} the decoded hatch, or `null`
+*/
+function readPatternFill(container, ctx) {
+	const patt = firstChild(container, "a:pattFill");
+	if (!patt) return null;
+	const wrapColor = (qname) => {
+		const wrap = firstChild(patt, qname);
+		const colorEl = wrap && firstChildElement(wrap);
+		return colorEl ? resolveColorElement(colorEl, ctx) : null;
+	};
+	return {
+		preset: attr(patt, "prst") ?? null,
+		foreground: wrapColor("a:fgClr"),
+		background: wrapColor("a:bgClr")
+	};
+}
+//#endregion
 //#region src/read/api/shapes/oxml.ts
 /**
 * Shape-element plumbing: the schema-successor lists that keep a get-or-added child in document
@@ -2910,9 +2941,7 @@ function readGeometryPath(path) {
 					swAng: (intValue(attr(seg, "swAng")) ?? 0) / 6e4
 				});
 				break;
-			case "close":
-				commands.push({ cmd: "close" });
-				break;
+			case "close": commands.push({ cmd: "close" });
 		}
 	}
 	return {
@@ -3491,19 +3520,7 @@ var Shape = class {
 	*/
 	get patternFill() {
 		const props = this.properties();
-		const patt = props && firstChild(props, "a:pattFill");
-		if (!patt) return null;
-		const ctx = this.slide.themeContext();
-		const resolveWrap = (qname) => {
-			const wrap = firstChild(patt, qname);
-			const colorEl = wrap && firstChildElement(wrap);
-			return colorEl ? resolveColorElement(colorEl, ctx) : null;
-		};
-		return {
-			preset: attr(patt, "prst") ?? null,
-			foreground: resolveWrap("a:fgClr"),
-			background: resolveWrap("a:bgClr")
-		};
+		return props ? readPatternFill(props, this.slide.themeContext()) : null;
 	}
 	/**
 	* The shape's picture (image) fill (`spPr/a:blipFill`), or `null` when the fill
@@ -4715,6 +4732,452 @@ function toNumberOrNull(value) {
 	return Number.isFinite(number) ? number : null;
 }
 //#endregion
+//#region src/read/api/table-edit.ts
+/**
+* Ordered mutation of a table cell's `a:tcPr`, and the schema facts every such edit needs.
+*
+* `CT_TableCellProperties` declares its children as a **sequence**, so an append-only
+* implementation produces an out-of-order `a:tcPr` — which PowerPoint reports as a corrupt
+* file rather than as a bad edit. Every insertion therefore goes through
+* {@link getOrAddChild} / {@link insertInOrder} with the new element's *successors*, which
+* is what {@link TCPR_AFTER} tabulates. Writing that table once, here, is the point of this
+* module: a setter that hand-rolls its own successor list is one rename away from silently
+* producing an invalid part.
+*
+* The attribute values are the other half. A value outside its `ST_` union is equally fatal
+* and equally silent, so each is checked against the enum before it is written — the same
+* validate-at-the-boundary rule the write path follows, with the difference that here there
+* is a caller to throw at rather than a deck to degrade.
+*/
+/**
+* `CT_TableCellProperties`' child sequence, in declaration order.
+* @see ECMA-376 Part 1 §21.1.3.17 (`a:tcPr`)
+*/
+const TCPR_SEQUENCE = [
+	"a:lnL",
+	"a:lnR",
+	"a:lnT",
+	"a:lnB",
+	"a:lnTlToBr",
+	"a:lnBlToTr",
+	"a:cell3D",
+	"a:noFill",
+	"a:solidFill",
+	"a:gradFill",
+	"a:blipFill",
+	"a:pattFill",
+	"a:grpFill",
+	"a:headers",
+	"a:extLst"
+];
+/**
+* For each `a:tcPr` child, the children that must follow it — i.e. what a new one is
+* inserted *before*. Derived from {@link TCPR_SEQUENCE} rather than written out, so the two
+* cannot disagree and adding a child to the sequence updates every successor list at once.
+*/
+const TCPR_AFTER = Object.fromEntries(TCPR_SEQUENCE.map((qname, index) => [qname, TCPR_SEQUENCE.slice(index + 1)]));
+/** The four edges plus the two diagonals, keyed as {@link TableCellEdge} names them. */
+const EDGE_QNAMES = {
+	left: "a:lnL",
+	right: "a:lnR",
+	top: "a:lnT",
+	bottom: "a:lnB",
+	tlToBr: "a:lnTlToBr",
+	blToTr: "a:lnBlToTr"
+};
+/** `ST_TextAnchoringType` — `a:tcPr/@anchor`. */
+const ANCHOR_VALUES = [
+	"t",
+	"ctr",
+	"b",
+	"just",
+	"dist"
+];
+/** `ST_TextVerticalType` — `a:tcPr/@vert`. */
+const VERT_VALUES = [
+	"horz",
+	"vert",
+	"vert270",
+	"wordArtVert",
+	"eaVert",
+	"mongolianVert",
+	"wordArtVertRtl"
+];
+/** `ST_TextHorzOverflowType` — `a:tcPr/@horzOverflow`. */
+const HORZ_OVERFLOW_VALUES = ["clip", "overflow"];
+/**
+* Check a value against its `ST_` union, throwing when it is outside.
+*
+* Throwing rather than warn-and-drop, which is the opposite of what the *write* path does
+* with the same enums — and deliberately so. On the write path an option comes from a deck
+* being built, and dropping one value is better than failing a whole build; here it comes
+* from a caller editing one attribute, so silently doing nothing would leave them looking at
+* an unchanged deck with no explanation.
+*
+* @param {string} value - the value the caller asked for
+* @param {readonly string[]} valid - the enum's members
+* @param {string} attribute - the attribute's name, for the message
+* @param {InvalidOptionErrorCode} code - the condition to report
+* @returns {string} `value`, when it is legal
+*/
+function checkEnum(value, valid, attribute, code) {
+	if (valid.includes(value)) return value;
+	throw new InvalidOptionError(code, `Invalid ${attribute}: ${JSON.stringify(value)}. Expected one of: ${valid.join(", ")}.`);
+}
+/**
+* Get or create a child of `a:tcPr` at its schema position.
+* @param {Element} tcPr - the cell's properties element
+* @param {string} qname - the child to get or create
+* @returns {Element} the existing or newly-inserted child
+*/
+function tcPrChild(tcPr, qname) {
+	return getOrAddChild(tcPr, qname, TCPR_AFTER[qname] ?? []);
+}
+/**
+* Insert an already-built subtree into `a:tcPr` at its schema position.
+* @param {Element} tcPr - the cell's properties element
+* @param {string} qname - the qname of the node being inserted (decides where it goes)
+* @param {Element} node - the subtree to insert
+*/
+function insertTcPrChild(tcPr, qname, node) {
+	insertInOrder(tcPr, node, TCPR_AFTER[qname] ?? []);
+}
+/**
+* Round a measurement to whole EMU, rejecting a value that cannot be written.
+* `NaN`/`Infinity` would reach the attribute verbatim and make the part invalid, which is
+* exactly the "silent coercion of invalid input" the project's policy rules out.
+*/
+function checkFiniteEmu(value, field, code) {
+	if (!Number.isFinite(value)) throw new InvalidOptionError(code, `${field} must be a finite number of EMU, got: ${String(value)}`);
+	return Math.round(value);
+}
+//#endregion
+//#region src/read/api/table-structure.ts
+/**
+* Structural edits to an existing `a:tbl`: adding and removing rows and columns, and
+* merging and unmerging cells.
+*
+* The one fact that makes this tractable is that a stored table's grid is already
+* **rectangular**. Unlike the write path — which receives lopsided row arrays and has to
+* build the merge grid itself (`gen/slide/objects/table.ts` STEP 3) — every `a:tr` in a
+* conformant `a:tbl` holds exactly one `a:tc` per grid column, with the covered half of each
+* span present and flagged. So "the cell at (r, c)" is simply the c-th `a:tc` of the r-th
+* `a:tr`, and an edit's whole job is keeping that rectangle true.
+*
+* Three things have to stay in step, and every function here is written around them:
+*
+* 1. `a:tblGrid/a:gridCol` count == each row's `a:tc` count.
+* 2. A cell with `@gridSpan="n"` is followed by exactly `n-1` cells carrying `@hMerge="1"`,
+*    and a cell with `@rowSpan="n"` is under-hung by `n-1` cells carrying `@vMerge="1"`, in
+*    the same columns.
+* 3. A covered cell carries no span attributes of its own — its extent is the origin's.
+*
+* Breaking any of them produces a table PowerPoint reports as a corrupt file rather than as
+* a bad edit, which is why the span bookkeeping here is explicit rather than incidental.
+*/
+/** Every `a:tr` of a table, in document order. */
+function rowsOf(tbl) {
+	return getElements(tbl, "a:tr");
+}
+/** Every `a:tc` of a row, in document (left-to-right) order. */
+function cellsOf(tr) {
+	return getElements(tr, "a:tc");
+}
+/** The table's `a:tblGrid`, or a thrown error — `CT_Table` requires one. */
+function gridOf(tbl) {
+	const grid = firstChild(tbl, "a:tblGrid");
+	if (!grid) throw new InvalidOptionError("table/column-index-out-of-range", "This table has no a:tblGrid, so its columns cannot be edited");
+	return grid;
+}
+/** A cell's `@gridSpan`, defaulting to 1. */
+function gridSpanOf(tc) {
+	return intValue(attr(tc, "gridSpan")) ?? 1;
+}
+/** A cell's `@rowSpan`, defaulting to 1. */
+function rowSpanOf(tc) {
+	return intValue(attr(tc, "rowSpan")) ?? 1;
+}
+/** Whether a cell is the covered half of a horizontal merge. */
+function isHMerge(tc) {
+	return attr(tc, "hMerge") === "1" || attr(tc, "hMerge") === "true";
+}
+/** Whether a cell is the covered half of a vertical merge. */
+function isVMerge(tc) {
+	return attr(tc, "vMerge") === "1" || attr(tc, "vMerge") === "true";
+}
+/**
+* Set a span attribute, removing it when the span collapses to 1 — the schema default, and
+* what PowerPoint itself writes for an unmerged cell.
+*/
+function setSpan(tc, name, value) {
+	if (value <= 1) removeAttr(tc, name);
+	else setAttr(tc, name, String(value));
+}
+/**
+* Walk left from `col` to the origin of the horizontal run containing it.
+* A run is an origin followed by its `hMerge` continuations, so the origin is the first
+* cell at or left of `col` that is not one.
+* @returns the origin's column index, or `col` itself when the cell stands alone
+*/
+function hRunOrigin(cells, col) {
+	let idx = col;
+	while (idx > 0) {
+		const cell = cells[idx];
+		if (!cell || !isHMerge(cell)) break;
+		idx -= 1;
+	}
+	return idx;
+}
+/**
+* Walk up from `row` to the origin of the vertical run containing `(row, col)`.
+* @returns the origin's row index, or `row` itself when the cell stands alone
+*/
+function vRunOrigin(rows, row, col) {
+	let idx = row;
+	while (idx > 0) {
+		const cell = rows[idx]?.[col];
+		if (!cell || !isVMerge(cell)) break;
+		idx -= 1;
+	}
+	return idx;
+}
+/** A fresh, empty `a:tc`, shaped the way PowerPoint writes one. */
+function makeCell(doc) {
+	const tc = createElement(doc, "a:tc");
+	const txBody = createElement(doc, "a:txBody");
+	txBody.appendChild(createElement(doc, "a:bodyPr"));
+	txBody.appendChild(createElement(doc, "a:lstStyle"));
+	txBody.appendChild(createElement(doc, "a:p"));
+	tc.appendChild(txBody);
+	tc.appendChild(createElement(doc, "a:tcPr"));
+	return tc;
+}
+/** The grid as a row-major array of `a:tc` elements. */
+function gridOfCells(tbl) {
+	return rowsOf(tbl).map((tr) => cellsOf(tr));
+}
+/** Guard an index against `[0, limit]` (inclusive upper bound, for insertion points). */
+function checkIndex(index, limit, what, inclusive) {
+	const max = inclusive ? limit : limit - 1;
+	if (!Number.isInteger(index) || index < 0 || index > max) throw new InvalidOptionError(what === "row" ? "table/row-index-out-of-range" : "table/column-index-out-of-range", `${what} index ${String(index)} is out of range (expected 0..${max})`);
+	return index;
+}
+/**
+* Insert a row at `index` (default: append).
+*
+* The subtle case is inserting **through** a vertical merge. If the row currently at `index`
+* holds a `vMerge` continuation in some column, the span it belongs to straddles the
+* insertion point — so the new row must continue that span rather than interrupt it: the
+* origin's `@rowSpan` grows by one and the new cell is another continuation. Interrupting it
+* instead would leave an origin claiming more rows than it has continuations, which is the
+* corrupt-file case.
+*/
+function insertRow(tbl, index) {
+	const rows = rowsOf(tbl);
+	const at = index === void 0 ? rows.length : checkIndex(index, rows.length, "row", true);
+	const grid = gridOfCells(tbl);
+	const colCount = getElements(gridOf(tbl), "a:gridCol").length;
+	const doc = ownerDocumentOf(tbl);
+	const tr = createElement(doc, "a:tr");
+	setAttr(tr, "h", "0");
+	for (let col = 0; col < colCount; col++) {
+		const tc = makeCell(doc);
+		const displaced = grid[at]?.[col];
+		if (displaced && isVMerge(displaced)) {
+			const origin = grid[vRunOrigin(grid, at, col)]?.[col];
+			if (origin) setSpan(origin, "rowSpan", rowSpanOf(origin) + 1);
+			setAttr(tc, "vMerge", "1");
+			if (isHMerge(displaced)) setAttr(tc, "hMerge", "1");
+			const span = gridSpanOf(displaced);
+			if (span > 1) setSpan(tc, "gridSpan", span);
+		}
+		tr.appendChild(tc);
+	}
+	const before = rows[at] ?? null;
+	tbl.insertBefore(tr, before);
+	return tr;
+}
+/**
+* Remove the row at `index`.
+*
+* Two span cases, and they pull in opposite directions. A cell in this row that *continues*
+* a span from above shortens that span by one. A cell in this row that *starts* one cannot
+* simply take its span away — the rows below still hold its continuations — so the first
+* continuation is promoted to origin and inherits the remaining extent. Its content is gone
+* with the row, which is inherent to removing a row rather than a choice made here.
+*/
+function removeRow(tbl, index) {
+	const rows = rowsOf(tbl);
+	const at = checkIndex(index, rows.length, "row", false);
+	const grid = gridOfCells(tbl);
+	const row = grid[at] ?? [];
+	for (let col = 0; col < row.length; col++) {
+		const tc = row[col];
+		if (!tc) continue;
+		if (isVMerge(tc)) {
+			const origin = grid[vRunOrigin(grid, at, col)]?.[col];
+			if (origin) setSpan(origin, "rowSpan", rowSpanOf(origin) - 1);
+			continue;
+		}
+		const span = rowSpanOf(tc);
+		if (span > 1) {
+			const heir = grid[at + 1]?.[col];
+			if (heir) {
+				removeAttr(heir, "vMerge");
+				setSpan(heir, "rowSpan", span - 1);
+				setSpan(heir, "gridSpan", gridSpanOf(tc));
+			}
+		}
+	}
+	const tr = rows[at];
+	if (tr) tbl.removeChild(tr);
+}
+/**
+* Insert a column at `index` (default: append), `widthEmu` wide.
+*
+* Mirrors {@link insertRow}'s split case on the other axis: when the cell currently at
+* `index` is an `hMerge` continuation, the insertion point falls inside a horizontal span,
+* so the span widens by one and the new cell joins it as another continuation.
+*/
+function insertColumn(tbl, index, widthEmu = 914400) {
+	const grid = gridOf(tbl);
+	const cols = getElements(grid, "a:gridCol");
+	const at = index === void 0 ? cols.length : checkIndex(index, cols.length, "column", true);
+	const doc = ownerDocumentOf(tbl);
+	const gridCol = createElement(doc, "a:gridCol");
+	setAttr(gridCol, "w", String(Math.round(widthEmu)));
+	grid.insertBefore(gridCol, cols[at] ?? null);
+	for (const tr of rowsOf(tbl)) {
+		const cells = cellsOf(tr);
+		const tc = makeCell(doc);
+		const displaced = cells[at];
+		if (displaced && isHMerge(displaced)) {
+			const origin = cells[hRunOrigin(cells, at)];
+			if (origin) setSpan(origin, "gridSpan", gridSpanOf(origin) + 1);
+			setAttr(tc, "hMerge", "1");
+			if (isVMerge(displaced)) setAttr(tc, "vMerge", "1");
+			const span = rowSpanOf(displaced);
+			if (span > 1) setSpan(tc, "rowSpan", span);
+		}
+		tr.insertBefore(tc, cells[at] ?? firstChild(tr, "a:extLst"));
+	}
+	return gridCol;
+}
+/**
+* Remove the column at `index`.
+*
+* When the column falls inside a horizontal span, the span shrinks by one and a
+* *continuation* is removed rather than the origin — so the merged region narrows but keeps
+* its content. Only a column whose cell stands alone loses that cell outright.
+*/
+function removeColumn(tbl, index) {
+	const grid = gridOf(tbl);
+	const cols = getElements(grid, "a:gridCol");
+	const at = checkIndex(index, cols.length, "column", false);
+	const col = cols[at];
+	if (col) grid.removeChild(col);
+	for (const tr of rowsOf(tbl)) {
+		const cells = cellsOf(tr);
+		const originIdx = hRunOrigin(cells, at);
+		const origin = cells[originIdx];
+		if (!origin) continue;
+		const span = gridSpanOf(origin);
+		if (span > 1) {
+			setSpan(origin, "gridSpan", span - 1);
+			const victim = cells[originIdx + span - 1];
+			if (victim) tr.removeChild(victim);
+			continue;
+		}
+		const tc = cells[at];
+		if (tc) tr.removeChild(tc);
+	}
+}
+/**
+* Merge the rectangle `(row1, col1)`–`(row2, col2)` into one cell.
+*
+* The top-left cell becomes the origin and keeps its content; every other cell in the
+* rectangle becomes a covered cell — flagged, stripped of its own span attributes, and
+* emptied, since a covered cell is never rendered.
+*
+* A rectangle whose boundary **cuts through** an existing merge is rejected rather than
+* silently widened. Widening would be the friendlier-looking choice and the wrong one: the
+* caller asked for a specific region, and quietly returning a different one is how a layout
+* ends up subtly wrong with nothing to point at.
+*/
+function mergeCells(tbl, row1, col1, row2, col2) {
+	const grid = gridOfCells(tbl);
+	const rowCount = grid.length;
+	const colCount = getElements(gridOf(tbl), "a:gridCol").length;
+	const r1 = Math.min(row1, row2);
+	const r2 = Math.max(row1, row2);
+	const c1 = Math.min(col1, col2);
+	const c2 = Math.max(col1, col2);
+	checkIndex(r1, rowCount, "row", false);
+	checkIndex(r2, rowCount, "row", false);
+	checkIndex(c1, colCount, "column", false);
+	checkIndex(c2, colCount, "column", false);
+	if (r1 === r2 && c1 === c2) throw new InvalidOptionError("table/merge-range-invalid", "A merge needs at least two cells; the given range covers one");
+	for (let r = r1; r <= r2; r++) for (let c = c1; c <= c2; c++) {
+		if (!grid[r]?.[c]) continue;
+		const originRow = vRunOrigin(grid, r, c);
+		const originCol = hRunOrigin(grid[r] ?? [], c);
+		const origin = grid[originRow]?.[originCol];
+		if (!origin) continue;
+		if (originRow < r1 || originCol < c1) throw new InvalidOptionError("table/merge-range-invalid", `The range (${r1},${c1})-(${r2},${c2}) starts inside an existing merged cell at (${originRow},${originCol}); unmerge it first`);
+		if (originRow + rowSpanOf(origin) - 1 > r2 || originCol + gridSpanOf(origin) - 1 > c2) throw new InvalidOptionError("table/merge-range-invalid", `The range (${r1},${c1})-(${r2},${c2}) cuts through an existing merged cell at (${originRow},${originCol}); unmerge it first`);
+	}
+	const origin = grid[r1]?.[c1];
+	if (!origin) return;
+	setSpan(origin, "gridSpan", c2 - c1 + 1);
+	setSpan(origin, "rowSpan", r2 - r1 + 1);
+	removeAttr(origin, "hMerge");
+	removeAttr(origin, "vMerge");
+	for (let r = r1; r <= r2; r++) for (let c = c1; c <= c2; c++) {
+		if (r === r1 && c === c1) continue;
+		const tc = grid[r]?.[c];
+		if (!tc) continue;
+		removeAttr(tc, "gridSpan");
+		removeAttr(tc, "rowSpan");
+		if (c > c1) setAttr(tc, "hMerge", "1");
+		else removeAttr(tc, "hMerge");
+		if (r > r1) setAttr(tc, "vMerge", "1");
+		else removeAttr(tc, "vMerge");
+		emptyCellText(tc);
+	}
+}
+/**
+* Split the merged cell whose origin is `(row, col)` back into individual cells.
+* The origin keeps its content; the cells it covered come back empty, which is what they
+* already were.
+*/
+function unmergeCell(tbl, row, col) {
+	const grid = gridOfCells(tbl);
+	checkIndex(row, grid.length, "row", false);
+	checkIndex(col, getElements(gridOf(tbl), "a:gridCol").length, "column", false);
+	const origin = grid[row]?.[col];
+	if (!origin) return;
+	if (isHMerge(origin) || isVMerge(origin)) throw new InvalidOptionError("table/merge-range-invalid", `The cell at (${row},${col}) is a covered cell, not a merge origin; unmerge the origin at (${vRunOrigin(grid, row, col)},${hRunOrigin(grid[row] ?? [], col)}) instead`);
+	const rowSpan = rowSpanOf(origin);
+	const gridSpan = gridSpanOf(origin);
+	if (rowSpan === 1 && gridSpan === 1) return;
+	removeAttr(origin, "gridSpan");
+	removeAttr(origin, "rowSpan");
+	for (let r = row; r < row + rowSpan; r++) for (let c = col; c < col + gridSpan; c++) {
+		if (r === row && c === col) continue;
+		const tc = grid[r]?.[c];
+		if (!tc) continue;
+		removeAttr(tc, "hMerge");
+		removeAttr(tc, "vMerge");
+	}
+}
+/** Reduce a cell's text body to a single empty paragraph. */
+function emptyCellText(tc) {
+	const txBody = firstChild(tc, "a:txBody");
+	if (!txBody) return;
+	for (const p of getElements(txBody, "a:p")) txBody.removeChild(p);
+	txBody.appendChild(createElement(ownerDocumentOf(txBody), "a:p"));
+}
+//#endregion
 //#region src/read/api/table-style-resolve.ts
 const TABLE_STYLES_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.presentationml.tableStyles+xml";
 /**
@@ -4893,6 +5356,63 @@ var Table = class {
 		const id = (tblPr && firstChild(tblPr, "a:tableStyleId"))?.textContent?.trim();
 		return id ? id : null;
 	}
+	/**
+	* The table's own background (`a:tblPr` fill) resolved against the slide's theme colour
+	* context to a literal hex, or `null` when the table carries no solid background.
+	*
+	* This is the table-level counterpart of {@link TableCell.resolvedFill}, and it is a
+	* genuinely different thing from a cell fill: a `a:tblPr` fill sits *behind* the grid, so
+	* a cell with no fill of its own shows it through. Reports `null` for a non-solid choice
+	* (`a:blipFill`/`a:gradFill`/`a:pattFill`/`a:noFill`) — read {@link pictureFill} for an
+	* image background — and `null` with no theme context.
+	*/
+	get resolvedFill() {
+		if (!this.themeColors) return null;
+		const tblPr = firstChild(this.tbl, "a:tblPr");
+		if (!tblPr || !FILL_CHOICES.some((q) => firstChild(tblPr, q))) return null;
+		return resolveSolidFillColor(tblPr, this.themeColors);
+	}
+	/**
+	* The table's picture background (`a:tblPr/a:blipFill`), or `null` when the table is not
+	* image-backed. The table-level twin of {@link TableCell.pictureFill}, and needed for the
+	* same reason: {@link resolvedFill} decodes only solid colours, so without this an
+	* image-backed table is indistinguishable from an unfilled one.
+	*/
+	get pictureFill() {
+		const tblPr = firstChild(this.tbl, "a:tblPr");
+		return tblPr ? readPictureFill(tblPr, this.rels ?? null) : null;
+	}
+	/**
+	* The table's gradient background (`a:tblPr/a:gradFill`), or `null` when it is not
+	* gradient-filled. Needed for the same reason {@link pictureFill} is:
+	* {@link resolvedFill} decodes only solid colours.
+	*/
+	get gradientFill() {
+		if (!this.themeColors) return null;
+		const tblPr = firstChild(this.tbl, "a:tblPr");
+		return tblPr ? readGradientFill(tblPr, this.themeColors) : null;
+	}
+	/**
+	* The table's pattern (hatch) background (`a:tblPr/a:pattFill`), or `null` when it is not
+	* pattern-filled.
+	*/
+	get patternFill() {
+		if (!this.themeColors) return null;
+		const tblPr = firstChild(this.tbl, "a:tblPr");
+		return tblPr ? readPatternFill(tblPr, this.themeColors) : null;
+	}
+	/**
+	* The raw `schemeClr` token of the table's own background
+	* (`a:tblPr/a:solidFill/a:schemeClr/@val`), or `null` for an absent or `srgbClr` fill.
+	* {@link resolvedFill} is the literal it resolves to; this is the unresolved reference,
+	* which is what a replica should carry so the copy still tracks its theme.
+	*/
+	get fillSchemeColor() {
+		const tblPr = firstChild(this.tbl, "a:tblPr");
+		const fill = tblPr && firstChild(tblPr, "a:solidFill");
+		const scheme = fill && firstChild(fill, "a:schemeClr");
+		return scheme ? attr(scheme, "val") : null;
+	}
 	/** Whether the first row is styled as a header (`a:tblPr/@firstRow`). */
 	get firstRowHeader() {
 		return this.#tblPrFlag("firstRow");
@@ -4909,6 +5429,83 @@ var Table = class {
 	cell(rowIndex, columnIndex) {
 		return this.rows[rowIndex]?.cells[columnIndex] ?? null;
 	}
+	/**
+	* Insert a row, defaulting to the bottom of the table. Returns the new {@link TableRow}.
+	*
+	* The new row is auto-height (`a:tr/@h="0"`) and its cells are empty. Inserting *through*
+	* a vertical merge extends that merge rather than interrupting it: the span's origin
+	* grows by a row and the new cell joins as a continuation, because an origin claiming
+	* more rows than it has continuations is a table PowerPoint reports as corrupt.
+	* @param {number} [index] - where to insert, `0`..`rowCount`; appended when omitted
+	* @throws {InvalidOptionError} when `index` is outside that range
+	*/
+	addRow(index) {
+		const tr = insertRow(this.tbl, index);
+		this.part.markDirty();
+		return new TableRow(tr, this.part, this.themeColors, this.#styleContext(), rowsOf(this.tbl).indexOf(tr), this.rels);
+	}
+	/**
+	* Remove the row at `index`, with its content.
+	*
+	* A cell in the row that *continues* a vertical merge shortens that merge. A cell that
+	* *starts* one hands the region to its first continuation, which becomes the new origin —
+	* the merged region survives one row shorter, and only the removed row's own text is lost.
+	* @throws {InvalidOptionError} when `index` is out of range
+	*/
+	removeRow(index) {
+		removeRow(this.tbl, index);
+		this.part.markDirty();
+	}
+	/**
+	* Insert a column, defaulting to the right-hand end. Updates `a:tblGrid` **and** every
+	* row, which is the pair that has to stay in step.
+	*
+	* The mirror of {@link addRow}'s merge case: inserting inside a horizontal merge widens
+	* it instead of splitting it.
+	* @param {number} [index] - where to insert, `0`..`columnCount`; appended when omitted
+	* @param {number} [widthEmu] - the new column's width; defaults to 1 inch
+	* @throws {InvalidOptionError} when `index` is outside that range
+	*/
+	addColumn(index, widthEmu) {
+		insertColumn(this.tbl, index, widthEmu);
+		this.part.markDirty();
+	}
+	/**
+	* Remove the column at `index`, from `a:tblGrid` and from every row.
+	*
+	* Inside a horizontal merge the region narrows by one and keeps its content: a covered
+	* cell is dropped rather than the origin. Elsewhere the column's cells go with it.
+	* @throws {InvalidOptionError} when `index` is out of range
+	*/
+	removeColumn(index) {
+		removeColumn(this.tbl, index);
+		this.part.markDirty();
+	}
+	/**
+	* Merge the rectangle between two cell positions into one cell. The top-left cell keeps
+	* its content; the rest become covered cells and are emptied, since a covered cell is
+	* never rendered.
+	*
+	* A rectangle that cuts through an existing merge is **rejected**, not silently widened
+	* to fit — the caller asked for a specific region, and quietly producing a different one
+	* is how a layout ends up wrong with nothing to point at. Unmerge first.
+	* @throws {InvalidOptionError} when an index is out of range, the range covers one cell,
+	*   or it partially overlaps an existing merge
+	*/
+	mergeCells(row1, col1, row2, col2) {
+		mergeCells(this.tbl, row1, col1, row2, col2);
+		this.part.markDirty();
+	}
+	/**
+	* Split the merged cell whose **origin** is `(row, col)` back into individual cells.
+	* A no-op on a cell that is not merged; addressing a covered cell instead of the origin
+	* throws, and the message names the origin to use.
+	* @throws {InvalidOptionError} when an index is out of range or the cell is a covered cell
+	*/
+	unmergeCell(row, col) {
+		unmergeCell(this.tbl, row, col);
+		this.part.markDirty();
+	}
 	/** Escape hatch: the underlying `a:tbl` element. After mutating it call {@link markDirty}, or `save()` writes the original bytes. */
 	get element_() {
 		return this.tbl;
@@ -4999,6 +5596,183 @@ var TableCell = class {
 		return firstChild(this.tc, "a:tcPr");
 	}
 	/**
+	* The cell's `a:tcPr`, creating it when absent.
+	*
+	* `CT_TableCell` sequences `a:txBody` then `a:tcPr` then `a:extLst`, so a newly created
+	* one is inserted before `a:extLst` — appending it blindly would put it after and make
+	* the part invalid. Every setter below goes through here for that reason.
+	*/
+	#getOrAddTcPr() {
+		return getOrAddChild(this.tc, "a:tcPr", ["a:extLst"]);
+	}
+	/**
+	* Set (or clear) the cell's vertical text anchor (`a:tcPr/@anchor`).
+	* `null` removes the attribute, leaving PowerPoint's default of top.
+	* @throws {InvalidOptionError} when the value is outside `ST_TextAnchoringType`
+	*/
+	setAnchor(value) {
+		this.#setTcPrAttr("anchor", value, ANCHOR_VALUES, "table/invalid-cell-anchor");
+	}
+	/**
+	* Set (or clear) the cell's text direction (`a:tcPr/@vert`), e.g. `'vert270'`.
+	* `null` removes the attribute, leaving the default horizontal text.
+	* @throws {InvalidOptionError} when the value is outside `ST_TextVerticalType`
+	*/
+	setVerticalText(value) {
+		this.#setTcPrAttr("vert", value, VERT_VALUES, "table/invalid-cell-vert");
+	}
+	/**
+	* Set (or clear) `a:tcPr/@horzOverflow` — what a single glyph too wide for the cell does.
+	* `null` removes the attribute; so does `'clip'` in effect, since it is the schema
+	* default, but the attribute is still written as asked.
+	* @throws {InvalidOptionError} when the value is outside `ST_TextHorzOverflowType`
+	*/
+	setHorzOverflow(value) {
+		this.#setTcPrAttr("horzOverflow", value, HORZ_OVERFLOW_VALUES, "table/invalid-cell-overflow");
+	}
+	/**
+	* Centre the cell's text block horizontally, or stop doing so (`a:tcPr/@anchorCtr`).
+	* `false` removes the attribute rather than writing `"0"`, since `false` is the schema
+	* default and the two are indistinguishable to a renderer.
+	*/
+	setAnchorCtr(value) {
+		const tcPr = this.#getOrAddTcPr();
+		if (value) setAttr(tcPr, "anchorCtr", "1");
+		else removeAttr(tcPr, "anchorCtr");
+		this.part.markDirty();
+	}
+	/**
+	* Set the cell's text insets in EMU (`a:tcPr/@marL`/`@marR`/`@marT`/`@marB`).
+	*
+	* Partial: only the sides named are touched, so `{ left: 0 }` flushes the text left and
+	* leaves the other three alone. A side given as `null` has its attribute removed, which
+	* returns it to the schema default (91440 EMU left/right, 45720 top/bottom) — not to
+	* zero. Pass `{}` to change nothing.
+	* @throws {InvalidOptionError} when a value is not a finite number
+	*/
+	setMarginsEmu(margins) {
+		const tcPr = this.#getOrAddTcPr();
+		const sides = [
+			["marL", margins.left],
+			["marR", margins.right],
+			["marT", margins.top],
+			["marB", margins.bottom]
+		];
+		for (const [name, value] of sides) {
+			if (value === void 0) continue;
+			if (value === null) removeAttr(tcPr, name);
+			else setAttr(tcPr, name, String(checkFiniteEmu(value, name, "table/invalid-cell-margin")));
+		}
+		this.part.markDirty();
+	}
+	/**
+	* Set (or clear) one of the cell's six borders — the four edges and the two diagonals.
+	*
+	* `null` removes the element entirely, which is "inherit", and is a different thing from
+	* `{ noFill: true }`, which writes an explicit no-border and suppresses whatever would
+	* otherwise be inherited. The element is inserted at its schema position rather than
+	* appended: `CT_TableCellProperties` is a sequence, and an out-of-order `a:tcPr` is
+	* reported by PowerPoint as a corrupt file rather than as a bad edit.
+	*
+	* Colour is either `color` (6-hex, `#` optional) or `schemeColor` (a theme token); giving
+	* both prefers the token, matching how the read side reports them.
+	* @throws {InvalidOptionError} when the width or colour cannot be written
+	*/
+	setBorder(edge, border) {
+		const qname = EDGE_QNAMES[edge];
+		if (!qname) throw new InvalidOptionError("table/invalid-cell-border", `Unknown table cell edge: ${JSON.stringify(edge)}. Expected one of: ${Object.keys(EDGE_QNAMES).join(", ")}.`);
+		if (border === null) {
+			const tcPr = this.#tcPr();
+			if (!tcPr || !firstChild(tcPr, qname)) return;
+			removeChildrenByQName(tcPr, [qname]);
+			this.part.markDirty();
+			return;
+		}
+		const tcPr = this.#getOrAddTcPr();
+		removeChildrenByQName(tcPr, [qname]);
+		const doc = ownerDocumentOf(tcPr);
+		const ln = createElement(doc, qname);
+		if (border.widthPt !== void 0 && border.widthPt !== null) setAttr(ln, "w", String(checkFiniteEmu(border.widthPt * 12700, "widthPt", "table/invalid-cell-border")));
+		if (border.noFill) ln.appendChild(createElement(doc, "a:noFill"));
+		else if (border.schemeColor || border.color) {
+			const fill = createElement(doc, "a:solidFill");
+			const scheme = border.schemeColor;
+			const clr = createElement(doc, scheme ? "a:schemeClr" : "a:srgbClr");
+			setAttr(clr, "val", scheme ? scheme : normalizeHex(border.color));
+			fill.appendChild(clr);
+			ln.appendChild(fill);
+		}
+		if (border.dash) {
+			const dash = createElement(doc, "a:prstDash");
+			setAttr(dash, "val", border.dash);
+			ln.appendChild(dash);
+		}
+		insertTcPrChild(tcPr, qname, ln);
+		this.part.markDirty();
+	}
+	/**
+	* Replace the cell's fill with a solid colour (`a:tcPr/a:solidFill`), or clear it.
+	*
+	* `null` removes the `a:solidFill` and lets the cell inherit from the table style again.
+	* That is not the same as {@link noFill}, which writes an explicit `a:noFill` and so
+	* suppresses the inherited shading. Any competing fill choice (`a:gradFill`,
+	* `a:blipFill`, …) is dropped first — `EG_FillProperties` admits one.
+	* @throws {InvalidOptionError} when `color` is not a 6-digit hex string
+	*/
+	setFillColor(color) {
+		this.#setFill(color === null ? null : {
+			qname: "a:srgbClr",
+			val: normalizeHex(color)
+		});
+	}
+	/**
+	* Replace the cell's fill with a theme colour token (`a:solidFill/a:schemeClr/@val`), or
+	* clear it. Preferred over {@link setFillColor} when the deck's theme should keep
+	* driving the colour.
+	*/
+	setFillSchemeColor(token) {
+		this.#setFill(token === null ? null : {
+			qname: "a:schemeClr",
+			val: token
+		});
+	}
+	/**
+	* Write an explicit `<a:noFill/>` on the cell — a transparent cell that shows the table
+	* background (or the slide) through. Distinct from `setFillColor(null)`, which removes
+	* the fill and lets the table style's shading apply again.
+	*/
+	noFill() {
+		const tcPr = this.#getOrAddTcPr();
+		removeChildrenByQName(tcPr, FILL_CHOICES);
+		tcPrChild(tcPr, "a:noFill");
+		this.part.markDirty();
+	}
+	/** Set or clear one `a:tcPr` attribute, vetting it against its schema enum first. */
+	#setTcPrAttr(name, value, valid, code) {
+		if (value === null) {
+			const tcPr = this.#tcPr();
+			if (!tcPr) return;
+			removeAttr(tcPr, name);
+			this.part.markDirty();
+			return;
+		}
+		const checked = checkEnum(value, valid, name, code);
+		setAttr(this.#getOrAddTcPr(), name, checked);
+		this.part.markDirty();
+	}
+	/** Replace (or remove) the cell's solid fill, keeping `EG_FillProperties` single-valued. */
+	#setFill(color) {
+		if (color === null) {
+			const tcPr = this.#tcPr();
+			if (!tcPr || !firstChild(tcPr, "a:solidFill")) return;
+			removeChildrenByQName(tcPr, ["a:solidFill"]);
+			this.part.markDirty();
+			return;
+		}
+		setSolidFill(this.#getOrAddTcPr(), TCPR_AFTER["a:solidFill"] ?? [], color);
+		this.part.markDirty();
+	}
+	/**
 	* The cell's solid fill resolved against the table's theme colour context to a
 	* literal hex — the table-cell counterpart of
 	* {@link import('./shapes.js').AutoShape.resolvedFill}. The cell's own
@@ -5020,11 +5794,25 @@ var TableCell = class {
 	*/
 	get resolvedFill() {
 		if (!this.themeColors) return null;
-		const tcPr = this.#tcPr();
-		if (tcPr && FILL_CHOICES.some((q) => firstChild(tcPr, q))) return resolveSolidFillColor(tcPr, this.themeColors);
+		if (this.hasOwnFill) return resolveSolidFillColor(this.#tcPr(), this.themeColors);
 		return this.style ? this.#styleFill() : null;
 	}
 	/**
+	* Whether the cell carries a fill of its **own** (`a:tcPr` holds an `EG_FillProperties`
+	* child), as opposed to inheriting one from the table style's header/banding rules.
+	*
+	* This is the flag that disambiguates {@link resolvedFill}, which deliberately reports
+	* either — it answers "what colour does this cell render as", and both sources are valid
+	* answers to that. Anything that has to reproduce the cell rather than describe it needs
+	* to know which: baking an inherited banding colour into a copy makes the copy look right
+	* until someone changes its table style, and then nothing moves. `false` for a cell whose
+	* `a:tcPr` is empty or absent, whatever the style graph would render it as.
+	*/
+	get hasOwnFill() {
+		const tcPr = this.#tcPr();
+		return !!tcPr && FILL_CHOICES.some((q) => firstChild(tcPr, q));
+	}
+	/**
 	* The cell's picture (image) fill (`a:tcPr/a:blipFill`), or `null` when the cell
 	* is not image-filled. The cell counterpart of
 	* {@link import('./shapes.js').AutoShape.pictureFill}: {@link resolvedFill}
@@ -5045,6 +5833,24 @@ var TableCell = class {
 		return resolveTableCellStyleFill(s.style.element_, s.flags, this.rowIndex, this.colIndex, s.rowCount, s.colCount, s.ctx);
 	}
 	/**
+	* The cell's gradient fill (`a:tcPr/a:gradFill`), or `null` when the cell is not
+	* gradient-filled. The cell twin of {@link Table.gradientFill}, and needed for the same
+	* reason {@link pictureFill} is: {@link resolvedFill} reports `null` for every non-solid
+	* choice, so without this a gradient cell is indistinguishable from an unfilled one.
+	*/
+	get gradientFill() {
+		const tcPr = this.#tcPr();
+		return tcPr && this.themeColors ? readGradientFill(tcPr, this.themeColors) : null;
+	}
+	/**
+	* The cell's pattern (hatch) fill (`a:tcPr/a:pattFill`), or `null` when the cell is not
+	* pattern-filled.
+	*/
+	get patternFill() {
+		const tcPr = this.#tcPr();
+		return tcPr && this.themeColors ? readPatternFill(tcPr, this.themeColors) : null;
+	}
+	/**
 	* The raw `schemeClr` token of the cell's solid fill (`a:tcPr/a:solidFill/a:schemeClr/@val`),
 	* e.g. `accent1`/`bg1`, or `null` when the fill is absent or an explicit `srgbClr`.
 	* The resolved literal is {@link resolvedFill}; this is the unresolved reference.
@@ -5111,6 +5917,88 @@ var TableCell = class {
 		return (tcPr && attr(tcPr, "anchor")) ?? null;
 	}
 	/**
+	* Whether the cell's whole text **block** is centred horizontally within it
+	* (`a:tcPr/@anchorCtr`). `false` when unset — that is the schema default, and it is
+	* what PowerPoint writes nothing for.
+	*
+	* Distinct from a paragraph's `align`, which decides where each *line* sits inside the
+	* text block; this decides where the block sits inside the cell.
+	*/
+	get anchorCtr() {
+		const tcPr = this.#tcPr();
+		return tcPr ? attr(tcPr, "anchorCtr") === "1" || attr(tcPr, "anchorCtr") === "true" : false;
+	}
+	/**
+	* The cell's 3-D bevel (`a:tcPr/a:cell3D`), or `null` when it has none.
+	*
+	* `CT_Cell3D` requires an `a:bevel`, so a present `cell3D` always reports a bevel;
+	* `lightRig` is `null` when the cell leaves the scene lighting to the renderer. Sizes are
+	* reported in **points** (the attributes are EMU), matching how the write option takes them.
+	*/
+	get cell3D() {
+		const tcPr = this.#tcPr();
+		const cell3D = tcPr && firstChild(tcPr, "a:cell3D");
+		if (!cell3D) return null;
+		const bevel = firstChild(cell3D, "a:bevel");
+		const rig = firstChild(cell3D, "a:lightRig");
+		const pts = (value) => {
+			const emu = intValue(value);
+			return emu === null ? null : emu / 12700;
+		};
+		return {
+			material: attr(cell3D, "prstMaterial") ?? null,
+			bevel: {
+				preset: bevel ? attr(bevel, "prst") ?? null : null,
+				widthPt: bevel ? pts(attr(bevel, "w")) : null,
+				heightPt: bevel ? pts(attr(bevel, "h")) : null
+			},
+			lightRig: rig ? {
+				rig: attr(rig, "rig") ?? null,
+				dir: attr(rig, "dir") ?? null
+			} : null
+		};
+	}
+	/**
+	* The cell's unique identifier (`a:tc/@id`), or `null` when it has none.
+	*
+	* This is what {@link headerIds} references: a data cell names the header cells that
+	* govern it by their `@id`, which is how a complex table tells a screen reader what a
+	* value means. Unrelated to the shape-level `p:cNvPr/@id` — it is an `xs:string` scoped
+	* to the table, not a slide-wide numeric id.
+	*
+	* **PowerPoint does not write this and strips it on save**, so it will read `null` on
+	* any deck PowerPoint has saved, however it was produced. It is surfaced for decks from
+	* other producers. There is deliberately no write-API counterpart — see
+	* `test/read/fixtures/authoring/probe-table-cell-a11y-and-3d.ps1` for the measurement.
+	*/
+	get id() {
+		return attr(this.tc, "id") ?? null;
+	}
+	/**
+	* The `@id`s of the header cells that govern this cell
+	* (`a:tcPr/a:headers/a:header/@val`), in document order. Empty when the cell declares no
+	* header association — which is the common case, since only a complex table needs one.
+	*
+	* Carries the same caveat as {@link id}: PowerPoint strips `a:headers` on save, so this
+	* is empty on any PowerPoint-saved deck. `Table.firstRowHeader` (`a:tblPr/@firstRow`) is
+	* the header marker PowerPoint does keep.
+	*/
+	get headerIds() {
+		const tcPr = this.#tcPr();
+		const headers = tcPr && firstChild(tcPr, "a:headers");
+		if (!headers) return [];
+		return getElements(headers, "a:header").map((header) => attr(header, "val")).filter((val) => val !== null && val !== "");
+	}
+	/**
+	* How the cell treats a glyph too wide for its text width (`a:tcPr/@horzOverflow`):
+	* `'clip'` cuts it at the cell edge, `'overflow'` lets it draw past. `null` when unset
+	* (PowerPoint clips). Not a wrap flag — cell text always wraps to the column width.
+	*/
+	get horzOverflow() {
+		const tcPr = this.#tcPr();
+		return (tcPr && attr(tcPr, "horzOverflow")) ?? null;
+	}
+	/**
 	* The cell's text insets in EMU (`a:tcPr/@marL`/`@marR`/`@marT`/`@marB`), or
 	* `null` when the cell sets none. Each side is `null` when only some are set.
 	*/
@@ -5360,6 +6248,6 @@ function buildShapes(parent, slide) {
 	return shapes;
 }
 //#endregion
-export { escapeXmlAttribute as $, resolveMasterColorContext as A, restyleSlide as B, Paragraph as C, readGradientFill as D, readPictureFill as E, flattenShape as F, relsPartNameFor as G, partNameExtension as H, flattenSlide as I, OOXML_NS as J, resolveRelativePartName as K, parseClrMap as L, resolveSlideColorContext as M, resolveSlideThemeParts as N, resolveColorElement as O, applyColorTransforms as P, createElement as Q, parseClrScheme as R, Shape as S, TextFrame as T, partNameToZipPath as U, styleRefFill as V, relativePartName as W, boolValue as X, attr as Y, childElements$2 as Z, ChartAxis as _, isGraphicFrame as a, intValue as at, Picture as b, wrapShapeElement as c, removeAttr as ct, TableCell as d, setAttr as dt, firstChild as et, TableRow as f, Chart as g, ChartExSeries as h, isConnector as i, insertInOrder as it, resolveNotesColorContext as j, resolveLayoutColorContext as k, GraphicFrame as l, removeChildrenByQName as lt, ChartExAxis as m, buildShapes as n, getElements as nt, isGroupShape as o, ownerDocumentOf as ot, ChartEx as p, zipPathToPartName as q, isAutoShape as r, getOrAddChild as rt, isPicture as s, parseXml as st, GroupShape as t, firstChildElement as tt, Table as u, serializeXml as ut, ChartSeries as v, Run as w, AutoShape as x, Connector as y, remapLiteralColors as z };
+export { createElement as $, resolveLayoutColorContext as A, remapLiteralColors as B, Paragraph as C, readPictureFill as D, readPatternFill as E, applyColorTransforms as F, relativePartName as G, styleRefFill as H, flattenShape as I, zipPathToPartName as J, relsPartNameFor as K, flattenSlide as L, resolveNotesColorContext as M, resolveSlideColorContext as N, readGradientFill as O, resolveSlideThemeParts as P, childElements$2 as Q, parseClrMap as R, Shape as S, TextFrame as T, partNameExtension as U, restyleSlide as V, partNameToZipPath as W, attr as X, OOXML_NS as Y, boolValue as Z, ChartAxis as _, isGraphicFrame as a, insertInOrder as at, Picture as b, wrapShapeElement as c, parseXml as ct, TableCell as d, serializeXml as dt, escapeXmlAttribute as et, TableRow as f, setAttr as ft, Chart as g, ChartExSeries as h, isConnector as i, getOrAddChild as it, resolveMasterColorContext as j, resolveColorElement as k, GraphicFrame as l, removeAttr as lt, ChartExAxis as m, buildShapes as n, firstChildElement as nt, isGroupShape as o, intValue as ot, ChartEx as p, resolveRelativePartName as q, isAutoShape as r, getElements as rt, isPicture as s, ownerDocumentOf as st, GroupShape as t, firstChild as tt, Table as u, removeChildrenByQName as ut, ChartSeries as v, Run as w, AutoShape as x, Connector as y, parseClrScheme as z };
 
-//# sourceMappingURL=shapes-BZU8UTW2.js.map
+//# sourceMappingURL=shapes-CaOgR0i1.js.map