@shbernal/ts-pptx 1.0.0 → 2.0.0

package/dist/{text-WRUbOy2r.js → text-B1ZrPEeK.js}

@@ -2,9 +2,9 @@ import { n as warn, r as warnOnce } from "./diagnostics-DYQC7xLV.js";
 import { n as InvalidOptionError, o as UnsupportedFeatureError, r as MediaError, t as InternalError } from "./errors-DGE9zh3U.js";
 import { a as FIXED_PCT_PER_PERCENT, d as emuToInches, g as pixelsToEmu, i as EMU_PER_POINT, l as STANDARD_LAYOUTS, m as inchesToEmu, r as EMU_PER_INCH, s as PERCENT_SCALE, t as ANGLE_UNITS_PER_DEGREE, v as ptToHundredths } from "./units-B-JUKwCS.js";
 import { $ as connectorPresetFor, C as DEF_PRES_LAYOUT_NAME, D as DEF_TEXT_GLOW, E as DEF_SLIDE_MARGIN_IN, F as PIECHART_COLORS, G as PlaceholderType, I as REGEX_HEX_COLOR, K as SchemeColor, L as SLDNUMFLDID, M as LAYOUT_IDX_SERIES_BASE, N as LETTERS, O as DEF_TEXT_SHADOW, Q as asChartType, R as XML_DECL, S as DEF_PRES_LAYOUT, T as DEF_SHAPE_SHADOW, Z as VALID_SHAPE_PRESETS, _ as DEF_CELL_BORDER, a as lineWidthToEmu, b as DEF_CHART_GRIDLINE, c as resolveTableColWidthsEmu, d as AXIS_ID_CATEGORY_PRIMARY, et as isChartExType, f as AXIS_ID_CATEGORY_SECONDARY, g as BARCHART_COLORS, h as AXIS_ID_VALUE_SECONDARY, i as inch2Emu, k as IMG_BROKEN, l as transparencyToAlpha, m as AXIS_ID_VALUE_PRIMARY, n as convertRotationDegrees, o as marginToEmu, p as AXIS_ID_SERIES_PRIMARY, r as getSmartParseNumber, s as opacityToAlpha, t as convertArcAngle, u as valToPts, v as DEF_CELL_MARGIN_IN, x as DEF_FONT_COLOR, y as DEF_CHART_BORDER } from "./units-internal-7JcMfYti.js";
-import { a as decodeBase64ToBytes, n as getImageSizeFromBase64, o as svgMarkupToDataUri, t as fitSrcRectPercents } from "./image-size-C5Z1sKof.js";
+import { a as decodeBase64ToBytes, n as getImageSizeFromBase64, o as svgMarkupToDataUri, t as fitSrcRectPercents } from "./image-size-C8uYE8GJ.js";
 import { t as getSlidesForTableRows } from "./autopage-tmfjRzL4.js";
-import { _ as parseFontMetrics, m as FontMetricsRegistry, n as measureText, r as computeTableLayout, t as applyMeasuredFit } from "./fit-CbxyHN69.js";
+import { _ as parseFontMetrics, m as FontMetricsRegistry, n as measureText, r as computeTableLayout, t as applyMeasuredFit } from "./fit-BSWY0AYt.js";
 import { a as flattenEmbeddedFaces, i as FONT_REL_TYPE, n as FONT_DATA_CONTENT_TYPE, o as serializeEmbeddedFontLst, r as FONT_DATA_EXTENSION, t as EMBEDDED_FONT_SLOTS } from "./embedded-fonts-MaynAHa9.js";
 import { ZipWriter } from "./zip.js";
 //#region src/media/content-type.ts
@@ -1829,7 +1829,10 @@ function groupObjectsDefinition(target, objectNames, opts) {
 		const key = encodeXmlAttrValue(name);
 		const matches = target._slideObjects.filter((obj) => obj.options?.objectName === key);
 		const [obj, ambiguous] = matches;
-		if (!obj) throw new InvalidOptionError("group/unresolved-object-name", `groupObjects(): cannot group "${name}" — ${findNameInGroups(target._slideObjects, key) ? "it is already inside a group (an object can only belong to one group)" : "no top-level object on this slide has that objectName"}.`);
+		if (!obj) {
+			const hint = findNameInGroups(target._slideObjects, key) ? "it is already inside a group (an object can only belong to one group)" : "no top-level object on this slide has that objectName";
+			throw new InvalidOptionError("group/unresolved-object-name", `groupObjects(): cannot group "${name}" — ${hint}.`);
+		}
 		if (ambiguous) throw new InvalidOptionError("group/ambiguous-object-name", `groupObjects(): objectName "${name}" is ambiguous — ${matches.length} objects on this slide share it. Give them unique objectNames.`);
 		if (!GROUPABLE_TYPES.includes(obj._type) || obj.options?.placeholder) {
 			const kind = obj.options?.placeholder ? "placeholder" : obj._type;
@@ -2148,6 +2151,44 @@ function normalizeBorderTuple(border) {
 		border
 	];
 }
+/** Fill a border's defaulted keys, preserving anything else the caller set (`cap`, `dashType`, …). */
+function withBorderDefaults(side) {
+	return {
+		...side,
+		type: side.type || DEF_CELL_BORDER.type,
+		color: side.color || DEF_CELL_BORDER.color,
+		width: typeof side.width === "number" ? side.width : DEF_CELL_BORDER.width
+	};
+}
+/**
+* Resolve `TableProps.outerBorder` into the `[top, right, bottom, left]` tuple the emitter
+* applies to the table's edge cells, with `undefined` for a side the caller left out.
+*
+* A sparse side is *not* the same as `{ type: 'none' }`: it means "leave this edge to
+* whatever `border` (or the cell's own `options.border`) already drew", whereas `'none'` is
+* an explicit instruction to erase the rule there. Keeping the hole is what lets
+* `outerBorder: [rule, undefined, rule, undefined]` add rules above and below a table
+* without also clearing its left and right edges.
+*/
+function normalizeOuterBorder(outer) {
+	if (!outer || typeof outer !== "object") return void 0;
+	const sides = Array.isArray(outer) ? outer : [
+		outer,
+		outer,
+		outer,
+		outer
+	];
+	const resolved = [
+		0,
+		1,
+		2,
+		3
+	].map((idx) => {
+		const side = sides[idx];
+		return side && typeof side === "object" ? withBorderDefaults(side) : void 0;
+	});
+	return resolved.some((side) => side !== void 0) ? resolved : void 0;
+}
 /**
 * Adds a table object to a slide definition.
 * @param {PresSlideInternal} target - slide object that the table should be added to
@@ -2197,6 +2238,9 @@ function applyTableHeaderColumnSugar(tableRows, opt) {
 /**
 * Transform loosely-typed table rows (strings / numbers / TableCell) into a grid of
 * well-formed TableCell objects with fully-resolved 4-side cell borders.
+*
+* @param srcRows - the rows as authored, after the `headerRow`/`columns` sugar
+* @param opt - the table's options
 */
 function normalizeTableRows(srcRows, opt) {
 	const arrRows = [];
@@ -2238,12 +2282,7 @@ function normalizeTableRows(srcRows, opt) {
 				3
 			].forEach((idx) => {
 				const side = cellBorderTuple[idx];
-				cellBorderTuple[idx] = {
-					...side,
-					type: side.type || DEF_CELL_BORDER.type,
-					color: side.color || DEF_CELL_BORDER.color,
-					width: typeof side.width === "number" ? side.width : DEF_CELL_BORDER.width
-				};
+				cellBorderTuple[idx] = withBorderDefaults(side);
 			});
 			newCellOptions.border = cellBorderTuple;
 			newRow.push(newCell);
@@ -2259,10 +2298,11 @@ function normalizeTableRows(srcRows, opt) {
 * the fill. Tables were the last major object kind not wired into `registerImageFillMedia`
 * (shapes do it at `define/shape.ts`, text boxes at `define/text.ts`).
 *
-* Two fill sources are walked, which between them cover all four ways a fill reaches a cell:
+* Three fill sources are walked, which between them cover every way a picture reaches a table:
 * the resolved cells (per-cell `options.fill`, plus `headerRow` and `columns[i]`, both baked
-* onto cells by the sugar step above), and the table-level `fill`, which is *not* baked —
-* `gen/slide/objects/table.ts` copies it onto each cell at emit time.
+* onto cells by the sugar step above), the table-level `fill`, which is *not* baked —
+* `gen/slide/objects/table.ts` copies it onto each cell at emit time — and `tableFill`, which
+* lands on `a:tblPr` itself and so needs its own relationship for the same reason.
 *
 * Keyed on fill **object identity**, not on the image source. The sugar spreads its options
 * shallowly, so one `headerRow` fill object is shared by every cell it styles; registering
@@ -2285,6 +2325,7 @@ function registerTableImageFills(target, rows, opt) {
 		registerImageFillMedia(target, fill);
 	};
 	register(opt.fill);
+	register(opt.tableFill);
 	rows.forEach((row) => {
 		row.forEach((cell) => {
 			register(cell.options?.fill);
@@ -2319,7 +2360,7 @@ function addTableDefinition(target, tableRows, options, slideLayout, presLayout,
 	];
 	if (!Array.isArray(opt.margin) || opt.margin.length !== 4 || opt.margin.some((v) => typeof v !== "number" || !Number.isFinite(v))) opt.margin = DEF_CELL_MARGIN_IN;
 	if (!JSON.stringify({ arrRows }).includes("hyperlink")) {
-		if (!opt.color) opt.color = opt.color || "000000";
+		if (!opt.color) opt.color = DEF_FONT_COLOR;
 	}
 	if (typeof opt.border === "string") {
 		warn("table/invalid-border", "addTable `border` option must be an object. Ex: `{border: {type:'none'}}`");
@@ -2332,14 +2373,15 @@ function addTableDefinition(target, tableRows, options, slideLayout, presLayout,
 			2,
 			3
 		].forEach((idx) => {
-			border[idx] = border[idx] ? {
-				...border[idx],
-				type: border[idx].type || DEF_CELL_BORDER.type,
-				color: border[idx].color || DEF_CELL_BORDER.color,
-				width: border[idx].width || DEF_CELL_BORDER.width
-			} : { type: "none" };
+			const side = border[idx];
+			border[idx] = side ? withBorderDefaults(side) : { type: "none" };
 		});
 	}
+	if (typeof opt.outerBorder === "string") {
+		warn("table/invalid-outer-border", "addTable `outerBorder` option must be an object. Ex: `{outerBorder: {type:'solid'}}`");
+		opt.outerBorder = void 0;
+	}
+	opt.outerBorder = normalizeOuterBorder(opt.outerBorder);
 	opt.autoPage = typeof opt.autoPage === "boolean" ? opt.autoPage : false;
 	opt.autoPagePlaceholder = typeof opt.autoPagePlaceholder === "boolean" ? opt.autoPagePlaceholder : false;
 	opt.autoPageRepeatHeader = typeof opt.autoPageRepeatHeader === "boolean" ? opt.autoPageRepeatHeader : false;
@@ -2381,7 +2423,7 @@ function addTableDefinition(target, tableRows, options, slideLayout, presLayout,
 		}
 	} else if (opt.w) {} else opt.w = Math.floor((presLayout._sizeW || presLayout.width) / EMU_PER_INCH - arrTableMargin[1] - arrTableMargin[3]);
 	if (opt.fitColumns === "shrink") {
-		const availWin = (presLayout._sizeW || presLayout.width) / EMU_PER_INCH - getSmartParseNumber(opt.x, "X", presLayout) / EMU_PER_INCH - arrTableMargin[3];
+		const availWin = (presLayout._sizeW || presLayout.width) / EMU_PER_INCH - getSmartParseNumber(opt.x, "X", presLayout) / EMU_PER_INCH - arrTableMargin[1];
 		if (availWin > 0) {
 			if (Array.isArray(opt.colW)) {
 				const sumIn = opt.colW.reduce((p, n) => p + (Number.isFinite(n) ? n : 0), 0);
@@ -3045,23 +3087,99 @@ function genXmlColorSelection(props) {
 			case "image":
 				outText += genXmlImageFill(typeof props === "string" ? void 0 : props);
 				break;
-			default:
-				outText += "";
-				break;
+			default: outText += "";
 		}
 	}
 	return outText;
 }
 //#endregion
 //#region src/gen/drawingml/line.ts
+/** Every key `BorderProps` defines. Keep in step with the interface in `types/style.ts`. */
+const BORDER_KEYS = [
+	"type",
+	"dashType",
+	"color",
+	"width",
+	"transparency",
+	"cap"
+];
+/**
+* The `ST_PresetLineDashVal` tokens `BorderProps.dashType` accepts — the same set
+* `ShapeLineProps.dashType` does, so a caller who knows one knows the other.
+*/
+const BORDER_DASH_VALUES = [
+	"solid",
+	"dot",
+	"dash",
+	"lgDash",
+	"dashDot",
+	"lgDashDot",
+	"lgDashDotDot",
+	"sysDash",
+	"sysDot",
+	"sysDashDot",
+	"sysDashDotDot"
+];
+/**
+* Resolve the `a:prstDash/@val` a border should emit.
+*
+* `BorderProps.type` is a three-way switch, so on its own it can only say "dashed" and
+* every dashed border collapses onto `sysDash`. `dashType` names the preset directly and
+* therefore wins when both are given; `type: 'none'` never reaches here, being decided by
+* the caller before any dash is chosen.
+*
+* A value outside `ST_PresetLineDashVal` would make the part schema-invalid, which
+* PowerPoint reports as a corrupt file rather than a mis-set option — so an unrecognized
+* one is reported and dropped back to what `type` implies.
+* @param {BorderProps} border - the caller's border properties
+* @returns {string} a value legal for `a:prstDash/@val`
+*/
+function resolveBorderDash(border) {
+	const fromType = border.type === "dash" ? "sysDash" : "solid";
+	const dash = border.dashType;
+	if (dash === void 0 || dash === null) return fromType;
+	if (BORDER_DASH_VALUES.includes(dash)) return dash;
+	warnOnce("border/invalid-dash-type", `border: dashType \`${String(dash)}\` is not a valid value and is ignored — use one of ${BORDER_DASH_VALUES.join(", ")}.`, {
+		received: dash,
+		valid: BORDER_DASH_VALUES
+	});
+	return fromType;
+}
+/**
+* Report an authored key that is not part of `BorderProps`, which the library would
+* otherwise drop without a sound.
+*
+* TypeScript's excess-property check already rejects a stray key on a border written
+* *inline* at the call site. It deliberately does not fire when the border is built as
+* a variable first (`const b = {...}; addTable(rows, { border: b })`) — a variable may
+* legitimately be a supertype. That exemption covers precisely the reuse pattern a
+* shared grid style encourages, so the mistake reaches here typed as valid and the
+* wrong-named value is discarded during generation. A `.pptx` gives no other signal:
+* nothing throws, the deck opens, and the border simply renders at its default weight.
+* @param border - the caller's border properties
+*/
+function warnUnknownBorderKeys(border) {
+	for (const key in border) {
+		if (!Object.hasOwn(border, key) || BORDER_KEYS.includes(key)) continue;
+		warnOnce("border/unknown-key", `border: unknown option \`${key}\` is ignored — valid keys are ${BORDER_KEYS.join(", ")}. Line thickness is \`width\`, in points.`, {
+			received: key,
+			valid: BORDER_KEYS
+		});
+	}
+}
 /**
 * Resolve a border's line width in points, falling back to `defaultPt` when `width`
 * is not a usable number.
+*
+* Every `BorderProps` the library reads — table cell borders, table-style regions, and
+* every chart border — resolves its width through here, so this doubles as the one
+* place that can vet a border's shape for all of them ({@link warnUnknownBorderKeys}).
 * @param {BorderProps} border - border properties (may carry `width`)
 * @param {number} defaultPt - width to use when `width` is not a finite number
 * @returns {number} resolved width in points
 */
 function resolveBorderWidth(border, defaultPt) {
+	warnUnknownBorderKeys(border);
 	const val = border.width;
 	return typeof val === "number" && !isNaN(val) ? val : defaultPt;
 }
@@ -6352,9 +6470,7 @@ function genXmlParagraphProperties(textObj, isDefault) {
 		case "justify":
 			paragraphPropXml += " algn=\"just\"";
 			break;
-		default:
-			paragraphPropXml += "";
-			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) })));
@@ -7094,10 +7210,7 @@ function genXmlCustGeom(options, cx, cy, layout) {
 					pt(point.x, point.y)
 				].map(raw), BEZ_INDENT));
 				break;
-			case "quadratic":
-				nodes.push(el("a:quadBezTo", null, [pt(point.curve.x1, point.curve.y1), pt(point.x, point.y)].map(raw), BEZ_INDENT));
-				break;
-			default: break;
+			case "quadratic": nodes.push(el("a:quadBezTo", null, [pt(point.curve.x1, point.curve.y1), pt(point.x, point.y)].map(raw), BEZ_INDENT));
 		}
 		else if ("close" in point) nodes.push(voidEl("a:close", null, SPACE_BEFORE_SLASH));
 		else if (point.moveTo || i === 0) nodes.push(el("a:moveTo", null, raw(pt(point.x, point.y))));
@@ -7214,12 +7327,15 @@ const ImageSizingXml = {
 		const r = imgSize.w - (boxDim.x + boxDim.w);
 		const t = boxDim.y;
 		const b = imgSize.h - (boxDim.y + boxDim.h);
-		if (l < 0 || r < 0 || t < 0 || b < 0) throw new InvalidOptionError("image/crop-window-overflows", `addImage sizing.type 'crop': crop window overflows image bounds — ${[
-			l < 0 && `x (${l < 0 ? -l : 0} past left edge)`,
-			r < 0 && `x+w (${-r} past right edge)`,
-			t < 0 && `y (${-t} past top edge)`,
-			b < 0 && `y+h (${-b} past bottom edge)`
-		].filter(Boolean).join(", ")}. Ensure x≥0, y≥0, x+w≤w, y+h≤h.`);
+		if (l < 0 || r < 0 || t < 0 || b < 0) {
+			const over = [
+				l < 0 && `x (${l < 0 ? -l : 0} past left edge)`,
+				r < 0 && `x+w (${-r} past right edge)`,
+				t < 0 && `y (${-t} past top edge)`,
+				b < 0 && `y+h (${-b} past bottom edge)`
+			].filter(Boolean).join(", ");
+			throw new InvalidOptionError("image/crop-window-overflows", `addImage sizing.type 'crop': crop window overflows image bounds — ${over}. Ensure x≥0, y≥0, x+w≤w, y+h≤h.`);
+		}
 		return voidEl("a:srcRect", {
 			l: Math.round(1e5 * (l / imgSize.w)),
 			r: Math.round(1e5 * (r / imgSize.w)),
@@ -7483,13 +7599,64 @@ function renderOleObject(slideItemObj, idx, x, y, cx, cy) {
 //#endregion
 //#region src/gen/drawingml/table-border.ts
 /**
-* Emit the `<a:lnL>/<a:lnR>/<a:lnT>/<a:lnB>` border children of an `<a:tcPr>` for a table cell.
-* Shared by normal cells and the dummy span (`_hmerge`/`_vmerge`) cells so a merged region's
-* outer edges render with the same border as its origin cell.
-* @param {BorderProps[]} cellBorder - 4-tuple of border props in [top, right, bottom, left] order
-* @return {string} concatenated border element XML, in the LRTB document order PowerPoint expects
+* One `<a:lnX>` border element. Every side of a table cell — the four edges and the two
+* diagonals — is a `CT_LineProperties`, so they differ only in element name.
+* @param {string} name - the element's local name (`lnL`, `lnTlToBr`, …)
+* @param {BorderProps} border - the resolved border for that side
+* @return {string} the border element XML
+*/
+function genBorderLine(name, border) {
+	const cap = createLineCap(border.cap);
+	if (border.type === "none") return el(`a:${name}`, {
+		w: 0,
+		cap,
+		cmpd: "sng",
+		algn: "ctr"
+	}, raw(voidEl("a:noFill")));
+	return el(`a:${name}`, {
+		w: valToPts(resolveBorderWidth(border, 1)),
+		cap,
+		cmpd: "sng",
+		algn: "ctr"
+	}, [
+		genXmlColorSelection({
+			color: border.color ?? "363636",
+			transparency: border.transparency
+		}),
+		voidEl("a:prstDash", { val: resolveBorderDash(border) }),
+		voidEl("a:round"),
+		voidEl("a:headEnd", {
+			type: "none",
+			w: "med",
+			len: "med"
+		}),
+		voidEl("a:tailEnd", {
+			type: "none",
+			w: "med",
+			len: "med"
+		})
+	].map(raw));
+}
+/**
+* Emit the border children of an `<a:tcPr>` for a table cell: the four edges, then the two
+* diagonals when the cell asks for them.
+*
+* The edges are shared by normal cells and the dummy span (`_hmerge`/`_vmerge`) cells so a
+* merged region's outer edges render with the same border as its origin cell. The diagonals
+* are **not**: a diagonal across a merged region is one stroke corner-to-corner, and
+* repeating it on each covered cell would draw a sawtooth instead. Only the span origin
+* carries them, which is also where PowerPoint puts them.
+*
+* A side may be missing, and missing is not the same as `{type:'none'}`: `none` writes an
+* explicit `w="0"` rule, which is direct formatting and overrides whatever a built-in table
+* style would have drawn there, while an omitted side leaves that edge to the style. The
+* definition step sends every cell here dense; a caller reaching this directly may not.
+*
+* @param {BorderProps[]} cellBorder - up to a 4-tuple of border props in [top, right, bottom, left] order
+* @param {TableCellDiagonals} [diagonal] - the cell's optional corner-to-corner rules
+* @return {string} concatenated border element XML, in the document order PowerPoint expects
 */
-function genTableCellBorderXml(cellBorder) {
+function genTableCellBorderXml(cellBorder, diagonal) {
 	let strXml = "";
 	[
 		{
@@ -7511,41 +7678,205 @@ function genTableCellBorderXml(cellBorder) {
 	].forEach((obj) => {
 		const border = cellBorder[obj.idx];
 		if (!border) return;
-		const cap = createLineCap(border.cap);
-		if (border.type !== "none") strXml += el(`a:${obj.name}`, {
-			w: valToPts(resolveBorderWidth(border, 1)),
-			cap,
-			cmpd: "sng",
-			algn: "ctr"
-		}, [
-			genXmlColorSelection({
-				color: border.color ?? "363636",
-				transparency: border.transparency
-			}),
-			voidEl("a:prstDash", { val: border.type === "dash" ? "sysDash" : "solid" }),
-			voidEl("a:round"),
-			voidEl("a:headEnd", {
-				type: "none",
-				w: "med",
-				len: "med"
-			}),
-			voidEl("a:tailEnd", {
-				type: "none",
-				w: "med",
-				len: "med"
-			})
-		].map(raw));
-		else strXml += el(`a:${obj.name}`, {
-			w: 0,
-			cap,
-			cmpd: "sng",
-			algn: "ctr"
-		}, raw(voidEl("a:noFill")));
+		strXml += genBorderLine(obj.name, border);
 	});
+	if (diagonal?.tlToBr) strXml += genBorderLine("lnTlToBr", diagonal.tlToBr);
+	if (diagonal?.blToTr) strXml += genBorderLine("lnBlToTr", diagonal.blToTr);
 	return strXml;
 }
 //#endregion
+//#region src/gen/drawingml/table-cell3d.ts
+/** `ST_BevelPresetType`. */
+const BEVEL_PRESETS = [
+	"relaxedInset",
+	"circle",
+	"slope",
+	"cross",
+	"angle",
+	"softRound",
+	"convex",
+	"coolSlant",
+	"divot",
+	"riblet",
+	"hardEdge",
+	"artDeco"
+];
+/** `ST_PresetMaterialType`. */
+const MATERIALS = [
+	"legacyMatte",
+	"legacyPlastic",
+	"legacyMetal",
+	"legacyWireframe",
+	"matte",
+	"plastic",
+	"metal",
+	"warmMatte",
+	"translucentPowder",
+	"powder",
+	"dkEdge",
+	"softEdge",
+	"clear",
+	"flat",
+	"softmetal"
+];
+/** `ST_LightRigType`. */
+const LIGHT_RIGS = [
+	"legacyFlat1",
+	"legacyFlat2",
+	"legacyFlat3",
+	"legacyFlat4",
+	"legacyNormal1",
+	"legacyNormal2",
+	"legacyNormal3",
+	"legacyNormal4",
+	"legacyHarsh1",
+	"legacyHarsh2",
+	"legacyHarsh3",
+	"legacyHarsh4",
+	"threePt",
+	"balanced",
+	"soft",
+	"harsh",
+	"flood",
+	"contrasting",
+	"morning",
+	"sunrise",
+	"sunset",
+	"chilly",
+	"freezing",
+	"flat",
+	"twoPt",
+	"glow",
+	"brightRoom"
+];
+/** `ST_LightRigDirection`. */
+const LIGHT_DIRECTIONS = [
+	"tl",
+	"t",
+	"tr",
+	"l",
+	"r",
+	"bl",
+	"b",
+	"br"
+];
+/**
+* Vet one enumerated value before it reaches the XML. Anything outside its `ST_` union would
+* make the slide part schema-invalid, and PowerPoint reports that as a corrupt file rather
+* than as a mis-set option — so an unrecognized value is reported and the attribute dropped,
+* leaving the renderer on the schema default.
+*/
+function resolveEnum(value, valid, field) {
+	if (value === void 0 || value === null) return null;
+	if (valid.includes(value)) return value;
+	warnOnce("table/invalid-cell3d", `table cell: cell3D \`${field}\` value \`${String(value)}\` is not valid and is ignored — use one of ${valid.join(", ")}.`, {
+		received: value,
+		field,
+		valid
+	});
+	return null;
+}
+/**
+* A bevel dimension in EMU (`ST_PositiveCoordinate`), from a width in points.
+* A negative or non-finite value cannot be written, so it falls back to the attribute's
+* own default of 76200 EMU (6pt) rather than emitting something PowerPoint would reject.
+*/
+function bevelSizeEmu(points, field) {
+	if (points === void 0 || points === null) return null;
+	if (!Number.isFinite(points) || points < 0) {
+		warnOnce("table/invalid-cell3d", `table cell: cell3D \`${field}\` must be a non-negative number of points; \`${String(points)}\` is ignored.`, {
+			received: points,
+			field
+		});
+		return null;
+	}
+	return valToPts(points);
+}
+/**
+* Emit a cell's `<a:cell3D>`, or `''` when it has none.
+* @param {TableCell3DProps} [cell3D] - the cell's 3-D options
+* @return {string} the `a:cell3D` element XML
+*/
+function genTableCell3DXml(cell3D) {
+	if (!cell3D || typeof cell3D !== "object") return "";
+	const bevel = voidEl("a:bevel", {
+		w: bevelSizeEmu(cell3D.width, "width"),
+		h: bevelSizeEmu(cell3D.height, "height"),
+		prst: resolveEnum(cell3D.preset, BEVEL_PRESETS, "preset")
+	});
+	const rig = resolveEnum(cell3D.lightRig?.rig, LIGHT_RIGS, "lightRig.rig");
+	const dir = resolveEnum(cell3D.lightRig?.dir, LIGHT_DIRECTIONS, "lightRig.dir");
+	const lightRig = rig && dir ? voidEl("a:lightRig", {
+		rig,
+		dir
+	}) : "";
+	if (cell3D.lightRig && !lightRig) warnOnce("table/invalid-cell3d", "table cell: cell3D `lightRig` needs both `rig` and `dir` (both are required by CT_LightRig); the light rig is dropped and the bevel takes the renderer default.", { received: cell3D.lightRig });
+	return el("a:cell3D", { prstMaterial: resolveEnum(cell3D.material, MATERIALS, "material") }, [raw(bevel), lightRig ? raw(lightRig) : null]);
+}
+//#endregion
 //#region src/gen/slide/objects/table.ts
+/** The two values `ST_TextHorzOverflowType` allows on `a:tcPr/@horzOverflow`. */
+const HORZ_OVERFLOW_VALUES = ["clip", "overflow"];
+/**
+* Validate a cell's `horzOverflow` before it reaches the XML. Anything outside
+* `ST_TextHorzOverflowType` would make the slide part schema-invalid — and PowerPoint
+* reports that as a corrupt file, not as a mis-set option — so an unrecognized value is
+* reported and dropped instead of written. `undefined` (the common case) emits nothing.
+*/
+function resolveHorzOverflow(value) {
+	if (value === void 0 || value === null) return null;
+	if (HORZ_OVERFLOW_VALUES.includes(value)) return value;
+	warnOnce("table/invalid-horz-overflow", `table cell: horzOverflow \`${String(value)}\` is not a valid value and is ignored — use ${HORZ_OVERFLOW_VALUES.join(" or ")}.`, {
+		received: value,
+		valid: HORZ_OVERFLOW_VALUES
+	});
+	return null;
+}
+/**
+* Overlay `TableProps.outerBorder` onto one cell's own 4-side border tuple.
+*
+* The perimeter is decided per **grid position**, not per authored cell, which is what makes
+* merges work: a colspan's origin sits at the left of its span and its covered `_hmerge`
+* cells sit to the right, so a span straddling the last column gets that column's rule on the
+* covered cell — exactly where PowerPoint defines a merged region's outer edge. A cell in the
+* table's interior touches no edge and comes back untouched.
+*
+* Returns the input array (not a copy) when nothing applies, so the common no-perimeter path
+* allocates nothing and stays byte-identical. Never mutates: `arrTabRows` holds the caller's
+* own cell objects and repeated `write()` calls must not accumulate borders.
+*
+* @param base - the cell's resolved `[top, right, bottom, left]` borders, or `null` when it has none
+* @param outer - the normalized perimeter tuple, `undefined` for a side the caller left out
+* @param at - where this cell sits in the merge grid
+* @returns the borders to emit, or `null` when there are none and the perimeter adds none
+*/
+function applyOuterBorder(base, outer, at) {
+	if (!outer) return base;
+	const onEdge = [
+		at.rIdx === 0,
+		at.cIdx === at.lastCol,
+		at.rIdx === at.lastRow,
+		at.cIdx === 0
+	];
+	const applies = [
+		0,
+		1,
+		2,
+		3
+	].filter((idx) => onEdge[idx] && outer[idx]);
+	if (applies.length === 0) return base;
+	const merged = base ? [...base] : [
+		{ type: "none" },
+		{ type: "none" },
+		{ type: "none" },
+		{ type: "none" }
+	];
+	for (const idx of applies) {
+		const side = outer[idx];
+		if (side) merged[idx] = side;
+	}
+	return merged;
+}
 /**
 * Render a `table` slide object to its `<p:graphicFrame>` XML (merge-grid, row/col spans, per-cell styling).
 */
@@ -7589,8 +7920,15 @@ function renderTableObject(slideItemObj, idx, x, y, cx, cy, placeholderObj, item
 			firstCol: objTabOpts.hasFirstColumn ? "1" : null,
 			lastCol: objTabOpts.hasLastColumn ? "1" : null
 		};
-		tblInner = objTabOpts.tableStyle ? el("a:tblPr", tblPrAttrs, raw(el("a:tableStyleId", null, objTabOpts.tableStyle))) : voidEl("a:tblPr", tblPrAttrs);
-	}
+		const tblPrChildren = (objTabOpts.tableFill ? genXmlColorSelection(objTabOpts.tableFill) : "") + (objTabOpts.tableStyle ? el("a:tableStyleId", null, objTabOpts.tableStyle) : "");
+		tblInner = tblPrChildren ? el("a:tblPr", tblPrAttrs, raw(tblPrChildren)) : voidEl("a:tblPr", tblPrAttrs);
+	}
+	const outerBorder = !objTabOpts.outerBorder ? void 0 : Array.isArray(objTabOpts.outerBorder) ? objTabOpts.outerBorder : [
+		objTabOpts.outerBorder,
+		objTabOpts.outerBorder,
+		objTabOpts.outerBorder,
+		objTabOpts.outerBorder
+	];
 	{
 		const gridColsEmu = resolveTableColWidthsEmu(objTabOpts.colW, cx, intColCnt);
 		tblInner += el("a:tblGrid", null, gridColsEmu.map((w) => raw(voidEl("a:gridCol", { w }))));
@@ -7642,8 +7980,14 @@ function renderTableObject(slideItemObj, idx, x, y, cx, cy, placeholderObj, item
 		else if (objTabOpts.rowH && !isNaN(Number(objTabOpts.rowH))) intRowH = inch2Emu(Number(objTabOpts.rowH));
 		else if (itemOpts.cy || itemOpts.h) intRowH = Math.round((itemOpts.h ? cy : typeof itemOpts.cy === "number" ? itemOpts.cy : 1) / arrTabRows.length);
 		const rowCells = [];
-		cells.forEach((cellObj) => {
+		cells.forEach((cellObj, cIdx) => {
 			const cell = cellObj;
+			const at = {
+				rIdx,
+				cIdx,
+				lastRow: arrTabRows.length - 1,
+				lastCol: cells.length - 1
+			};
 			const cellSpanAttrs = {
 				rowSpan: cell.options?.rowspan && cell.options.rowspan > 1 ? cell.options.rowspan : void 0,
 				gridSpan: cell.options?.colspan && cell.options.colspan > 1 ? cell.options.colspan : void 0,
@@ -7652,11 +7996,11 @@ function renderTableObject(slideItemObj, idx, x, y, cx, cy, placeholderObj, item
 			};
 			if (cell._hmerge || cell._vmerge) {
 				const origin = cell._spanOrigin;
+				const originOpts = origin?.options || {};
 				let spanPrXml = "";
+				const originBorder = applyOuterBorder(Array.isArray(originOpts.border) ? originOpts.border : null, outerBorder, at);
+				if (originBorder) spanPrXml += genTableCellBorderXml(originBorder);
 				if (origin) {
-					const originOpts = origin.options || {};
-					const originBorder = Array.isArray(originOpts.border) ? originOpts.border : null;
-					if (originBorder) spanPrXml += genTableCellBorderXml(originBorder);
 					const spanFill = originOpts.fill || "";
 					if (spanFill) spanPrXml += genXmlColorSelection(spanFill);
 				}
@@ -7694,16 +8038,25 @@ function renderTableObject(slideItemObj, idx, x, y, cx, cy, placeholderObj, item
 				cellMargin
 			];
 			if (!Array.isArray(cellMargin) || cellMargin.length !== 4 || cellMargin.some((v) => typeof v !== "number" || !isFinite(v))) cellMargin = DEF_CELL_MARGIN_IN;
+			const cellHorzOverflow = resolveHorzOverflow(cellOpts.horzOverflow);
 			const tcPrAttrs = {
 				marL: marginToEmu(cellMargin[3]),
 				marR: marginToEmu(cellMargin[1]),
 				marT: marginToEmu(cellMargin[0]),
 				marB: marginToEmu(cellMargin[2]),
 				anchor: cellValign,
-				vert: cellTextDir
+				anchorCtr: cellOpts.anchorCtr ? "1" : null,
+				vert: cellTextDir,
+				horzOverflow: cellHorzOverflow
 			};
-			const cellBorder = Array.isArray(cellOpts.border) ? cellOpts.border : null;
-			rowCells.push(el("a:tc", cellSpanAttrs, [raw(genXmlTextBody(cell)), raw(el("a:tcPr", tcPrAttrs, [cellBorder ? raw(genTableCellBorderXml(cellBorder)) : null, raw(cellFill)], { closePrefix: "  " }))], { closePrefix: " " }));
+			const cellBorder = applyOuterBorder(Array.isArray(cellOpts.border) ? cellOpts.border : null, outerBorder, at);
+			const cellDiagonal = cellOpts.diagonal;
+			const cellBorderXml = cellBorder || cellDiagonal ? genTableCellBorderXml(cellBorder ?? [], cellDiagonal) : "";
+			rowCells.push(el("a:tc", cellSpanAttrs, [raw(genXmlTextBody(cell)), raw(el("a:tcPr", tcPrAttrs, [
+				raw(cellBorderXml),
+				raw(genTableCell3DXml(cellOpts.cell3D)),
+				raw(cellFill)
+			], { closePrefix: "  " }))], { closePrefix: " " }));
 		});
 		tblInner += el("a:tr", { h: intRowH }, rowCells.map(raw));
 	});
@@ -8204,9 +8557,7 @@ function slideObjectToXml(slide) {
 				strSlideXml += "</p:grpSp>";
 				break;
 			}
-			default:
-				strSlideXml += "";
-				break;
+			default: strSlideXml += "";
 		}
 		return strSlideXml;
 	};
@@ -9614,79 +9965,11 @@ function makeXmlViewProps() {
 * @see: http://openxmldeveloper.org/discussions/formats/f/13/p/2398/8107.aspx
 * @return {string} XML
 */
-function makeXmlTableStyles(tableStyles = []) {
-	const attrs = {
+function makeXmlTableStyles() {
+	return XML_DECL + "\r\n" + voidEl("a:tblStyleLst", {
 		"xmlns:a": "http://schemas.openxmlformats.org/drawingml/2006/main",
 		def: "{5C22544A-7EE6-4342-B048-85BDC9FD1C3A}"
-	};
-	if (!tableStyles || tableStyles.length === 0) return XML_DECL + "\r\n" + voidEl("a:tblStyleLst", attrs);
-	return XML_DECL + "\r\n" + el("a:tblStyleLst", attrs, tableStyles.map(({ guid, def }) => raw(el("a:tblStyle", {
-		styleId: guid,
-		styleName: def.name
-	}, [
-		["wholeTbl", def.wholeTbl],
-		["band1H", def.band1H],
-		["band2H", def.band2H],
-		["band1V", def.band1V],
-		["band2V", def.band2V],
-		["lastCol", def.lastCol],
-		["firstCol", def.firstCol],
-		["lastRow", def.lastRow],
-		["firstRow", def.firstRow]
-	].map(([name, region]) => region ? raw(genXmlTableStyleRegion(name, region)) : null)))));
-}
-/**
-* Build one `CT_TablePartStyle` region (e.g. `firstRow`, `band1H`) for a custom table style.
-* Emits `tcTxStyle` (text) before `tcStyle` (cell fill/borders) per the schema sequence.
-* @param {string} name - region element name
-* @param {TableStyleRegionProps} region - region styling
-* @return {string} XML
-*/
-function genXmlTableStyleRegion(name, region) {
-	const children = [region.bold !== void 0 || region.italic !== void 0 || region.color ? raw(el("a:tcTxStyle", {
-		b: region.bold ? "on" : null,
-		i: region.italic ? "on" : null
-	}, [raw(voidEl("a:fontRef", { idx: "minor" })), region.color ? raw(createColorElement(region.color)) : null])) : null, region.border !== void 0 || region.fill !== void 0 ? raw(el("a:tcStyle", null, [region.border !== void 0 ? raw(genXmlTableStyleBorders(region.border)) : null, region.fill !== void 0 ? raw(el("a:fill", null, raw(genXmlColorSelection(region.fill)))) : null])) : null];
-	return el(`a:${name}`, null, children);
-}
-/**
-* Build the `tcBdr` border block for a custom table style region.
-* A single `BorderProps` styles all four sides plus the interior grid lines; a
-* TRBL array styles only the four outer sides. Sides are emitted in schema order.
-* @param {BorderProps | BorderProps[]} border - border definition
-* @return {string} XML
-*/
-function genXmlTableStyleBorders(border) {
-	let sides;
-	if (Array.isArray(border)) {
-		const [top, right, bottom, left] = border;
-		sides = [
-			["left", left],
-			["right", right],
-			["top", top],
-			["bottom", bottom]
-		];
-	} else sides = [
-		["left", border],
-		["right", border],
-		["top", border],
-		["bottom", border],
-		["insideH", border],
-		["insideV", border]
-	];
-	return el("a:tcBdr", null, sides.map(([side, b]) => {
-		if (!b) return null;
-		if (b.type === "none") return raw(el(`a:${side}`, null, raw(el("a:ln", null, raw(voidEl("a:noFill"))))));
-		return raw(el(`a:${side}`, null, raw(el("a:ln", {
-			w: lineWidthToEmu(resolveBorderWidth(b, 1)),
-			cap: "flat",
-			cmpd: "sng",
-			algn: "ctr"
-		}, [raw(genXmlColorSelection({
-			color: b.color ?? "666666",
-			transparency: b.transparency
-		})), raw(voidEl("a:prstDash", { val: b.type === "dash" ? "sysDash" : "solid" }))]))));
-	}));
+	});
 }
 //#endregion
 //#region src/gen/slide/comments.ts
@@ -10333,7 +10616,7 @@ async function buildPackageParts(source, props) {
 		zip.add("ppt/theme/theme2.xml", makeXmlTheme(pres));
 		zip.add("ppt/presentation.xml", makeXmlPresentation(pres));
 		zip.add("ppt/presProps.xml", makeXmlPresProps());
-		zip.add("ppt/tableStyles.xml", makeXmlTableStyles(source.tableStyles));
+		zip.add("ppt/tableStyles.xml", makeXmlTableStyles());
 		zip.add("ppt/viewProps.xml", makeXmlViewProps());
 		pres.slideLayouts.forEach((layout, idx) => {
 			zip.add(`ppt/slideLayouts/slideLayout${idx + 1}.xml`, makeXmlLayout(layout));
@@ -10444,7 +10727,7 @@ async function writePackage(source, props) {
 * @see https://docs.microsoft.com/en-us/office/open-xml/structure-of-a-presentationml-document
 * @see https://docs.microsoft.com/en-us/previous-versions/office/developer/office-2010/hh273476(v=office.14)
 */
-const VERSION = "1.0.0";
+const VERSION = "2.0.0";
 function standardLayoutToPresLayout(layout) {
 	return {
 		name: layout.name,
@@ -10600,7 +10883,6 @@ var PresentationCore = class {
 	}
 	/** custom document properties stored in docProps/custom.xml */
 	_customProperties;
-	_tableStyles;
 	/**
 	* slide layout definition objects, used for generating slide layout files.
 	* `protected` (not `private`) so the browser entry subclass can resolve
@@ -10679,7 +10961,6 @@ var PresentationCore = class {
 		this._slides = [];
 		this._sections = [];
 		this._customProperties = [];
-		this._tableStyles = [];
 		this._masterSlide = {
 			addChart: null,
 			addComment: null,
@@ -10746,7 +11027,6 @@ var PresentationCore = class {
 			runtime: this._runtime,
 			presentation: this.internalPresentation,
 			customProperties: this._customProperties,
-			tableStyles: this._tableStyles,
 			fontMetrics: this._fontMetrics
 		};
 	}
@@ -11193,31 +11473,6 @@ var PresentationCore = class {
 		if (propsClone.background) addBackgroundDefinition(propsClone.background, newLayout);
 		if (newLayout._slideNumberProps && !this._masterSlide._slideNumberProps) this._masterSlide._slideNumberProps = newLayout._slideNumberProps;
 	}
-	/**
-	* Register a reusable custom table style and return its GUID.
-	* The style is written to `ppt/tableStyles.xml` and is editable in PowerPoint's
-	* Table Styles gallery. Pass the returned GUID as `TableProps.tableStyle`, and use
-	* the `has*` flags (`hasHeader`, `hasBandedRows`, …) to activate the matching regions.
-	* @param {TableStyleProps} props - custom table style definition (requires `name`)
-	* @returns {string} braced GUID to use as `tableStyle`
-	* @example
-	* const brand = pptx.defineTableStyle({
-	*   name: 'Brand Banded',
-	*   firstRow: { fill:'1A2B3C', color:'FFFFFF', bold:true },
-	*   band1H:   { fill:'EAF1F8' },
-	* })
-	* slide.addTable(rows, { tableStyle: brand, hasHeader:true, hasBandedRows:true })
-	*/
-	defineTableStyle(props) {
-		if (!props || typeof props !== "object") throw new InvalidOptionError("table-style/missing-argument", "defineTableStyle() requires a `{ name, ... }` object argument");
-		if (!props.name || typeof props.name !== "string") throw new InvalidOptionError("table-style/missing-name", "defineTableStyle() requires a non-empty `name`");
-		const guid = `{${getUuid("xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx").toUpperCase()}}`;
-		this._tableStyles.push({
-			guid,
-			def: props
-		});
-		return guid;
-	}
 };
 //#endregion
 //#region src/types/text.ts
@@ -11235,4 +11490,4 @@ function textRuns(runs) {
 //#endregion
 export { textRuns as n, PresentationCore as r, textRun as t };
 
-//# sourceMappingURL=text-WRUbOy2r.js.map
+//# sourceMappingURL=text-B1ZrPEeK.js.map